diff --git a/pkg/front_end/lib/src/api_prototype/lowering_predicates.dart b/pkg/front_end/lib/src/api_prototype/lowering_predicates.dart
index 9fbf8d6547c..c425dfb38b6 100644
--- a/pkg/front_end/lib/src/api_prototype/lowering_predicates.dart
+++ b/pkg/front_end/lib/src/api_prototype/lowering_predicates.dart
@@ -502,9 +502,6 @@ Field? getLateFieldTarget(Member node) {
 ///
 /// The default value of this variable is `null`.
 bool isLateLoweredLocal(VariableDeclaration node) {
-  assert(node.isLowered ||
-      node.name == null ||
-      !isLateLoweredLocalName(node.name!));
   return node.isLowered && isLateLoweredLocalName(node.name!);
 }
 
@@ -515,7 +512,8 @@ bool isLateLoweredLocalName(String name) {
       name.startsWith(lateLocalPrefix) &&
       !name.endsWith(lateIsSetSuffix) &&
       !name.endsWith(lateLocalGetterSuffix) &&
-      !name.endsWith(lateLocalSetterSuffix);
+      !name.endsWith(lateLocalSetterSuffix) &&
+      !name.contains(joinedIntermediateInfix);
 }
 
 /// Returns the name of the original late local variable from the [name] of the
@@ -547,9 +545,6 @@ String extractLocalNameFromLateLoweredLocal(String name) {
 ///
 /// The default value of this variable is `false`.
 bool isLateLoweredIsSetLocal(VariableDeclaration node) {
-  assert(node.isLowered ||
-      node.name == null ||
-      !isLateLoweredIsSetLocalName(node.name!));
   return node.isLowered && isLateLoweredIsSetLocalName(node.name!);
 }
 
@@ -586,9 +581,6 @@ String extractLocalNameFromLateLoweredIsSet(String name) {
 ///
 /// where '#local#get' is the local function for reading the variable.
 bool isLateLoweredLocalGetter(VariableDeclaration node) {
-  assert(node.isLowered ||
-      node.name == null ||
-      !isLateLoweredLocalGetterName(node.name!));
   return node.isLowered && isLateLoweredLocalGetterName(node.name!);
 }
 
@@ -627,9 +619,6 @@ String extractLocalNameFromLateLoweredGetter(String name) {
 /// where '#local#set' is the local function for setting the value of the
 /// variable.
 bool isLateLoweredLocalSetter(VariableDeclaration node) {
-  assert(node.isLowered ||
-      node.name == null ||
-      !isLateLoweredLocalSetterName(node.name!));
   return node.isLowered && isLateLoweredLocalSetterName(node.name!);
 }
 
@@ -737,6 +726,83 @@ String? _extractLocalName(String name) {
     return extractLocalNameFromLateLoweredSetter(name);
   } else if (isLateLoweredIsSetLocalName(name)) {
     return extractLocalNameFromLateLoweredIsSet(name);
+  } else if (isJoinedIntermediateName(name)) {
+    return extractJoinedIntermediateName(name);
   }
   return null;
 }
+
+/// Infix used for the name of a joined intermediate variable.
+///
+/// See [isJoinedIntermediateName] for details.
+const String joinedIntermediateInfix = "#case#";
+
+/// Returns `true` if [node] is a joined intermediate variable.
+///
+/// See [isJoinedIntermediateName] for details.
+bool isJoinedIntermediateVariable(VariableDeclaration node) {
+  return node.isLowered &&
+      node.name != null &&
+      isJoinedIntermediateName(node.name!);
+}
+
+/// Returns `true` if [name] is the name of the "joined intermediate" variable
+/// for a "joined local variable".
+///
+/// A joined local variable occurs when variables of the same name are declared
+/// in multiple switch cases for the same body. For instance
+///
+///     switch (o) {
+///       case [var a, _] when a > 5:
+///       case [_, var a] when a < 5:
+///         print(a);
+///     }
+///
+/// In this cases the 'a' in `print(a)` is a joined variable but the 'a'
+/// variables used in the guards of the case are joined intermediate variables:
+///
+///     {
+///       var a#case#0; // intermediate variable for the joined variable 'a'.
+///       var a#case#1; // intermediate variable for the joined variable 'a'.
+///       var #t1; // temporary variable for the joined variable 'a'.
+///       if (o is List<dynamic> &&
+///           o.length == 2 &&
+///           let #1 in #t1 = a#case#0 = o[0] in true &&
+///           a#case#0 > 5 ||
+///           o is List<dynamic> &&
+///           o.length == 2 &&
+///           let #1 in #t1 = a#case#1 = o[1] in true &&
+///           a#case#1 < 5) {
+///         var a = #t1;
+///         {
+///           print(a);
+///         }
+///       }
+///     }
+///
+bool isJoinedIntermediateName(String name) {
+  int index = name.indexOf(joinedIntermediateInfix);
+  if (index == -1) {
+    return false;
+  }
+  return int.tryParse(name.substring(index + joinedIntermediateInfix.length)) !=
+      null;
+}
+
+/// Returns the original name for a joined intermediate variable from the [name]
+/// of the lowered variable.
+///
+/// This method assumes that `isJoinedIntermediateName(name)` is `true`.
+///
+/// See [isJoinedIntermediateName] for details.
+String extractJoinedIntermediateName(String name) {
+  int index = name.indexOf(joinedIntermediateInfix);
+  return name.substring(0, index);
+}
+
+/// Infix used for the name of a joined intermediate variable.
+///
+/// See [isJoinedIntermediateName] for details.
+String createJoinedIntermediateName(String variableName, int index) {
+  return '$variableName$joinedIntermediateInfix$index';
+}
diff --git a/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart b/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart
index 8e7561dbe9f..2e8e09fceab 100644
--- a/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart
@@ -35,6 +35,7 @@ import 'package:_fe_analyzer_shared/src/exhaustiveness/space.dart';
 import 'package:_fe_analyzer_shared/src/exhaustiveness/exhaustive.dart';
 import 'package:_fe_analyzer_shared/src/exhaustiveness/static_type.dart';
 
+import '../../api_prototype/lowering_predicates.dart';
 import '../../base/nnbd_mode.dart';
 import '../fasta_codes.dart';
 
@@ -856,261 +857,579 @@ class ConstantsTransformer extends RemovingTransformer {
     return node;
   }
 
+  Map<PatternSwitchStatement, _PatternSwitchStatementInfo>
+      _currentPatternSwitchStatementInfoMap = {};
+
+  @override
+  TreeNode visitContinueSwitchStatement(
+      ContinueSwitchStatement node, TreeNode? removalSentinel) {
+    SwitchCase targetSwitchCase = node.target;
+    if (targetSwitchCase is PatternSwitchCase) {
+      // This is continue to a pattern switch case.
+      PatternSwitchStatement patternSwitchStatement =
+          targetSwitchCase.parent as PatternSwitchStatement;
+      _PatternSwitchStatementInfo? info =
+          _currentPatternSwitchStatementInfoMap[patternSwitchStatement];
+      if (info != null) {
+        // The pattern switch statement has continue statements and its switch
+        // case pattern-guards do not consist solely of guard-less constant
+        // patterns whose value has a primitive equals method.
+        PatternSwitchCase sourceSwitchCase = info.currentSwitchCase!;
+        int? sourceCaseIndex = info.switchCaseIndexMap[sourceSwitchCase];
+        if (sourceCaseIndex == null) {
+          // The enclosing switch case is _not_ a continue target, so we need
+          // to replace the continue with setting the switch index variable and
+          // a jump to the generated switch statement.
+          int targetCaseIndex = info.switchCaseIndexMap[targetSwitchCase]!;
+          return new _InlinedBlock([
+            createExpressionStatement(createVariableSet(
+                info.switchIndexVariable,
+                createIntLiteral(targetCaseIndex, fileOffset: node.fileOffset),
+                fileOffset: node.fileOffset)),
+            createBreakStatement(info.innerLabeledStatement,
+                fileOffset: node.fileOffset),
+          ])
+            ..fileOffset = node.fileOffset;
+        }
+      }
+    }
+    return node;
+  }
+
   @override
   TreeNode visitPatternSwitchStatement(
       PatternSwitchStatement node, TreeNode? removalSentinel) {
-    super.visitPatternSwitchStatement(node, removalSentinel);
+    // The pattern switch statement has three different lowerings:
+    //
+    // 1) If the switch case pattern-guards consists solely of guard-less
+    //    constant patterns whose value has a primitive equals method. For this
+    //    case we generate switch using an ordinary switch statement.
+    //
+    //    The pattern switch statement _can_ contain continue switch statements.
+    //
+    //    For instance:
+    //
+    //      enum E { a, b, c }
+    //      method(E e) {
+    //        switch (e) { // PatternSwitchStatement
+    //          case E.a:
+    //            print('a');
+    //            continue label;
+    //          case E.b:
+    //            print('b');
+    //          label:
+    //          case E.c:
+    //            print('c');
+    //        }
+    //      }
+    //
+    //    is encoded as
+    //
+    //      enum E { a, b }
+    //      method(E e) {
+    //        #outer:
+    //        switch (e) { // SwitchStatement
+    //          case E.a:
+    //            print('a');
+    //            continue label;
+    //          case E.a:
+    //            print('a');
+    //            break #outer;
+    //          label:
+    //          case E.b:
+    //            print('b');
+    //        }
+    //      }
+    //
+    // 2) Otherwise, if the pattern switch statement does _not_ contain continue
+    //    switch statements, we generate a sequence of blocks containing each
+    //    case, surrounded by labeled block.
+    //
+    //    For instance:
+    //
+    //      method(o) {
+    //        switch (o) { // PatternSwitchStatement
+    //          case [var a]:
+    //            print(a);
+    //          case {1: var a}:
+    //            print(a);
+    //        }
+    //      }
+    //
+    //    is encoded as
+    //
+    //      method(o) {
+    //        #outer: {
+    //          { // case [var a]:
+    //            var a;
+    //            if (o is List<dynamic> &&
+    //                o.length == 1 &&
+    //                let # = a = o[0] in true) {
+    //              print(a);
+    //              break #outer;
+    //            }
+    //          }
+    //          { // case {1: var a}:
+    //            var a;
+    //            if (o is Map<dynamic, dynamic> &&
+    //                o.length == 1 &&
+    //                o.containsKey(1) &&
+    //                let # = a = o[1] in true) {
+    //              print(a);
+    //              break #outer;
+    //            }
+    //          }
+    //        } // end of #outer
+    //      }
+    //
+    // 3) Otherwise, we generate a sequence of blocks containing each case,
+    //    surrounded by labeled block, followed by a switch statement containing
+    //    the bodies for switch cases that are targets of a continue.
+    //
+    //    For instance:
+    //
+    //      method(o) {
+    //        switch (o) { // PatternSwitchStatement
+    //          case [var a]:
+    //          case [_, var a]:
+    //            print(a);
+    //            continue label1;
+    //          case {1: var a}:
+    //            print(a);
+    //          label1:
+    //          case 'b':
+    //            print('b');
+    //            continue label2;
+    //          label2:
+    //          case 'c':
+    //            print('c');
+    //          case 'd':
+    //            print('d');
+    //        }
+    //      }
+    //
+    //    is encoded as
+    //
+    //      method(o) {
+    //        #outer: {
+    //          int #switchIndex = -1;
+    //          #inner: {
+    //            { // case [var a]:
+    //              var a#0;
+    //              var a#1;
+    //              var #t1;
+    //              if (o is List<dynamic> &&
+    //                  o.length == 1 &&
+    //                  let # = #t1 = a = o[0] in true ||
+    //                  o is List<dynamic &&
+    //                  o.length == 2 &&
+    //                  let # = #t1 = a = o[1] in true) {
+    //                var a = #t1;
+    //                print(a);
+    //                #switchIndex = 0;
+    //                break #inner;
+    //              }
+    //            }
+    //            { // case {1: var a}:
+    //              var a;
+    //              if (o is Map<dynamic, dynamic> &&
+    //                  o.length == 1 &&
+    //                  o.containsKey(1) &&
+    //                  let a = o[1] in true) {
+    //                print(a);
+    //                break #outer;
+    //              }
+    //            }
+    //            { // case 'b':
+    //              if ('b' == o) {
+    //                #switchIndex = 0;
+    //                break #inner;
+    //              }
+    //            }
+    //            { // case 'c':
+    //              if ('c'' == o) {
+    //                #switchIndex = 1;
+    //                break #inner;
+    //              }
+    //            }
+    //            { // case 'd':
+    //              if ('d' == o) {
+    //                print('d');
+    //                break #outer;
+    //              }
+    //            }
+    //          } // end of #inner
+    //          switch (#switchIndex) {
+    //            label1:
+    //            case 0: // body for case 'b':
+    //              print('b');
+    //              continue label2;
+    //            label2:
+    //            case 1: // body for case 'c':
+    //              print('c');
+    //              break #outer;
+    //          }
+    //        } // end of #outer
+    //      }
+
+    // Instead calling `super.visitPatternSwitchStatement` to transform the
+    // children of the [node], we transform its expression and the children of
+    // its [PatternSwitchCase]s directly to collect information about continue
+    // statements.
+    node.expression = transform(node.expression)..parent = node;
 
     DartType scrutineeType = node.expressionType!;
-    MatchingCache matchingCache = createMatchingCache();
-    MatchingExpressionVisitor matchingExpressionVisitor =
-        new MatchingExpressionVisitor(matchingCache);
-    CacheableExpression matchedExpression =
-        matchingCache.createRootExpression(node.expression, scrutineeType);
-
-    // matchResultVariable: int RVAR = -1;
-    VariableDeclaration matchResultVariable = createInitializedVariable(
-        createIntLiteral(-1, fileOffset: node.fileOffset),
-        typeEnvironment.coreTypes.intNonNullableRawType,
-        fileOffset: node.fileOffset);
-
-    List<Statement> replacementStatements = [];
-
-    List<SwitchCase> replacementCases = [];
-
-    List<VariableDeclaration> declaredVariableHelpers = [];
-
-    List<Statement> ifStatements = [];
 
+    // If `true`, the switch expressions consists solely of guard-less constant
+    // patterns whose value has a primitive equals method. For this case we
+    // generate switch using an ordinary switch statement.
+    bool primitiveEqualConstantsOnly = true;
     bool hasContinue = false;
-    for (PatternSwitchCase switchCase in node.cases) {
-      if (switchCase.labelUsers.isNotEmpty) {
-        hasContinue = true;
-        break;
-      }
-    }
-    List<List<DelayedExpression>> matchingExpressions =
-        new List.generate(node.cases.length, (int caseIndex) {
-      PatternSwitchCase switchCase = node.cases[caseIndex];
-      return new List.generate(switchCase.patternGuards.length,
-          (int headIndex) {
-        Pattern pattern = switchCase.patternGuards[headIndex].pattern;
-        DelayedExpression matchingExpression =
-            matchingExpressionVisitor.visitPattern(pattern, matchedExpression);
-        matchingExpression.registerUse();
-        return matchingExpression;
-      });
-    });
 
-    Map<String, List<VariableDeclaration>> declaredVariablesByName = {};
-
-    for (int caseIndex = 0; caseIndex < node.cases.length; caseIndex++) {
-      PatternSwitchCase switchCase = node.cases[caseIndex];
-      Statement body = switchCase.body;
-
-      // TODO(cstefantsova): Make sure an error is reported if the variables
-      // declared in the heads aren't compatible to each other.
-      Map<String, VariableDeclaration> caseDeclaredVariableHelpersByName = {
-        for (VariableDeclaration variable in switchCase.jointVariables)
-          variable.name!: createUninitializedVariable(const DynamicType(),
-              fileOffset: node.fileOffset)
-      };
-
-      Expression? caseCondition;
-      for (int headIndex = 0;
-          headIndex < switchCase.patternGuards.length;
-          headIndex++) {
-        PatternGuard patternGuard = switchCase.patternGuards[headIndex];
-        Pattern pattern = patternGuard.pattern;
-        Expression? guard = patternGuard.guard;
-
-        replacementStatements.addAll(pattern.declaredVariables);
-
-        for (VariableDeclaration variable in pattern.declaredVariables) {
-          (declaredVariablesByName[variable.name!] ??= []).add(variable);
-        }
-
-        DelayedExpression matchingExpression =
-            matchingExpressions[caseIndex][headIndex];
-        Expression headCondition =
-            matchingExpression.createExpression(typeEnvironment);
-        if (guard != null) {
-          headCondition = createAndExpression(headCondition, guard,
-              fileOffset: guard.fileOffset);
-        }
-
-        for (VariableDeclaration declaredVariable
-            in pattern.declaredVariables) {
-          String variableName = declaredVariable.name!;
-
-          VariableDeclaration? variableHelper =
-              caseDeclaredVariableHelpersByName[variableName];
-          if (variableHelper != null) {
-            // headCondition: `headCondition` &&
-            //     let _ = `variableHelper` = `declaredVariable` in true
-            headCondition = createAndExpression(
-                headCondition,
-                createLetEffect(
-                    effect: createVariableSet(
-                        variableHelper, createVariableGet(declaredVariable),
-                        fileOffset: node.fileOffset),
-                    result: createBoolLiteral(true,
-                        fileOffset: declaredVariable.fileOffset)),
-                fileOffset: declaredVariable.fileOffset);
-          }
-        }
-
-        if (caseCondition != null) {
-          caseCondition = createOrExpression(caseCondition, headCondition,
-              fileOffset: node.fileOffset);
-        } else {
-          caseCondition = headCondition;
-        }
-      }
-
-      if (switchCase.isDefault) {
-        if (caseCondition != null) {
-          caseCondition = createOrExpression(caseCondition,
-              createBoolLiteral(true, fileOffset: switchCase.fileOffset),
-              fileOffset: switchCase.fileOffset);
-        }
-      }
-
-      declaredVariableHelpers.addAll(caseDeclaredVariableHelpersByName.values);
-
-      for (VariableDeclaration jointVariable in switchCase.jointVariables) {
-        // In case of [InvalidExpression], there's an error associated with
-        // the variable, and it shouldn't be initialized.
-        if (jointVariable.initializer is! InvalidExpression) {
-          // `jointVariable`:
-          //     `jointVariable` =
-          //         `declaredVariableHelper`{`declaredVariable.type`}
-          //   ==> `jointVariable` = HVAR{`declaredVariable.type`}
-          jointVariable.initializer = createVariableGet(
-              caseDeclaredVariableHelpersByName[jointVariable.name!]!,
-              promotedType: jointVariable.type)
-            ..parent = jointVariable;
-        }
-      }
-      Statement caseBlock;
-      if (hasContinue) {
-        // setMatchResult: `matchResultVariable` = `caseIndex`;
-        //   ==> RVAR = `caseIndex`;
-        Statement setMatchResult = createExpressionStatement(createVariableSet(
-            matchResultVariable,
-            createIntLiteral(caseIndex, fileOffset: node.fileOffset),
-            fileOffset: node.fileOffset));
-
-        caseBlock = setMatchResult;
-
-        SwitchCase replacementCase = createSwitchCase(
-            [createIntLiteral(caseIndex, fileOffset: node.fileOffset)],
-            [node.fileOffset],
-            createBlock([
-              ...switchCase.jointVariables,
-              if (body is! Block || body.statements.isNotEmpty) body
-            ], fileOffset: node.fileOffset),
-            isDefault: switchCase.isDefault,
-            fileOffset: node.fileOffset);
-
-        for (Statement labelUser in switchCase.labelUsers) {
-          if (labelUser is ContinueSwitchStatement) {
-            labelUser.target = replacementCase;
-          } else {
-            // TODO(cstefantsova): Handle other label user types.
-            return throw new UnsupportedError(
-                "Unexpected label user: ${labelUser.runtimeType}");
-          }
-        }
-
-        replacementCases.add(replacementCase);
-      } else {
-        caseBlock = createBlock([
-          ...switchCase.jointVariables,
-          if (body is! Block || body.statements.isNotEmpty) body
-        ], fileOffset: switchCase.fileOffset);
-      }
-
-      if (caseCondition != null) {
-        ifStatements.add(createIfStatement(caseCondition, caseBlock,
-            fileOffset: switchCase.fileOffset));
-      } else {
-        ifStatements.add(caseBlock);
-      }
-    }
-
-    // TODO(johnniwinther): Find a better way to avoid name clashes between
-    // cases.
-    for (List<VariableDeclaration> variables
-        in declaredVariablesByName.values) {
-      if (variables.length > 1) {
-        for (int i = 1; i < variables.length; i++) {
-          variables[i].name = '${variables[i].name}${"#$i"}';
-        }
-      }
-    }
-
-    Statement? ifStatement;
-    for (Statement statement in ifStatements.reversed) {
-      if (statement is IfStatement) {
-        statement.otherwise = ifStatement?..parent = statement;
-      }
-      ifStatement = statement;
-    }
-
-    if (hasContinue) {
-      replacementStatements = [
-        matchResultVariable,
-        ...replacementStatements,
-        ...matchingCache.declarations,
-        ...declaredVariableHelpers,
-        if (ifStatement != null) ifStatement,
-        createSwitchStatement(
-            createVariableGet(matchResultVariable), replacementCases,
-            isExplicitlyExhaustive: false, fileOffset: node.fileOffset)
-      ];
-    } else {
-      replacementStatements = [
-        ...replacementStatements,
-        ...matchingCache.declarations,
-        ...declaredVariableHelpers,
-        if (ifStatement != null) ifStatement,
-      ];
-    }
-
-    Statement replacementStatement;
-    if (replacementStatements.length == 1) {
-      replacementStatement = replacementStatements.first;
-    } else {
-      replacementStatement = new Block(replacementStatements)
-        ..fileOffset = node.fileOffset;
-    }
-    // TODO(johnniwinther): Remove this work-around for the `libraryOf`
-    //  function.
-    replacementStatement..parent = node.parent;
-
-    List<PatternGuard> patternGuards = [];
+    Map<PatternSwitchCase, int> switchCaseIndex = {};
     // TODO(johnniwinther): Use `PatternSwitchStatement.hasDefault` instead.
     bool hasDefault = false;
     for (PatternSwitchCase switchCase in node.cases) {
-      patternGuards.addAll(switchCase.patternGuards);
       if (switchCase.isDefault) {
         hasDefault = true;
       }
+      if (switchCase.labelUsers.isNotEmpty) {
+        hasContinue = true;
+        switchCaseIndex[switchCase] = switchCaseIndex.length;
+      }
+      // Constant evaluate the pattern guards.
+      transformList(switchCase.patternGuards, switchCase, dummyPatternGuard);
+      if (primitiveEqualConstantsOnly) {
+        for (PatternGuard patternGuard in switchCase.patternGuards) {
+          if (patternGuard.guard != null) {
+            primitiveEqualConstantsOnly = false;
+          } else {
+            Pattern pattern = patternGuard.pattern;
+            if (pattern is ConstantPattern) {
+              Constant constant = pattern.value!;
+              if (!constantEvaluator.hasPrimitiveEqual(constant,
+                  allowPseudoPrimitive: false)) {
+                primitiveEqualConstantsOnly = false;
+              }
+            } else {
+              primitiveEqualConstantsOnly = false;
+            }
+          }
+        }
+      }
     }
-    _checkExhaustiveness(
-        node, replacementStatement, scrutineeType, patternGuards,
-        hasDefault: hasDefault,
-        mustBeExhaustive: computeIsAlwaysExhaustiveType(
-            scrutineeType, typeEnvironment.coreTypes),
-        fileOffset: node.expression.fileOffset);
 
-    // TODO(johnniwinther): Remove this work-around for the `libraryOf`
-    //  function.
-    replacementStatement..parent = node.parent;
+    bool isAlwaysExhaustiveType =
+        computeIsAlwaysExhaustiveType(scrutineeType, typeEnvironment.coreTypes);
+
+    Statement replacement;
+    if (primitiveEqualConstantsOnly) {
+      List<SwitchCase> switchCases = [];
+      for (PatternSwitchCase patternSwitchCase in node.cases) {
+        patternSwitchCase.body = transform(patternSwitchCase.body)
+          ..parent = patternSwitchCase;
+
+        List<int> expressionOffsets = [];
+        List<Expression> expressions = [];
+        for (PatternGuard patternGuard in patternSwitchCase.patternGuards) {
+          ConstantPattern constantPattern =
+              patternGuard.pattern as ConstantPattern;
+          expressionOffsets.add(constantPattern.fileOffset);
+          expressions.add(new ConstantExpression(
+              constantPattern.value!, constantPattern.expressionType!)
+            ..fileOffset = constantPattern.expression.fileOffset);
+        }
+        SwitchCase switchCase = new SwitchCase(
+            expressions, expressionOffsets, patternSwitchCase.body,
+            isDefault: patternSwitchCase.isDefault)
+          ..fileOffset = patternSwitchCase.fileOffset
+          ..fileOffset;
+        switchCases.add(switchCase);
+        for (Statement labelUser in patternSwitchCase.labelUsers) {
+          (labelUser as ContinueSwitchStatement).target = switchCase;
+        }
+      }
+      replacement = createSwitchStatement(node.expression, switchCases,
+          isExplicitlyExhaustive: !hasDefault && isAlwaysExhaustiveType,
+          fileOffset: node.fileOffset);
+    } else {
+      // matchResultVariable: int RVAR = -1;
+      VariableDeclaration matchResultVariable = createInitializedVariable(
+          createIntLiteral(-1, fileOffset: node.fileOffset),
+          typeEnvironment.coreTypes.intNonNullableRawType,
+          fileOffset: node.fileOffset);
+      LabeledStatement innerLabeledStatement =
+          createLabeledStatement(dummyStatement, fileOffset: node.fileOffset);
+
+      _PatternSwitchStatementInfo info = new _PatternSwitchStatementInfo(
+          matchResultVariable, innerLabeledStatement, switchCaseIndex);
+      _currentPatternSwitchStatementInfoMap[node] = info;
+      for (PatternSwitchCase switchCase in node.cases) {
+        info.currentSwitchCase = switchCase;
+        switchCase.body = transform(switchCase.body)..parent = switchCase;
+      }
+      _currentPatternSwitchStatementInfoMap.remove(node);
+
+      MatchingCache matchingCache = createMatchingCache();
+      MatchingExpressionVisitor matchingExpressionVisitor =
+          new MatchingExpressionVisitor(matchingCache);
+      CacheableExpression matchedExpression =
+          matchingCache.createRootExpression(node.expression, scrutineeType);
+
+      List<Statement> replacementStatements = [];
+
+      List<SwitchCase> replacementCases = [];
+
+      List<VariableDeclaration> declaredVariableHelpers = [];
+
+      List<Statement> cases = [];
+
+      List<List<DelayedExpression>> matchingExpressions =
+          new List.generate(node.cases.length, (int caseIndex) {
+        PatternSwitchCase switchCase = node.cases[caseIndex];
+        return new List.generate(switchCase.patternGuards.length,
+            (int headIndex) {
+          Pattern pattern = switchCase.patternGuards[headIndex].pattern;
+          DelayedExpression matchingExpression = matchingExpressionVisitor
+              .visitPattern(pattern, matchedExpression);
+          matchingExpression.registerUse();
+          return matchingExpression;
+        });
+      });
+
+      // TODO(johnniwinther): Remove this when an error is reported in case of
+      // variables and labels on the same switch case.
+      Map<String, List<VariableDeclaration>> declaredVariablesByName = {};
+
+      for (int caseIndex = 0; caseIndex < node.cases.length; caseIndex++) {
+        PatternSwitchCase switchCase = node.cases[caseIndex];
+        Statement body = switchCase.body;
+
+        // TODO(cstefantsova): Make sure an error is reported if the variables
+        // declared in the heads aren't compatible to each other.
+        Map<String, VariableDeclaration> caseDeclaredVariableHelpersByName = {
+          for (VariableDeclaration variable in switchCase.jointVariables)
+            variable.name!: createUninitializedVariable(const DynamicType(),
+                fileOffset: node.fileOffset)
+        };
+
+        bool isContinueTarget = switchCaseIndex.containsKey(switchCase);
+
+        List<VariableDeclaration> caseVariables = [];
+
+        // TODO(johnniwinther): Is there a way to avoid these name clashes?
+        Map<String, List<VariableDeclaration>> caseVariablesByName = {};
+
+        Expression? caseCondition;
+        for (int headIndex = 0;
+            headIndex < switchCase.patternGuards.length;
+            headIndex++) {
+          PatternGuard patternGuard = switchCase.patternGuards[headIndex];
+          Pattern pattern = patternGuard.pattern;
+          Expression? guard = patternGuard.guard;
+
+          if (isContinueTarget) {
+            // TODO(johnniwinther): In this case it should be an error to have
+            // any variables. This is not currently reported.
+            replacementStatements.addAll(pattern.declaredVariables);
+
+            for (VariableDeclaration variable in pattern.declaredVariables) {
+              (declaredVariablesByName[variable.name!] ??= []).add(variable);
+            }
+          } else {
+            for (VariableDeclaration variable in pattern.declaredVariables) {
+              (caseVariablesByName[variable.name!] ??= []).add(variable);
+            }
+            caseVariables.addAll(pattern.declaredVariables);
+          }
+
+          DelayedExpression matchingExpression =
+              matchingExpressions[caseIndex][headIndex];
+          Expression headCondition =
+              matchingExpression.createExpression(typeEnvironment);
+          if (guard != null) {
+            headCondition = createAndExpression(headCondition, guard,
+                fileOffset: guard.fileOffset);
+          }
+
+          for (VariableDeclaration declaredVariable
+              in pattern.declaredVariables) {
+            String variableName = declaredVariable.name!;
+
+            VariableDeclaration? variableHelper =
+                caseDeclaredVariableHelpersByName[variableName];
+            if (variableHelper != null) {
+              // headCondition: `headCondition` &&
+              //     let _ = `variableHelper` = `declaredVariable` in true
+              headCondition = createAndExpression(
+                  headCondition,
+                  createLetEffect(
+                      effect: createVariableSet(
+                          variableHelper, createVariableGet(declaredVariable),
+                          fileOffset: node.fileOffset),
+                      result: createBoolLiteral(true,
+                          fileOffset: declaredVariable.fileOffset)),
+                  fileOffset: declaredVariable.fileOffset);
+            }
+          }
+
+          if (caseCondition != null) {
+            caseCondition = createOrExpression(caseCondition, headCondition,
+                fileOffset: node.fileOffset);
+          } else {
+            caseCondition = headCondition;
+          }
+        }
+
+        if (switchCase.isDefault) {
+          if (caseCondition != null) {
+            caseCondition = createOrExpression(caseCondition,
+                createBoolLiteral(true, fileOffset: switchCase.fileOffset),
+                fileOffset: switchCase.fileOffset);
+          }
+        }
+
+        for (List<VariableDeclaration> variables
+            in caseVariablesByName.values) {
+          if (variables.length > 1) {
+            for (int i = 0; i < variables.length; i++) {
+              VariableDeclaration variable = variables[i];
+              variable.isLowered = true;
+              variable.name = createJoinedIntermediateName(variable.name!, i);
+            }
+          }
+        }
+
+        declaredVariableHelpers
+            .addAll(caseDeclaredVariableHelpersByName.values);
+
+        for (VariableDeclaration jointVariable in switchCase.jointVariables) {
+          // In case of [InvalidExpression], there's an error associated with
+          // the variable, and it shouldn't be initialized.
+          if (jointVariable.initializer is! InvalidExpression) {
+            // `jointVariable`:
+            //     `jointVariable` =
+            //         `declaredVariableHelper`{`declaredVariable.type`}
+            //   ==> `jointVariable` = HVAR{`declaredVariable.type`}
+            jointVariable.initializer = createVariableGet(
+                caseDeclaredVariableHelpersByName[jointVariable.name!]!,
+                promotedType: jointVariable.type)
+              ..parent = jointVariable;
+          }
+        }
+        Statement caseBlock;
+        if (isContinueTarget) {
+          int continueTargetIndex = switchCaseIndex[switchCase]!;
+
+          // setMatchResult: `matchResultVariable` = `caseIndex`;
+          //   ==> RVAR = `caseIndex`;
+          Statement setMatchResult = createExpressionStatement(
+              createVariableSet(
+                  matchResultVariable,
+                  createIntLiteral(continueTargetIndex,
+                      fileOffset: node.fileOffset),
+                  fileOffset: node.fileOffset));
+
+          caseBlock = createBlock([
+            setMatchResult,
+            createBreakStatement(innerLabeledStatement,
+                fileOffset: switchCase.fileOffset),
+          ], fileOffset: switchCase.fileOffset);
+
+          SwitchCase replacementCase = createSwitchCase(
+              [
+                createIntLiteral(continueTargetIndex,
+                    fileOffset: node.fileOffset)
+              ],
+              [
+                node.fileOffset
+              ],
+              createBlock([
+                ...switchCase.jointVariables,
+                if (body is! Block || body.statements.isNotEmpty) body
+              ], fileOffset: node.fileOffset),
+              isDefault: switchCase.isDefault,
+              fileOffset: node.fileOffset);
+
+          for (Statement labelUser in switchCase.labelUsers) {
+            if (labelUser is ContinueSwitchStatement) {
+              labelUser.target = replacementCase;
+            } else {
+              // TODO(cstefantsova): Handle other label user types.
+              return throw new UnsupportedError(
+                  "Unexpected label user: ${labelUser.runtimeType}");
+            }
+          }
+
+          replacementCases.add(replacementCase);
+        } else {
+          caseBlock = createBlock([
+            ...switchCase.jointVariables,
+            if (body is! Block || body.statements.isNotEmpty) body
+          ], fileOffset: switchCase.fileOffset);
+        }
+
+        if (caseCondition != null) {
+          caseBlock = createIfStatement(caseCondition, caseBlock,
+              fileOffset: switchCase.fileOffset);
+        }
+        cases.add(createBlock([...caseVariables, caseBlock],
+            fileOffset: switchCase.fileOffset));
+      }
+
+      // TODO(johnniwinther): Find a better way to avoid name clashes between
+      // cases.
+      for (List<VariableDeclaration> variables
+          in declaredVariablesByName.values) {
+        if (variables.length > 1) {
+          for (int i = 1; i < variables.length; i++) {
+            variables[i].name = '${variables[i].name}${"#$i"}';
+          }
+        }
+      }
+
+      if (hasContinue) {
+        Statement casesBlock = createBlock(cases, fileOffset: node.fileOffset);
+        innerLabeledStatement.body = casesBlock..parent = innerLabeledStatement;
+        replacementStatements = [
+          matchResultVariable,
+          ...replacementStatements,
+          ...matchingCache.declarations,
+          ...declaredVariableHelpers,
+          innerLabeledStatement,
+          createSwitchStatement(
+              createVariableGet(matchResultVariable), replacementCases,
+              isExplicitlyExhaustive: false, fileOffset: node.fileOffset)
+        ];
+      } else {
+        replacementStatements = [
+          ...replacementStatements,
+          ...matchingCache.declarations,
+          ...declaredVariableHelpers,
+          ...cases,
+        ];
+      }
+
+      if (replacementStatements.length == 1) {
+        replacement = replacementStatements.first;
+      } else {
+        replacement = new Block(replacementStatements)
+          ..fileOffset = node.fileOffset;
+      }
+    }
+    List<PatternGuard> patternGuards = [];
+    for (PatternSwitchCase switchCase in node.cases) {
+      patternGuards.addAll(switchCase.patternGuards);
+    }
+    _checkExhaustiveness(node, replacement, scrutineeType, patternGuards,
+        hasDefault: hasDefault,
+        mustBeExhaustive: isAlwaysExhaustiveType,
+        fileOffset: node.expression.fileOffset);
+    // TODO(johnniwinther): Avoid this work-around for [getFileUri].
+    replacement.parent = node.parent;
     // TODO(johnniwinther): Avoid transform of [replacement] by generating
     //  already constant evaluated lowering.
-    return transform(replacementStatement);
+    return transform(replacement);
   }
 
   void _checkExhaustiveness(TreeNode node, TreeNode replacement,
@@ -1173,7 +1492,6 @@ class ConstantsTransformer extends RemovingTransformer {
   @override
   TreeNode visitSwitchStatement(
       SwitchStatement node, TreeNode? removalSentinel) {
-    //return _handleExhaustiveness(node, node, () {
     TreeNode result = super.visitSwitchStatement(node, removalSentinel);
     Library library = _staticTypeContext!.enclosingLibrary;
     // ignore: unnecessary_null_comparison
@@ -1198,7 +1516,6 @@ class ConstantsTransformer extends RemovingTransformer {
       }
     }
     return result;
-    //});
   }
 
   @override
@@ -1238,9 +1555,8 @@ class ConstantsTransformer extends RemovingTransformer {
     } else {
       result = replacementStatements.single;
     }
-    // TODO(johnniwinther): Remove this work-around for the `libraryOf`
-    //  function.
-    result..parent = node.parent;
+    // TODO(johnniwinther): Avoid this work-around for [getFileUri].
+    result.parent = node.parent;
     return transform(result);
   }
 
@@ -1291,9 +1607,8 @@ class ConstantsTransformer extends RemovingTransformer {
 
     _InlinedBlock inlinedBlock = new _InlinedBlock(replacementStatements)
       ..fileOffset = node.fileOffset;
-    // TODO(johnniwinther): Remove this work-around for the `libraryOf`
-    //  function.
-    inlinedBlock..parent = node.parent;
+    // TODO(johnniwinther): Avoid this work-around for [getFileUri].
+    inlinedBlock.parent = node.parent;
     transformStatementList(replacementStatements, inlinedBlock);
     return inlinedBlock;
   }
@@ -1340,9 +1655,8 @@ class ConstantsTransformer extends RemovingTransformer {
         createBlock(replacementStatements, fileOffset: node.fileOffset),
         readMatchedExpression,
         fileOffset: node.fileOffset);
-    // TODO(johnniwinther): Remove this work-around for the `libraryOf`
-    //  function.
-    result..parent = node.parent;
+    // TODO(johnniwinther): Avoid this work-around for [getFileUri].
+    result.parent = node.parent;
     return transform(result);
   }
 
@@ -1400,90 +1714,147 @@ class ConstantsTransformer extends RemovingTransformer {
     super.visitSwitchExpression(node, removalSentinel);
 
     DartType scrutineeType = node.expressionType!;
-    MatchingCache matchingCache = createMatchingCache();
-    MatchingExpressionVisitor matchingExpressionVisitor =
-        new MatchingExpressionVisitor(matchingCache);
-    CacheableExpression matchedExpression =
-        matchingCache.createRootExpression(node.expression, scrutineeType);
 
-    // valueVariable: `valueType` valueVariable;
-    VariableDeclaration valueVariable = createUninitializedVariable(
-        node.staticType!,
-        fileOffset: node.fileOffset);
-
-    List<Statement> replacementStatements = [];
-
-    List<VariableDeclaration> declaredVariableHelpers = [];
-
-    List<IfStatement> ifStatements = [];
-
-    Map<String, List<VariableDeclaration>> declaredVariablesByName = {};
-
-    List<DelayedExpression> matchingExpressions =
-        new List.generate(node.cases.length, (int caseIndex) {
-      SwitchExpressionCase switchCase = node.cases[caseIndex];
-      DelayedExpression matchingExpression = matchingExpressionVisitor
-          .visitPattern(switchCase.patternGuard.pattern, matchedExpression);
-      matchingExpression.registerUse();
-      return matchingExpression;
-    });
-
-    for (int caseIndex = 0; caseIndex < node.cases.length; caseIndex++) {
-      SwitchExpressionCase switchCase = node.cases[caseIndex];
-      Expression body = switchCase.expression;
-
-      PatternGuard patternGuard = switchCase.patternGuard;
-      Pattern pattern = patternGuard.pattern;
-      Expression? guard = patternGuard.guard;
-
-      replacementStatements.addAll(pattern.declaredVariables);
-
-      for (VariableDeclaration variable in pattern.declaredVariables) {
-        (declaredVariablesByName[variable.name!] ??= []).add(variable);
-      }
-
-      DelayedExpression matchingExpression = matchingExpressions[caseIndex];
-      Expression caseCondition =
-          matchingExpression.createExpression(typeEnvironment);
-      if (guard != null) {
-        caseCondition = createAndExpression(caseCondition, guard,
-            fileOffset: guard.fileOffset);
-      }
-
-      ifStatements.add(createIfStatement(
-          caseCondition,
-          createExpressionStatement(createVariableSet(valueVariable, body,
-              fileOffset: node.fileOffset)),
-          fileOffset: switchCase.fileOffset));
-    }
-
-    // TODO(johnniwinther): Find a better way to avoid name clashes between
-    // cases.
-    for (List<VariableDeclaration> variables
-        in declaredVariablesByName.values) {
-      if (variables.length > 1) {
-        for (int i = 1; i < variables.length; i++) {
-          variables[i].name = '${variables[i].name}${"#$i"}';
+    // If `true`, the switch expressions consists solely of guard-less constant
+    // patterns whose value has a primitive equals method. For this case we
+    // generate switch using an ordinary switch statement.
+    bool primitiveEqualConstantsOnly = true;
+    for (SwitchExpressionCase switchCase in node.cases) {
+      if (primitiveEqualConstantsOnly) {
+        PatternGuard patternGuard = switchCase.patternGuard;
+        if (patternGuard.guard != null) {
+          primitiveEqualConstantsOnly = false;
+          break;
+        } else {
+          Pattern pattern = patternGuard.pattern;
+          if (pattern is ConstantPattern) {
+            Constant constant = pattern.value!;
+            if (!constantEvaluator.hasPrimitiveEqual(constant,
+                allowPseudoPrimitive: false)) {
+              primitiveEqualConstantsOnly = false;
+              break;
+            }
+          } else {
+            primitiveEqualConstantsOnly = false;
+            break;
+          }
         }
       }
     }
 
-    IfStatement? ifStatement;
-    for (IfStatement statement in ifStatements.reversed) {
-      statement.otherwise = ifStatement?..parent = statement;
-      ifStatement = statement;
-    }
+    Expression replacement;
+    if (primitiveEqualConstantsOnly) {
+      VariableDeclaration valueVariable = createUninitializedVariable(
+          node.staticType!,
+          fileOffset: node.fileOffset);
 
-    Expression replacement = createBlockExpression(
-        createBlock([
-          valueVariable,
-          ...replacementStatements,
-          ...matchingCache.declarations,
-          ...declaredVariableHelpers,
-          if (ifStatement != null) ifStatement,
-        ], fileOffset: node.fileOffset),
-        createVariableGet(valueVariable),
-        fileOffset: node.fileOffset);
+      LabeledStatement labeledStatement =
+          createLabeledStatement(dummyStatement, fileOffset: node.fileOffset);
+      List<SwitchCase> switchCases = [];
+      for (SwitchExpressionCase switchExpressionCase in node.cases) {
+        List<int> expressionOffsets = [];
+        List<Expression> expressions = [];
+        PatternGuard patternGuard = switchExpressionCase.patternGuard;
+        ConstantPattern constantPattern =
+            patternGuard.pattern as ConstantPattern;
+        expressionOffsets.add(constantPattern.fileOffset);
+        expressions.add(new ConstantExpression(
+            constantPattern.value!, constantPattern.expressionType!)
+          ..fileOffset = constantPattern.expression.fileOffset);
+
+        SwitchCase switchCase = new SwitchCase(
+            expressions,
+            expressionOffsets,
+            createBlock([
+              createExpressionStatement(createVariableSet(
+                  valueVariable, switchExpressionCase.expression,
+                  fileOffset: switchExpressionCase.expression.fileOffset)),
+              createBreakStatement(labeledStatement,
+                  fileOffset: switchExpressionCase.expression.fileOffset),
+            ], fileOffset: switchExpressionCase.fileOffset),
+            isDefault: false)
+          ..fileOffset = switchExpressionCase.fileOffset
+          ..fileOffset;
+        switchCases.add(switchCase);
+      }
+      labeledStatement.body = createSwitchStatement(
+          node.expression, switchCases,
+          isExplicitlyExhaustive: true, fileOffset: node.fileOffset)
+        ..parent = labeledStatement;
+      replacement = createBlockExpression(
+          createBlock([
+            valueVariable,
+            labeledStatement,
+          ], fileOffset: node.fileOffset),
+          createVariableGet(valueVariable),
+          fileOffset: node.fileOffset);
+    } else {
+      MatchingCache matchingCache = createMatchingCache();
+      MatchingExpressionVisitor matchingExpressionVisitor =
+          new MatchingExpressionVisitor(matchingCache);
+      CacheableExpression matchedExpression =
+          matchingCache.createRootExpression(node.expression, scrutineeType);
+
+      LabeledStatement labeledStatement =
+          createLabeledStatement(dummyStatement, fileOffset: node.fileOffset);
+
+      // valueVariable: `valueType` valueVariable;
+      VariableDeclaration valueVariable = createUninitializedVariable(
+          node.staticType!,
+          fileOffset: node.fileOffset);
+
+      List<Statement> cases = [];
+
+      List<DelayedExpression> matchingExpressions =
+          new List.generate(node.cases.length, (int caseIndex) {
+        SwitchExpressionCase switchCase = node.cases[caseIndex];
+        DelayedExpression matchingExpression = matchingExpressionVisitor
+            .visitPattern(switchCase.patternGuard.pattern, matchedExpression);
+        matchingExpression.registerUse();
+        return matchingExpression;
+      });
+
+      for (int caseIndex = 0; caseIndex < node.cases.length; caseIndex++) {
+        SwitchExpressionCase switchCase = node.cases[caseIndex];
+        Expression body = switchCase.expression;
+
+        PatternGuard patternGuard = switchCase.patternGuard;
+        Pattern pattern = patternGuard.pattern;
+        Expression? guard = patternGuard.guard;
+
+        DelayedExpression matchingExpression = matchingExpressions[caseIndex];
+        Expression caseCondition =
+            matchingExpression.createExpression(typeEnvironment);
+        if (guard != null) {
+          caseCondition = createAndExpression(caseCondition, guard,
+              fileOffset: guard.fileOffset);
+        }
+
+        cases.add(createBlock([
+          ...pattern.declaredVariables,
+          createIfStatement(
+              caseCondition,
+              createBlock([
+                createExpressionStatement(createVariableSet(valueVariable, body,
+                    fileOffset: node.fileOffset)),
+                createBreakStatement(labeledStatement,
+                    fileOffset: switchCase.fileOffset),
+              ], fileOffset: switchCase.fileOffset),
+              fileOffset: switchCase.fileOffset)
+        ], fileOffset: switchCase.fileOffset));
+      }
+
+      labeledStatement.body = createBlock(cases, fileOffset: node.fileOffset)
+        ..parent = labeledStatement;
+      replacement = createBlockExpression(
+          createBlock([
+            valueVariable,
+            ...matchingCache.declarations,
+            labeledStatement,
+          ], fileOffset: node.fileOffset),
+          createVariableGet(valueVariable),
+          fileOffset: node.fileOffset);
+    }
 
     List<PatternGuard> patternGuards = [];
     for (SwitchExpressionCase switchCase in node.cases) {
@@ -1494,9 +1865,8 @@ class ConstantsTransformer extends RemovingTransformer {
         mustBeExhaustive: true,
         fileOffset: node.expression.fileOffset);
 
-    // TODO(johnniwinther): Remove this work-around for the `libraryOf`
-    //  function.
-    replacement..parent = node.parent;
+    // TODO(johnniwinther): Avoid this work-around for [getFileUri].
+    replacement.parent = node.parent;
     // TODO(johnniwinther): Avoid transform of [replacement] by generating
     //  already constant evaluated lowering.
     return transform(replacement);
@@ -1704,6 +2074,12 @@ class ConstantEvaluator implements ExpressionVisitor<Constant> {
 
   late Map<Class, bool> primitiveEqualCache;
 
+  /// Classes that are considered having a primitive equals but where the
+  /// `operator ==` is actually defined through as custom method. For instance
+  /// the `Symbol` class. When lowering a pattern switch to a regular switch,
+  /// these are not allowed.
+  late Set<Class> pseudoPrimitiveClasses;
+
   final NullConstant nullConstant = new NullConstant();
   final BoolConstant trueConstant = new BoolConstant(true);
   final BoolConstant falseConstant = new BoolConstant(false);
@@ -1743,6 +2119,11 @@ class ConstantEvaluator implements ExpressionVisitor<Constant> {
           "ConstantsBackend does not support unevaluated constants.");
     }
     intFolder = new ConstantIntFolder.forSemantics(this, numberSemantics);
+    pseudoPrimitiveClasses = <Class>{
+      coreTypes.internalSymbolClass,
+      coreTypes.symbolClass,
+      coreTypes.typeClass,
+    };
     primitiveEqualCache = <Class, bool>{
       coreTypes.boolClass: true,
       coreTypes.doubleClass: false,
@@ -4376,18 +4757,21 @@ class ConstantEvaluator implements ExpressionVisitor<Constant> {
     return null;
   }
 
-  bool hasPrimitiveEqual(Constant constant) {
+  bool hasPrimitiveEqual(Constant constant,
+      {bool allowPseudoPrimitive = true}) {
     if (intFolder.isInt(constant)) return true;
     if (constant is RecordConstant) {
       bool nonPrimitiveEqualsFound = false;
       for (Constant field in constant.positional) {
-        if (!hasPrimitiveEqual(field)) {
+        if (!hasPrimitiveEqual(field,
+            allowPseudoPrimitive: allowPseudoPrimitive)) {
           nonPrimitiveEqualsFound = true;
           break;
         }
       }
       for (Constant field in constant.named.values) {
-        if (!hasPrimitiveEqual(field)) {
+        if (!hasPrimitiveEqual(field,
+            allowPseudoPrimitive: allowPseudoPrimitive)) {
           nonPrimitiveEqualsFound = true;
           break;
         }
@@ -4397,7 +4781,14 @@ class ConstantEvaluator implements ExpressionVisitor<Constant> {
       }
     }
     DartType type = constant.getType(_staticTypeContext!);
-    return !(type is InterfaceType && !classHasPrimitiveEqual(type.classNode));
+    if (type is InterfaceType) {
+      bool result = classHasPrimitiveEqual(type.classNode);
+      if (result && !allowPseudoPrimitive) {
+        result = !pseudoPrimitiveClasses.contains(type.classNode);
+      }
+      return result;
+    }
+    return true;
   }
 
   bool classHasPrimitiveEqual(Class klass) {
@@ -5573,3 +5964,26 @@ bool _isFormalParameter(VariableDeclaration variable) {
 class _InlinedBlock extends Block {
   _InlinedBlock(List<Statement> statements) : super(statements);
 }
+
+/// Information about a currently transformed [PatternSwitchStatement].
+class _PatternSwitchStatementInfo {
+  /// The variable used as the switch expression in the generated
+  /// [SwitchStatement].
+  final VariableDeclaration switchIndexVariable;
+
+  /// The labeled statement that wraps the case matching.
+  ///
+  /// This is used as a break target to jump to the generated switch statement
+  /// for a continue statement from outside the generated switch statement.
+  final LabeledStatement innerLabeledStatement;
+
+  /// Map from [PatternSwitchCase]s that are continue targets to the index
+  /// used for there body in the generated [SwitchStatement].
+  final Map<PatternSwitchCase, int> switchCaseIndexMap;
+
+  /// The [PatternSwitchCase] currently being transformed.
+  PatternSwitchCase? currentSwitchCase;
+
+  _PatternSwitchStatementInfo(this.switchIndexVariable,
+      this.innerLabeledStatement, this.switchCaseIndexMap);
+}
diff --git a/pkg/front_end/lib/src/testing/id_extractor.dart b/pkg/front_end/lib/src/testing/id_extractor.dart
index 73888ecbd71..53b2808f024 100644
--- a/pkg/front_end/lib/src/testing/id_extractor.dart
+++ b/pkg/front_end/lib/src/testing/id_extractor.dart
@@ -4,7 +4,6 @@
 
 import 'package:_fe_analyzer_shared/src/testing/id.dart';
 import 'package:kernel/ast.dart';
-import '../api_prototype/lowering_predicates.dart';
 
 /// Compute a canonical [Id] for kernel-based nodes.
 MemberId computeMemberId(Member node) {
@@ -298,9 +297,9 @@ abstract class DataExtractor<T> extends Visitor<void>
     computeForNode(
         node,
         computeDefaultNodeId(node,
-            // TODO(johnniwinther): Remove this when late lowered setter
-            //  functions can have an offset.
-            skipNodeWithNoOffset: isLateLoweredLocalSetter(node.variable)));
+            // TODO(johnniwinther): Remove this when synthesized local functions
+            //  can have (same) offsets without breaking the VM.
+            skipNodeWithNoOffset: true));
     super.visitFunctionDeclaration(node);
   }
 
diff --git a/pkg/front_end/test/predicates/data/extension.dart b/pkg/front_end/test/predicates/data/extension.dart
index ac1dd00d047..2b84ac826c5 100644
--- a/pkg/front_end/test/predicates/data/extension.dart
+++ b/pkg/front_end/test/predicates/data/extension.dart
@@ -3,11 +3,23 @@
 // BSD-style license that can be found in the LICENSE file.
 
 extension Extension on int {
-  int /*extensionThis*/ instanceMethod() => this;
+  int /*
+   extensionThis,
+   name=this
+  */
+      instanceMethod() => this;
 
-  int get /*extensionThis*/ instanceGetter => this;
+  int get /*
+   extensionThis,
+   name=this
+  */
+      instanceGetter => this;
 
-  void set /*extensionThis*/ instanceSetter(int value) {}
+  void set /*
+   extensionThis,
+   name=this
+  */
+      instanceSetter(int value) {}
 
   static int staticMethod() => 42;
 
diff --git a/pkg/front_end/test/predicates/data/late.dart b/pkg/front_end/test/predicates/data/late.dart
index fa148d6ac38..ae84ae26769 100644
--- a/pkg/front_end/test/predicates/data/late.dart
+++ b/pkg/front_end/test/predicates/data/late.dart
@@ -772,14 +772,16 @@ method() {
       /*
        lateLocal,
        lateLocalGetter,
-       lateLocalSetter
+       lateLocalSetter,
+       name=localNonNullableWithoutInitializer
       */
       localNonNullableWithoutInitializer;
   late final int
       /*
        lateLocal,
        lateLocalGetter,
-       lateLocalSetter
+       lateLocalSetter,
+       name=finalLocalNonNullableWithoutInitializer
       */
       finalLocalNonNullableWithoutInitializer;
   late int?
@@ -787,12 +789,14 @@ method() {
        lateIsSetLocal,
        lateLocal,
        lateLocalGetter,
-       lateLocalSetter
+       lateLocalSetter,
+       name=localNullableWithoutInitializer
       */
       /*sentinel.
        lateLocal,
        lateLocalGetter,
-       lateLocalSetter
+       lateLocalSetter,
+       name=localNullableWithoutInitializer
       */
       localNullableWithoutInitializer;
   late final int?
@@ -800,48 +804,56 @@ method() {
        lateIsSetLocal,
        lateLocal,
        lateLocalGetter,
-       lateLocalSetter
+       lateLocalSetter,
+       name=finalLocalNullableWithoutInitializer
       */
       /*sentinel.
        lateLocal,
        lateLocalGetter,
-       lateLocalSetter
+       lateLocalSetter,
+       name=finalLocalNullableWithoutInitializer
       */
       finalLocalNullableWithoutInitializer;
   late int
       /*
        lateLocal,
        lateLocalGetter,
-       lateLocalSetter
+       lateLocalSetter,
+       name=localNonNullableWithInitializer
       */
       localNonNullableWithInitializer = 21;
   late final int /*
-       lateLocal,
-       lateLocalGetter
-      */
+   lateLocal,
+   lateLocalGetter,
+   name=finalLocalNonNullableWithInitializer
+  */
       finalLocalNonNullableWithInitializer = 22;
   late int?
       /*is-null.
        lateIsSetLocal,
        lateLocal,
        lateLocalGetter,
-       lateLocalSetter
+       lateLocalSetter,
+       name=localNullableWithInitializer
       */
       /*sentinel.
        lateLocal,
        lateLocalGetter,
-       lateLocalSetter
+       lateLocalSetter,
+       name=localNullableWithInitializer
       */
       localNullableWithInitializer = 23;
   late final int?
       /*is-null.
        lateIsSetLocal,
        lateLocal,
-       lateLocalGetter
+       lateLocalGetter,
+       name=finalLocalNullableWithInitializer
       */
       /*sentinel.
        lateLocal,
-       lateLocalGetter
+       lateLocalGetter,
+       name=finalLocalNullableWithInitializer
       */
       finalLocalNullableWithInitializer = 24;
 }
diff --git a/pkg/front_end/test/predicates/data/pattern_switch.dart b/pkg/front_end/test/predicates/data/pattern_switch.dart
new file mode 100644
index 00000000000..9b2eba9e9c3
--- /dev/null
+++ b/pkg/front_end/test/predicates/data/pattern_switch.dart
@@ -0,0 +1,17 @@
+// 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.
+
+method(o) {
+  switch (o) {
+    case [var /*
+     joinedIntermediate,
+     name=a
+    */a] when a > 5:
+    case [_, var /*
+     joinedIntermediate,
+     name=a
+    */a] when a < 5:
+      print(a);
+  }
+}
\ No newline at end of file
diff --git a/pkg/front_end/test/predicates/predicate_test.dart b/pkg/front_end/test/predicates/predicate_test.dart
index 2ffdc45f204..8c5002fca5c 100644
--- a/pkg/front_end/test/predicates/predicate_test.dart
+++ b/pkg/front_end/test/predicates/predicate_test.dart
@@ -51,6 +51,8 @@ Future<void> main(List<String> args) async {
 }
 
 class Tags {
+  static const String name = 'name';
+
   static const String lateField = 'lateField';
   static const String lateFieldName = 'lateFieldName';
   static const String lateIsSetField = 'lateIsSetField';
@@ -69,6 +71,8 @@ class Tags {
   static const String tearoffLowering = 'tearoffLowering';
   static const String tearoffConstructor = 'tearoffConstructor';
   static const String tearoffTypedef = 'tearoffTypedef';
+
+  static const String joinedIntermediate = 'joinedIntermediate';
 }
 
 class PredicateDataComputer extends DataComputer<Features> {
@@ -99,8 +103,8 @@ class PredicateDataComputer extends DataComputer<Features> {
 }
 
 class PredicateDataExtractor extends CfeDataExtractor<Features> {
-  Map<String, Features> featureMap = {};
-  Map<String, NodeId> nodeIdMap = {};
+  Map<Object?, Features> featureMap = {};
+  Map<Object?, NodeId> nodeIdMap = {};
 
   PredicateDataExtractor(InternalCompilerResult compilerResult,
       Map<Id, ActualData<Features>> actualMap)
@@ -170,12 +174,12 @@ class PredicateDataExtractor extends CfeDataExtractor<Features> {
   @override
   void visitProcedure(Procedure node) {
     super.visitProcedure(node);
-    nodeIdMap.forEach((String name, NodeId id) {
-      Features? features = featureMap[name];
+    nodeIdMap.forEach((Object? identity, NodeId id) {
+      Features? features = featureMap[identity];
       if (features != null) {
         TreeNode nodeWithOffset = computeTreeNodeWithOffset(node)!;
         registerValue(
-            nodeWithOffset.location!.file, id.value, id, features, name);
+            nodeWithOffset.location!.file, id.value, id, features, '$identity');
       }
     });
     nodeIdMap.clear();
@@ -184,33 +188,45 @@ class PredicateDataExtractor extends CfeDataExtractor<Features> {
 
   @override
   void visitVariableDeclaration(VariableDeclaration node) {
+    Object? identity;
     String? name;
     String? tag;
     if (isLateLoweredLocal(node)) {
       name = extractLocalNameFromLateLoweredLocal(node.name!);
       tag = Tags.lateLocal;
+      identity = name;
     } else if (isLateLoweredIsSetLocal(node)) {
       name = extractLocalNameFromLateLoweredIsSet(node.name!);
       tag = Tags.lateIsSetLocal;
+      identity = name;
     } else if (isLateLoweredLocalGetter(node)) {
       name = extractLocalNameFromLateLoweredGetter(node.name!);
       tag = Tags.lateLocalGetter;
+      identity = name;
     } else if (isLateLoweredLocalSetter(node)) {
       name = extractLocalNameFromLateLoweredSetter(node.name!);
       tag = Tags.lateLocalSetter;
+      identity = name;
     } else if (isExtensionThis(node)) {
       name = extractLocalNameForExtensionThis(node.name!);
       tag = Tags.extensionThis;
+      identity = name;
+    } else if (isJoinedIntermediateVariable(node)) {
+      name = extractJoinedIntermediateName(node.name!);
+      tag = Tags.joinedIntermediate;
+      identity = node;
     } else if (node.name != null) {
       name = node.name;
+      identity = name;
     }
     if (name != null) {
       if (node.fileOffset != TreeNode.noOffset) {
-        nodeIdMap[name] ??= new NodeId(node.fileOffset, IdKind.node);
+        nodeIdMap[identity] ??= new NodeId(node.fileOffset, IdKind.node);
       }
       if (tag != null) {
-        Features features = featureMap[name] ??= new Features();
+        Features features = featureMap[identity] ??= new Features();
         features.add(tag);
+        features[Tags.name] = name;
       }
     }
     super.visitVariableDeclaration(node);
diff --git a/pkg/front_end/test/spell_checking_list_code.txt b/pkg/front_end/test/spell_checking_list_code.txt
index c9ec78409da..e2283e27069 100644
--- a/pkg/front_end/test/spell_checking_list_code.txt
+++ b/pkg/front_end/test/spell_checking_list_code.txt
@@ -1498,6 +1498,7 @@ supernode
 supers
 suppose
 surprising
+surrounded
 suspended
 svar
 svg
diff --git a/pkg/front_end/testcases/const_functions/const_functions_switch_statements.dart.strong.expect b/pkg/front_end/testcases/const_functions/const_functions_switch_statements.dart.strong.expect
index 3153d038c6f..a7f7e57dffb 100644
--- a/pkg/front_end/testcases/const_functions/const_functions_switch_statements.dart.strong.expect
+++ b/pkg/front_end/testcases/const_functions/const_functions_switch_statements.dart.strong.expect
@@ -16,76 +16,57 @@ static const field core::int var8 = #C6;
 static const field core::int var9 = #C3;
 static method basicSwitch(core::int x) → core::int {
   #L1:
-  {
-    final synthesized core::int #0#0 = x;
-    if(#C7 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+  switch(x) {
+    #L2:
+    case #C7:
       {
         return 100;
       }
-    }
-    else {
+    #L3:
+    default:
       {
         x = x.{core::num::+}(1){(core::num) → core::int};
         break #L1;
       }
-    }
   }
   return x;
 }
 static method multipleCaseSwitch(core::int x) → core::int {
-  #L2:
-  {
-    final synthesized core::int #0#0 = x;
-    if(#C7 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C8 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+  #L4:
+  switch(x) {
+    #L5:
+    case #C7:
+    case #C8:
       {
         return 100;
       }
-    }
-    else {
+    #L6:
+    default:
       {
-        break #L2;
+        break #L4;
       }
-    }
   }
   return 0;
 }
 static method continueLabelSwitch(core::int x) → core::int {
-  #L3:
-  {
-    core::int #t1 = -1;
-    final synthesized core::int #0#0 = x;
-    if(#C7 =={core::num::==}{(core::Object) → core::bool} #0#0)
-      #t1 = 0;
-    else
-      if(#C8 =={core::num::==}{(core::Object) → core::bool} #0#0)
-        #t1 = 1;
-      else
-        if(#C2 =={core::num::==}{(core::Object) → core::bool} #0#0)
-          #t1 = 2;
-    switch(#t1) {
-      #L4:
-      case #C3:
-        {
-          {
-            x = x.{core::num::+}(100){(core::num) → core::int};
-            continue #L5;
-          }
-        }
-      #L6:
-      case #C7:
-        {
-          {
-            continue #L4;
-          }
-        }
-      #L5:
-      case #C8:
-        {
-          {
-            return x.{core::num::+}(3){(core::num) → core::int};
-          }
-        }
-    }
+  #L7:
+  switch(x) {
+    #L8:
+    case #C7:
+      {
+        x = x.{core::num::+}(100){(core::num) → core::int};
+        continue #L9;
+      }
+    #L10:
+    case #C8:
+      {
+        continue #L8;
+      }
+    #L9:
+    case #C2:
+      {
+        return x.{core::num::+}(3){(core::num) → core::int};
+      }
   }
   return 0;
 }
diff --git a/pkg/front_end/testcases/const_functions/const_functions_switch_statements.dart.strong.transformed.expect b/pkg/front_end/testcases/const_functions/const_functions_switch_statements.dart.strong.transformed.expect
index 3153d038c6f..a7f7e57dffb 100644
--- a/pkg/front_end/testcases/const_functions/const_functions_switch_statements.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/const_functions/const_functions_switch_statements.dart.strong.transformed.expect
@@ -16,76 +16,57 @@ static const field core::int var8 = #C6;
 static const field core::int var9 = #C3;
 static method basicSwitch(core::int x) → core::int {
   #L1:
-  {
-    final synthesized core::int #0#0 = x;
-    if(#C7 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+  switch(x) {
+    #L2:
+    case #C7:
       {
         return 100;
       }
-    }
-    else {
+    #L3:
+    default:
       {
         x = x.{core::num::+}(1){(core::num) → core::int};
         break #L1;
       }
-    }
   }
   return x;
 }
 static method multipleCaseSwitch(core::int x) → core::int {
-  #L2:
-  {
-    final synthesized core::int #0#0 = x;
-    if(#C7 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C8 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+  #L4:
+  switch(x) {
+    #L5:
+    case #C7:
+    case #C8:
       {
         return 100;
       }
-    }
-    else {
+    #L6:
+    default:
       {
-        break #L2;
+        break #L4;
       }
-    }
   }
   return 0;
 }
 static method continueLabelSwitch(core::int x) → core::int {
-  #L3:
-  {
-    core::int #t1 = -1;
-    final synthesized core::int #0#0 = x;
-    if(#C7 =={core::num::==}{(core::Object) → core::bool} #0#0)
-      #t1 = 0;
-    else
-      if(#C8 =={core::num::==}{(core::Object) → core::bool} #0#0)
-        #t1 = 1;
-      else
-        if(#C2 =={core::num::==}{(core::Object) → core::bool} #0#0)
-          #t1 = 2;
-    switch(#t1) {
-      #L4:
-      case #C3:
-        {
-          {
-            x = x.{core::num::+}(100){(core::num) → core::int};
-            continue #L5;
-          }
-        }
-      #L6:
-      case #C7:
-        {
-          {
-            continue #L4;
-          }
-        }
-      #L5:
-      case #C8:
-        {
-          {
-            return x.{core::num::+}(3){(core::num) → core::int};
-          }
-        }
-    }
+  #L7:
+  switch(x) {
+    #L8:
+    case #C7:
+      {
+        x = x.{core::num::+}(100){(core::num) → core::int};
+        continue #L9;
+      }
+    #L10:
+    case #C8:
+      {
+        continue #L8;
+      }
+    #L9:
+    case #C2:
+      {
+        return x.{core::num::+}(3){(core::num) → core::int};
+      }
   }
   return 0;
 }
diff --git a/pkg/front_end/testcases/const_functions/const_functions_switch_statements.dart.weak.expect b/pkg/front_end/testcases/const_functions/const_functions_switch_statements.dart.weak.expect
index 3153d038c6f..a7f7e57dffb 100644
--- a/pkg/front_end/testcases/const_functions/const_functions_switch_statements.dart.weak.expect
+++ b/pkg/front_end/testcases/const_functions/const_functions_switch_statements.dart.weak.expect
@@ -16,76 +16,57 @@ static const field core::int var8 = #C6;
 static const field core::int var9 = #C3;
 static method basicSwitch(core::int x) → core::int {
   #L1:
-  {
-    final synthesized core::int #0#0 = x;
-    if(#C7 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+  switch(x) {
+    #L2:
+    case #C7:
       {
         return 100;
       }
-    }
-    else {
+    #L3:
+    default:
       {
         x = x.{core::num::+}(1){(core::num) → core::int};
         break #L1;
       }
-    }
   }
   return x;
 }
 static method multipleCaseSwitch(core::int x) → core::int {
-  #L2:
-  {
-    final synthesized core::int #0#0 = x;
-    if(#C7 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C8 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+  #L4:
+  switch(x) {
+    #L5:
+    case #C7:
+    case #C8:
       {
         return 100;
       }
-    }
-    else {
+    #L6:
+    default:
       {
-        break #L2;
+        break #L4;
       }
-    }
   }
   return 0;
 }
 static method continueLabelSwitch(core::int x) → core::int {
-  #L3:
-  {
-    core::int #t1 = -1;
-    final synthesized core::int #0#0 = x;
-    if(#C7 =={core::num::==}{(core::Object) → core::bool} #0#0)
-      #t1 = 0;
-    else
-      if(#C8 =={core::num::==}{(core::Object) → core::bool} #0#0)
-        #t1 = 1;
-      else
-        if(#C2 =={core::num::==}{(core::Object) → core::bool} #0#0)
-          #t1 = 2;
-    switch(#t1) {
-      #L4:
-      case #C3:
-        {
-          {
-            x = x.{core::num::+}(100){(core::num) → core::int};
-            continue #L5;
-          }
-        }
-      #L6:
-      case #C7:
-        {
-          {
-            continue #L4;
-          }
-        }
-      #L5:
-      case #C8:
-        {
-          {
-            return x.{core::num::+}(3){(core::num) → core::int};
-          }
-        }
-    }
+  #L7:
+  switch(x) {
+    #L8:
+    case #C7:
+      {
+        x = x.{core::num::+}(100){(core::num) → core::int};
+        continue #L9;
+      }
+    #L10:
+    case #C8:
+      {
+        continue #L8;
+      }
+    #L9:
+    case #C2:
+      {
+        return x.{core::num::+}(3){(core::num) → core::int};
+      }
   }
   return 0;
 }
diff --git a/pkg/front_end/testcases/const_functions/const_functions_switch_statements.dart.weak.modular.expect b/pkg/front_end/testcases/const_functions/const_functions_switch_statements.dart.weak.modular.expect
index 3153d038c6f..a7f7e57dffb 100644
--- a/pkg/front_end/testcases/const_functions/const_functions_switch_statements.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/const_functions/const_functions_switch_statements.dart.weak.modular.expect
@@ -16,76 +16,57 @@ static const field core::int var8 = #C6;
 static const field core::int var9 = #C3;
 static method basicSwitch(core::int x) → core::int {
   #L1:
-  {
-    final synthesized core::int #0#0 = x;
-    if(#C7 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+  switch(x) {
+    #L2:
+    case #C7:
       {
         return 100;
       }
-    }
-    else {
+    #L3:
+    default:
       {
         x = x.{core::num::+}(1){(core::num) → core::int};
         break #L1;
       }
-    }
   }
   return x;
 }
 static method multipleCaseSwitch(core::int x) → core::int {
-  #L2:
-  {
-    final synthesized core::int #0#0 = x;
-    if(#C7 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C8 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+  #L4:
+  switch(x) {
+    #L5:
+    case #C7:
+    case #C8:
       {
         return 100;
       }
-    }
-    else {
+    #L6:
+    default:
       {
-        break #L2;
+        break #L4;
       }
-    }
   }
   return 0;
 }
 static method continueLabelSwitch(core::int x) → core::int {
-  #L3:
-  {
-    core::int #t1 = -1;
-    final synthesized core::int #0#0 = x;
-    if(#C7 =={core::num::==}{(core::Object) → core::bool} #0#0)
-      #t1 = 0;
-    else
-      if(#C8 =={core::num::==}{(core::Object) → core::bool} #0#0)
-        #t1 = 1;
-      else
-        if(#C2 =={core::num::==}{(core::Object) → core::bool} #0#0)
-          #t1 = 2;
-    switch(#t1) {
-      #L4:
-      case #C3:
-        {
-          {
-            x = x.{core::num::+}(100){(core::num) → core::int};
-            continue #L5;
-          }
-        }
-      #L6:
-      case #C7:
-        {
-          {
-            continue #L4;
-          }
-        }
-      #L5:
-      case #C8:
-        {
-          {
-            return x.{core::num::+}(3){(core::num) → core::int};
-          }
-        }
-    }
+  #L7:
+  switch(x) {
+    #L8:
+    case #C7:
+      {
+        x = x.{core::num::+}(100){(core::num) → core::int};
+        continue #L9;
+      }
+    #L10:
+    case #C8:
+      {
+        continue #L8;
+      }
+    #L9:
+    case #C2:
+      {
+        return x.{core::num::+}(3){(core::num) → core::int};
+      }
   }
   return 0;
 }
diff --git a/pkg/front_end/testcases/const_functions/const_functions_switch_statements.dart.weak.transformed.expect b/pkg/front_end/testcases/const_functions/const_functions_switch_statements.dart.weak.transformed.expect
index 3153d038c6f..a7f7e57dffb 100644
--- a/pkg/front_end/testcases/const_functions/const_functions_switch_statements.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/const_functions/const_functions_switch_statements.dart.weak.transformed.expect
@@ -16,76 +16,57 @@ static const field core::int var8 = #C6;
 static const field core::int var9 = #C3;
 static method basicSwitch(core::int x) → core::int {
   #L1:
-  {
-    final synthesized core::int #0#0 = x;
-    if(#C7 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+  switch(x) {
+    #L2:
+    case #C7:
       {
         return 100;
       }
-    }
-    else {
+    #L3:
+    default:
       {
         x = x.{core::num::+}(1){(core::num) → core::int};
         break #L1;
       }
-    }
   }
   return x;
 }
 static method multipleCaseSwitch(core::int x) → core::int {
-  #L2:
-  {
-    final synthesized core::int #0#0 = x;
-    if(#C7 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C8 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+  #L4:
+  switch(x) {
+    #L5:
+    case #C7:
+    case #C8:
       {
         return 100;
       }
-    }
-    else {
+    #L6:
+    default:
       {
-        break #L2;
+        break #L4;
       }
-    }
   }
   return 0;
 }
 static method continueLabelSwitch(core::int x) → core::int {
-  #L3:
-  {
-    core::int #t1 = -1;
-    final synthesized core::int #0#0 = x;
-    if(#C7 =={core::num::==}{(core::Object) → core::bool} #0#0)
-      #t1 = 0;
-    else
-      if(#C8 =={core::num::==}{(core::Object) → core::bool} #0#0)
-        #t1 = 1;
-      else
-        if(#C2 =={core::num::==}{(core::Object) → core::bool} #0#0)
-          #t1 = 2;
-    switch(#t1) {
-      #L4:
-      case #C3:
-        {
-          {
-            x = x.{core::num::+}(100){(core::num) → core::int};
-            continue #L5;
-          }
-        }
-      #L6:
-      case #C7:
-        {
-          {
-            continue #L4;
-          }
-        }
-      #L5:
-      case #C8:
-        {
-          {
-            return x.{core::num::+}(3){(core::num) → core::int};
-          }
-        }
-    }
+  #L7:
+  switch(x) {
+    #L8:
+    case #C7:
+      {
+        x = x.{core::num::+}(100){(core::num) → core::int};
+        continue #L9;
+      }
+    #L10:
+    case #C8:
+      {
+        continue #L8;
+      }
+    #L9:
+    case #C2:
+      {
+        return x.{core::num::+}(3){(core::num) → core::int};
+      }
   }
   return 0;
 }
diff --git a/pkg/front_end/testcases/general/await_complex.dart.strong.expect b/pkg/front_end/testcases/general/await_complex.dart.strong.expect
index 5fe951fe646..351e10d8dbf 100644
--- a/pkg/front_end/testcases/general/await_complex.dart.strong.expect
+++ b/pkg/front_end/testcases/general/await_complex.dart.strong.expect
@@ -191,18 +191,17 @@ static method controlFlow() → dynamic async /* futureValueType= dynamic */ {
       self::expect(0, await func<core::int>(0){(core::int) → FutureOr<core::int>} /* runtimeCheckType= asy::Future<core::int> */ );
     }
     #L1:
-    {
-      final synthesized core::int #0#0 = await func<core::int>(2){(core::int) → FutureOr<core::int>} /* runtimeCheckType= asy::Future<core::int> */ ;
-      if(#C3 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+    switch(await func<core::int>(2){(core::int) → FutureOr<core::int>} /* runtimeCheckType= asy::Future<core::int> */ ) {
+      #L2:
+      case #C3:
         {
           break #L1;
         }
-      }
-      else {
+      #L3:
+      default:
         {
           throw "unreachable";
         }
-      }
     }
     self::expect(42, await(() → asy::Future<core::int> async /* futureValueType= core::int */ {
       return await func<core::int>(42){(core::int) → FutureOr<core::int>} /* runtimeCheckType= asy::Future<core::int> */ ;
diff --git a/pkg/front_end/testcases/general/await_complex.dart.strong.transformed.expect b/pkg/front_end/testcases/general/await_complex.dart.strong.transformed.expect
index 0234e38526d..abad71e3f0f 100644
--- a/pkg/front_end/testcases/general/await_complex.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/general/await_complex.dart.strong.transformed.expect
@@ -201,18 +201,17 @@ static method controlFlow() → dynamic async /* futureValueType= dynamic */ {
           self::expect(0, await func<core::int>(0){(core::int) → FutureOr<core::int>} /* runtimeCheckType= asy::Future<core::int> */ );
         }
         #L1:
-        {
-          final synthesized core::int #0#0 = await func<core::int>(2){(core::int) → FutureOr<core::int>} /* runtimeCheckType= asy::Future<core::int> */ ;
-          if(#C3 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        switch(await func<core::int>(2){(core::int) → FutureOr<core::int>} /* runtimeCheckType= asy::Future<core::int> */ ) {
+          #L2:
+          case #C3:
             {
               break #L1;
             }
-          }
-          else {
+          #L3:
+          default:
             {
               throw "unreachable";
             }
-          }
         }
         self::expect(42, await(() → asy::Future<core::int> async /* futureValueType= core::int */ {
           return await func<core::int>(42){(core::int) → FutureOr<core::int>} /* runtimeCheckType= asy::Future<core::int> */ ;
diff --git a/pkg/front_end/testcases/general/await_complex.dart.weak.expect b/pkg/front_end/testcases/general/await_complex.dart.weak.expect
index 3b42ab31bad..0fc04632c2e 100644
--- a/pkg/front_end/testcases/general/await_complex.dart.weak.expect
+++ b/pkg/front_end/testcases/general/await_complex.dart.weak.expect
@@ -192,18 +192,17 @@ static method controlFlow() → dynamic async /* futureValueType= dynamic */ {
       self::expect(0, await func<core::int>(0){(core::int) → FutureOr<core::int>} /* runtimeCheckType= asy::Future<core::int> */ );
     }
     #L1:
-    {
-      final synthesized core::int #0#0 = await func<core::int>(2){(core::int) → FutureOr<core::int>} /* runtimeCheckType= asy::Future<core::int> */ ;
-      if(#C3 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+    switch(await func<core::int>(2){(core::int) → FutureOr<core::int>} /* runtimeCheckType= asy::Future<core::int> */ ) {
+      #L2:
+      case #C3:
         {
           break #L1;
         }
-      }
-      else {
+      #L3:
+      default:
         {
           throw "unreachable";
         }
-      }
     }
     self::expect(42, await(() → asy::Future<core::int> async /* futureValueType= core::int */ {
       return await func<core::int>(42){(core::int) → FutureOr<core::int>} /* runtimeCheckType= asy::Future<core::int> */ ;
diff --git a/pkg/front_end/testcases/general/await_complex.dart.weak.modular.expect b/pkg/front_end/testcases/general/await_complex.dart.weak.modular.expect
index 3b42ab31bad..0fc04632c2e 100644
--- a/pkg/front_end/testcases/general/await_complex.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/general/await_complex.dart.weak.modular.expect
@@ -192,18 +192,17 @@ static method controlFlow() → dynamic async /* futureValueType= dynamic */ {
       self::expect(0, await func<core::int>(0){(core::int) → FutureOr<core::int>} /* runtimeCheckType= asy::Future<core::int> */ );
     }
     #L1:
-    {
-      final synthesized core::int #0#0 = await func<core::int>(2){(core::int) → FutureOr<core::int>} /* runtimeCheckType= asy::Future<core::int> */ ;
-      if(#C3 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+    switch(await func<core::int>(2){(core::int) → FutureOr<core::int>} /* runtimeCheckType= asy::Future<core::int> */ ) {
+      #L2:
+      case #C3:
         {
           break #L1;
         }
-      }
-      else {
+      #L3:
+      default:
         {
           throw "unreachable";
         }
-      }
     }
     self::expect(42, await(() → asy::Future<core::int> async /* futureValueType= core::int */ {
       return await func<core::int>(42){(core::int) → FutureOr<core::int>} /* runtimeCheckType= asy::Future<core::int> */ ;
diff --git a/pkg/front_end/testcases/general/await_complex.dart.weak.transformed.expect b/pkg/front_end/testcases/general/await_complex.dart.weak.transformed.expect
index f336d1d671c..ed5994521c0 100644
--- a/pkg/front_end/testcases/general/await_complex.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/general/await_complex.dart.weak.transformed.expect
@@ -202,18 +202,17 @@ static method controlFlow() → dynamic async /* futureValueType= dynamic */ {
           self::expect(0, await func<core::int>(0){(core::int) → FutureOr<core::int>} /* runtimeCheckType= asy::Future<core::int> */ );
         }
         #L1:
-        {
-          final synthesized core::int #0#0 = await func<core::int>(2){(core::int) → FutureOr<core::int>} /* runtimeCheckType= asy::Future<core::int> */ ;
-          if(#C3 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        switch(await func<core::int>(2){(core::int) → FutureOr<core::int>} /* runtimeCheckType= asy::Future<core::int> */ ) {
+          #L2:
+          case #C3:
             {
               break #L1;
             }
-          }
-          else {
+          #L3:
+          default:
             {
               throw "unreachable";
             }
-          }
         }
         self::expect(42, await(() → asy::Future<core::int> async /* futureValueType= core::int */ {
           return await func<core::int>(42){(core::int) → FutureOr<core::int>} /* runtimeCheckType= asy::Future<core::int> */ ;
diff --git a/pkg/front_end/testcases/general/empty_switch.dart.strong.expect b/pkg/front_end/testcases/general/empty_switch.dart.strong.expect
index c3dd8487e3b..25160b565f1 100644
--- a/pkg/front_end/testcases/general/empty_switch.dart.strong.expect
+++ b/pkg/front_end/testcases/general/empty_switch.dart.strong.expect
@@ -3,5 +3,6 @@ import self as self;
 
 static method main() → dynamic {
   #L1:
-  {}
+  switch(1) {
+  }
 }
diff --git a/pkg/front_end/testcases/general/empty_switch.dart.strong.transformed.expect b/pkg/front_end/testcases/general/empty_switch.dart.strong.transformed.expect
index c3dd8487e3b..25160b565f1 100644
--- a/pkg/front_end/testcases/general/empty_switch.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/general/empty_switch.dart.strong.transformed.expect
@@ -3,5 +3,6 @@ import self as self;
 
 static method main() → dynamic {
   #L1:
-  {}
+  switch(1) {
+  }
 }
diff --git a/pkg/front_end/testcases/general/empty_switch.dart.weak.expect b/pkg/front_end/testcases/general/empty_switch.dart.weak.expect
index c3dd8487e3b..25160b565f1 100644
--- a/pkg/front_end/testcases/general/empty_switch.dart.weak.expect
+++ b/pkg/front_end/testcases/general/empty_switch.dart.weak.expect
@@ -3,5 +3,6 @@ import self as self;
 
 static method main() → dynamic {
   #L1:
-  {}
+  switch(1) {
+  }
 }
diff --git a/pkg/front_end/testcases/general/empty_switch.dart.weak.modular.expect b/pkg/front_end/testcases/general/empty_switch.dart.weak.modular.expect
index c3dd8487e3b..25160b565f1 100644
--- a/pkg/front_end/testcases/general/empty_switch.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/general/empty_switch.dart.weak.modular.expect
@@ -3,5 +3,6 @@ import self as self;
 
 static method main() → dynamic {
   #L1:
-  {}
+  switch(1) {
+  }
 }
diff --git a/pkg/front_end/testcases/general/empty_switch.dart.weak.transformed.expect b/pkg/front_end/testcases/general/empty_switch.dart.weak.transformed.expect
index c3dd8487e3b..25160b565f1 100644
--- a/pkg/front_end/testcases/general/empty_switch.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/general/empty_switch.dart.weak.transformed.expect
@@ -3,5 +3,6 @@ import self as self;
 
 static method main() → dynamic {
   #L1:
-  {}
+  switch(1) {
+  }
 }
diff --git a/pkg/front_end/testcases/general/issue44733.dart.strong.expect b/pkg/front_end/testcases/general/issue44733.dart.strong.expect
index bf63016dfff..7ae886ddff0 100644
--- a/pkg/front_end/testcases/general/issue44733.dart.strong.expect
+++ b/pkg/front_end/testcases/general/issue44733.dart.strong.expect
@@ -76,6 +76,7 @@ B get x => super.x;
            ^^^^^"{<invalid>}.x;
 static method f() → void {
   #L1:
-  {}
+  switch(self::x.{self::A::y}{invalid-type}{<invalid>}.z) {
+  }
 }
 static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/general/issue44733.dart.strong.transformed.expect b/pkg/front_end/testcases/general/issue44733.dart.strong.transformed.expect
index 76ed11434d1..60707a40bdf 100644
--- a/pkg/front_end/testcases/general/issue44733.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/general/issue44733.dart.strong.transformed.expect
@@ -76,6 +76,7 @@ B get x => super.x;
            ^^^^^"{<invalid>}.x;
 static method f() → void {
   #L1:
-  {}
+  switch(self::x.{self::A::y}{invalid-type}{<invalid>}.z) {
+  }
 }
 static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/general/issue44733.dart.weak.expect b/pkg/front_end/testcases/general/issue44733.dart.weak.expect
index bf63016dfff..7ae886ddff0 100644
--- a/pkg/front_end/testcases/general/issue44733.dart.weak.expect
+++ b/pkg/front_end/testcases/general/issue44733.dart.weak.expect
@@ -76,6 +76,7 @@ B get x => super.x;
            ^^^^^"{<invalid>}.x;
 static method f() → void {
   #L1:
-  {}
+  switch(self::x.{self::A::y}{invalid-type}{<invalid>}.z) {
+  }
 }
 static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/general/issue44733.dart.weak.modular.expect b/pkg/front_end/testcases/general/issue44733.dart.weak.modular.expect
index bf63016dfff..7ae886ddff0 100644
--- a/pkg/front_end/testcases/general/issue44733.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/general/issue44733.dart.weak.modular.expect
@@ -76,6 +76,7 @@ B get x => super.x;
            ^^^^^"{<invalid>}.x;
 static method f() → void {
   #L1:
-  {}
+  switch(self::x.{self::A::y}{invalid-type}{<invalid>}.z) {
+  }
 }
 static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/general/issue44733.dart.weak.transformed.expect b/pkg/front_end/testcases/general/issue44733.dart.weak.transformed.expect
index 76ed11434d1..60707a40bdf 100644
--- a/pkg/front_end/testcases/general/issue44733.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/general/issue44733.dart.weak.transformed.expect
@@ -76,6 +76,7 @@ B get x => super.x;
            ^^^^^"{<invalid>}.x;
 static method f() → void {
   #L1:
-  {}
+  switch(self::x.{self::A::y}{invalid-type}{<invalid>}.z) {
+  }
 }
 static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/general/issue49697_2/main.dart.strong.expect b/pkg/front_end/testcases/general/issue49697_2/main.dart.strong.expect
index 9adb38cb580..845eb069527 100644
--- a/pkg/front_end/testcases/general/issue49697_2/main.dart.strong.expect
+++ b/pkg/front_end/testcases/general/issue49697_2/main.dart.strong.expect
@@ -67,125 +67,111 @@ class B extends core::_Enum /*isEnum*/  {
 }
 static method a1(self::A? a) → core::int? {
   #L1:
-  {
-    final synthesized self::A? #0#0 = a;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  switch(a) /*isExplicitlyExhaustive*/ {
+    #L2:
+    case #C3:
       {
         return 0;
       }
-    }
   }
 }
 static method a2(self::A? a) → core::int? {
-  #L2:
-  {
-    final synthesized self::A? #0#0 = a;
-    if(#0#0 == null) {
+  #L3:
+  switch(a) /*isExplicitlyExhaustive*/ {
+    #L4:
+    case #C11:
       {
         return null;
       }
-    }
-    else
-      if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          return 0;
-        }
+    #L5:
+    case #C3:
+      {
+        return 0;
       }
   }
 }
 static method b1(self::B b) → core::int {
-  #L3:
-  {
-    final synthesized self::B #0#0 = b;
-    if(#C8 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L6:
+  switch(b) /*isExplicitlyExhaustive*/ {
+    #L7:
+    case #C8:
       {
         return 0;
       }
-    }
-    else
-      if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          return 1;
-        }
+    #L8:
+    case #C9:
+      {
+        return 1;
       }
   }
 }
 static method b2(self::B? b) → core::int? {
-  #L4:
-  {
-    final synthesized self::B? #0#0 = b;
-    if(#0#0 == null) {
+  #L9:
+  switch(b) /*isExplicitlyExhaustive*/ {
+    #L10:
+    case #C11:
       {
         return null;
       }
-    }
-    else
-      if(#C8 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          return 0;
-        }
+    #L11:
+    case #C8:
+      {
+        return 0;
       }
   }
 }
 static method c1(mai::C? c) → core::int? {
-  #L5:
-  {
-    final synthesized mai::C? #0#0 = c;
-    if(#C11 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L12:
+  switch(c) /*isExplicitlyExhaustive*/ {
+    #L13:
+    case #C12:
       {
         return 0;
       }
-    }
   }
 }
 static method c2(mai::C? c) → core::int? {
-  #L6:
-  {
-    final synthesized mai::C? #0#0 = c;
-    if(#0#0 == null) {
+  #L14:
+  switch(c) /*isExplicitlyExhaustive*/ {
+    #L15:
+    case #C11:
       {
         return null;
       }
-    }
-    else
-      if(#C11 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          return 0;
-        }
+    #L16:
+    case #C12:
+      {
+        return 0;
       }
   }
 }
 static method d1(mai::D d) → core::int {
-  #L7:
-  {
-    final synthesized mai::D #0#0 = d;
-    if(#C12 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L17:
+  switch(d) /*isExplicitlyExhaustive*/ {
+    #L18:
+    case #C13:
       {
         return 0;
       }
-    }
-    else
-      if(#C13 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          return 1;
-        }
+    #L19:
+    case #C14:
+      {
+        return 1;
       }
   }
 }
 static method d2(mai::D? d) → core::int? {
-  #L8:
-  {
-    final synthesized mai::D? #0#0 = d;
-    if(#0#0 == null) {
+  #L20:
+  switch(d) /*isExplicitlyExhaustive*/ {
+    #L21:
+    case #C11:
       {
         return null;
       }
-    }
-    else
-      if(#C12 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          return 0;
-        }
+    #L22:
+    case #C13:
+      {
+        return 0;
       }
   }
 }
@@ -194,10 +180,10 @@ static method main() → void {
   self::a2(#C6);
   self::b1(#C9);
   self::b2(#C9);
-  self::c1(#C14);
-  self::c2(#C14);
-  self::d1(#C13);
-  self::d2(#C13);
+  self::c1(#C15);
+  self::c2(#C15);
+  self::d1(#C14);
+  self::d2(#C14);
 }
 
 library /*isNonNullableByDefault*/;
@@ -205,9 +191,9 @@ import self as mai;
 import "dart:core" as core;
 
 class C extends core::_Enum /*isEnum*/  {
-  static const field core::List<mai::C> values = #C15;
-  enum-element static const field mai::C a = #C11;
-  enum-element static const field mai::C b = #C14;
+  static const field core::List<mai::C> values = #C16;
+  enum-element static const field mai::C a = #C12;
+  enum-element static const field mai::C b = #C15;
   const constructor •(core::int #index, core::String #name) → mai::C
     : super core::_Enum::•(#index, #name)
     ;
@@ -215,10 +201,10 @@ class C extends core::_Enum /*isEnum*/  {
     return "C.${this.{core::_Enum::_name}{core::String}}";
 }
 class D extends core::_Enum /*isEnum*/  {
-  static const field core::List<mai::D> values = #C16;
-  static const field mai::D c = #C12;
-  enum-element static const field mai::D a = #C12;
-  enum-element static const field mai::D b = #C13;
+  static const field core::List<mai::D> values = #C17;
+  static const field mai::D c = #C13;
+  enum-element static const field mai::D a = #C13;
+  enum-element static const field mai::D b = #C14;
   const constructor •(core::int #index, core::String #name) → mai::D
     : super core::_Enum::•(#index, #name)
     ;
@@ -237,12 +223,13 @@ constants  {
   #C8 = self::B {index:#C1, _name:#C2}
   #C9 = self::B {index:#C4, _name:#C5}
   #C10 = <self::B>[#C8, #C9]
-  #C11 = mai::C {index:#C1, _name:#C2}
-  #C12 = mai::D {index:#C1, _name:#C2}
-  #C13 = mai::D {index:#C4, _name:#C5}
-  #C14 = mai::C {index:#C4, _name:#C5}
-  #C15 = <mai::C>[#C11, #C14]
-  #C16 = <mai::D>[#C12, #C13]
+  #C11 = null
+  #C12 = mai::C {index:#C1, _name:#C2}
+  #C13 = mai::D {index:#C1, _name:#C2}
+  #C14 = mai::D {index:#C4, _name:#C5}
+  #C15 = mai::C {index:#C4, _name:#C5}
+  #C16 = <mai::C>[#C12, #C15]
+  #C17 = <mai::D>[#C13, #C14]
 }
 
 
diff --git a/pkg/front_end/testcases/general/issue49697_2/main.dart.strong.transformed.expect b/pkg/front_end/testcases/general/issue49697_2/main.dart.strong.transformed.expect
index 9adb38cb580..845eb069527 100644
--- a/pkg/front_end/testcases/general/issue49697_2/main.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/general/issue49697_2/main.dart.strong.transformed.expect
@@ -67,125 +67,111 @@ class B extends core::_Enum /*isEnum*/  {
 }
 static method a1(self::A? a) → core::int? {
   #L1:
-  {
-    final synthesized self::A? #0#0 = a;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  switch(a) /*isExplicitlyExhaustive*/ {
+    #L2:
+    case #C3:
       {
         return 0;
       }
-    }
   }
 }
 static method a2(self::A? a) → core::int? {
-  #L2:
-  {
-    final synthesized self::A? #0#0 = a;
-    if(#0#0 == null) {
+  #L3:
+  switch(a) /*isExplicitlyExhaustive*/ {
+    #L4:
+    case #C11:
       {
         return null;
       }
-    }
-    else
-      if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          return 0;
-        }
+    #L5:
+    case #C3:
+      {
+        return 0;
       }
   }
 }
 static method b1(self::B b) → core::int {
-  #L3:
-  {
-    final synthesized self::B #0#0 = b;
-    if(#C8 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L6:
+  switch(b) /*isExplicitlyExhaustive*/ {
+    #L7:
+    case #C8:
       {
         return 0;
       }
-    }
-    else
-      if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          return 1;
-        }
+    #L8:
+    case #C9:
+      {
+        return 1;
       }
   }
 }
 static method b2(self::B? b) → core::int? {
-  #L4:
-  {
-    final synthesized self::B? #0#0 = b;
-    if(#0#0 == null) {
+  #L9:
+  switch(b) /*isExplicitlyExhaustive*/ {
+    #L10:
+    case #C11:
       {
         return null;
       }
-    }
-    else
-      if(#C8 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          return 0;
-        }
+    #L11:
+    case #C8:
+      {
+        return 0;
       }
   }
 }
 static method c1(mai::C? c) → core::int? {
-  #L5:
-  {
-    final synthesized mai::C? #0#0 = c;
-    if(#C11 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L12:
+  switch(c) /*isExplicitlyExhaustive*/ {
+    #L13:
+    case #C12:
       {
         return 0;
       }
-    }
   }
 }
 static method c2(mai::C? c) → core::int? {
-  #L6:
-  {
-    final synthesized mai::C? #0#0 = c;
-    if(#0#0 == null) {
+  #L14:
+  switch(c) /*isExplicitlyExhaustive*/ {
+    #L15:
+    case #C11:
       {
         return null;
       }
-    }
-    else
-      if(#C11 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          return 0;
-        }
+    #L16:
+    case #C12:
+      {
+        return 0;
       }
   }
 }
 static method d1(mai::D d) → core::int {
-  #L7:
-  {
-    final synthesized mai::D #0#0 = d;
-    if(#C12 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L17:
+  switch(d) /*isExplicitlyExhaustive*/ {
+    #L18:
+    case #C13:
       {
         return 0;
       }
-    }
-    else
-      if(#C13 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          return 1;
-        }
+    #L19:
+    case #C14:
+      {
+        return 1;
       }
   }
 }
 static method d2(mai::D? d) → core::int? {
-  #L8:
-  {
-    final synthesized mai::D? #0#0 = d;
-    if(#0#0 == null) {
+  #L20:
+  switch(d) /*isExplicitlyExhaustive*/ {
+    #L21:
+    case #C11:
       {
         return null;
       }
-    }
-    else
-      if(#C12 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          return 0;
-        }
+    #L22:
+    case #C13:
+      {
+        return 0;
       }
   }
 }
@@ -194,10 +180,10 @@ static method main() → void {
   self::a2(#C6);
   self::b1(#C9);
   self::b2(#C9);
-  self::c1(#C14);
-  self::c2(#C14);
-  self::d1(#C13);
-  self::d2(#C13);
+  self::c1(#C15);
+  self::c2(#C15);
+  self::d1(#C14);
+  self::d2(#C14);
 }
 
 library /*isNonNullableByDefault*/;
@@ -205,9 +191,9 @@ import self as mai;
 import "dart:core" as core;
 
 class C extends core::_Enum /*isEnum*/  {
-  static const field core::List<mai::C> values = #C15;
-  enum-element static const field mai::C a = #C11;
-  enum-element static const field mai::C b = #C14;
+  static const field core::List<mai::C> values = #C16;
+  enum-element static const field mai::C a = #C12;
+  enum-element static const field mai::C b = #C15;
   const constructor •(core::int #index, core::String #name) → mai::C
     : super core::_Enum::•(#index, #name)
     ;
@@ -215,10 +201,10 @@ class C extends core::_Enum /*isEnum*/  {
     return "C.${this.{core::_Enum::_name}{core::String}}";
 }
 class D extends core::_Enum /*isEnum*/  {
-  static const field core::List<mai::D> values = #C16;
-  static const field mai::D c = #C12;
-  enum-element static const field mai::D a = #C12;
-  enum-element static const field mai::D b = #C13;
+  static const field core::List<mai::D> values = #C17;
+  static const field mai::D c = #C13;
+  enum-element static const field mai::D a = #C13;
+  enum-element static const field mai::D b = #C14;
   const constructor •(core::int #index, core::String #name) → mai::D
     : super core::_Enum::•(#index, #name)
     ;
@@ -237,12 +223,13 @@ constants  {
   #C8 = self::B {index:#C1, _name:#C2}
   #C9 = self::B {index:#C4, _name:#C5}
   #C10 = <self::B>[#C8, #C9]
-  #C11 = mai::C {index:#C1, _name:#C2}
-  #C12 = mai::D {index:#C1, _name:#C2}
-  #C13 = mai::D {index:#C4, _name:#C5}
-  #C14 = mai::C {index:#C4, _name:#C5}
-  #C15 = <mai::C>[#C11, #C14]
-  #C16 = <mai::D>[#C12, #C13]
+  #C11 = null
+  #C12 = mai::C {index:#C1, _name:#C2}
+  #C13 = mai::D {index:#C1, _name:#C2}
+  #C14 = mai::D {index:#C4, _name:#C5}
+  #C15 = mai::C {index:#C4, _name:#C5}
+  #C16 = <mai::C>[#C12, #C15]
+  #C17 = <mai::D>[#C13, #C14]
 }
 
 
diff --git a/pkg/front_end/testcases/general/issue49697_2/main.dart.weak.expect b/pkg/front_end/testcases/general/issue49697_2/main.dart.weak.expect
index 398c5698b10..cf20fdd46b1 100644
--- a/pkg/front_end/testcases/general/issue49697_2/main.dart.weak.expect
+++ b/pkg/front_end/testcases/general/issue49697_2/main.dart.weak.expect
@@ -67,125 +67,111 @@ class B extends core::_Enum /*isEnum*/  {
 }
 static method a1(self::A? a) → core::int? {
   #L1:
-  {
-    final synthesized self::A? #0#0 = a;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  switch(a) /*isExplicitlyExhaustive*/ {
+    #L2:
+    case #C3:
       {
         return 0;
       }
-    }
   }
 }
 static method a2(self::A? a) → core::int? {
-  #L2:
-  {
-    final synthesized self::A? #0#0 = a;
-    if(#0#0 == null) {
+  #L3:
+  switch(a) /*isExplicitlyExhaustive*/ {
+    #L4:
+    case #C11:
       {
         return null;
       }
-    }
-    else
-      if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          return 0;
-        }
+    #L5:
+    case #C3:
+      {
+        return 0;
       }
   }
 }
 static method b1(self::B b) → core::int {
-  #L3:
-  {
-    final synthesized self::B #0#0 = b;
-    if(#C8 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L6:
+  switch(b) /*isExplicitlyExhaustive*/ {
+    #L7:
+    case #C8:
       {
         return 0;
       }
-    }
-    else
-      if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          return 1;
-        }
+    #L8:
+    case #C9:
+      {
+        return 1;
       }
   }
 }
 static method b2(self::B? b) → core::int? {
-  #L4:
-  {
-    final synthesized self::B? #0#0 = b;
-    if(#0#0 == null) {
+  #L9:
+  switch(b) /*isExplicitlyExhaustive*/ {
+    #L10:
+    case #C11:
       {
         return null;
       }
-    }
-    else
-      if(#C8 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          return 0;
-        }
+    #L11:
+    case #C8:
+      {
+        return 0;
       }
   }
 }
 static method c1(mai::C? c) → core::int? {
-  #L5:
-  {
-    final synthesized mai::C? #0#0 = c;
-    if(#C11 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L12:
+  switch(c) /*isExplicitlyExhaustive*/ {
+    #L13:
+    case #C12:
       {
         return 0;
       }
-    }
   }
 }
 static method c2(mai::C? c) → core::int? {
-  #L6:
-  {
-    final synthesized mai::C? #0#0 = c;
-    if(#0#0 == null) {
+  #L14:
+  switch(c) /*isExplicitlyExhaustive*/ {
+    #L15:
+    case #C11:
       {
         return null;
       }
-    }
-    else
-      if(#C11 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          return 0;
-        }
+    #L16:
+    case #C12:
+      {
+        return 0;
       }
   }
 }
 static method d1(mai::D d) → core::int {
-  #L7:
-  {
-    final synthesized mai::D #0#0 = d;
-    if(#C12 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L17:
+  switch(d) /*isExplicitlyExhaustive*/ {
+    #L18:
+    case #C13:
       {
         return 0;
       }
-    }
-    else
-      if(#C13 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          return 1;
-        }
+    #L19:
+    case #C14:
+      {
+        return 1;
       }
   }
 }
 static method d2(mai::D? d) → core::int? {
-  #L8:
-  {
-    final synthesized mai::D? #0#0 = d;
-    if(#0#0 == null) {
+  #L20:
+  switch(d) /*isExplicitlyExhaustive*/ {
+    #L21:
+    case #C11:
       {
         return null;
       }
-    }
-    else
-      if(#C12 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          return 0;
-        }
+    #L22:
+    case #C13:
+      {
+        return 0;
       }
   }
 }
@@ -194,10 +180,10 @@ static method main() → void {
   self::a2(#C6);
   self::b1(#C9);
   self::b2(#C9);
-  self::c1(#C14);
-  self::c2(#C14);
-  self::d1(#C13);
-  self::d2(#C13);
+  self::c1(#C15);
+  self::c2(#C15);
+  self::d1(#C14);
+  self::d2(#C14);
 }
 
 library /*isNonNullableByDefault*/;
@@ -205,9 +191,9 @@ import self as mai;
 import "dart:core" as core;
 
 class C extends core::_Enum /*isEnum*/  {
-  static const field core::List<mai::C> values = #C15;
-  enum-element static const field mai::C a = #C11;
-  enum-element static const field mai::C b = #C14;
+  static const field core::List<mai::C> values = #C16;
+  enum-element static const field mai::C a = #C12;
+  enum-element static const field mai::C b = #C15;
   const constructor •(core::int #index, core::String #name) → mai::C
     : super core::_Enum::•(#index, #name)
     ;
@@ -215,10 +201,10 @@ class C extends core::_Enum /*isEnum*/  {
     return "C.${this.{core::_Enum::_name}{core::String}}";
 }
 class D extends core::_Enum /*isEnum*/  {
-  static const field core::List<mai::D> values = #C16;
-  static const field mai::D c = #C12;
-  enum-element static const field mai::D a = #C12;
-  enum-element static const field mai::D b = #C13;
+  static const field core::List<mai::D> values = #C17;
+  static const field mai::D c = #C13;
+  enum-element static const field mai::D a = #C13;
+  enum-element static const field mai::D b = #C14;
   const constructor •(core::int #index, core::String #name) → mai::D
     : super core::_Enum::•(#index, #name)
     ;
@@ -237,12 +223,13 @@ constants  {
   #C8 = self::B {index:#C1, _name:#C2}
   #C9 = self::B {index:#C4, _name:#C5}
   #C10 = <self::B*>[#C8, #C9]
-  #C11 = mai::C {index:#C1, _name:#C2}
-  #C12 = mai::D {index:#C1, _name:#C2}
-  #C13 = mai::D {index:#C4, _name:#C5}
-  #C14 = mai::C {index:#C4, _name:#C5}
-  #C15 = <mai::C*>[#C11, #C14]
-  #C16 = <mai::D*>[#C12, #C13]
+  #C11 = null
+  #C12 = mai::C {index:#C1, _name:#C2}
+  #C13 = mai::D {index:#C1, _name:#C2}
+  #C14 = mai::D {index:#C4, _name:#C5}
+  #C15 = mai::C {index:#C4, _name:#C5}
+  #C16 = <mai::C*>[#C12, #C15]
+  #C17 = <mai::D*>[#C13, #C14]
 }
 
 
diff --git a/pkg/front_end/testcases/general/issue49697_2/main.dart.weak.modular.expect b/pkg/front_end/testcases/general/issue49697_2/main.dart.weak.modular.expect
index 3b8ff96ab24..17e607adbe6 100644
--- a/pkg/front_end/testcases/general/issue49697_2/main.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/general/issue49697_2/main.dart.weak.modular.expect
@@ -67,125 +67,111 @@ class B extends core::_Enum /*isEnum*/  {
 }
 static method a1(self::A? a) → core::int? {
   #L1:
-  {
-    final synthesized self::A? #0#0 = a;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  switch(a) /*isExplicitlyExhaustive*/ {
+    #L2:
+    case #C3:
       {
         return 0;
       }
-    }
   }
 }
 static method a2(self::A? a) → core::int? {
-  #L2:
-  {
-    final synthesized self::A? #0#0 = a;
-    if(#0#0 == null) {
+  #L3:
+  switch(a) /*isExplicitlyExhaustive*/ {
+    #L4:
+    case #C11:
       {
         return null;
       }
-    }
-    else
-      if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          return 0;
-        }
+    #L5:
+    case #C3:
+      {
+        return 0;
       }
   }
 }
 static method b1(self::B b) → core::int {
-  #L3:
-  {
-    final synthesized self::B #0#0 = b;
-    if(#C8 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L6:
+  switch(b) /*isExplicitlyExhaustive*/ {
+    #L7:
+    case #C8:
       {
         return 0;
       }
-    }
-    else
-      if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          return 1;
-        }
+    #L8:
+    case #C9:
+      {
+        return 1;
       }
   }
 }
 static method b2(self::B? b) → core::int? {
-  #L4:
-  {
-    final synthesized self::B? #0#0 = b;
-    if(#0#0 == null) {
+  #L9:
+  switch(b) /*isExplicitlyExhaustive*/ {
+    #L10:
+    case #C11:
       {
         return null;
       }
-    }
-    else
-      if(#C8 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          return 0;
-        }
+    #L11:
+    case #C8:
+      {
+        return 0;
       }
   }
 }
 static method c1(mai::C? c) → core::int? {
-  #L5:
-  {
-    final synthesized mai::C? #0#0 = c;
-    if(#C11 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L12:
+  switch(c) /*isExplicitlyExhaustive*/ {
+    #L13:
+    case #C12:
       {
         return 0;
       }
-    }
   }
 }
 static method c2(mai::C? c) → core::int? {
-  #L6:
-  {
-    final synthesized mai::C? #0#0 = c;
-    if(#0#0 == null) {
+  #L14:
+  switch(c) /*isExplicitlyExhaustive*/ {
+    #L15:
+    case #C11:
       {
         return null;
       }
-    }
-    else
-      if(#C11 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          return 0;
-        }
+    #L16:
+    case #C12:
+      {
+        return 0;
       }
   }
 }
 static method d1(mai::D d) → core::int {
-  #L7:
-  {
-    final synthesized mai::D #0#0 = d;
-    if(#C12 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L17:
+  switch(d) /*isExplicitlyExhaustive*/ {
+    #L18:
+    case #C13:
       {
         return 0;
       }
-    }
-    else
-      if(#C13 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          return 1;
-        }
+    #L19:
+    case #C14:
+      {
+        return 1;
       }
   }
 }
 static method d2(mai::D? d) → core::int? {
-  #L8:
-  {
-    final synthesized mai::D? #0#0 = d;
-    if(#0#0 == null) {
+  #L20:
+  switch(d) /*isExplicitlyExhaustive*/ {
+    #L21:
+    case #C11:
       {
         return null;
       }
-    }
-    else
-      if(#C12 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          return 0;
-        }
+    #L22:
+    case #C13:
+      {
+        return 0;
       }
   }
 }
@@ -194,10 +180,10 @@ static method main() → void {
   self::a2(#C6);
   self::b1(#C9);
   self::b2(#C9);
-  self::c1(#C14);
-  self::c2(#C14);
-  self::d1(#C13);
-  self::d2(#C13);
+  self::c1(#C15);
+  self::c2(#C15);
+  self::d1(#C14);
+  self::d2(#C14);
 }
 
 constants  {
@@ -211,10 +197,11 @@ constants  {
   #C8 = self::B {index:#C1, _name:#C2}
   #C9 = self::B {index:#C4, _name:#C5}
   #C10 = <self::B*>[#C8, #C9]
-  #C11 = mai::C {index:#C1, _name:#C2}
-  #C12 = mai::D {index:#C1, _name:#C2}
-  #C13 = mai::D {index:#C4, _name:#C5}
-  #C14 = mai::C {index:#C4, _name:#C5}
+  #C11 = null
+  #C12 = mai::C {index:#C1, _name:#C2}
+  #C13 = mai::D {index:#C1, _name:#C2}
+  #C14 = mai::D {index:#C4, _name:#C5}
+  #C15 = mai::C {index:#C4, _name:#C5}
 }
 
 
diff --git a/pkg/front_end/testcases/general/issue49697_2/main.dart.weak.transformed.expect b/pkg/front_end/testcases/general/issue49697_2/main.dart.weak.transformed.expect
index 398c5698b10..cf20fdd46b1 100644
--- a/pkg/front_end/testcases/general/issue49697_2/main.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/general/issue49697_2/main.dart.weak.transformed.expect
@@ -67,125 +67,111 @@ class B extends core::_Enum /*isEnum*/  {
 }
 static method a1(self::A? a) → core::int? {
   #L1:
-  {
-    final synthesized self::A? #0#0 = a;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  switch(a) /*isExplicitlyExhaustive*/ {
+    #L2:
+    case #C3:
       {
         return 0;
       }
-    }
   }
 }
 static method a2(self::A? a) → core::int? {
-  #L2:
-  {
-    final synthesized self::A? #0#0 = a;
-    if(#0#0 == null) {
+  #L3:
+  switch(a) /*isExplicitlyExhaustive*/ {
+    #L4:
+    case #C11:
       {
         return null;
       }
-    }
-    else
-      if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          return 0;
-        }
+    #L5:
+    case #C3:
+      {
+        return 0;
       }
   }
 }
 static method b1(self::B b) → core::int {
-  #L3:
-  {
-    final synthesized self::B #0#0 = b;
-    if(#C8 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L6:
+  switch(b) /*isExplicitlyExhaustive*/ {
+    #L7:
+    case #C8:
       {
         return 0;
       }
-    }
-    else
-      if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          return 1;
-        }
+    #L8:
+    case #C9:
+      {
+        return 1;
       }
   }
 }
 static method b2(self::B? b) → core::int? {
-  #L4:
-  {
-    final synthesized self::B? #0#0 = b;
-    if(#0#0 == null) {
+  #L9:
+  switch(b) /*isExplicitlyExhaustive*/ {
+    #L10:
+    case #C11:
       {
         return null;
       }
-    }
-    else
-      if(#C8 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          return 0;
-        }
+    #L11:
+    case #C8:
+      {
+        return 0;
       }
   }
 }
 static method c1(mai::C? c) → core::int? {
-  #L5:
-  {
-    final synthesized mai::C? #0#0 = c;
-    if(#C11 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L12:
+  switch(c) /*isExplicitlyExhaustive*/ {
+    #L13:
+    case #C12:
       {
         return 0;
       }
-    }
   }
 }
 static method c2(mai::C? c) → core::int? {
-  #L6:
-  {
-    final synthesized mai::C? #0#0 = c;
-    if(#0#0 == null) {
+  #L14:
+  switch(c) /*isExplicitlyExhaustive*/ {
+    #L15:
+    case #C11:
       {
         return null;
       }
-    }
-    else
-      if(#C11 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          return 0;
-        }
+    #L16:
+    case #C12:
+      {
+        return 0;
       }
   }
 }
 static method d1(mai::D d) → core::int {
-  #L7:
-  {
-    final synthesized mai::D #0#0 = d;
-    if(#C12 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L17:
+  switch(d) /*isExplicitlyExhaustive*/ {
+    #L18:
+    case #C13:
       {
         return 0;
       }
-    }
-    else
-      if(#C13 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          return 1;
-        }
+    #L19:
+    case #C14:
+      {
+        return 1;
       }
   }
 }
 static method d2(mai::D? d) → core::int? {
-  #L8:
-  {
-    final synthesized mai::D? #0#0 = d;
-    if(#0#0 == null) {
+  #L20:
+  switch(d) /*isExplicitlyExhaustive*/ {
+    #L21:
+    case #C11:
       {
         return null;
       }
-    }
-    else
-      if(#C12 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          return 0;
-        }
+    #L22:
+    case #C13:
+      {
+        return 0;
       }
   }
 }
@@ -194,10 +180,10 @@ static method main() → void {
   self::a2(#C6);
   self::b1(#C9);
   self::b2(#C9);
-  self::c1(#C14);
-  self::c2(#C14);
-  self::d1(#C13);
-  self::d2(#C13);
+  self::c1(#C15);
+  self::c2(#C15);
+  self::d1(#C14);
+  self::d2(#C14);
 }
 
 library /*isNonNullableByDefault*/;
@@ -205,9 +191,9 @@ import self as mai;
 import "dart:core" as core;
 
 class C extends core::_Enum /*isEnum*/  {
-  static const field core::List<mai::C> values = #C15;
-  enum-element static const field mai::C a = #C11;
-  enum-element static const field mai::C b = #C14;
+  static const field core::List<mai::C> values = #C16;
+  enum-element static const field mai::C a = #C12;
+  enum-element static const field mai::C b = #C15;
   const constructor •(core::int #index, core::String #name) → mai::C
     : super core::_Enum::•(#index, #name)
     ;
@@ -215,10 +201,10 @@ class C extends core::_Enum /*isEnum*/  {
     return "C.${this.{core::_Enum::_name}{core::String}}";
 }
 class D extends core::_Enum /*isEnum*/  {
-  static const field core::List<mai::D> values = #C16;
-  static const field mai::D c = #C12;
-  enum-element static const field mai::D a = #C12;
-  enum-element static const field mai::D b = #C13;
+  static const field core::List<mai::D> values = #C17;
+  static const field mai::D c = #C13;
+  enum-element static const field mai::D a = #C13;
+  enum-element static const field mai::D b = #C14;
   const constructor •(core::int #index, core::String #name) → mai::D
     : super core::_Enum::•(#index, #name)
     ;
@@ -237,12 +223,13 @@ constants  {
   #C8 = self::B {index:#C1, _name:#C2}
   #C9 = self::B {index:#C4, _name:#C5}
   #C10 = <self::B*>[#C8, #C9]
-  #C11 = mai::C {index:#C1, _name:#C2}
-  #C12 = mai::D {index:#C1, _name:#C2}
-  #C13 = mai::D {index:#C4, _name:#C5}
-  #C14 = mai::C {index:#C4, _name:#C5}
-  #C15 = <mai::C*>[#C11, #C14]
-  #C16 = <mai::D*>[#C12, #C13]
+  #C11 = null
+  #C12 = mai::C {index:#C1, _name:#C2}
+  #C13 = mai::D {index:#C1, _name:#C2}
+  #C14 = mai::D {index:#C4, _name:#C5}
+  #C15 = mai::C {index:#C4, _name:#C5}
+  #C16 = <mai::C*>[#C12, #C15]
+  #C17 = <mai::D*>[#C13, #C14]
 }
 
 
diff --git a/pkg/front_end/testcases/general/labeled_default.dart.strong.expect b/pkg/front_end/testcases/general/labeled_default.dart.strong.expect
index c3dd8487e3b..98e9ec13607 100644
--- a/pkg/front_end/testcases/general/labeled_default.dart.strong.expect
+++ b/pkg/front_end/testcases/general/labeled_default.dart.strong.expect
@@ -3,5 +3,9 @@ import self as self;
 
 static method main() → dynamic {
   #L1:
-  {}
+  switch(1) {
+    #L2:
+    default:
+      {}
+  }
 }
diff --git a/pkg/front_end/testcases/general/labeled_default.dart.strong.transformed.expect b/pkg/front_end/testcases/general/labeled_default.dart.strong.transformed.expect
index c3dd8487e3b..98e9ec13607 100644
--- a/pkg/front_end/testcases/general/labeled_default.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/general/labeled_default.dart.strong.transformed.expect
@@ -3,5 +3,9 @@ import self as self;
 
 static method main() → dynamic {
   #L1:
-  {}
+  switch(1) {
+    #L2:
+    default:
+      {}
+  }
 }
diff --git a/pkg/front_end/testcases/general/labeled_default.dart.weak.expect b/pkg/front_end/testcases/general/labeled_default.dart.weak.expect
index c3dd8487e3b..98e9ec13607 100644
--- a/pkg/front_end/testcases/general/labeled_default.dart.weak.expect
+++ b/pkg/front_end/testcases/general/labeled_default.dart.weak.expect
@@ -3,5 +3,9 @@ import self as self;
 
 static method main() → dynamic {
   #L1:
-  {}
+  switch(1) {
+    #L2:
+    default:
+      {}
+  }
 }
diff --git a/pkg/front_end/testcases/general/labeled_default.dart.weak.modular.expect b/pkg/front_end/testcases/general/labeled_default.dart.weak.modular.expect
index c3dd8487e3b..98e9ec13607 100644
--- a/pkg/front_end/testcases/general/labeled_default.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/general/labeled_default.dart.weak.modular.expect
@@ -3,5 +3,9 @@ import self as self;
 
 static method main() → dynamic {
   #L1:
-  {}
+  switch(1) {
+    #L2:
+    default:
+      {}
+  }
 }
diff --git a/pkg/front_end/testcases/general/labeled_default.dart.weak.transformed.expect b/pkg/front_end/testcases/general/labeled_default.dart.weak.transformed.expect
index c3dd8487e3b..98e9ec13607 100644
--- a/pkg/front_end/testcases/general/labeled_default.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/general/labeled_default.dart.weak.transformed.expect
@@ -3,5 +3,9 @@ import self as self;
 
 static method main() → dynamic {
   #L1:
-  {}
+  switch(1) {
+    #L2:
+    default:
+      {}
+  }
 }
diff --git a/pkg/front_end/testcases/general/statements.dart.strong.expect b/pkg/front_end/testcases/general/statements.dart.strong.expect
index 1a382e1540a..8e6804cb184 100644
--- a/pkg/front_end/testcases/general/statements.dart.strong.expect
+++ b/pkg/front_end/testcases/general/statements.dart.strong.expect
@@ -68,127 +68,86 @@ static method main() → dynamic {
     core::print(e);
   }
   #L1:
-  {
-    final synthesized core::int #0#0 = 1;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+  switch(1) {
+    #L2:
+    case #C1:
+    case #C2:
       {
         core::print("Hello from switch case!");
         break #L1;
       }
-    }
-    else {
+    #L3:
+    default:
       {
         break #L1;
       }
-    }
   }
-  #L2:
-  {
-    core::int #t3 = -1;
-    final synthesized core::int #1#0 = 4;
-    if(#C2 =={core::num::==}{(core::Object) → core::bool} #1#0)
-      #t3 = 0;
-    else
-      if(#C1 =={core::num::==}{(core::Object) → core::bool} #1#0)
-        #t3 = 1;
-      else
-        if(#C3 =={core::num::==}{(core::Object) → core::bool} #1#0)
-          #t3 = 2;
-        else
-          if(#C4 =={core::num::==}{(core::Object) → core::bool} #1#0)
-            #t3 = 3;
-          else
-            #t3 = 4;
-    switch(#t3) {
-      #L3:
-      case #C3:
-        {
-          {
-            core::print("Hello from case 2!");
-            break #L2;
-          }
-        }
-      #L4:
-      case #C1:
-        {
-          {
-            core::print("Hello from case 1!");
-            continue #L3;
-          }
-        }
-      #L5:
-      case #C2:
-        {
-          {
-            core::print("Hello from case 0!");
-            continue #L4;
-          }
-        }
-      #L6:
-      case #C5:
-        {
-          {
-            core::print("Hello from case 4!");
-            continue #L7;
-          }
-        }
-      #L7:
-      case #C4:
-      default:
-        {
-          {
-            continue #L5;
-          }
-        }
-    }
+  #L4:
+  switch(4) {
+    #L5:
+    case #C2:
+      {
+        core::print("Hello from case 2!");
+        break #L4;
+      }
+    #L6:
+    case #C1:
+      {
+        core::print("Hello from case 1!");
+        continue #L5;
+      }
+    #L7:
+    case #C3:
+      {
+        core::print("Hello from case 0!");
+        continue #L6;
+      }
+    #L8:
+    case #C4:
+      {
+        core::print("Hello from case 4!");
+        continue #L9;
+      }
+    #L9:
+    default:
+      {
+        continue #L7;
+      }
   }
-  #L8:
-  {
-    core::int #t4 = -1;
-    final synthesized core::int #2#0 = 4;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #2#0)
-      #t4 = 0;
-    else
-      #t4 = 1;
-    switch(#t4) {
-      #L9:
-      case #C3:
-        {
-          {
-            core::print("Hello from next case 1");
-            break #L8;
-          }
-        }
-      #L10:
-      case #C1:
-      default:
-        {
-          {
-            continue #L9;
-          }
-        }
-    }
+  #L10:
+  switch(4) {
+    #L11:
+    case #C1:
+      {
+        core::print("Hello from next case 1");
+        break #L10;
+      }
+    #L12:
+    default:
+      {
+        continue #L11;
+      }
   }
   core::int i = 0;
-  #L11:
+  #L13:
   do
-    #L12:
+    #L14:
     {
       core::print("Hello from do-while!");
       if((i = i.{core::num::+}(1){(core::num) → core::int}).{core::num::<}(3){(core::num) → core::bool})
-        break #L12;
-      break #L11;
+        break #L14;
+      break #L13;
     }
   while (true)
   i = 0;
-  #L13:
+  #L15:
   while (true)
-    #L14:
+    #L16:
     {
       core::print("Hello from while!");
       if((i = i.{core::num::+}(1){(core::num) → core::int}).{core::num::<}(3){(core::num) → core::bool})
-        break #L14;
-      break #L13;
+        break #L16;
+      break #L15;
     }
 }
 
@@ -197,5 +156,4 @@ constants  {
   #C2 = 2
   #C3 = 0
   #C4 = 4
-  #C5 = 3
 }
diff --git a/pkg/front_end/testcases/general/statements.dart.strong.transformed.expect b/pkg/front_end/testcases/general/statements.dart.strong.transformed.expect
index a6c83a8eb7b..b94523a08a0 100644
--- a/pkg/front_end/testcases/general/statements.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/general/statements.dart.strong.transformed.expect
@@ -102,127 +102,86 @@ static method main() → dynamic {
     core::print(e);
   }
   #L1:
-  {
-    final synthesized core::int #0#0 = 1;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+  switch(1) {
+    #L2:
+    case #C1:
+    case #C2:
       {
         core::print("Hello from switch case!");
         break #L1;
       }
-    }
-    else {
+    #L3:
+    default:
       {
         break #L1;
       }
-    }
   }
-  #L2:
-  {
-    core::int #t4 = -1;
-    final synthesized core::int #1#0 = 4;
-    if(#C2 =={core::num::==}{(core::Object) → core::bool} #1#0)
-      #t4 = 0;
-    else
-      if(#C1 =={core::num::==}{(core::Object) → core::bool} #1#0)
-        #t4 = 1;
-      else
-        if(#C3 =={core::num::==}{(core::Object) → core::bool} #1#0)
-          #t4 = 2;
-        else
-          if(#C4 =={core::num::==}{(core::Object) → core::bool} #1#0)
-            #t4 = 3;
-          else
-            #t4 = 4;
-    switch(#t4) {
-      #L3:
-      case #C3:
-        {
-          {
-            core::print("Hello from case 2!");
-            break #L2;
-          }
-        }
-      #L4:
-      case #C1:
-        {
-          {
-            core::print("Hello from case 1!");
-            continue #L3;
-          }
-        }
-      #L5:
-      case #C2:
-        {
-          {
-            core::print("Hello from case 0!");
-            continue #L4;
-          }
-        }
-      #L6:
-      case #C5:
-        {
-          {
-            core::print("Hello from case 4!");
-            continue #L7;
-          }
-        }
-      #L7:
-      case #C4:
-      default:
-        {
-          {
-            continue #L5;
-          }
-        }
-    }
+  #L4:
+  switch(4) {
+    #L5:
+    case #C2:
+      {
+        core::print("Hello from case 2!");
+        break #L4;
+      }
+    #L6:
+    case #C1:
+      {
+        core::print("Hello from case 1!");
+        continue #L5;
+      }
+    #L7:
+    case #C3:
+      {
+        core::print("Hello from case 0!");
+        continue #L6;
+      }
+    #L8:
+    case #C4:
+      {
+        core::print("Hello from case 4!");
+        continue #L9;
+      }
+    #L9:
+    default:
+      {
+        continue #L7;
+      }
   }
-  #L8:
-  {
-    core::int #t5 = -1;
-    final synthesized core::int #2#0 = 4;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #2#0)
-      #t5 = 0;
-    else
-      #t5 = 1;
-    switch(#t5) {
-      #L9:
-      case #C3:
-        {
-          {
-            core::print("Hello from next case 1");
-            break #L8;
-          }
-        }
-      #L10:
-      case #C1:
-      default:
-        {
-          {
-            continue #L9;
-          }
-        }
-    }
+  #L10:
+  switch(4) {
+    #L11:
+    case #C1:
+      {
+        core::print("Hello from next case 1");
+        break #L10;
+      }
+    #L12:
+    default:
+      {
+        continue #L11;
+      }
   }
   core::int i = 0;
-  #L11:
+  #L13:
   do
-    #L12:
+    #L14:
     {
       core::print("Hello from do-while!");
       if((i = i.{core::num::+}(1){(core::num) → core::int}).{core::num::<}(3){(core::num) → core::bool})
-        break #L12;
-      break #L11;
+        break #L14;
+      break #L13;
     }
   while (true)
   i = 0;
-  #L13:
+  #L15:
   while (true)
-    #L14:
+    #L16:
     {
       core::print("Hello from while!");
       if((i = i.{core::num::+}(1){(core::num) → core::int}).{core::num::<}(3){(core::num) → core::bool})
-        break #L14;
-      break #L13;
+        break #L16;
+      break #L15;
     }
 }
 
@@ -231,5 +190,4 @@ constants  {
   #C2 = 2
   #C3 = 0
   #C4 = 4
-  #C5 = 3
 }
diff --git a/pkg/front_end/testcases/general/statements.dart.weak.expect b/pkg/front_end/testcases/general/statements.dart.weak.expect
index 1a382e1540a..8e6804cb184 100644
--- a/pkg/front_end/testcases/general/statements.dart.weak.expect
+++ b/pkg/front_end/testcases/general/statements.dart.weak.expect
@@ -68,127 +68,86 @@ static method main() → dynamic {
     core::print(e);
   }
   #L1:
-  {
-    final synthesized core::int #0#0 = 1;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+  switch(1) {
+    #L2:
+    case #C1:
+    case #C2:
       {
         core::print("Hello from switch case!");
         break #L1;
       }
-    }
-    else {
+    #L3:
+    default:
       {
         break #L1;
       }
-    }
   }
-  #L2:
-  {
-    core::int #t3 = -1;
-    final synthesized core::int #1#0 = 4;
-    if(#C2 =={core::num::==}{(core::Object) → core::bool} #1#0)
-      #t3 = 0;
-    else
-      if(#C1 =={core::num::==}{(core::Object) → core::bool} #1#0)
-        #t3 = 1;
-      else
-        if(#C3 =={core::num::==}{(core::Object) → core::bool} #1#0)
-          #t3 = 2;
-        else
-          if(#C4 =={core::num::==}{(core::Object) → core::bool} #1#0)
-            #t3 = 3;
-          else
-            #t3 = 4;
-    switch(#t3) {
-      #L3:
-      case #C3:
-        {
-          {
-            core::print("Hello from case 2!");
-            break #L2;
-          }
-        }
-      #L4:
-      case #C1:
-        {
-          {
-            core::print("Hello from case 1!");
-            continue #L3;
-          }
-        }
-      #L5:
-      case #C2:
-        {
-          {
-            core::print("Hello from case 0!");
-            continue #L4;
-          }
-        }
-      #L6:
-      case #C5:
-        {
-          {
-            core::print("Hello from case 4!");
-            continue #L7;
-          }
-        }
-      #L7:
-      case #C4:
-      default:
-        {
-          {
-            continue #L5;
-          }
-        }
-    }
+  #L4:
+  switch(4) {
+    #L5:
+    case #C2:
+      {
+        core::print("Hello from case 2!");
+        break #L4;
+      }
+    #L6:
+    case #C1:
+      {
+        core::print("Hello from case 1!");
+        continue #L5;
+      }
+    #L7:
+    case #C3:
+      {
+        core::print("Hello from case 0!");
+        continue #L6;
+      }
+    #L8:
+    case #C4:
+      {
+        core::print("Hello from case 4!");
+        continue #L9;
+      }
+    #L9:
+    default:
+      {
+        continue #L7;
+      }
   }
-  #L8:
-  {
-    core::int #t4 = -1;
-    final synthesized core::int #2#0 = 4;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #2#0)
-      #t4 = 0;
-    else
-      #t4 = 1;
-    switch(#t4) {
-      #L9:
-      case #C3:
-        {
-          {
-            core::print("Hello from next case 1");
-            break #L8;
-          }
-        }
-      #L10:
-      case #C1:
-      default:
-        {
-          {
-            continue #L9;
-          }
-        }
-    }
+  #L10:
+  switch(4) {
+    #L11:
+    case #C1:
+      {
+        core::print("Hello from next case 1");
+        break #L10;
+      }
+    #L12:
+    default:
+      {
+        continue #L11;
+      }
   }
   core::int i = 0;
-  #L11:
+  #L13:
   do
-    #L12:
+    #L14:
     {
       core::print("Hello from do-while!");
       if((i = i.{core::num::+}(1){(core::num) → core::int}).{core::num::<}(3){(core::num) → core::bool})
-        break #L12;
-      break #L11;
+        break #L14;
+      break #L13;
     }
   while (true)
   i = 0;
-  #L13:
+  #L15:
   while (true)
-    #L14:
+    #L16:
     {
       core::print("Hello from while!");
       if((i = i.{core::num::+}(1){(core::num) → core::int}).{core::num::<}(3){(core::num) → core::bool})
-        break #L14;
-      break #L13;
+        break #L16;
+      break #L15;
     }
 }
 
@@ -197,5 +156,4 @@ constants  {
   #C2 = 2
   #C3 = 0
   #C4 = 4
-  #C5 = 3
 }
diff --git a/pkg/front_end/testcases/general/statements.dart.weak.modular.expect b/pkg/front_end/testcases/general/statements.dart.weak.modular.expect
index 1a382e1540a..8e6804cb184 100644
--- a/pkg/front_end/testcases/general/statements.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/general/statements.dart.weak.modular.expect
@@ -68,127 +68,86 @@ static method main() → dynamic {
     core::print(e);
   }
   #L1:
-  {
-    final synthesized core::int #0#0 = 1;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+  switch(1) {
+    #L2:
+    case #C1:
+    case #C2:
       {
         core::print("Hello from switch case!");
         break #L1;
       }
-    }
-    else {
+    #L3:
+    default:
       {
         break #L1;
       }
-    }
   }
-  #L2:
-  {
-    core::int #t3 = -1;
-    final synthesized core::int #1#0 = 4;
-    if(#C2 =={core::num::==}{(core::Object) → core::bool} #1#0)
-      #t3 = 0;
-    else
-      if(#C1 =={core::num::==}{(core::Object) → core::bool} #1#0)
-        #t3 = 1;
-      else
-        if(#C3 =={core::num::==}{(core::Object) → core::bool} #1#0)
-          #t3 = 2;
-        else
-          if(#C4 =={core::num::==}{(core::Object) → core::bool} #1#0)
-            #t3 = 3;
-          else
-            #t3 = 4;
-    switch(#t3) {
-      #L3:
-      case #C3:
-        {
-          {
-            core::print("Hello from case 2!");
-            break #L2;
-          }
-        }
-      #L4:
-      case #C1:
-        {
-          {
-            core::print("Hello from case 1!");
-            continue #L3;
-          }
-        }
-      #L5:
-      case #C2:
-        {
-          {
-            core::print("Hello from case 0!");
-            continue #L4;
-          }
-        }
-      #L6:
-      case #C5:
-        {
-          {
-            core::print("Hello from case 4!");
-            continue #L7;
-          }
-        }
-      #L7:
-      case #C4:
-      default:
-        {
-          {
-            continue #L5;
-          }
-        }
-    }
+  #L4:
+  switch(4) {
+    #L5:
+    case #C2:
+      {
+        core::print("Hello from case 2!");
+        break #L4;
+      }
+    #L6:
+    case #C1:
+      {
+        core::print("Hello from case 1!");
+        continue #L5;
+      }
+    #L7:
+    case #C3:
+      {
+        core::print("Hello from case 0!");
+        continue #L6;
+      }
+    #L8:
+    case #C4:
+      {
+        core::print("Hello from case 4!");
+        continue #L9;
+      }
+    #L9:
+    default:
+      {
+        continue #L7;
+      }
   }
-  #L8:
-  {
-    core::int #t4 = -1;
-    final synthesized core::int #2#0 = 4;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #2#0)
-      #t4 = 0;
-    else
-      #t4 = 1;
-    switch(#t4) {
-      #L9:
-      case #C3:
-        {
-          {
-            core::print("Hello from next case 1");
-            break #L8;
-          }
-        }
-      #L10:
-      case #C1:
-      default:
-        {
-          {
-            continue #L9;
-          }
-        }
-    }
+  #L10:
+  switch(4) {
+    #L11:
+    case #C1:
+      {
+        core::print("Hello from next case 1");
+        break #L10;
+      }
+    #L12:
+    default:
+      {
+        continue #L11;
+      }
   }
   core::int i = 0;
-  #L11:
+  #L13:
   do
-    #L12:
+    #L14:
     {
       core::print("Hello from do-while!");
       if((i = i.{core::num::+}(1){(core::num) → core::int}).{core::num::<}(3){(core::num) → core::bool})
-        break #L12;
-      break #L11;
+        break #L14;
+      break #L13;
     }
   while (true)
   i = 0;
-  #L13:
+  #L15:
   while (true)
-    #L14:
+    #L16:
     {
       core::print("Hello from while!");
       if((i = i.{core::num::+}(1){(core::num) → core::int}).{core::num::<}(3){(core::num) → core::bool})
-        break #L14;
-      break #L13;
+        break #L16;
+      break #L15;
     }
 }
 
@@ -197,5 +156,4 @@ constants  {
   #C2 = 2
   #C3 = 0
   #C4 = 4
-  #C5 = 3
 }
diff --git a/pkg/front_end/testcases/general/statements.dart.weak.transformed.expect b/pkg/front_end/testcases/general/statements.dart.weak.transformed.expect
index a6c83a8eb7b..b94523a08a0 100644
--- a/pkg/front_end/testcases/general/statements.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/general/statements.dart.weak.transformed.expect
@@ -102,127 +102,86 @@ static method main() → dynamic {
     core::print(e);
   }
   #L1:
-  {
-    final synthesized core::int #0#0 = 1;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+  switch(1) {
+    #L2:
+    case #C1:
+    case #C2:
       {
         core::print("Hello from switch case!");
         break #L1;
       }
-    }
-    else {
+    #L3:
+    default:
       {
         break #L1;
       }
-    }
   }
-  #L2:
-  {
-    core::int #t4 = -1;
-    final synthesized core::int #1#0 = 4;
-    if(#C2 =={core::num::==}{(core::Object) → core::bool} #1#0)
-      #t4 = 0;
-    else
-      if(#C1 =={core::num::==}{(core::Object) → core::bool} #1#0)
-        #t4 = 1;
-      else
-        if(#C3 =={core::num::==}{(core::Object) → core::bool} #1#0)
-          #t4 = 2;
-        else
-          if(#C4 =={core::num::==}{(core::Object) → core::bool} #1#0)
-            #t4 = 3;
-          else
-            #t4 = 4;
-    switch(#t4) {
-      #L3:
-      case #C3:
-        {
-          {
-            core::print("Hello from case 2!");
-            break #L2;
-          }
-        }
-      #L4:
-      case #C1:
-        {
-          {
-            core::print("Hello from case 1!");
-            continue #L3;
-          }
-        }
-      #L5:
-      case #C2:
-        {
-          {
-            core::print("Hello from case 0!");
-            continue #L4;
-          }
-        }
-      #L6:
-      case #C5:
-        {
-          {
-            core::print("Hello from case 4!");
-            continue #L7;
-          }
-        }
-      #L7:
-      case #C4:
-      default:
-        {
-          {
-            continue #L5;
-          }
-        }
-    }
+  #L4:
+  switch(4) {
+    #L5:
+    case #C2:
+      {
+        core::print("Hello from case 2!");
+        break #L4;
+      }
+    #L6:
+    case #C1:
+      {
+        core::print("Hello from case 1!");
+        continue #L5;
+      }
+    #L7:
+    case #C3:
+      {
+        core::print("Hello from case 0!");
+        continue #L6;
+      }
+    #L8:
+    case #C4:
+      {
+        core::print("Hello from case 4!");
+        continue #L9;
+      }
+    #L9:
+    default:
+      {
+        continue #L7;
+      }
   }
-  #L8:
-  {
-    core::int #t5 = -1;
-    final synthesized core::int #2#0 = 4;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #2#0)
-      #t5 = 0;
-    else
-      #t5 = 1;
-    switch(#t5) {
-      #L9:
-      case #C3:
-        {
-          {
-            core::print("Hello from next case 1");
-            break #L8;
-          }
-        }
-      #L10:
-      case #C1:
-      default:
-        {
-          {
-            continue #L9;
-          }
-        }
-    }
+  #L10:
+  switch(4) {
+    #L11:
+    case #C1:
+      {
+        core::print("Hello from next case 1");
+        break #L10;
+      }
+    #L12:
+    default:
+      {
+        continue #L11;
+      }
   }
   core::int i = 0;
-  #L11:
+  #L13:
   do
-    #L12:
+    #L14:
     {
       core::print("Hello from do-while!");
       if((i = i.{core::num::+}(1){(core::num) → core::int}).{core::num::<}(3){(core::num) → core::bool})
-        break #L12;
-      break #L11;
+        break #L14;
+      break #L13;
     }
   while (true)
   i = 0;
-  #L13:
+  #L15:
   while (true)
-    #L14:
+    #L16:
     {
       core::print("Hello from while!");
       if((i = i.{core::num::+}(1){(core::num) → core::int}).{core::num::<}(3){(core::num) → core::bool})
-        break #L14;
-      break #L13;
+        break #L16;
+      break #L15;
     }
 }
 
@@ -231,5 +190,4 @@ constants  {
   #C2 = 2
   #C3 = 0
   #C4 = 4
-  #C5 = 3
 }
diff --git a/pkg/front_end/testcases/general/switch_error_recovery.dart.strong.expect b/pkg/front_end/testcases/general/switch_error_recovery.dart.strong.expect
index f4f945fe72f..3d26d352f74 100644
--- a/pkg/front_end/testcases/general/switch_error_recovery.dart.strong.expect
+++ b/pkg/front_end/testcases/general/switch_error_recovery.dart.strong.expect
@@ -16,5 +16,8 @@ class C<X extends core::Object? = dynamic, Y extends core::Object? = dynamic> ex
 }
 static method main() → void {
   #L1:
-  {}
+  switch(1) {
+    #L2:
+      {}
+  }
 }
diff --git a/pkg/front_end/testcases/general/switch_error_recovery.dart.strong.transformed.expect b/pkg/front_end/testcases/general/switch_error_recovery.dart.strong.transformed.expect
index f4f945fe72f..3d26d352f74 100644
--- a/pkg/front_end/testcases/general/switch_error_recovery.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/general/switch_error_recovery.dart.strong.transformed.expect
@@ -16,5 +16,8 @@ class C<X extends core::Object? = dynamic, Y extends core::Object? = dynamic> ex
 }
 static method main() → void {
   #L1:
-  {}
+  switch(1) {
+    #L2:
+      {}
+  }
 }
diff --git a/pkg/front_end/testcases/general/switch_error_recovery.dart.weak.expect b/pkg/front_end/testcases/general/switch_error_recovery.dart.weak.expect
index f4f945fe72f..3d26d352f74 100644
--- a/pkg/front_end/testcases/general/switch_error_recovery.dart.weak.expect
+++ b/pkg/front_end/testcases/general/switch_error_recovery.dart.weak.expect
@@ -16,5 +16,8 @@ class C<X extends core::Object? = dynamic, Y extends core::Object? = dynamic> ex
 }
 static method main() → void {
   #L1:
-  {}
+  switch(1) {
+    #L2:
+      {}
+  }
 }
diff --git a/pkg/front_end/testcases/general/switch_error_recovery.dart.weak.modular.expect b/pkg/front_end/testcases/general/switch_error_recovery.dart.weak.modular.expect
index f4f945fe72f..3d26d352f74 100644
--- a/pkg/front_end/testcases/general/switch_error_recovery.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/general/switch_error_recovery.dart.weak.modular.expect
@@ -16,5 +16,8 @@ class C<X extends core::Object? = dynamic, Y extends core::Object? = dynamic> ex
 }
 static method main() → void {
   #L1:
-  {}
+  switch(1) {
+    #L2:
+      {}
+  }
 }
diff --git a/pkg/front_end/testcases/general/switch_error_recovery.dart.weak.transformed.expect b/pkg/front_end/testcases/general/switch_error_recovery.dart.weak.transformed.expect
index f4f945fe72f..3d26d352f74 100644
--- a/pkg/front_end/testcases/general/switch_error_recovery.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/general/switch_error_recovery.dart.weak.transformed.expect
@@ -16,5 +16,8 @@ class C<X extends core::Object? = dynamic, Y extends core::Object? = dynamic> ex
 }
 static method main() → void {
   #L1:
-  {}
+  switch(1) {
+    #L2:
+      {}
+  }
 }
diff --git a/pkg/front_end/testcases/incremental/flutter_widget_transform_pattern.yaml.world.1.expect b/pkg/front_end/testcases/incremental/flutter_widget_transform_pattern.yaml.world.1.expect
index dee30d94869..44d9294b420 100644
--- a/pkg/front_end/testcases/incremental/flutter_widget_transform_pattern.yaml.world.1.expect
+++ b/pkg/front_end/testcases/incremental/flutter_widget_transform_pattern.yaml.world.1.expect
@@ -48,13 +48,12 @@ library from "org-dartlang-test:///main.dart" as main {
   }
   static method method(dynamic o) → dynamic {
     #L1:
-    {
-      final synthesized dynamic #0#0 = o;
-      if(#C7 =={dart.core::num::==}{(dart.core::Object) → dart.core::bool} #0#0) {
+    switch(o) {
+      #L2:
+      case #C7:
         {
           return new main::Foo::•($creationLocationd_0dea112b090073317d4: #C10);
         }
-      }
     }
     return null;
   }
diff --git a/pkg/front_end/testcases/incremental/flutter_widget_transform_pattern.yaml.world.2.expect b/pkg/front_end/testcases/incremental/flutter_widget_transform_pattern.yaml.world.2.expect
index dee30d94869..44d9294b420 100644
--- a/pkg/front_end/testcases/incremental/flutter_widget_transform_pattern.yaml.world.2.expect
+++ b/pkg/front_end/testcases/incremental/flutter_widget_transform_pattern.yaml.world.2.expect
@@ -48,13 +48,12 @@ library from "org-dartlang-test:///main.dart" as main {
   }
   static method method(dynamic o) → dynamic {
     #L1:
-    {
-      final synthesized dynamic #0#0 = o;
-      if(#C7 =={dart.core::num::==}{(dart.core::Object) → dart.core::bool} #0#0) {
+    switch(o) {
+      #L2:
+      case #C7:
         {
           return new main::Foo::•($creationLocationd_0dea112b090073317d4: #C10);
         }
-      }
     }
     return null;
   }
diff --git a/pkg/front_end/testcases/inference/switch_continue.dart.strong.expect b/pkg/front_end/testcases/inference/switch_continue.dart.strong.expect
index bcd5a184e2f..aa4038a58f7 100644
--- a/pkg/front_end/testcases/inference/switch_continue.dart.strong.expect
+++ b/pkg/front_end/testcases/inference/switch_continue.dart.strong.expect
@@ -4,32 +4,19 @@ import "dart:core" as core;
 
 static method test(core::int x, () → void f) → void {
   #L1:
-  {
-    core::int #t1 = -1;
-    final synthesized core::int #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0)
-      #t1 = 0;
-    else
-      if(#C2 =={core::num::==}{(core::Object) → core::bool} #0#0)
-        #t1 = 1;
-    switch(#t1) {
-      #L2:
-      case #C1:
-        {
-          {
-            f(){() → void};
-            continue #L3;
-          }
-        }
-      #L3:
-      case #C2:
-        {
-          {
-            f(){() → void};
-            break #L1;
-          }
-        }
-    }
+  switch(x) {
+    #L2:
+    case #C1:
+      {
+        f(){() → void};
+        continue #L3;
+      }
+    #L3:
+    case #C2:
+      {
+        f(){() → void};
+        break #L1;
+      }
   }
 }
 static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/switch_continue.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/switch_continue.dart.strong.transformed.expect
index bcd5a184e2f..aa4038a58f7 100644
--- a/pkg/front_end/testcases/inference/switch_continue.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference/switch_continue.dart.strong.transformed.expect
@@ -4,32 +4,19 @@ import "dart:core" as core;
 
 static method test(core::int x, () → void f) → void {
   #L1:
-  {
-    core::int #t1 = -1;
-    final synthesized core::int #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0)
-      #t1 = 0;
-    else
-      if(#C2 =={core::num::==}{(core::Object) → core::bool} #0#0)
-        #t1 = 1;
-    switch(#t1) {
-      #L2:
-      case #C1:
-        {
-          {
-            f(){() → void};
-            continue #L3;
-          }
-        }
-      #L3:
-      case #C2:
-        {
-          {
-            f(){() → void};
-            break #L1;
-          }
-        }
-    }
+  switch(x) {
+    #L2:
+    case #C1:
+      {
+        f(){() → void};
+        continue #L3;
+      }
+    #L3:
+    case #C2:
+      {
+        f(){() → void};
+        break #L1;
+      }
   }
 }
 static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/switch_continue.dart.weak.expect b/pkg/front_end/testcases/inference/switch_continue.dart.weak.expect
index bcd5a184e2f..aa4038a58f7 100644
--- a/pkg/front_end/testcases/inference/switch_continue.dart.weak.expect
+++ b/pkg/front_end/testcases/inference/switch_continue.dart.weak.expect
@@ -4,32 +4,19 @@ import "dart:core" as core;
 
 static method test(core::int x, () → void f) → void {
   #L1:
-  {
-    core::int #t1 = -1;
-    final synthesized core::int #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0)
-      #t1 = 0;
-    else
-      if(#C2 =={core::num::==}{(core::Object) → core::bool} #0#0)
-        #t1 = 1;
-    switch(#t1) {
-      #L2:
-      case #C1:
-        {
-          {
-            f(){() → void};
-            continue #L3;
-          }
-        }
-      #L3:
-      case #C2:
-        {
-          {
-            f(){() → void};
-            break #L1;
-          }
-        }
-    }
+  switch(x) {
+    #L2:
+    case #C1:
+      {
+        f(){() → void};
+        continue #L3;
+      }
+    #L3:
+    case #C2:
+      {
+        f(){() → void};
+        break #L1;
+      }
   }
 }
 static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/switch_continue.dart.weak.modular.expect b/pkg/front_end/testcases/inference/switch_continue.dart.weak.modular.expect
index bcd5a184e2f..aa4038a58f7 100644
--- a/pkg/front_end/testcases/inference/switch_continue.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/inference/switch_continue.dart.weak.modular.expect
@@ -4,32 +4,19 @@ import "dart:core" as core;
 
 static method test(core::int x, () → void f) → void {
   #L1:
-  {
-    core::int #t1 = -1;
-    final synthesized core::int #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0)
-      #t1 = 0;
-    else
-      if(#C2 =={core::num::==}{(core::Object) → core::bool} #0#0)
-        #t1 = 1;
-    switch(#t1) {
-      #L2:
-      case #C1:
-        {
-          {
-            f(){() → void};
-            continue #L3;
-          }
-        }
-      #L3:
-      case #C2:
-        {
-          {
-            f(){() → void};
-            break #L1;
-          }
-        }
-    }
+  switch(x) {
+    #L2:
+    case #C1:
+      {
+        f(){() → void};
+        continue #L3;
+      }
+    #L3:
+    case #C2:
+      {
+        f(){() → void};
+        break #L1;
+      }
   }
 }
 static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/switch_continue.dart.weak.transformed.expect b/pkg/front_end/testcases/inference/switch_continue.dart.weak.transformed.expect
index bcd5a184e2f..aa4038a58f7 100644
--- a/pkg/front_end/testcases/inference/switch_continue.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/inference/switch_continue.dart.weak.transformed.expect
@@ -4,32 +4,19 @@ import "dart:core" as core;
 
 static method test(core::int x, () → void f) → void {
   #L1:
-  {
-    core::int #t1 = -1;
-    final synthesized core::int #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0)
-      #t1 = 0;
-    else
-      if(#C2 =={core::num::==}{(core::Object) → core::bool} #0#0)
-        #t1 = 1;
-    switch(#t1) {
-      #L2:
-      case #C1:
-        {
-          {
-            f(){() → void};
-            continue #L3;
-          }
-        }
-      #L3:
-      case #C2:
-        {
-          {
-            f(){() → void};
-            break #L1;
-          }
-        }
-    }
+  switch(x) {
+    #L2:
+    case #C1:
+      {
+        f(){() → void};
+        continue #L3;
+      }
+    #L3:
+    case #C2:
+      {
+        f(){() → void};
+        break #L1;
+      }
   }
 }
 static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference_new/switch.dart.strong.expect b/pkg/front_end/testcases/inference_new/switch.dart.strong.expect
index 6b2eaa388d8..d06de435229 100644
--- a/pkg/front_end/testcases/inference_new/switch.dart.strong.expect
+++ b/pkg/front_end/testcases/inference_new/switch.dart.strong.expect
@@ -11,20 +11,19 @@ static method f<T extends core::Object? = dynamic>() → self::f::T%
   return throw "";
 static method test(self::C<core::int> x) → void {
   #L1:
-  {
-    final synthesized self::C<core::int> #0#0 = x;
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  switch(x) {
+    #L2:
+    case #C1:
       {
         core::int y = 0;
         break #L1;
       }
-    }
-    else {
+    #L3:
+    default:
       {
         core::int y = 0;
         break #L1;
       }
-    }
   }
 }
 static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference_new/switch.dart.strong.transformed.expect b/pkg/front_end/testcases/inference_new/switch.dart.strong.transformed.expect
index 6b2eaa388d8..d06de435229 100644
--- a/pkg/front_end/testcases/inference_new/switch.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference_new/switch.dart.strong.transformed.expect
@@ -11,20 +11,19 @@ static method f<T extends core::Object? = dynamic>() → self::f::T%
   return throw "";
 static method test(self::C<core::int> x) → void {
   #L1:
-  {
-    final synthesized self::C<core::int> #0#0 = x;
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  switch(x) {
+    #L2:
+    case #C1:
       {
         core::int y = 0;
         break #L1;
       }
-    }
-    else {
+    #L3:
+    default:
       {
         core::int y = 0;
         break #L1;
       }
-    }
   }
 }
 static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference_new/switch.dart.weak.expect b/pkg/front_end/testcases/inference_new/switch.dart.weak.expect
index bf3bdebed8c..5619c315c27 100644
--- a/pkg/front_end/testcases/inference_new/switch.dart.weak.expect
+++ b/pkg/front_end/testcases/inference_new/switch.dart.weak.expect
@@ -11,20 +11,19 @@ static method f<T extends core::Object? = dynamic>() → self::f::T%
   return throw "";
 static method test(self::C<core::int> x) → void {
   #L1:
-  {
-    final synthesized self::C<core::int> #0#0 = x;
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  switch(x) {
+    #L2:
+    case #C1:
       {
         core::int y = 0;
         break #L1;
       }
-    }
-    else {
+    #L3:
+    default:
       {
         core::int y = 0;
         break #L1;
       }
-    }
   }
 }
 static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference_new/switch.dart.weak.modular.expect b/pkg/front_end/testcases/inference_new/switch.dart.weak.modular.expect
index bf3bdebed8c..5619c315c27 100644
--- a/pkg/front_end/testcases/inference_new/switch.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/inference_new/switch.dart.weak.modular.expect
@@ -11,20 +11,19 @@ static method f<T extends core::Object? = dynamic>() → self::f::T%
   return throw "";
 static method test(self::C<core::int> x) → void {
   #L1:
-  {
-    final synthesized self::C<core::int> #0#0 = x;
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  switch(x) {
+    #L2:
+    case #C1:
       {
         core::int y = 0;
         break #L1;
       }
-    }
-    else {
+    #L3:
+    default:
       {
         core::int y = 0;
         break #L1;
       }
-    }
   }
 }
 static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference_new/switch.dart.weak.transformed.expect b/pkg/front_end/testcases/inference_new/switch.dart.weak.transformed.expect
index bf3bdebed8c..5619c315c27 100644
--- a/pkg/front_end/testcases/inference_new/switch.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/inference_new/switch.dart.weak.transformed.expect
@@ -11,20 +11,19 @@ static method f<T extends core::Object? = dynamic>() → self::f::T%
   return throw "";
 static method test(self::C<core::int> x) → void {
   #L1:
-  {
-    final synthesized self::C<core::int> #0#0 = x;
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  switch(x) {
+    #L2:
+    case #C1:
       {
         core::int y = 0;
         break #L1;
       }
-    }
-    else {
+    #L3:
+    default:
       {
         core::int y = 0;
         break #L1;
       }
-    }
   }
 }
 static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/late_lowering/caching.dart.strong.expect b/pkg/front_end/testcases/late_lowering/caching.dart.strong.expect
index b629ee1ba59..3ffef7ae9bb 100644
--- a/pkg/front_end/testcases/late_lowering/caching.dart.strong.expect
+++ b/pkg/front_end/testcases/late_lowering/caching.dart.strong.expect
@@ -457,10 +457,6 @@ static method switchStatement(dynamic o) → core::int {
   core::print("o = ${o}");
   #L1:
   {
-    dynamic a;
-    core::int b;
-    dynamic c;
-    dynamic d;
     final synthesized dynamic #0#0 = o;
     synthesized core::Object? #0#4;
     synthesized core::bool #0#4#isSet = false;
@@ -530,188 +526,219 @@ static method switchStatement(dynamic o) → core::int {
     synthesized core::bool #0#104#isSet = false;
     function #0#104#func() → dynamic
       return #0#104#isSet ?{dynamic} #0#104 : let final dynamic #t67 = #0#104#isSet = true in #0#104 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic};
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        return 1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return 1;
+        }
       }
     }
-    else
+    {
       if(#0#0 is{ForNonNullableByDefault} ({f: core::Object?}) && ((let final dynamic #t68 = #0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in (#0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int).{core::num::>=}(#C2){(core::num) → core::bool}) && (let final dynamic #t69 = #0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in (#0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int).{core::num::<}(#C3){(core::num) → core::bool}))) {
         {
           return 2;
         }
       }
-      else
-        if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C5 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-          {
-            return 3;
-          }
+    }
+    {
+      if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C5 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return 3;
         }
-        else
-          if(#0#0 is{ForNonNullableByDefault} ({g: core::Object?}) && (let final dynamic #t70 = #0#15#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in #C6 =={core::num::==}{(core::Object) → core::bool} #0#15#func(){() → core::Object?} as{ForNonNullableByDefault} core::int)) {
-            {
-              return 4;
-            }
-          }
-          else
-            if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?}) && (let final dynamic #t71 = (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final dynamic #t72 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?})}.a{core::Object?})! in true)) {
-              {
-                return 5;
-              }
-            }
-            else
-              if(#0#0 is{ForNonNullableByDefault} ({b: core::Object?}) && (!((#0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final dynamic #t73 = #0#23#isSet = true in #0#23 = #0#0{({b: core::Object?})}.b{core::Object?}) == null) ?{core::bool} true : false)) {
-                {
-                  return 6;
-                }
-              }
-              else
-                if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t74 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C7 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic}) {
-                  {
-                    return 7;
-                  }
-                }
-                else
-                  if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34#func(){() → core::bool} && #C7 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic}) {
-                    {
-                      return 8;
-                    }
-                  }
-                  else
-                    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38#func(){() → core::bool} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#43#func(){() → dynamic}) {
-                      {
-                        return 9;
-                      }
-                    }
-                    else
-                      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34#func(){() → core::bool} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && (#0#47#func(){() → core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t75 = #0#50#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#50#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final dynamic #t76 = #0#53#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#53#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool}))) {
-                        {
-                          return 10;
-                        }
-                      }
-                      else
-                        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38#func(){() → core::bool} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C4 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && (#0#58#func(){() → core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t77 = #0#61#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#61#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final dynamic #t78 = #0#64#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#64#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})) && #C5 =={core::num::==}{(core::Object) → core::bool} #0#43#func(){() → dynamic}) {
-                          {
-                            return 11;
-                          }
-                        }
-                        else
-                          if(#0#0 is{ForNonNullableByDefault} self::Class && #C1 =={core::num::==}{(core::Object) → core::bool} #0#69#func(){() → core::int}) {
-                            {
-                              return 12;
-                            }
-                          }
-                          else
-                            if(#0#0 is{ForNonNullableByDefault} self::Class && #C7 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::finalField}{core::int}) {
-                              {
-                                return 13;
-                              }
-                            }
-                            else
-                              if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#69#func(){() → core::int} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::getter}{core::int}) {
-                                {
-                                  return 14;
-                                }
-                              }
-                              else
-                                if(#0#0 is{ForNonNullableByDefault} self::Class) {
-                                  {
-                                    return 15;
-                                  }
-                                }
-                                else
-                                  if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C9) {
-                                    {
-                                      return 16;
-                                    }
-                                  }
-                                  else
-                                    if(#0#0 is{ForNonNullableByDefault} ({e: core::Object?}) && !(#0#0{({e: core::Object?})}.e{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C10)) {
-                                      {
-                                        return 17;
-                                      }
-                                    }
-                                    else
-                                      if(#0#0 is{ForNonNullableByDefault} core::Map<core::int, core::int> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t79 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t80 = #0#26#isSet = true in #0#26 = #0#0{core::Map<core::int, core::int>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<core::int, core::int>}.{core::Map::containsKey}(#C3){(core::Object?) → core::bool} && (#0#0{core::Map<core::int, core::int>}.{core::Map::[]}(#C3){(core::Object?) → core::int?} as{ForNonNullableByDefault} core::int).{core::num::>=}(#C11){(core::num) → core::bool}) {
-                                        {
-                                          return 18;
-                                        }
-                                      }
-                                      else
-                                        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t81 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t82 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && (let final dynamic #t83 = #0#30#func(){() → dynamic} in true)) {
-                                          {
-                                            return 19;
-                                          }
-                                        }
-                                        else
-                                          if(#0#0 is{ForNonNullableByDefault} core::bool) {
-                                            {
-                                              return 20;
-                                            }
-                                          }
-                                          else
-                                            if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t84 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C12) {
-                                              {
-                                                return 21;
-                                              }
-                                            }
-                                            else
-                                              if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t85 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t86 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C12){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C12){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::int) {
-                                                {
-                                                  return 22;
-                                                }
-                                              }
-                                              else
-                                                if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t87 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::String) {
-                                                  {
-                                                    return 23;
-                                                  }
-                                                }
-                                                else
-                                                  if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t88 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t89 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C7){(core::Object?) → core::bool} && (let final dynamic #t90 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C7){(core::Object?) → dynamic} in true)) {
-                                                    {
-                                                      return 24;
-                                                    }
-                                                  }
-                                                  else
-                                                    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t91 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t92 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && (#0#104#func(){() → dynamic} is{ForNonNullableByDefault} core::int && (let final dynamic #t93 = b = #0#104#func(){() → dynamic} as{ForNonNullableByDefault} core::int in true))) {
-                                                      {
-                                                        return 25;
-                                                      }
-                                                    }
-                                                    else
-                                                      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
-                                                        {
-                                                          return 26;
-                                                        }
-                                                      }
-                                                      else
-                                                        if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?, b: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final dynamic #t94 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?, b: core::Object?})}.a{core::Object?}) && (let final dynamic #t95 = c = #0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final dynamic #t96 = #0#23#isSet = true in #0#23 = #0#0{({a: core::Object?, b: core::Object?})}.b{core::Object?} in true)) {
-                                                          {
-                                                            return 27;
-                                                          }
-                                                        }
-                                                        else
-                                                          if(#0#0 is{ForNonNullableByDefault} ({c: core::Object?, d: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{({c: core::Object?, d: core::Object?})}.c{core::Object?} && (let final dynamic #t97 = d = #0#0{({c: core::Object?, d: core::Object?})}.d{core::Object?} in true) && d is{ForNonNullableByDefault} core::int) {
-                                                            {
-                                                              return 28;
-                                                            }
-                                                          }
-                                                          else {
-                                                            {
-                                                              return 0;
-                                                            }
-                                                          }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} ({g: core::Object?}) && (let final dynamic #t70 = #0#15#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in #C6 =={core::num::==}{(core::Object) → core::bool} #0#15#func(){() → core::Object?} as{ForNonNullableByDefault} core::int)) {
+        {
+          return 4;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?}) && (let final dynamic #t71 = (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final dynamic #t72 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?})}.a{core::Object?})! in true)) {
+        {
+          return 5;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} ({b: core::Object?}) && (!((#0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final dynamic #t73 = #0#23#isSet = true in #0#23 = #0#0{({b: core::Object?})}.b{core::Object?}) == null) ?{core::bool} true : false)) {
+        {
+          return 6;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t74 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C7 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic}) {
+        {
+          return 7;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34#func(){() → core::bool} && #C7 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic}) {
+        {
+          return 8;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38#func(){() → core::bool} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#43#func(){() → dynamic}) {
+        {
+          return 9;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34#func(){() → core::bool} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && (#0#47#func(){() → core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t75 = #0#50#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#50#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final dynamic #t76 = #0#53#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#53#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool}))) {
+        {
+          return 10;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38#func(){() → core::bool} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C4 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && (#0#58#func(){() → core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t77 = #0#61#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#61#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final dynamic #t78 = #0#64#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#64#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})) && #C5 =={core::num::==}{(core::Object) → core::bool} #0#43#func(){() → dynamic}) {
+        {
+          return 11;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Class && #C1 =={core::num::==}{(core::Object) → core::bool} #0#69#func(){() → core::int}) {
+        {
+          return 12;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Class && #C7 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::finalField}{core::int}) {
+        {
+          return 13;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#69#func(){() → core::int} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::getter}{core::int}) {
+        {
+          return 14;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Class) {
+        {
+          return 15;
+        }
+      }
+    }
+    {
+      if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C9) {
+        {
+          return 16;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} ({e: core::Object?}) && !(#0#0{({e: core::Object?})}.e{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C10)) {
+        {
+          return 17;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<core::int, core::int> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t79 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t80 = #0#26#isSet = true in #0#26 = #0#0{core::Map<core::int, core::int>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<core::int, core::int>}.{core::Map::containsKey}(#C3){(core::Object?) → core::bool} && (#0#0{core::Map<core::int, core::int>}.{core::Map::[]}(#C3){(core::Object?) → core::int?} as{ForNonNullableByDefault} core::int).{core::num::>=}(#C11){(core::num) → core::bool}) {
+        {
+          return 18;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t81 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t82 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && (let final dynamic #t83 = #0#30#func(){() → dynamic} in true)) {
+        {
+          return 19;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::bool) {
+        {
+          return 20;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t84 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C12) {
+        {
+          return 21;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t85 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t86 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C12){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C12){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::int) {
+        {
+          return 22;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t87 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::String) {
+        {
+          return 23;
+        }
+      }
+    }
+    {
+      dynamic a;
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t88 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t89 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C7){(core::Object?) → core::bool} && (let final dynamic #t90 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C7){(core::Object?) → dynamic} in true)) {
+        {
+          return 24;
+        }
+      }
+    }
+    {
+      core::int b;
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t91 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t92 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && (#0#104#func(){() → dynamic} is{ForNonNullableByDefault} core::int && (let final dynamic #t93 = b = #0#104#func(){() → dynamic} as{ForNonNullableByDefault} core::int in true))) {
+        {
+          return 25;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+        {
+          return 26;
+        }
+      }
+    }
+    {
+      dynamic c;
+      if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?, b: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final dynamic #t94 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?, b: core::Object?})}.a{core::Object?}) && (let final dynamic #t95 = c = #0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final dynamic #t96 = #0#23#isSet = true in #0#23 = #0#0{({a: core::Object?, b: core::Object?})}.b{core::Object?} in true)) {
+        {
+          return 27;
+        }
+      }
+    }
+    {
+      dynamic d;
+      if(#0#0 is{ForNonNullableByDefault} ({c: core::Object?, d: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{({c: core::Object?, d: core::Object?})}.c{core::Object?} && (let final dynamic #t97 = d = #0#0{({c: core::Object?, d: core::Object?})}.d{core::Object?} in true) && d is{ForNonNullableByDefault} core::int) {
+        {
+          return 28;
+        }
+      }
+    }
+    {
+      {
+        {
+          return 0;
+        }
+      }
+    }
   }
 }
 static method switchExpression(dynamic o) → core::int {
   core::print("o = ${o}");
   return block {
     core::int #t98;
-    dynamic a;
-    core::int b;
-    dynamic c;
-    dynamic d;
     final synthesized dynamic #0#0 = o;
     synthesized core::Object? #0#4;
     synthesized core::bool #0#4#isSet = false;
@@ -781,92 +808,187 @@ static method switchExpression(dynamic o) → core::int {
     synthesized core::bool #0#104#isSet = false;
     function #0#104#func() → dynamic
       return #0#104#isSet ?{dynamic} #0#104 : let final dynamic #t117 = #0#104#isSet = true in #0#104 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic};
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0)
-      #t98 = 1;
-    else
-      if(#0#0 is{ForNonNullableByDefault} ({f: core::Object?}) && ((let final dynamic #t118 = #0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in (#0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int).{core::num::>=}(#C2){(core::num) → core::bool}) && (let final dynamic #t119 = #0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in (#0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int).{core::num::<}(#C3){(core::num) → core::bool})))
-        #t98 = 2;
-      else
-        if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C5 =={core::num::==}{(core::Object) → core::bool} #0#0)
+    #L2:
+    {
+      {
+        if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+          #t98 = 1;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({f: core::Object?}) && ((let final dynamic #t118 = #0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in (#0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int).{core::num::>=}(#C2){(core::num) → core::bool}) && (let final dynamic #t119 = #0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in (#0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int).{core::num::<}(#C3){(core::num) → core::bool}))) {
+          #t98 = 2;
+          break #L2;
+        }
+      }
+      {
+        if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C5 =={core::num::==}{(core::Object) → core::bool} #0#0) {
           #t98 = 3;
-        else
-          if(#0#0 is{ForNonNullableByDefault} ({g: core::Object?}) && (let final dynamic #t120 = #0#15#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in #C6 =={core::num::==}{(core::Object) → core::bool} #0#15#func(){() → core::Object?} as{ForNonNullableByDefault} core::int))
-            #t98 = 4;
-          else
-            if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?}) && (let final dynamic #t121 = (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final dynamic #t122 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?})}.a{core::Object?})! in true))
-              #t98 = 5;
-            else
-              if(#0#0 is{ForNonNullableByDefault} ({b: core::Object?}) && (!((#0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final dynamic #t123 = #0#23#isSet = true in #0#23 = #0#0{({b: core::Object?})}.b{core::Object?}) == null) ?{core::bool} true : false))
-                #t98 = 6;
-              else
-                if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t124 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C7 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic})
-                  #t98 = 7;
-                else
-                  if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34#func(){() → core::bool} && #C7 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic})
-                    #t98 = 8;
-                  else
-                    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38#func(){() → core::bool} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#43#func(){() → dynamic})
-                      #t98 = 9;
-                    else
-                      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34#func(){() → core::bool} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && (#0#47#func(){() → core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t125 = #0#50#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#50#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final dynamic #t126 = #0#53#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#53#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})))
-                        #t98 = 10;
-                      else
-                        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38#func(){() → core::bool} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C4 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && (#0#58#func(){() → core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t127 = #0#61#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#61#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final dynamic #t128 = #0#64#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#64#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})) && #C5 =={core::num::==}{(core::Object) → core::bool} #0#43#func(){() → dynamic})
-                          #t98 = 11;
-                        else
-                          if(#0#0 is{ForNonNullableByDefault} self::Class && #C1 =={core::num::==}{(core::Object) → core::bool} #0#69#func(){() → core::int})
-                            #t98 = 12;
-                          else
-                            if(#0#0 is{ForNonNullableByDefault} self::Class && #C7 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::finalField}{core::int})
-                              #t98 = 13;
-                            else
-                              if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#69#func(){() → core::int} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::getter}{core::int})
-                                #t98 = 14;
-                              else
-                                if(#0#0 is{ForNonNullableByDefault} self::Class)
-                                  #t98 = 15;
-                                else
-                                  if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C9)
-                                    #t98 = 16;
-                                  else
-                                    if(#0#0 is{ForNonNullableByDefault} ({e: core::Object?}) && !(#0#0{({e: core::Object?})}.e{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C10))
-                                      #t98 = 17;
-                                    else
-                                      if(#0#0 is{ForNonNullableByDefault} core::Map<core::int, core::int> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t129 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t130 = #0#26#isSet = true in #0#26 = #0#0{core::Map<core::int, core::int>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<core::int, core::int>}.{core::Map::containsKey}(#C3){(core::Object?) → core::bool} && (#0#0{core::Map<core::int, core::int>}.{core::Map::[]}(#C3){(core::Object?) → core::int?} as{ForNonNullableByDefault} core::int).{core::num::>=}(#C11){(core::num) → core::bool})
-                                        #t98 = 18;
-                                      else
-                                        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t131 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t132 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && (let final dynamic #t133 = #0#30#func(){() → dynamic} in true))
-                                          #t98 = 19;
-                                        else
-                                          if(#0#0 is{ForNonNullableByDefault} core::bool)
-                                            #t98 = 20;
-                                          else
-                                            if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t134 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C12)
-                                              #t98 = 21;
-                                            else
-                                              if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t135 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t136 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C12){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C12){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::int)
-                                                #t98 = 22;
-                                              else
-                                                if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t137 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::String)
-                                                  #t98 = 23;
-                                                else
-                                                  if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t138 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t139 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C7){(core::Object?) → core::bool} && (let final dynamic #t140 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C7){(core::Object?) → dynamic} in true))
-                                                    #t98 = 24;
-                                                  else
-                                                    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t141 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t142 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && (#0#104#func(){() → dynamic} is{ForNonNullableByDefault} core::int && (let final dynamic #t143 = b = #0#104#func(){() → dynamic} as{ForNonNullableByDefault} core::int in true)))
-                                                      #t98 = 25;
-                                                    else
-                                                      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?})
-                                                        #t98 = 26;
-                                                      else
-                                                        if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?, b: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final dynamic #t144 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?, b: core::Object?})}.a{core::Object?}) && (let final dynamic #t145 = c = #0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final dynamic #t146 = #0#23#isSet = true in #0#23 = #0#0{({a: core::Object?, b: core::Object?})}.b{core::Object?} in true))
-                                                          #t98 = 27;
-                                                        else
-                                                          if(#0#0 is{ForNonNullableByDefault} ({c: core::Object?, d: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{({c: core::Object?, d: core::Object?})}.c{core::Object?} && (let final dynamic #t147 = d = #0#0{({c: core::Object?, d: core::Object?})}.d{core::Object?} in true) && d is{ForNonNullableByDefault} core::int)
-                                                            #t98 = 28;
-                                                          else
-                                                            if(true)
-                                                              #t98 = 0;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({g: core::Object?}) && (let final dynamic #t120 = #0#15#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in #C6 =={core::num::==}{(core::Object) → core::bool} #0#15#func(){() → core::Object?} as{ForNonNullableByDefault} core::int)) {
+          #t98 = 4;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?}) && (let final dynamic #t121 = (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final dynamic #t122 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?})}.a{core::Object?})! in true)) {
+          #t98 = 5;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({b: core::Object?}) && (!((#0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final dynamic #t123 = #0#23#isSet = true in #0#23 = #0#0{({b: core::Object?})}.b{core::Object?}) == null) ?{core::bool} true : false)) {
+          #t98 = 6;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t124 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C7 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic}) {
+          #t98 = 7;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34#func(){() → core::bool} && #C7 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic}) {
+          #t98 = 8;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38#func(){() → core::bool} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#43#func(){() → dynamic}) {
+          #t98 = 9;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34#func(){() → core::bool} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && (#0#47#func(){() → core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t125 = #0#50#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#50#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final dynamic #t126 = #0#53#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#53#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool}))) {
+          #t98 = 10;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38#func(){() → core::bool} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C4 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && (#0#58#func(){() → core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t127 = #0#61#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#61#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final dynamic #t128 = #0#64#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#64#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})) && #C5 =={core::num::==}{(core::Object) → core::bool} #0#43#func(){() → dynamic}) {
+          #t98 = 11;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} self::Class && #C1 =={core::num::==}{(core::Object) → core::bool} #0#69#func(){() → core::int}) {
+          #t98 = 12;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} self::Class && #C7 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::finalField}{core::int}) {
+          #t98 = 13;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#69#func(){() → core::int} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::getter}{core::int}) {
+          #t98 = 14;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} self::Class) {
+          #t98 = 15;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C9) {
+          #t98 = 16;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({e: core::Object?}) && !(#0#0{({e: core::Object?})}.e{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C10)) {
+          #t98 = 17;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::Map<core::int, core::int> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t129 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t130 = #0#26#isSet = true in #0#26 = #0#0{core::Map<core::int, core::int>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<core::int, core::int>}.{core::Map::containsKey}(#C3){(core::Object?) → core::bool} && (#0#0{core::Map<core::int, core::int>}.{core::Map::[]}(#C3){(core::Object?) → core::int?} as{ForNonNullableByDefault} core::int).{core::num::>=}(#C11){(core::num) → core::bool}) {
+          #t98 = 18;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t131 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t132 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && (let final dynamic #t133 = #0#30#func(){() → dynamic} in true)) {
+          #t98 = 19;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::bool) {
+          #t98 = 20;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t134 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C12) {
+          #t98 = 21;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t135 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t136 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C12){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C12){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::int) {
+          #t98 = 22;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t137 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::String) {
+          #t98 = 23;
+          break #L2;
+        }
+      }
+      {
+        dynamic a;
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t138 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t139 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C7){(core::Object?) → core::bool} && (let final dynamic #t140 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C7){(core::Object?) → dynamic} in true)) {
+          #t98 = 24;
+          break #L2;
+        }
+      }
+      {
+        core::int b;
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t141 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t142 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && (#0#104#func(){() → dynamic} is{ForNonNullableByDefault} core::int && (let final dynamic #t143 = b = #0#104#func(){() → dynamic} as{ForNonNullableByDefault} core::int in true))) {
+          #t98 = 25;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+          #t98 = 26;
+          break #L2;
+        }
+      }
+      {
+        dynamic c;
+        if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?, b: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final dynamic #t144 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?, b: core::Object?})}.a{core::Object?}) && (let final dynamic #t145 = c = #0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final dynamic #t146 = #0#23#isSet = true in #0#23 = #0#0{({a: core::Object?, b: core::Object?})}.b{core::Object?} in true)) {
+          #t98 = 27;
+          break #L2;
+        }
+      }
+      {
+        dynamic d;
+        if(#0#0 is{ForNonNullableByDefault} ({c: core::Object?, d: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{({c: core::Object?, d: core::Object?})}.c{core::Object?} && (let final dynamic #t147 = d = #0#0{({c: core::Object?, d: core::Object?})}.d{core::Object?} in true) && d is{ForNonNullableByDefault} core::int) {
+          #t98 = 28;
+          break #L2;
+        }
+      }
+      {
+        if(true) {
+          #t98 = 0;
+          break #L2;
+        }
+      }
+    }
   } =>#t98;
 }
 static method test(dynamic expected, dynamic value) → dynamic {
diff --git a/pkg/front_end/testcases/late_lowering/caching.dart.strong.transformed.expect b/pkg/front_end/testcases/late_lowering/caching.dart.strong.transformed.expect
index 5e53052935d..353fe40f2e4 100644
--- a/pkg/front_end/testcases/late_lowering/caching.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/late_lowering/caching.dart.strong.transformed.expect
@@ -457,10 +457,6 @@ static method switchStatement(dynamic o) → core::int {
   core::print("o = ${o}");
   #L1:
   {
-    dynamic a;
-    core::int b;
-    dynamic c;
-    dynamic d;
     final synthesized dynamic #0#0 = o;
     synthesized core::Object? #0#4;
     synthesized core::bool #0#4#isSet = false;
@@ -530,188 +526,219 @@ static method switchStatement(dynamic o) → core::int {
     synthesized core::bool #0#104#isSet = false;
     function #0#104#func() → dynamic
       return #0#104#isSet ?{dynamic} #0#104 : let final core::bool* #t69 = #0#104#isSet = true in #0#104 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic};
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        return 1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return 1;
+        }
       }
     }
-    else
+    {
       if(#0#0 is{ForNonNullableByDefault} ({f: core::Object?}) && ((let final core::int #t70 = #0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in (#0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int).{core::num::>=}(#C2){(core::num) → core::bool}) && (let final core::int #t71 = #0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in (#0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int).{core::num::<}(#C3){(core::num) → core::bool}))) {
         {
           return 2;
         }
       }
-      else
-        if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C5 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-          {
-            return 3;
-          }
+    }
+    {
+      if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C5 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return 3;
         }
-        else
-          if(#0#0 is{ForNonNullableByDefault} ({g: core::Object?}) && (let final core::int #t72 = #0#15#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in #C6 =={core::num::==}{(core::Object) → core::bool} #0#15#func(){() → core::Object?} as{ForNonNullableByDefault} core::int)) {
-            {
-              return 4;
-            }
-          }
-          else
-            if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?}) && (let final core::Object? #t73 = (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final core::bool* #t74 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?})}.a{core::Object?})! in true)) {
-              {
-                return 5;
-              }
-            }
-            else
-              if(#0#0 is{ForNonNullableByDefault} ({b: core::Object?}) && (!((#0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final core::bool* #t75 = #0#23#isSet = true in #0#23 = #0#0{({b: core::Object?})}.b{core::Object?}) == null) ?{core::bool} true : false)) {
-                {
-                  return 6;
-                }
-              }
-              else
-                if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t76 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C7 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic}) {
-                  {
-                    return 7;
-                  }
-                }
-                else
-                  if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34#func(){() → core::bool} && #C7 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic}) {
-                    {
-                      return 8;
-                    }
-                  }
-                  else
-                    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38#func(){() → core::bool} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#43#func(){() → dynamic}) {
-                      {
-                        return 9;
-                      }
-                    }
-                    else
-                      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34#func(){() → core::bool} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && (#0#47#func(){() → core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final core::int #t77 = #0#50#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#50#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final core::int #t78 = #0#53#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#53#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool}))) {
-                        {
-                          return 10;
-                        }
-                      }
-                      else
-                        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38#func(){() → core::bool} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C4 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && (#0#58#func(){() → core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final core::int #t79 = #0#61#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#61#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final core::int #t80 = #0#64#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#64#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})) && #C5 =={core::num::==}{(core::Object) → core::bool} #0#43#func(){() → dynamic}) {
-                          {
-                            return 11;
-                          }
-                        }
-                        else
-                          if(#0#0 is{ForNonNullableByDefault} self::Class && #C1 =={core::num::==}{(core::Object) → core::bool} #0#69#func(){() → core::int}) {
-                            {
-                              return 12;
-                            }
-                          }
-                          else
-                            if(#0#0 is{ForNonNullableByDefault} self::Class && #C7 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::finalField}{core::int}) {
-                              {
-                                return 13;
-                              }
-                            }
-                            else
-                              if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#69#func(){() → core::int} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::getter}{core::int}) {
-                                {
-                                  return 14;
-                                }
-                              }
-                              else
-                                if(#0#0 is{ForNonNullableByDefault} self::Class) {
-                                  {
-                                    return 15;
-                                  }
-                                }
-                                else
-                                  if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C9) {
-                                    {
-                                      return 16;
-                                    }
-                                  }
-                                  else
-                                    if(#0#0 is{ForNonNullableByDefault} ({e: core::Object?}) && !(#0#0{({e: core::Object?})}.e{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C10)) {
-                                      {
-                                        return 17;
-                                      }
-                                    }
-                                    else
-                                      if(#0#0 is{ForNonNullableByDefault} core::Map<core::int, core::int> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t81 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t82 = #0#26#isSet = true in #0#26 = #0#0{core::Map<core::int, core::int>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<core::int, core::int>}.{core::Map::containsKey}(#C3){(core::Object?) → core::bool} && (let core::int? #t83 = #0#0{core::Map<core::int, core::int>}.{core::Map::[]}(#C3){(core::Object?) → core::int?} in #t83 == null ?{core::int} #t83 as{ForNonNullableByDefault} core::int : #t83{core::int}).{core::num::>=}(#C11){(core::num) → core::bool}) {
-                                        {
-                                          return 18;
-                                        }
-                                      }
-                                      else
-                                        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t84 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t85 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && (let final dynamic #t86 = #0#30#func(){() → dynamic} in true)) {
-                                          {
-                                            return 19;
-                                          }
-                                        }
-                                        else
-                                          if(#0#0 is{ForNonNullableByDefault} core::bool) {
-                                            {
-                                              return 20;
-                                            }
-                                          }
-                                          else
-                                            if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t87 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C12) {
-                                              {
-                                                return 21;
-                                              }
-                                            }
-                                            else
-                                              if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t88 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t89 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C12){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C12){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::int) {
-                                                {
-                                                  return 22;
-                                                }
-                                              }
-                                              else
-                                                if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t90 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::String) {
-                                                  {
-                                                    return 23;
-                                                  }
-                                                }
-                                                else
-                                                  if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t91 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t92 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C7){(core::Object?) → core::bool} && (let final dynamic #t93 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C7){(core::Object?) → dynamic} in true)) {
-                                                    {
-                                                      return 24;
-                                                    }
-                                                  }
-                                                  else
-                                                    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t94 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t95 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && (#0#104#func(){() → dynamic} is{ForNonNullableByDefault} core::int && (let final core::int #t96 = b = #0#104#func(){() → dynamic} as{ForNonNullableByDefault} core::int in true))) {
-                                                      {
-                                                        return 25;
-                                                      }
-                                                    }
-                                                    else
-                                                      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
-                                                        {
-                                                          return 26;
-                                                        }
-                                                      }
-                                                      else
-                                                        if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?, b: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final core::bool* #t97 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?, b: core::Object?})}.a{core::Object?}) && (let final core::Object? #t98 = c = #0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final core::bool* #t99 = #0#23#isSet = true in #0#23 = #0#0{({a: core::Object?, b: core::Object?})}.b{core::Object?} in true)) {
-                                                          {
-                                                            return 27;
-                                                          }
-                                                        }
-                                                        else
-                                                          if(#0#0 is{ForNonNullableByDefault} ({c: core::Object?, d: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{({c: core::Object?, d: core::Object?})}.c{core::Object?} && (let final core::Object? #t100 = d = #0#0{({c: core::Object?, d: core::Object?})}.d{core::Object?} in true) && d is{ForNonNullableByDefault} core::int) {
-                                                            {
-                                                              return 28;
-                                                            }
-                                                          }
-                                                          else {
-                                                            {
-                                                              return 0;
-                                                            }
-                                                          }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} ({g: core::Object?}) && (let final core::int #t72 = #0#15#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in #C6 =={core::num::==}{(core::Object) → core::bool} #0#15#func(){() → core::Object?} as{ForNonNullableByDefault} core::int)) {
+        {
+          return 4;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?}) && (let final core::Object? #t73 = (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final core::bool* #t74 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?})}.a{core::Object?})! in true)) {
+        {
+          return 5;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} ({b: core::Object?}) && (!((#0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final core::bool* #t75 = #0#23#isSet = true in #0#23 = #0#0{({b: core::Object?})}.b{core::Object?}) == null) ?{core::bool} true : false)) {
+        {
+          return 6;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t76 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C7 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic}) {
+        {
+          return 7;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34#func(){() → core::bool} && #C7 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic}) {
+        {
+          return 8;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38#func(){() → core::bool} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#43#func(){() → dynamic}) {
+        {
+          return 9;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34#func(){() → core::bool} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && (#0#47#func(){() → core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final core::int #t77 = #0#50#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#50#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final core::int #t78 = #0#53#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#53#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool}))) {
+        {
+          return 10;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38#func(){() → core::bool} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C4 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && (#0#58#func(){() → core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final core::int #t79 = #0#61#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#61#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final core::int #t80 = #0#64#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#64#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})) && #C5 =={core::num::==}{(core::Object) → core::bool} #0#43#func(){() → dynamic}) {
+        {
+          return 11;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Class && #C1 =={core::num::==}{(core::Object) → core::bool} #0#69#func(){() → core::int}) {
+        {
+          return 12;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Class && #C7 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::finalField}{core::int}) {
+        {
+          return 13;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#69#func(){() → core::int} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::getter}{core::int}) {
+        {
+          return 14;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Class) {
+        {
+          return 15;
+        }
+      }
+    }
+    {
+      if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C9) {
+        {
+          return 16;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} ({e: core::Object?}) && !(#0#0{({e: core::Object?})}.e{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C10)) {
+        {
+          return 17;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<core::int, core::int> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t81 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t82 = #0#26#isSet = true in #0#26 = #0#0{core::Map<core::int, core::int>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<core::int, core::int>}.{core::Map::containsKey}(#C3){(core::Object?) → core::bool} && (let core::int? #t83 = #0#0{core::Map<core::int, core::int>}.{core::Map::[]}(#C3){(core::Object?) → core::int?} in #t83 == null ?{core::int} #t83 as{ForNonNullableByDefault} core::int : #t83{core::int}).{core::num::>=}(#C11){(core::num) → core::bool}) {
+        {
+          return 18;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t84 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t85 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && (let final dynamic #t86 = #0#30#func(){() → dynamic} in true)) {
+        {
+          return 19;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::bool) {
+        {
+          return 20;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t87 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C12) {
+        {
+          return 21;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t88 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t89 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C12){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C12){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::int) {
+        {
+          return 22;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t90 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::String) {
+        {
+          return 23;
+        }
+      }
+    }
+    {
+      dynamic a;
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t91 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t92 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C7){(core::Object?) → core::bool} && (let final dynamic #t93 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C7){(core::Object?) → dynamic} in true)) {
+        {
+          return 24;
+        }
+      }
+    }
+    {
+      core::int b;
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t94 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t95 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && (#0#104#func(){() → dynamic} is{ForNonNullableByDefault} core::int && (let final core::int #t96 = b = #0#104#func(){() → dynamic} as{ForNonNullableByDefault} core::int in true))) {
+        {
+          return 25;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+        {
+          return 26;
+        }
+      }
+    }
+    {
+      dynamic c;
+      if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?, b: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final core::bool* #t97 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?, b: core::Object?})}.a{core::Object?}) && (let final core::Object? #t98 = c = #0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final core::bool* #t99 = #0#23#isSet = true in #0#23 = #0#0{({a: core::Object?, b: core::Object?})}.b{core::Object?} in true)) {
+        {
+          return 27;
+        }
+      }
+    }
+    {
+      dynamic d;
+      if(#0#0 is{ForNonNullableByDefault} ({c: core::Object?, d: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{({c: core::Object?, d: core::Object?})}.c{core::Object?} && (let final core::Object? #t100 = d = #0#0{({c: core::Object?, d: core::Object?})}.d{core::Object?} in true) && d is{ForNonNullableByDefault} core::int) {
+        {
+          return 28;
+        }
+      }
+    }
+    {
+      {
+        {
+          return 0;
+        }
+      }
+    }
   }
 }
 static method switchExpression(dynamic o) → core::int {
   core::print("o = ${o}");
   return block {
     core::int #t101;
-    dynamic a;
-    core::int b;
-    dynamic c;
-    dynamic d;
     final synthesized dynamic #0#0 = o;
     synthesized core::Object? #0#4;
     synthesized core::bool #0#4#isSet = false;
@@ -781,92 +808,187 @@ static method switchExpression(dynamic o) → core::int {
     synthesized core::bool #0#104#isSet = false;
     function #0#104#func() → dynamic
       return #0#104#isSet ?{dynamic} #0#104 : let final core::bool* #t120 = #0#104#isSet = true in #0#104 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic};
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0)
-      #t101 = 1;
-    else
-      if(#0#0 is{ForNonNullableByDefault} ({f: core::Object?}) && ((let final core::int #t121 = #0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in (#0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int).{core::num::>=}(#C2){(core::num) → core::bool}) && (let final core::int #t122 = #0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in (#0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int).{core::num::<}(#C3){(core::num) → core::bool})))
-        #t101 = 2;
-      else
-        if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C5 =={core::num::==}{(core::Object) → core::bool} #0#0)
+    #L2:
+    {
+      {
+        if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+          #t101 = 1;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({f: core::Object?}) && ((let final core::int #t121 = #0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in (#0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int).{core::num::>=}(#C2){(core::num) → core::bool}) && (let final core::int #t122 = #0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in (#0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int).{core::num::<}(#C3){(core::num) → core::bool}))) {
+          #t101 = 2;
+          break #L2;
+        }
+      }
+      {
+        if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C5 =={core::num::==}{(core::Object) → core::bool} #0#0) {
           #t101 = 3;
-        else
-          if(#0#0 is{ForNonNullableByDefault} ({g: core::Object?}) && (let final core::int #t123 = #0#15#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in #C6 =={core::num::==}{(core::Object) → core::bool} #0#15#func(){() → core::Object?} as{ForNonNullableByDefault} core::int))
-            #t101 = 4;
-          else
-            if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?}) && (let final core::Object? #t124 = (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final core::bool* #t125 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?})}.a{core::Object?})! in true))
-              #t101 = 5;
-            else
-              if(#0#0 is{ForNonNullableByDefault} ({b: core::Object?}) && (!((#0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final core::bool* #t126 = #0#23#isSet = true in #0#23 = #0#0{({b: core::Object?})}.b{core::Object?}) == null) ?{core::bool} true : false))
-                #t101 = 6;
-              else
-                if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t127 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C7 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic})
-                  #t101 = 7;
-                else
-                  if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34#func(){() → core::bool} && #C7 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic})
-                    #t101 = 8;
-                  else
-                    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38#func(){() → core::bool} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#43#func(){() → dynamic})
-                      #t101 = 9;
-                    else
-                      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34#func(){() → core::bool} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && (#0#47#func(){() → core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final core::int #t128 = #0#50#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#50#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final core::int #t129 = #0#53#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#53#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})))
-                        #t101 = 10;
-                      else
-                        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38#func(){() → core::bool} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C4 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && (#0#58#func(){() → core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final core::int #t130 = #0#61#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#61#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final core::int #t131 = #0#64#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#64#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})) && #C5 =={core::num::==}{(core::Object) → core::bool} #0#43#func(){() → dynamic})
-                          #t101 = 11;
-                        else
-                          if(#0#0 is{ForNonNullableByDefault} self::Class && #C1 =={core::num::==}{(core::Object) → core::bool} #0#69#func(){() → core::int})
-                            #t101 = 12;
-                          else
-                            if(#0#0 is{ForNonNullableByDefault} self::Class && #C7 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::finalField}{core::int})
-                              #t101 = 13;
-                            else
-                              if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#69#func(){() → core::int} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::getter}{core::int})
-                                #t101 = 14;
-                              else
-                                if(#0#0 is{ForNonNullableByDefault} self::Class)
-                                  #t101 = 15;
-                                else
-                                  if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C9)
-                                    #t101 = 16;
-                                  else
-                                    if(#0#0 is{ForNonNullableByDefault} ({e: core::Object?}) && !(#0#0{({e: core::Object?})}.e{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C10))
-                                      #t101 = 17;
-                                    else
-                                      if(#0#0 is{ForNonNullableByDefault} core::Map<core::int, core::int> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t132 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t133 = #0#26#isSet = true in #0#26 = #0#0{core::Map<core::int, core::int>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<core::int, core::int>}.{core::Map::containsKey}(#C3){(core::Object?) → core::bool} && (let core::int? #t134 = #0#0{core::Map<core::int, core::int>}.{core::Map::[]}(#C3){(core::Object?) → core::int?} in #t134 == null ?{core::int} #t134 as{ForNonNullableByDefault} core::int : #t134{core::int}).{core::num::>=}(#C11){(core::num) → core::bool})
-                                        #t101 = 18;
-                                      else
-                                        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t135 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t136 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && (let final dynamic #t137 = #0#30#func(){() → dynamic} in true))
-                                          #t101 = 19;
-                                        else
-                                          if(#0#0 is{ForNonNullableByDefault} core::bool)
-                                            #t101 = 20;
-                                          else
-                                            if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t138 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C12)
-                                              #t101 = 21;
-                                            else
-                                              if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t139 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t140 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C12){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C12){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::int)
-                                                #t101 = 22;
-                                              else
-                                                if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t141 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::String)
-                                                  #t101 = 23;
-                                                else
-                                                  if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t142 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t143 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C7){(core::Object?) → core::bool} && (let final dynamic #t144 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C7){(core::Object?) → dynamic} in true))
-                                                    #t101 = 24;
-                                                  else
-                                                    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t145 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t146 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && (#0#104#func(){() → dynamic} is{ForNonNullableByDefault} core::int && (let final core::int #t147 = b = #0#104#func(){() → dynamic} as{ForNonNullableByDefault} core::int in true)))
-                                                      #t101 = 25;
-                                                    else
-                                                      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?})
-                                                        #t101 = 26;
-                                                      else
-                                                        if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?, b: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final core::bool* #t148 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?, b: core::Object?})}.a{core::Object?}) && (let final core::Object? #t149 = c = #0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final core::bool* #t150 = #0#23#isSet = true in #0#23 = #0#0{({a: core::Object?, b: core::Object?})}.b{core::Object?} in true))
-                                                          #t101 = 27;
-                                                        else
-                                                          if(#0#0 is{ForNonNullableByDefault} ({c: core::Object?, d: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{({c: core::Object?, d: core::Object?})}.c{core::Object?} && (let final core::Object? #t151 = d = #0#0{({c: core::Object?, d: core::Object?})}.d{core::Object?} in true) && d is{ForNonNullableByDefault} core::int)
-                                                            #t101 = 28;
-                                                          else
-                                                            if(true)
-                                                              #t101 = 0;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({g: core::Object?}) && (let final core::int #t123 = #0#15#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in #C6 =={core::num::==}{(core::Object) → core::bool} #0#15#func(){() → core::Object?} as{ForNonNullableByDefault} core::int)) {
+          #t101 = 4;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?}) && (let final core::Object? #t124 = (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final core::bool* #t125 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?})}.a{core::Object?})! in true)) {
+          #t101 = 5;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({b: core::Object?}) && (!((#0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final core::bool* #t126 = #0#23#isSet = true in #0#23 = #0#0{({b: core::Object?})}.b{core::Object?}) == null) ?{core::bool} true : false)) {
+          #t101 = 6;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t127 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C7 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic}) {
+          #t101 = 7;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34#func(){() → core::bool} && #C7 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic}) {
+          #t101 = 8;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38#func(){() → core::bool} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#43#func(){() → dynamic}) {
+          #t101 = 9;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34#func(){() → core::bool} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && (#0#47#func(){() → core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final core::int #t128 = #0#50#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#50#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final core::int #t129 = #0#53#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#53#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool}))) {
+          #t101 = 10;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38#func(){() → core::bool} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C4 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && (#0#58#func(){() → core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final core::int #t130 = #0#61#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#61#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final core::int #t131 = #0#64#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#64#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})) && #C5 =={core::num::==}{(core::Object) → core::bool} #0#43#func(){() → dynamic}) {
+          #t101 = 11;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} self::Class && #C1 =={core::num::==}{(core::Object) → core::bool} #0#69#func(){() → core::int}) {
+          #t101 = 12;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} self::Class && #C7 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::finalField}{core::int}) {
+          #t101 = 13;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#69#func(){() → core::int} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::getter}{core::int}) {
+          #t101 = 14;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} self::Class) {
+          #t101 = 15;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C9) {
+          #t101 = 16;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({e: core::Object?}) && !(#0#0{({e: core::Object?})}.e{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C10)) {
+          #t101 = 17;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::Map<core::int, core::int> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t132 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t133 = #0#26#isSet = true in #0#26 = #0#0{core::Map<core::int, core::int>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<core::int, core::int>}.{core::Map::containsKey}(#C3){(core::Object?) → core::bool} && (let core::int? #t134 = #0#0{core::Map<core::int, core::int>}.{core::Map::[]}(#C3){(core::Object?) → core::int?} in #t134 == null ?{core::int} #t134 as{ForNonNullableByDefault} core::int : #t134{core::int}).{core::num::>=}(#C11){(core::num) → core::bool}) {
+          #t101 = 18;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t135 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t136 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && (let final dynamic #t137 = #0#30#func(){() → dynamic} in true)) {
+          #t101 = 19;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::bool) {
+          #t101 = 20;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t138 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C12) {
+          #t101 = 21;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t139 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t140 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C12){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C12){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::int) {
+          #t101 = 22;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t141 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::String) {
+          #t101 = 23;
+          break #L2;
+        }
+      }
+      {
+        dynamic a;
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t142 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t143 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C7){(core::Object?) → core::bool} && (let final dynamic #t144 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C7){(core::Object?) → dynamic} in true)) {
+          #t101 = 24;
+          break #L2;
+        }
+      }
+      {
+        core::int b;
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t145 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t146 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && (#0#104#func(){() → dynamic} is{ForNonNullableByDefault} core::int && (let final core::int #t147 = b = #0#104#func(){() → dynamic} as{ForNonNullableByDefault} core::int in true))) {
+          #t101 = 25;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+          #t101 = 26;
+          break #L2;
+        }
+      }
+      {
+        dynamic c;
+        if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?, b: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final core::bool* #t148 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?, b: core::Object?})}.a{core::Object?}) && (let final core::Object? #t149 = c = #0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final core::bool* #t150 = #0#23#isSet = true in #0#23 = #0#0{({a: core::Object?, b: core::Object?})}.b{core::Object?} in true)) {
+          #t101 = 27;
+          break #L2;
+        }
+      }
+      {
+        dynamic d;
+        if(#0#0 is{ForNonNullableByDefault} ({c: core::Object?, d: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{({c: core::Object?, d: core::Object?})}.c{core::Object?} && (let final core::Object? #t151 = d = #0#0{({c: core::Object?, d: core::Object?})}.d{core::Object?} in true) && d is{ForNonNullableByDefault} core::int) {
+          #t101 = 28;
+          break #L2;
+        }
+      }
+      {
+        if(true) {
+          #t101 = 0;
+          break #L2;
+        }
+      }
+    }
   } =>#t101;
 }
 static method test(dynamic expected, dynamic value) → dynamic {
diff --git a/pkg/front_end/testcases/late_lowering/caching.dart.weak.expect b/pkg/front_end/testcases/late_lowering/caching.dart.weak.expect
index b629ee1ba59..3ffef7ae9bb 100644
--- a/pkg/front_end/testcases/late_lowering/caching.dart.weak.expect
+++ b/pkg/front_end/testcases/late_lowering/caching.dart.weak.expect
@@ -457,10 +457,6 @@ static method switchStatement(dynamic o) → core::int {
   core::print("o = ${o}");
   #L1:
   {
-    dynamic a;
-    core::int b;
-    dynamic c;
-    dynamic d;
     final synthesized dynamic #0#0 = o;
     synthesized core::Object? #0#4;
     synthesized core::bool #0#4#isSet = false;
@@ -530,188 +526,219 @@ static method switchStatement(dynamic o) → core::int {
     synthesized core::bool #0#104#isSet = false;
     function #0#104#func() → dynamic
       return #0#104#isSet ?{dynamic} #0#104 : let final dynamic #t67 = #0#104#isSet = true in #0#104 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic};
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        return 1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return 1;
+        }
       }
     }
-    else
+    {
       if(#0#0 is{ForNonNullableByDefault} ({f: core::Object?}) && ((let final dynamic #t68 = #0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in (#0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int).{core::num::>=}(#C2){(core::num) → core::bool}) && (let final dynamic #t69 = #0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in (#0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int).{core::num::<}(#C3){(core::num) → core::bool}))) {
         {
           return 2;
         }
       }
-      else
-        if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C5 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-          {
-            return 3;
-          }
+    }
+    {
+      if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C5 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return 3;
         }
-        else
-          if(#0#0 is{ForNonNullableByDefault} ({g: core::Object?}) && (let final dynamic #t70 = #0#15#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in #C6 =={core::num::==}{(core::Object) → core::bool} #0#15#func(){() → core::Object?} as{ForNonNullableByDefault} core::int)) {
-            {
-              return 4;
-            }
-          }
-          else
-            if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?}) && (let final dynamic #t71 = (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final dynamic #t72 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?})}.a{core::Object?})! in true)) {
-              {
-                return 5;
-              }
-            }
-            else
-              if(#0#0 is{ForNonNullableByDefault} ({b: core::Object?}) && (!((#0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final dynamic #t73 = #0#23#isSet = true in #0#23 = #0#0{({b: core::Object?})}.b{core::Object?}) == null) ?{core::bool} true : false)) {
-                {
-                  return 6;
-                }
-              }
-              else
-                if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t74 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C7 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic}) {
-                  {
-                    return 7;
-                  }
-                }
-                else
-                  if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34#func(){() → core::bool} && #C7 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic}) {
-                    {
-                      return 8;
-                    }
-                  }
-                  else
-                    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38#func(){() → core::bool} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#43#func(){() → dynamic}) {
-                      {
-                        return 9;
-                      }
-                    }
-                    else
-                      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34#func(){() → core::bool} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && (#0#47#func(){() → core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t75 = #0#50#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#50#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final dynamic #t76 = #0#53#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#53#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool}))) {
-                        {
-                          return 10;
-                        }
-                      }
-                      else
-                        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38#func(){() → core::bool} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C4 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && (#0#58#func(){() → core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t77 = #0#61#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#61#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final dynamic #t78 = #0#64#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#64#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})) && #C5 =={core::num::==}{(core::Object) → core::bool} #0#43#func(){() → dynamic}) {
-                          {
-                            return 11;
-                          }
-                        }
-                        else
-                          if(#0#0 is{ForNonNullableByDefault} self::Class && #C1 =={core::num::==}{(core::Object) → core::bool} #0#69#func(){() → core::int}) {
-                            {
-                              return 12;
-                            }
-                          }
-                          else
-                            if(#0#0 is{ForNonNullableByDefault} self::Class && #C7 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::finalField}{core::int}) {
-                              {
-                                return 13;
-                              }
-                            }
-                            else
-                              if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#69#func(){() → core::int} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::getter}{core::int}) {
-                                {
-                                  return 14;
-                                }
-                              }
-                              else
-                                if(#0#0 is{ForNonNullableByDefault} self::Class) {
-                                  {
-                                    return 15;
-                                  }
-                                }
-                                else
-                                  if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C9) {
-                                    {
-                                      return 16;
-                                    }
-                                  }
-                                  else
-                                    if(#0#0 is{ForNonNullableByDefault} ({e: core::Object?}) && !(#0#0{({e: core::Object?})}.e{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C10)) {
-                                      {
-                                        return 17;
-                                      }
-                                    }
-                                    else
-                                      if(#0#0 is{ForNonNullableByDefault} core::Map<core::int, core::int> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t79 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t80 = #0#26#isSet = true in #0#26 = #0#0{core::Map<core::int, core::int>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<core::int, core::int>}.{core::Map::containsKey}(#C3){(core::Object?) → core::bool} && (#0#0{core::Map<core::int, core::int>}.{core::Map::[]}(#C3){(core::Object?) → core::int?} as{ForNonNullableByDefault} core::int).{core::num::>=}(#C11){(core::num) → core::bool}) {
-                                        {
-                                          return 18;
-                                        }
-                                      }
-                                      else
-                                        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t81 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t82 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && (let final dynamic #t83 = #0#30#func(){() → dynamic} in true)) {
-                                          {
-                                            return 19;
-                                          }
-                                        }
-                                        else
-                                          if(#0#0 is{ForNonNullableByDefault} core::bool) {
-                                            {
-                                              return 20;
-                                            }
-                                          }
-                                          else
-                                            if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t84 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C12) {
-                                              {
-                                                return 21;
-                                              }
-                                            }
-                                            else
-                                              if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t85 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t86 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C12){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C12){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::int) {
-                                                {
-                                                  return 22;
-                                                }
-                                              }
-                                              else
-                                                if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t87 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::String) {
-                                                  {
-                                                    return 23;
-                                                  }
-                                                }
-                                                else
-                                                  if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t88 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t89 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C7){(core::Object?) → core::bool} && (let final dynamic #t90 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C7){(core::Object?) → dynamic} in true)) {
-                                                    {
-                                                      return 24;
-                                                    }
-                                                  }
-                                                  else
-                                                    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t91 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t92 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && (#0#104#func(){() → dynamic} is{ForNonNullableByDefault} core::int && (let final dynamic #t93 = b = #0#104#func(){() → dynamic} as{ForNonNullableByDefault} core::int in true))) {
-                                                      {
-                                                        return 25;
-                                                      }
-                                                    }
-                                                    else
-                                                      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
-                                                        {
-                                                          return 26;
-                                                        }
-                                                      }
-                                                      else
-                                                        if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?, b: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final dynamic #t94 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?, b: core::Object?})}.a{core::Object?}) && (let final dynamic #t95 = c = #0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final dynamic #t96 = #0#23#isSet = true in #0#23 = #0#0{({a: core::Object?, b: core::Object?})}.b{core::Object?} in true)) {
-                                                          {
-                                                            return 27;
-                                                          }
-                                                        }
-                                                        else
-                                                          if(#0#0 is{ForNonNullableByDefault} ({c: core::Object?, d: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{({c: core::Object?, d: core::Object?})}.c{core::Object?} && (let final dynamic #t97 = d = #0#0{({c: core::Object?, d: core::Object?})}.d{core::Object?} in true) && d is{ForNonNullableByDefault} core::int) {
-                                                            {
-                                                              return 28;
-                                                            }
-                                                          }
-                                                          else {
-                                                            {
-                                                              return 0;
-                                                            }
-                                                          }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} ({g: core::Object?}) && (let final dynamic #t70 = #0#15#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in #C6 =={core::num::==}{(core::Object) → core::bool} #0#15#func(){() → core::Object?} as{ForNonNullableByDefault} core::int)) {
+        {
+          return 4;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?}) && (let final dynamic #t71 = (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final dynamic #t72 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?})}.a{core::Object?})! in true)) {
+        {
+          return 5;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} ({b: core::Object?}) && (!((#0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final dynamic #t73 = #0#23#isSet = true in #0#23 = #0#0{({b: core::Object?})}.b{core::Object?}) == null) ?{core::bool} true : false)) {
+        {
+          return 6;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t74 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C7 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic}) {
+        {
+          return 7;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34#func(){() → core::bool} && #C7 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic}) {
+        {
+          return 8;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38#func(){() → core::bool} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#43#func(){() → dynamic}) {
+        {
+          return 9;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34#func(){() → core::bool} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && (#0#47#func(){() → core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t75 = #0#50#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#50#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final dynamic #t76 = #0#53#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#53#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool}))) {
+        {
+          return 10;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38#func(){() → core::bool} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C4 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && (#0#58#func(){() → core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t77 = #0#61#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#61#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final dynamic #t78 = #0#64#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#64#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})) && #C5 =={core::num::==}{(core::Object) → core::bool} #0#43#func(){() → dynamic}) {
+        {
+          return 11;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Class && #C1 =={core::num::==}{(core::Object) → core::bool} #0#69#func(){() → core::int}) {
+        {
+          return 12;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Class && #C7 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::finalField}{core::int}) {
+        {
+          return 13;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#69#func(){() → core::int} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::getter}{core::int}) {
+        {
+          return 14;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Class) {
+        {
+          return 15;
+        }
+      }
+    }
+    {
+      if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C9) {
+        {
+          return 16;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} ({e: core::Object?}) && !(#0#0{({e: core::Object?})}.e{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C10)) {
+        {
+          return 17;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<core::int, core::int> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t79 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t80 = #0#26#isSet = true in #0#26 = #0#0{core::Map<core::int, core::int>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<core::int, core::int>}.{core::Map::containsKey}(#C3){(core::Object?) → core::bool} && (#0#0{core::Map<core::int, core::int>}.{core::Map::[]}(#C3){(core::Object?) → core::int?} as{ForNonNullableByDefault} core::int).{core::num::>=}(#C11){(core::num) → core::bool}) {
+        {
+          return 18;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t81 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t82 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && (let final dynamic #t83 = #0#30#func(){() → dynamic} in true)) {
+        {
+          return 19;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::bool) {
+        {
+          return 20;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t84 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C12) {
+        {
+          return 21;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t85 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t86 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C12){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C12){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::int) {
+        {
+          return 22;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t87 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::String) {
+        {
+          return 23;
+        }
+      }
+    }
+    {
+      dynamic a;
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t88 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t89 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C7){(core::Object?) → core::bool} && (let final dynamic #t90 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C7){(core::Object?) → dynamic} in true)) {
+        {
+          return 24;
+        }
+      }
+    }
+    {
+      core::int b;
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t91 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t92 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && (#0#104#func(){() → dynamic} is{ForNonNullableByDefault} core::int && (let final dynamic #t93 = b = #0#104#func(){() → dynamic} as{ForNonNullableByDefault} core::int in true))) {
+        {
+          return 25;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+        {
+          return 26;
+        }
+      }
+    }
+    {
+      dynamic c;
+      if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?, b: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final dynamic #t94 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?, b: core::Object?})}.a{core::Object?}) && (let final dynamic #t95 = c = #0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final dynamic #t96 = #0#23#isSet = true in #0#23 = #0#0{({a: core::Object?, b: core::Object?})}.b{core::Object?} in true)) {
+        {
+          return 27;
+        }
+      }
+    }
+    {
+      dynamic d;
+      if(#0#0 is{ForNonNullableByDefault} ({c: core::Object?, d: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{({c: core::Object?, d: core::Object?})}.c{core::Object?} && (let final dynamic #t97 = d = #0#0{({c: core::Object?, d: core::Object?})}.d{core::Object?} in true) && d is{ForNonNullableByDefault} core::int) {
+        {
+          return 28;
+        }
+      }
+    }
+    {
+      {
+        {
+          return 0;
+        }
+      }
+    }
   }
 }
 static method switchExpression(dynamic o) → core::int {
   core::print("o = ${o}");
   return block {
     core::int #t98;
-    dynamic a;
-    core::int b;
-    dynamic c;
-    dynamic d;
     final synthesized dynamic #0#0 = o;
     synthesized core::Object? #0#4;
     synthesized core::bool #0#4#isSet = false;
@@ -781,92 +808,187 @@ static method switchExpression(dynamic o) → core::int {
     synthesized core::bool #0#104#isSet = false;
     function #0#104#func() → dynamic
       return #0#104#isSet ?{dynamic} #0#104 : let final dynamic #t117 = #0#104#isSet = true in #0#104 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic};
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0)
-      #t98 = 1;
-    else
-      if(#0#0 is{ForNonNullableByDefault} ({f: core::Object?}) && ((let final dynamic #t118 = #0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in (#0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int).{core::num::>=}(#C2){(core::num) → core::bool}) && (let final dynamic #t119 = #0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in (#0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int).{core::num::<}(#C3){(core::num) → core::bool})))
-        #t98 = 2;
-      else
-        if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C5 =={core::num::==}{(core::Object) → core::bool} #0#0)
+    #L2:
+    {
+      {
+        if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+          #t98 = 1;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({f: core::Object?}) && ((let final dynamic #t118 = #0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in (#0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int).{core::num::>=}(#C2){(core::num) → core::bool}) && (let final dynamic #t119 = #0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in (#0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int).{core::num::<}(#C3){(core::num) → core::bool}))) {
+          #t98 = 2;
+          break #L2;
+        }
+      }
+      {
+        if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C5 =={core::num::==}{(core::Object) → core::bool} #0#0) {
           #t98 = 3;
-        else
-          if(#0#0 is{ForNonNullableByDefault} ({g: core::Object?}) && (let final dynamic #t120 = #0#15#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in #C6 =={core::num::==}{(core::Object) → core::bool} #0#15#func(){() → core::Object?} as{ForNonNullableByDefault} core::int))
-            #t98 = 4;
-          else
-            if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?}) && (let final dynamic #t121 = (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final dynamic #t122 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?})}.a{core::Object?})! in true))
-              #t98 = 5;
-            else
-              if(#0#0 is{ForNonNullableByDefault} ({b: core::Object?}) && (!((#0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final dynamic #t123 = #0#23#isSet = true in #0#23 = #0#0{({b: core::Object?})}.b{core::Object?}) == null) ?{core::bool} true : false))
-                #t98 = 6;
-              else
-                if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t124 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C7 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic})
-                  #t98 = 7;
-                else
-                  if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34#func(){() → core::bool} && #C7 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic})
-                    #t98 = 8;
-                  else
-                    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38#func(){() → core::bool} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#43#func(){() → dynamic})
-                      #t98 = 9;
-                    else
-                      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34#func(){() → core::bool} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && (#0#47#func(){() → core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t125 = #0#50#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#50#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final dynamic #t126 = #0#53#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#53#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})))
-                        #t98 = 10;
-                      else
-                        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38#func(){() → core::bool} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C4 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && (#0#58#func(){() → core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t127 = #0#61#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#61#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final dynamic #t128 = #0#64#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#64#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})) && #C5 =={core::num::==}{(core::Object) → core::bool} #0#43#func(){() → dynamic})
-                          #t98 = 11;
-                        else
-                          if(#0#0 is{ForNonNullableByDefault} self::Class && #C1 =={core::num::==}{(core::Object) → core::bool} #0#69#func(){() → core::int})
-                            #t98 = 12;
-                          else
-                            if(#0#0 is{ForNonNullableByDefault} self::Class && #C7 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::finalField}{core::int})
-                              #t98 = 13;
-                            else
-                              if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#69#func(){() → core::int} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::getter}{core::int})
-                                #t98 = 14;
-                              else
-                                if(#0#0 is{ForNonNullableByDefault} self::Class)
-                                  #t98 = 15;
-                                else
-                                  if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C9)
-                                    #t98 = 16;
-                                  else
-                                    if(#0#0 is{ForNonNullableByDefault} ({e: core::Object?}) && !(#0#0{({e: core::Object?})}.e{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C10))
-                                      #t98 = 17;
-                                    else
-                                      if(#0#0 is{ForNonNullableByDefault} core::Map<core::int, core::int> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t129 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t130 = #0#26#isSet = true in #0#26 = #0#0{core::Map<core::int, core::int>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<core::int, core::int>}.{core::Map::containsKey}(#C3){(core::Object?) → core::bool} && (#0#0{core::Map<core::int, core::int>}.{core::Map::[]}(#C3){(core::Object?) → core::int?} as{ForNonNullableByDefault} core::int).{core::num::>=}(#C11){(core::num) → core::bool})
-                                        #t98 = 18;
-                                      else
-                                        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t131 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t132 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && (let final dynamic #t133 = #0#30#func(){() → dynamic} in true))
-                                          #t98 = 19;
-                                        else
-                                          if(#0#0 is{ForNonNullableByDefault} core::bool)
-                                            #t98 = 20;
-                                          else
-                                            if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t134 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C12)
-                                              #t98 = 21;
-                                            else
-                                              if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t135 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t136 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C12){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C12){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::int)
-                                                #t98 = 22;
-                                              else
-                                                if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t137 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::String)
-                                                  #t98 = 23;
-                                                else
-                                                  if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t138 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t139 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C7){(core::Object?) → core::bool} && (let final dynamic #t140 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C7){(core::Object?) → dynamic} in true))
-                                                    #t98 = 24;
-                                                  else
-                                                    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t141 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t142 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && (#0#104#func(){() → dynamic} is{ForNonNullableByDefault} core::int && (let final dynamic #t143 = b = #0#104#func(){() → dynamic} as{ForNonNullableByDefault} core::int in true)))
-                                                      #t98 = 25;
-                                                    else
-                                                      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?})
-                                                        #t98 = 26;
-                                                      else
-                                                        if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?, b: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final dynamic #t144 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?, b: core::Object?})}.a{core::Object?}) && (let final dynamic #t145 = c = #0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final dynamic #t146 = #0#23#isSet = true in #0#23 = #0#0{({a: core::Object?, b: core::Object?})}.b{core::Object?} in true))
-                                                          #t98 = 27;
-                                                        else
-                                                          if(#0#0 is{ForNonNullableByDefault} ({c: core::Object?, d: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{({c: core::Object?, d: core::Object?})}.c{core::Object?} && (let final dynamic #t147 = d = #0#0{({c: core::Object?, d: core::Object?})}.d{core::Object?} in true) && d is{ForNonNullableByDefault} core::int)
-                                                            #t98 = 28;
-                                                          else
-                                                            if(true)
-                                                              #t98 = 0;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({g: core::Object?}) && (let final dynamic #t120 = #0#15#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in #C6 =={core::num::==}{(core::Object) → core::bool} #0#15#func(){() → core::Object?} as{ForNonNullableByDefault} core::int)) {
+          #t98 = 4;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?}) && (let final dynamic #t121 = (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final dynamic #t122 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?})}.a{core::Object?})! in true)) {
+          #t98 = 5;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({b: core::Object?}) && (!((#0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final dynamic #t123 = #0#23#isSet = true in #0#23 = #0#0{({b: core::Object?})}.b{core::Object?}) == null) ?{core::bool} true : false)) {
+          #t98 = 6;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t124 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C7 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic}) {
+          #t98 = 7;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34#func(){() → core::bool} && #C7 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic}) {
+          #t98 = 8;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38#func(){() → core::bool} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#43#func(){() → dynamic}) {
+          #t98 = 9;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34#func(){() → core::bool} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && (#0#47#func(){() → core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t125 = #0#50#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#50#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final dynamic #t126 = #0#53#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#53#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool}))) {
+          #t98 = 10;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38#func(){() → core::bool} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C4 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && (#0#58#func(){() → core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t127 = #0#61#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#61#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final dynamic #t128 = #0#64#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#64#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})) && #C5 =={core::num::==}{(core::Object) → core::bool} #0#43#func(){() → dynamic}) {
+          #t98 = 11;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} self::Class && #C1 =={core::num::==}{(core::Object) → core::bool} #0#69#func(){() → core::int}) {
+          #t98 = 12;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} self::Class && #C7 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::finalField}{core::int}) {
+          #t98 = 13;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#69#func(){() → core::int} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::getter}{core::int}) {
+          #t98 = 14;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} self::Class) {
+          #t98 = 15;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C9) {
+          #t98 = 16;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({e: core::Object?}) && !(#0#0{({e: core::Object?})}.e{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C10)) {
+          #t98 = 17;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::Map<core::int, core::int> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t129 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t130 = #0#26#isSet = true in #0#26 = #0#0{core::Map<core::int, core::int>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<core::int, core::int>}.{core::Map::containsKey}(#C3){(core::Object?) → core::bool} && (#0#0{core::Map<core::int, core::int>}.{core::Map::[]}(#C3){(core::Object?) → core::int?} as{ForNonNullableByDefault} core::int).{core::num::>=}(#C11){(core::num) → core::bool}) {
+          #t98 = 18;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t131 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t132 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && (let final dynamic #t133 = #0#30#func(){() → dynamic} in true)) {
+          #t98 = 19;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::bool) {
+          #t98 = 20;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t134 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C12) {
+          #t98 = 21;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t135 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t136 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C12){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C12){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::int) {
+          #t98 = 22;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t137 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::String) {
+          #t98 = 23;
+          break #L2;
+        }
+      }
+      {
+        dynamic a;
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t138 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t139 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C7){(core::Object?) → core::bool} && (let final dynamic #t140 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C7){(core::Object?) → dynamic} in true)) {
+          #t98 = 24;
+          break #L2;
+        }
+      }
+      {
+        core::int b;
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t141 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t142 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && (#0#104#func(){() → dynamic} is{ForNonNullableByDefault} core::int && (let final dynamic #t143 = b = #0#104#func(){() → dynamic} as{ForNonNullableByDefault} core::int in true))) {
+          #t98 = 25;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+          #t98 = 26;
+          break #L2;
+        }
+      }
+      {
+        dynamic c;
+        if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?, b: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final dynamic #t144 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?, b: core::Object?})}.a{core::Object?}) && (let final dynamic #t145 = c = #0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final dynamic #t146 = #0#23#isSet = true in #0#23 = #0#0{({a: core::Object?, b: core::Object?})}.b{core::Object?} in true)) {
+          #t98 = 27;
+          break #L2;
+        }
+      }
+      {
+        dynamic d;
+        if(#0#0 is{ForNonNullableByDefault} ({c: core::Object?, d: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{({c: core::Object?, d: core::Object?})}.c{core::Object?} && (let final dynamic #t147 = d = #0#0{({c: core::Object?, d: core::Object?})}.d{core::Object?} in true) && d is{ForNonNullableByDefault} core::int) {
+          #t98 = 28;
+          break #L2;
+        }
+      }
+      {
+        if(true) {
+          #t98 = 0;
+          break #L2;
+        }
+      }
+    }
   } =>#t98;
 }
 static method test(dynamic expected, dynamic value) → dynamic {
diff --git a/pkg/front_end/testcases/late_lowering/caching.dart.weak.modular.expect b/pkg/front_end/testcases/late_lowering/caching.dart.weak.modular.expect
index b629ee1ba59..3ffef7ae9bb 100644
--- a/pkg/front_end/testcases/late_lowering/caching.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/late_lowering/caching.dart.weak.modular.expect
@@ -457,10 +457,6 @@ static method switchStatement(dynamic o) → core::int {
   core::print("o = ${o}");
   #L1:
   {
-    dynamic a;
-    core::int b;
-    dynamic c;
-    dynamic d;
     final synthesized dynamic #0#0 = o;
     synthesized core::Object? #0#4;
     synthesized core::bool #0#4#isSet = false;
@@ -530,188 +526,219 @@ static method switchStatement(dynamic o) → core::int {
     synthesized core::bool #0#104#isSet = false;
     function #0#104#func() → dynamic
       return #0#104#isSet ?{dynamic} #0#104 : let final dynamic #t67 = #0#104#isSet = true in #0#104 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic};
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        return 1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return 1;
+        }
       }
     }
-    else
+    {
       if(#0#0 is{ForNonNullableByDefault} ({f: core::Object?}) && ((let final dynamic #t68 = #0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in (#0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int).{core::num::>=}(#C2){(core::num) → core::bool}) && (let final dynamic #t69 = #0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in (#0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int).{core::num::<}(#C3){(core::num) → core::bool}))) {
         {
           return 2;
         }
       }
-      else
-        if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C5 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-          {
-            return 3;
-          }
+    }
+    {
+      if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C5 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return 3;
         }
-        else
-          if(#0#0 is{ForNonNullableByDefault} ({g: core::Object?}) && (let final dynamic #t70 = #0#15#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in #C6 =={core::num::==}{(core::Object) → core::bool} #0#15#func(){() → core::Object?} as{ForNonNullableByDefault} core::int)) {
-            {
-              return 4;
-            }
-          }
-          else
-            if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?}) && (let final dynamic #t71 = (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final dynamic #t72 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?})}.a{core::Object?})! in true)) {
-              {
-                return 5;
-              }
-            }
-            else
-              if(#0#0 is{ForNonNullableByDefault} ({b: core::Object?}) && (!((#0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final dynamic #t73 = #0#23#isSet = true in #0#23 = #0#0{({b: core::Object?})}.b{core::Object?}) == null) ?{core::bool} true : false)) {
-                {
-                  return 6;
-                }
-              }
-              else
-                if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t74 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C7 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic}) {
-                  {
-                    return 7;
-                  }
-                }
-                else
-                  if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34#func(){() → core::bool} && #C7 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic}) {
-                    {
-                      return 8;
-                    }
-                  }
-                  else
-                    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38#func(){() → core::bool} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#43#func(){() → dynamic}) {
-                      {
-                        return 9;
-                      }
-                    }
-                    else
-                      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34#func(){() → core::bool} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && (#0#47#func(){() → core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t75 = #0#50#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#50#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final dynamic #t76 = #0#53#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#53#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool}))) {
-                        {
-                          return 10;
-                        }
-                      }
-                      else
-                        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38#func(){() → core::bool} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C4 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && (#0#58#func(){() → core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t77 = #0#61#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#61#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final dynamic #t78 = #0#64#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#64#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})) && #C5 =={core::num::==}{(core::Object) → core::bool} #0#43#func(){() → dynamic}) {
-                          {
-                            return 11;
-                          }
-                        }
-                        else
-                          if(#0#0 is{ForNonNullableByDefault} self::Class && #C1 =={core::num::==}{(core::Object) → core::bool} #0#69#func(){() → core::int}) {
-                            {
-                              return 12;
-                            }
-                          }
-                          else
-                            if(#0#0 is{ForNonNullableByDefault} self::Class && #C7 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::finalField}{core::int}) {
-                              {
-                                return 13;
-                              }
-                            }
-                            else
-                              if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#69#func(){() → core::int} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::getter}{core::int}) {
-                                {
-                                  return 14;
-                                }
-                              }
-                              else
-                                if(#0#0 is{ForNonNullableByDefault} self::Class) {
-                                  {
-                                    return 15;
-                                  }
-                                }
-                                else
-                                  if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C9) {
-                                    {
-                                      return 16;
-                                    }
-                                  }
-                                  else
-                                    if(#0#0 is{ForNonNullableByDefault} ({e: core::Object?}) && !(#0#0{({e: core::Object?})}.e{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C10)) {
-                                      {
-                                        return 17;
-                                      }
-                                    }
-                                    else
-                                      if(#0#0 is{ForNonNullableByDefault} core::Map<core::int, core::int> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t79 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t80 = #0#26#isSet = true in #0#26 = #0#0{core::Map<core::int, core::int>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<core::int, core::int>}.{core::Map::containsKey}(#C3){(core::Object?) → core::bool} && (#0#0{core::Map<core::int, core::int>}.{core::Map::[]}(#C3){(core::Object?) → core::int?} as{ForNonNullableByDefault} core::int).{core::num::>=}(#C11){(core::num) → core::bool}) {
-                                        {
-                                          return 18;
-                                        }
-                                      }
-                                      else
-                                        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t81 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t82 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && (let final dynamic #t83 = #0#30#func(){() → dynamic} in true)) {
-                                          {
-                                            return 19;
-                                          }
-                                        }
-                                        else
-                                          if(#0#0 is{ForNonNullableByDefault} core::bool) {
-                                            {
-                                              return 20;
-                                            }
-                                          }
-                                          else
-                                            if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t84 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C12) {
-                                              {
-                                                return 21;
-                                              }
-                                            }
-                                            else
-                                              if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t85 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t86 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C12){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C12){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::int) {
-                                                {
-                                                  return 22;
-                                                }
-                                              }
-                                              else
-                                                if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t87 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::String) {
-                                                  {
-                                                    return 23;
-                                                  }
-                                                }
-                                                else
-                                                  if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t88 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t89 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C7){(core::Object?) → core::bool} && (let final dynamic #t90 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C7){(core::Object?) → dynamic} in true)) {
-                                                    {
-                                                      return 24;
-                                                    }
-                                                  }
-                                                  else
-                                                    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t91 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t92 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && (#0#104#func(){() → dynamic} is{ForNonNullableByDefault} core::int && (let final dynamic #t93 = b = #0#104#func(){() → dynamic} as{ForNonNullableByDefault} core::int in true))) {
-                                                      {
-                                                        return 25;
-                                                      }
-                                                    }
-                                                    else
-                                                      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
-                                                        {
-                                                          return 26;
-                                                        }
-                                                      }
-                                                      else
-                                                        if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?, b: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final dynamic #t94 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?, b: core::Object?})}.a{core::Object?}) && (let final dynamic #t95 = c = #0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final dynamic #t96 = #0#23#isSet = true in #0#23 = #0#0{({a: core::Object?, b: core::Object?})}.b{core::Object?} in true)) {
-                                                          {
-                                                            return 27;
-                                                          }
-                                                        }
-                                                        else
-                                                          if(#0#0 is{ForNonNullableByDefault} ({c: core::Object?, d: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{({c: core::Object?, d: core::Object?})}.c{core::Object?} && (let final dynamic #t97 = d = #0#0{({c: core::Object?, d: core::Object?})}.d{core::Object?} in true) && d is{ForNonNullableByDefault} core::int) {
-                                                            {
-                                                              return 28;
-                                                            }
-                                                          }
-                                                          else {
-                                                            {
-                                                              return 0;
-                                                            }
-                                                          }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} ({g: core::Object?}) && (let final dynamic #t70 = #0#15#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in #C6 =={core::num::==}{(core::Object) → core::bool} #0#15#func(){() → core::Object?} as{ForNonNullableByDefault} core::int)) {
+        {
+          return 4;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?}) && (let final dynamic #t71 = (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final dynamic #t72 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?})}.a{core::Object?})! in true)) {
+        {
+          return 5;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} ({b: core::Object?}) && (!((#0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final dynamic #t73 = #0#23#isSet = true in #0#23 = #0#0{({b: core::Object?})}.b{core::Object?}) == null) ?{core::bool} true : false)) {
+        {
+          return 6;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t74 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C7 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic}) {
+        {
+          return 7;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34#func(){() → core::bool} && #C7 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic}) {
+        {
+          return 8;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38#func(){() → core::bool} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#43#func(){() → dynamic}) {
+        {
+          return 9;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34#func(){() → core::bool} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && (#0#47#func(){() → core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t75 = #0#50#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#50#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final dynamic #t76 = #0#53#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#53#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool}))) {
+        {
+          return 10;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38#func(){() → core::bool} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C4 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && (#0#58#func(){() → core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t77 = #0#61#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#61#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final dynamic #t78 = #0#64#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#64#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})) && #C5 =={core::num::==}{(core::Object) → core::bool} #0#43#func(){() → dynamic}) {
+        {
+          return 11;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Class && #C1 =={core::num::==}{(core::Object) → core::bool} #0#69#func(){() → core::int}) {
+        {
+          return 12;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Class && #C7 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::finalField}{core::int}) {
+        {
+          return 13;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#69#func(){() → core::int} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::getter}{core::int}) {
+        {
+          return 14;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Class) {
+        {
+          return 15;
+        }
+      }
+    }
+    {
+      if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C9) {
+        {
+          return 16;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} ({e: core::Object?}) && !(#0#0{({e: core::Object?})}.e{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C10)) {
+        {
+          return 17;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<core::int, core::int> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t79 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t80 = #0#26#isSet = true in #0#26 = #0#0{core::Map<core::int, core::int>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<core::int, core::int>}.{core::Map::containsKey}(#C3){(core::Object?) → core::bool} && (#0#0{core::Map<core::int, core::int>}.{core::Map::[]}(#C3){(core::Object?) → core::int?} as{ForNonNullableByDefault} core::int).{core::num::>=}(#C11){(core::num) → core::bool}) {
+        {
+          return 18;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t81 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t82 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && (let final dynamic #t83 = #0#30#func(){() → dynamic} in true)) {
+        {
+          return 19;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::bool) {
+        {
+          return 20;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t84 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C12) {
+        {
+          return 21;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t85 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t86 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C12){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C12){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::int) {
+        {
+          return 22;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t87 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::String) {
+        {
+          return 23;
+        }
+      }
+    }
+    {
+      dynamic a;
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t88 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t89 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C7){(core::Object?) → core::bool} && (let final dynamic #t90 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C7){(core::Object?) → dynamic} in true)) {
+        {
+          return 24;
+        }
+      }
+    }
+    {
+      core::int b;
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t91 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t92 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && (#0#104#func(){() → dynamic} is{ForNonNullableByDefault} core::int && (let final dynamic #t93 = b = #0#104#func(){() → dynamic} as{ForNonNullableByDefault} core::int in true))) {
+        {
+          return 25;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+        {
+          return 26;
+        }
+      }
+    }
+    {
+      dynamic c;
+      if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?, b: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final dynamic #t94 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?, b: core::Object?})}.a{core::Object?}) && (let final dynamic #t95 = c = #0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final dynamic #t96 = #0#23#isSet = true in #0#23 = #0#0{({a: core::Object?, b: core::Object?})}.b{core::Object?} in true)) {
+        {
+          return 27;
+        }
+      }
+    }
+    {
+      dynamic d;
+      if(#0#0 is{ForNonNullableByDefault} ({c: core::Object?, d: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{({c: core::Object?, d: core::Object?})}.c{core::Object?} && (let final dynamic #t97 = d = #0#0{({c: core::Object?, d: core::Object?})}.d{core::Object?} in true) && d is{ForNonNullableByDefault} core::int) {
+        {
+          return 28;
+        }
+      }
+    }
+    {
+      {
+        {
+          return 0;
+        }
+      }
+    }
   }
 }
 static method switchExpression(dynamic o) → core::int {
   core::print("o = ${o}");
   return block {
     core::int #t98;
-    dynamic a;
-    core::int b;
-    dynamic c;
-    dynamic d;
     final synthesized dynamic #0#0 = o;
     synthesized core::Object? #0#4;
     synthesized core::bool #0#4#isSet = false;
@@ -781,92 +808,187 @@ static method switchExpression(dynamic o) → core::int {
     synthesized core::bool #0#104#isSet = false;
     function #0#104#func() → dynamic
       return #0#104#isSet ?{dynamic} #0#104 : let final dynamic #t117 = #0#104#isSet = true in #0#104 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic};
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0)
-      #t98 = 1;
-    else
-      if(#0#0 is{ForNonNullableByDefault} ({f: core::Object?}) && ((let final dynamic #t118 = #0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in (#0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int).{core::num::>=}(#C2){(core::num) → core::bool}) && (let final dynamic #t119 = #0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in (#0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int).{core::num::<}(#C3){(core::num) → core::bool})))
-        #t98 = 2;
-      else
-        if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C5 =={core::num::==}{(core::Object) → core::bool} #0#0)
+    #L2:
+    {
+      {
+        if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+          #t98 = 1;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({f: core::Object?}) && ((let final dynamic #t118 = #0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in (#0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int).{core::num::>=}(#C2){(core::num) → core::bool}) && (let final dynamic #t119 = #0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in (#0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int).{core::num::<}(#C3){(core::num) → core::bool}))) {
+          #t98 = 2;
+          break #L2;
+        }
+      }
+      {
+        if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C5 =={core::num::==}{(core::Object) → core::bool} #0#0) {
           #t98 = 3;
-        else
-          if(#0#0 is{ForNonNullableByDefault} ({g: core::Object?}) && (let final dynamic #t120 = #0#15#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in #C6 =={core::num::==}{(core::Object) → core::bool} #0#15#func(){() → core::Object?} as{ForNonNullableByDefault} core::int))
-            #t98 = 4;
-          else
-            if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?}) && (let final dynamic #t121 = (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final dynamic #t122 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?})}.a{core::Object?})! in true))
-              #t98 = 5;
-            else
-              if(#0#0 is{ForNonNullableByDefault} ({b: core::Object?}) && (!((#0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final dynamic #t123 = #0#23#isSet = true in #0#23 = #0#0{({b: core::Object?})}.b{core::Object?}) == null) ?{core::bool} true : false))
-                #t98 = 6;
-              else
-                if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t124 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C7 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic})
-                  #t98 = 7;
-                else
-                  if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34#func(){() → core::bool} && #C7 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic})
-                    #t98 = 8;
-                  else
-                    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38#func(){() → core::bool} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#43#func(){() → dynamic})
-                      #t98 = 9;
-                    else
-                      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34#func(){() → core::bool} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && (#0#47#func(){() → core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t125 = #0#50#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#50#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final dynamic #t126 = #0#53#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#53#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})))
-                        #t98 = 10;
-                      else
-                        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38#func(){() → core::bool} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C4 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && (#0#58#func(){() → core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t127 = #0#61#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#61#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final dynamic #t128 = #0#64#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#64#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})) && #C5 =={core::num::==}{(core::Object) → core::bool} #0#43#func(){() → dynamic})
-                          #t98 = 11;
-                        else
-                          if(#0#0 is{ForNonNullableByDefault} self::Class && #C1 =={core::num::==}{(core::Object) → core::bool} #0#69#func(){() → core::int})
-                            #t98 = 12;
-                          else
-                            if(#0#0 is{ForNonNullableByDefault} self::Class && #C7 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::finalField}{core::int})
-                              #t98 = 13;
-                            else
-                              if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#69#func(){() → core::int} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::getter}{core::int})
-                                #t98 = 14;
-                              else
-                                if(#0#0 is{ForNonNullableByDefault} self::Class)
-                                  #t98 = 15;
-                                else
-                                  if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C9)
-                                    #t98 = 16;
-                                  else
-                                    if(#0#0 is{ForNonNullableByDefault} ({e: core::Object?}) && !(#0#0{({e: core::Object?})}.e{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C10))
-                                      #t98 = 17;
-                                    else
-                                      if(#0#0 is{ForNonNullableByDefault} core::Map<core::int, core::int> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t129 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t130 = #0#26#isSet = true in #0#26 = #0#0{core::Map<core::int, core::int>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<core::int, core::int>}.{core::Map::containsKey}(#C3){(core::Object?) → core::bool} && (#0#0{core::Map<core::int, core::int>}.{core::Map::[]}(#C3){(core::Object?) → core::int?} as{ForNonNullableByDefault} core::int).{core::num::>=}(#C11){(core::num) → core::bool})
-                                        #t98 = 18;
-                                      else
-                                        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t131 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t132 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && (let final dynamic #t133 = #0#30#func(){() → dynamic} in true))
-                                          #t98 = 19;
-                                        else
-                                          if(#0#0 is{ForNonNullableByDefault} core::bool)
-                                            #t98 = 20;
-                                          else
-                                            if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t134 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C12)
-                                              #t98 = 21;
-                                            else
-                                              if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t135 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t136 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C12){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C12){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::int)
-                                                #t98 = 22;
-                                              else
-                                                if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t137 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::String)
-                                                  #t98 = 23;
-                                                else
-                                                  if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t138 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t139 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C7){(core::Object?) → core::bool} && (let final dynamic #t140 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C7){(core::Object?) → dynamic} in true))
-                                                    #t98 = 24;
-                                                  else
-                                                    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t141 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t142 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && (#0#104#func(){() → dynamic} is{ForNonNullableByDefault} core::int && (let final dynamic #t143 = b = #0#104#func(){() → dynamic} as{ForNonNullableByDefault} core::int in true)))
-                                                      #t98 = 25;
-                                                    else
-                                                      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?})
-                                                        #t98 = 26;
-                                                      else
-                                                        if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?, b: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final dynamic #t144 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?, b: core::Object?})}.a{core::Object?}) && (let final dynamic #t145 = c = #0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final dynamic #t146 = #0#23#isSet = true in #0#23 = #0#0{({a: core::Object?, b: core::Object?})}.b{core::Object?} in true))
-                                                          #t98 = 27;
-                                                        else
-                                                          if(#0#0 is{ForNonNullableByDefault} ({c: core::Object?, d: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{({c: core::Object?, d: core::Object?})}.c{core::Object?} && (let final dynamic #t147 = d = #0#0{({c: core::Object?, d: core::Object?})}.d{core::Object?} in true) && d is{ForNonNullableByDefault} core::int)
-                                                            #t98 = 28;
-                                                          else
-                                                            if(true)
-                                                              #t98 = 0;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({g: core::Object?}) && (let final dynamic #t120 = #0#15#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in #C6 =={core::num::==}{(core::Object) → core::bool} #0#15#func(){() → core::Object?} as{ForNonNullableByDefault} core::int)) {
+          #t98 = 4;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?}) && (let final dynamic #t121 = (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final dynamic #t122 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?})}.a{core::Object?})! in true)) {
+          #t98 = 5;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({b: core::Object?}) && (!((#0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final dynamic #t123 = #0#23#isSet = true in #0#23 = #0#0{({b: core::Object?})}.b{core::Object?}) == null) ?{core::bool} true : false)) {
+          #t98 = 6;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t124 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C7 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic}) {
+          #t98 = 7;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34#func(){() → core::bool} && #C7 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic}) {
+          #t98 = 8;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38#func(){() → core::bool} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#43#func(){() → dynamic}) {
+          #t98 = 9;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34#func(){() → core::bool} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && (#0#47#func(){() → core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t125 = #0#50#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#50#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final dynamic #t126 = #0#53#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#53#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool}))) {
+          #t98 = 10;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38#func(){() → core::bool} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C4 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && (#0#58#func(){() → core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t127 = #0#61#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#61#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final dynamic #t128 = #0#64#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#64#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})) && #C5 =={core::num::==}{(core::Object) → core::bool} #0#43#func(){() → dynamic}) {
+          #t98 = 11;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} self::Class && #C1 =={core::num::==}{(core::Object) → core::bool} #0#69#func(){() → core::int}) {
+          #t98 = 12;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} self::Class && #C7 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::finalField}{core::int}) {
+          #t98 = 13;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#69#func(){() → core::int} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::getter}{core::int}) {
+          #t98 = 14;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} self::Class) {
+          #t98 = 15;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C9) {
+          #t98 = 16;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({e: core::Object?}) && !(#0#0{({e: core::Object?})}.e{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C10)) {
+          #t98 = 17;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::Map<core::int, core::int> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t129 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t130 = #0#26#isSet = true in #0#26 = #0#0{core::Map<core::int, core::int>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<core::int, core::int>}.{core::Map::containsKey}(#C3){(core::Object?) → core::bool} && (#0#0{core::Map<core::int, core::int>}.{core::Map::[]}(#C3){(core::Object?) → core::int?} as{ForNonNullableByDefault} core::int).{core::num::>=}(#C11){(core::num) → core::bool}) {
+          #t98 = 18;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t131 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t132 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && (let final dynamic #t133 = #0#30#func(){() → dynamic} in true)) {
+          #t98 = 19;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::bool) {
+          #t98 = 20;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t134 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C12) {
+          #t98 = 21;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t135 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t136 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C12){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C12){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::int) {
+          #t98 = 22;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t137 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::String) {
+          #t98 = 23;
+          break #L2;
+        }
+      }
+      {
+        dynamic a;
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t138 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t139 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C7){(core::Object?) → core::bool} && (let final dynamic #t140 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C7){(core::Object?) → dynamic} in true)) {
+          #t98 = 24;
+          break #L2;
+        }
+      }
+      {
+        core::int b;
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t141 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t142 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && (#0#104#func(){() → dynamic} is{ForNonNullableByDefault} core::int && (let final dynamic #t143 = b = #0#104#func(){() → dynamic} as{ForNonNullableByDefault} core::int in true))) {
+          #t98 = 25;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+          #t98 = 26;
+          break #L2;
+        }
+      }
+      {
+        dynamic c;
+        if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?, b: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final dynamic #t144 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?, b: core::Object?})}.a{core::Object?}) && (let final dynamic #t145 = c = #0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final dynamic #t146 = #0#23#isSet = true in #0#23 = #0#0{({a: core::Object?, b: core::Object?})}.b{core::Object?} in true)) {
+          #t98 = 27;
+          break #L2;
+        }
+      }
+      {
+        dynamic d;
+        if(#0#0 is{ForNonNullableByDefault} ({c: core::Object?, d: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{({c: core::Object?, d: core::Object?})}.c{core::Object?} && (let final dynamic #t147 = d = #0#0{({c: core::Object?, d: core::Object?})}.d{core::Object?} in true) && d is{ForNonNullableByDefault} core::int) {
+          #t98 = 28;
+          break #L2;
+        }
+      }
+      {
+        if(true) {
+          #t98 = 0;
+          break #L2;
+        }
+      }
+    }
   } =>#t98;
 }
 static method test(dynamic expected, dynamic value) → dynamic {
diff --git a/pkg/front_end/testcases/late_lowering/caching.dart.weak.transformed.expect b/pkg/front_end/testcases/late_lowering/caching.dart.weak.transformed.expect
index 065b4995c84..4128e507100 100644
--- a/pkg/front_end/testcases/late_lowering/caching.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/late_lowering/caching.dart.weak.transformed.expect
@@ -457,10 +457,6 @@ static method switchStatement(dynamic o) → core::int {
   core::print("o = ${o}");
   #L1:
   {
-    dynamic a;
-    core::int b;
-    dynamic c;
-    dynamic d;
     final synthesized dynamic #0#0 = o;
     synthesized core::Object? #0#4;
     synthesized core::bool #0#4#isSet = false;
@@ -530,188 +526,219 @@ static method switchStatement(dynamic o) → core::int {
     synthesized core::bool #0#104#isSet = false;
     function #0#104#func() → dynamic
       return #0#104#isSet ?{dynamic} #0#104 : let final core::bool* #t67 = #0#104#isSet = true in #0#104 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic};
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        return 1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return 1;
+        }
       }
     }
-    else
+    {
       if(#0#0 is{ForNonNullableByDefault} ({f: core::Object?}) && ((let final core::int #t68 = #0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in (#0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int).{core::num::>=}(#C2){(core::num) → core::bool}) && (let final core::int #t69 = #0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in (#0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int).{core::num::<}(#C3){(core::num) → core::bool}))) {
         {
           return 2;
         }
       }
-      else
-        if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C5 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-          {
-            return 3;
-          }
+    }
+    {
+      if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C5 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return 3;
         }
-        else
-          if(#0#0 is{ForNonNullableByDefault} ({g: core::Object?}) && (let final core::int #t70 = #0#15#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in #C6 =={core::num::==}{(core::Object) → core::bool} #0#15#func(){() → core::Object?} as{ForNonNullableByDefault} core::int)) {
-            {
-              return 4;
-            }
-          }
-          else
-            if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?}) && (let final core::Object? #t71 = (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final core::bool* #t72 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?})}.a{core::Object?})! in true)) {
-              {
-                return 5;
-              }
-            }
-            else
-              if(#0#0 is{ForNonNullableByDefault} ({b: core::Object?}) && (!((#0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final core::bool* #t73 = #0#23#isSet = true in #0#23 = #0#0{({b: core::Object?})}.b{core::Object?}) == null) ?{core::bool} true : false)) {
-                {
-                  return 6;
-                }
-              }
-              else
-                if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t74 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C7 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic}) {
-                  {
-                    return 7;
-                  }
-                }
-                else
-                  if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34#func(){() → core::bool} && #C7 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic}) {
-                    {
-                      return 8;
-                    }
-                  }
-                  else
-                    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38#func(){() → core::bool} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#43#func(){() → dynamic}) {
-                      {
-                        return 9;
-                      }
-                    }
-                    else
-                      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34#func(){() → core::bool} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && (#0#47#func(){() → core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final core::int #t75 = #0#50#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#50#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final core::int #t76 = #0#53#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#53#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool}))) {
-                        {
-                          return 10;
-                        }
-                      }
-                      else
-                        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38#func(){() → core::bool} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C4 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && (#0#58#func(){() → core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final core::int #t77 = #0#61#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#61#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final core::int #t78 = #0#64#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#64#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})) && #C5 =={core::num::==}{(core::Object) → core::bool} #0#43#func(){() → dynamic}) {
-                          {
-                            return 11;
-                          }
-                        }
-                        else
-                          if(#0#0 is{ForNonNullableByDefault} self::Class && #C1 =={core::num::==}{(core::Object) → core::bool} #0#69#func(){() → core::int}) {
-                            {
-                              return 12;
-                            }
-                          }
-                          else
-                            if(#0#0 is{ForNonNullableByDefault} self::Class && #C7 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::finalField}{core::int}) {
-                              {
-                                return 13;
-                              }
-                            }
-                            else
-                              if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#69#func(){() → core::int} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::getter}{core::int}) {
-                                {
-                                  return 14;
-                                }
-                              }
-                              else
-                                if(#0#0 is{ForNonNullableByDefault} self::Class) {
-                                  {
-                                    return 15;
-                                  }
-                                }
-                                else
-                                  if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C9) {
-                                    {
-                                      return 16;
-                                    }
-                                  }
-                                  else
-                                    if(#0#0 is{ForNonNullableByDefault} ({e: core::Object?}) && !(#0#0{({e: core::Object?})}.e{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C10)) {
-                                      {
-                                        return 17;
-                                      }
-                                    }
-                                    else
-                                      if(#0#0 is{ForNonNullableByDefault} core::Map<core::int, core::int> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t79 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t80 = #0#26#isSet = true in #0#26 = #0#0{core::Map<core::int, core::int>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<core::int, core::int>}.{core::Map::containsKey}(#C3){(core::Object?) → core::bool} && #0#0{core::Map<core::int, core::int>}.{core::Map::[]}(#C3){(core::Object?) → core::int?}.{core::num::>=}(#C11){(core::num) → core::bool}) {
-                                        {
-                                          return 18;
-                                        }
-                                      }
-                                      else
-                                        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t81 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t82 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && (let final dynamic #t83 = #0#30#func(){() → dynamic} in true)) {
-                                          {
-                                            return 19;
-                                          }
-                                        }
-                                        else
-                                          if(#0#0 is{ForNonNullableByDefault} core::bool) {
-                                            {
-                                              return 20;
-                                            }
-                                          }
-                                          else
-                                            if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t84 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C12) {
-                                              {
-                                                return 21;
-                                              }
-                                            }
-                                            else
-                                              if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t85 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t86 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C12){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C12){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::int) {
-                                                {
-                                                  return 22;
-                                                }
-                                              }
-                                              else
-                                                if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t87 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::String) {
-                                                  {
-                                                    return 23;
-                                                  }
-                                                }
-                                                else
-                                                  if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t88 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t89 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C7){(core::Object?) → core::bool} && (let final dynamic #t90 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C7){(core::Object?) → dynamic} in true)) {
-                                                    {
-                                                      return 24;
-                                                    }
-                                                  }
-                                                  else
-                                                    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t91 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t92 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && (#0#104#func(){() → dynamic} is{ForNonNullableByDefault} core::int && (let final core::int #t93 = b = #0#104#func(){() → dynamic} as{ForNonNullableByDefault} core::int in true))) {
-                                                      {
-                                                        return 25;
-                                                      }
-                                                    }
-                                                    else
-                                                      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
-                                                        {
-                                                          return 26;
-                                                        }
-                                                      }
-                                                      else
-                                                        if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?, b: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final core::bool* #t94 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?, b: core::Object?})}.a{core::Object?}) && (let final core::Object? #t95 = c = #0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final core::bool* #t96 = #0#23#isSet = true in #0#23 = #0#0{({a: core::Object?, b: core::Object?})}.b{core::Object?} in true)) {
-                                                          {
-                                                            return 27;
-                                                          }
-                                                        }
-                                                        else
-                                                          if(#0#0 is{ForNonNullableByDefault} ({c: core::Object?, d: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{({c: core::Object?, d: core::Object?})}.c{core::Object?} && (let final core::Object? #t97 = d = #0#0{({c: core::Object?, d: core::Object?})}.d{core::Object?} in true) && d is{ForNonNullableByDefault} core::int) {
-                                                            {
-                                                              return 28;
-                                                            }
-                                                          }
-                                                          else {
-                                                            {
-                                                              return 0;
-                                                            }
-                                                          }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} ({g: core::Object?}) && (let final core::int #t70 = #0#15#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in #C6 =={core::num::==}{(core::Object) → core::bool} #0#15#func(){() → core::Object?} as{ForNonNullableByDefault} core::int)) {
+        {
+          return 4;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?}) && (let final core::Object? #t71 = (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final core::bool* #t72 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?})}.a{core::Object?})! in true)) {
+        {
+          return 5;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} ({b: core::Object?}) && (!((#0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final core::bool* #t73 = #0#23#isSet = true in #0#23 = #0#0{({b: core::Object?})}.b{core::Object?}) == null) ?{core::bool} true : false)) {
+        {
+          return 6;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t74 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C7 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic}) {
+        {
+          return 7;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34#func(){() → core::bool} && #C7 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic}) {
+        {
+          return 8;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38#func(){() → core::bool} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#43#func(){() → dynamic}) {
+        {
+          return 9;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34#func(){() → core::bool} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && (#0#47#func(){() → core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final core::int #t75 = #0#50#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#50#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final core::int #t76 = #0#53#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#53#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool}))) {
+        {
+          return 10;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38#func(){() → core::bool} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C4 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && (#0#58#func(){() → core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final core::int #t77 = #0#61#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#61#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final core::int #t78 = #0#64#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#64#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})) && #C5 =={core::num::==}{(core::Object) → core::bool} #0#43#func(){() → dynamic}) {
+        {
+          return 11;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Class && #C1 =={core::num::==}{(core::Object) → core::bool} #0#69#func(){() → core::int}) {
+        {
+          return 12;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Class && #C7 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::finalField}{core::int}) {
+        {
+          return 13;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#69#func(){() → core::int} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::getter}{core::int}) {
+        {
+          return 14;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Class) {
+        {
+          return 15;
+        }
+      }
+    }
+    {
+      if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C9) {
+        {
+          return 16;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} ({e: core::Object?}) && !(#0#0{({e: core::Object?})}.e{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C10)) {
+        {
+          return 17;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<core::int, core::int> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t79 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t80 = #0#26#isSet = true in #0#26 = #0#0{core::Map<core::int, core::int>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<core::int, core::int>}.{core::Map::containsKey}(#C3){(core::Object?) → core::bool} && #0#0{core::Map<core::int, core::int>}.{core::Map::[]}(#C3){(core::Object?) → core::int?}.{core::num::>=}(#C11){(core::num) → core::bool}) {
+        {
+          return 18;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t81 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t82 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && (let final dynamic #t83 = #0#30#func(){() → dynamic} in true)) {
+        {
+          return 19;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::bool) {
+        {
+          return 20;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t84 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C12) {
+        {
+          return 21;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t85 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t86 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C12){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C12){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::int) {
+        {
+          return 22;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t87 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::String) {
+        {
+          return 23;
+        }
+      }
+    }
+    {
+      dynamic a;
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t88 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t89 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C7){(core::Object?) → core::bool} && (let final dynamic #t90 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C7){(core::Object?) → dynamic} in true)) {
+        {
+          return 24;
+        }
+      }
+    }
+    {
+      core::int b;
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t91 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t92 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && (#0#104#func(){() → dynamic} is{ForNonNullableByDefault} core::int && (let final core::int #t93 = b = #0#104#func(){() → dynamic} as{ForNonNullableByDefault} core::int in true))) {
+        {
+          return 25;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+        {
+          return 26;
+        }
+      }
+    }
+    {
+      dynamic c;
+      if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?, b: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final core::bool* #t94 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?, b: core::Object?})}.a{core::Object?}) && (let final core::Object? #t95 = c = #0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final core::bool* #t96 = #0#23#isSet = true in #0#23 = #0#0{({a: core::Object?, b: core::Object?})}.b{core::Object?} in true)) {
+        {
+          return 27;
+        }
+      }
+    }
+    {
+      dynamic d;
+      if(#0#0 is{ForNonNullableByDefault} ({c: core::Object?, d: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{({c: core::Object?, d: core::Object?})}.c{core::Object?} && (let final core::Object? #t97 = d = #0#0{({c: core::Object?, d: core::Object?})}.d{core::Object?} in true) && d is{ForNonNullableByDefault} core::int) {
+        {
+          return 28;
+        }
+      }
+    }
+    {
+      {
+        {
+          return 0;
+        }
+      }
+    }
   }
 }
 static method switchExpression(dynamic o) → core::int {
   core::print("o = ${o}");
   return block {
     core::int #t98;
-    dynamic a;
-    core::int b;
-    dynamic c;
-    dynamic d;
     final synthesized dynamic #0#0 = o;
     synthesized core::Object? #0#4;
     synthesized core::bool #0#4#isSet = false;
@@ -781,92 +808,187 @@ static method switchExpression(dynamic o) → core::int {
     synthesized core::bool #0#104#isSet = false;
     function #0#104#func() → dynamic
       return #0#104#isSet ?{dynamic} #0#104 : let final core::bool* #t117 = #0#104#isSet = true in #0#104 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic};
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0)
-      #t98 = 1;
-    else
-      if(#0#0 is{ForNonNullableByDefault} ({f: core::Object?}) && ((let final core::int #t118 = #0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in (#0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int).{core::num::>=}(#C2){(core::num) → core::bool}) && (let final core::int #t119 = #0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in (#0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int).{core::num::<}(#C3){(core::num) → core::bool})))
-        #t98 = 2;
-      else
-        if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C5 =={core::num::==}{(core::Object) → core::bool} #0#0)
+    #L2:
+    {
+      {
+        if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+          #t98 = 1;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({f: core::Object?}) && ((let final core::int #t118 = #0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in (#0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int).{core::num::>=}(#C2){(core::num) → core::bool}) && (let final core::int #t119 = #0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in (#0#4#func(){() → core::Object?} as{ForNonNullableByDefault} core::int).{core::num::<}(#C3){(core::num) → core::bool}))) {
+          #t98 = 2;
+          break #L2;
+        }
+      }
+      {
+        if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C5 =={core::num::==}{(core::Object) → core::bool} #0#0) {
           #t98 = 3;
-        else
-          if(#0#0 is{ForNonNullableByDefault} ({g: core::Object?}) && (let final core::int #t120 = #0#15#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in #C6 =={core::num::==}{(core::Object) → core::bool} #0#15#func(){() → core::Object?} as{ForNonNullableByDefault} core::int))
-            #t98 = 4;
-          else
-            if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?}) && (let final core::Object? #t121 = (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final core::bool* #t122 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?})}.a{core::Object?})! in true))
-              #t98 = 5;
-            else
-              if(#0#0 is{ForNonNullableByDefault} ({b: core::Object?}) && (!((#0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final core::bool* #t123 = #0#23#isSet = true in #0#23 = #0#0{({b: core::Object?})}.b{core::Object?}) == null) ?{core::bool} true : false))
-                #t98 = 6;
-              else
-                if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t124 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C7 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic})
-                  #t98 = 7;
-                else
-                  if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34#func(){() → core::bool} && #C7 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic})
-                    #t98 = 8;
-                  else
-                    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38#func(){() → core::bool} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#43#func(){() → dynamic})
-                      #t98 = 9;
-                    else
-                      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34#func(){() → core::bool} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && (#0#47#func(){() → core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final core::int #t125 = #0#50#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#50#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final core::int #t126 = #0#53#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#53#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})))
-                        #t98 = 10;
-                      else
-                        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38#func(){() → core::bool} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C4 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && (#0#58#func(){() → core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final core::int #t127 = #0#61#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#61#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final core::int #t128 = #0#64#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#64#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})) && #C5 =={core::num::==}{(core::Object) → core::bool} #0#43#func(){() → dynamic})
-                          #t98 = 11;
-                        else
-                          if(#0#0 is{ForNonNullableByDefault} self::Class && #C1 =={core::num::==}{(core::Object) → core::bool} #0#69#func(){() → core::int})
-                            #t98 = 12;
-                          else
-                            if(#0#0 is{ForNonNullableByDefault} self::Class && #C7 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::finalField}{core::int})
-                              #t98 = 13;
-                            else
-                              if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#69#func(){() → core::int} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::getter}{core::int})
-                                #t98 = 14;
-                              else
-                                if(#0#0 is{ForNonNullableByDefault} self::Class)
-                                  #t98 = 15;
-                                else
-                                  if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C9)
-                                    #t98 = 16;
-                                  else
-                                    if(#0#0 is{ForNonNullableByDefault} ({e: core::Object?}) && !(#0#0{({e: core::Object?})}.e{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C10))
-                                      #t98 = 17;
-                                    else
-                                      if(#0#0 is{ForNonNullableByDefault} core::Map<core::int, core::int> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t129 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t130 = #0#26#isSet = true in #0#26 = #0#0{core::Map<core::int, core::int>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<core::int, core::int>}.{core::Map::containsKey}(#C3){(core::Object?) → core::bool} && #0#0{core::Map<core::int, core::int>}.{core::Map::[]}(#C3){(core::Object?) → core::int?}.{core::num::>=}(#C11){(core::num) → core::bool})
-                                        #t98 = 18;
-                                      else
-                                        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t131 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t132 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && (let final dynamic #t133 = #0#30#func(){() → dynamic} in true))
-                                          #t98 = 19;
-                                        else
-                                          if(#0#0 is{ForNonNullableByDefault} core::bool)
-                                            #t98 = 20;
-                                          else
-                                            if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t134 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C12)
-                                              #t98 = 21;
-                                            else
-                                              if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t135 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t136 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C12){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C12){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::int)
-                                                #t98 = 22;
-                                              else
-                                                if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t137 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::String)
-                                                  #t98 = 23;
-                                                else
-                                                  if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t138 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t139 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C7){(core::Object?) → core::bool} && (let final dynamic #t140 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C7){(core::Object?) → dynamic} in true))
-                                                    #t98 = 24;
-                                                  else
-                                                    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t141 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t142 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && (#0#104#func(){() → dynamic} is{ForNonNullableByDefault} core::int && (let final core::int #t143 = b = #0#104#func(){() → dynamic} as{ForNonNullableByDefault} core::int in true)))
-                                                      #t98 = 25;
-                                                    else
-                                                      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?})
-                                                        #t98 = 26;
-                                                      else
-                                                        if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?, b: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final core::bool* #t144 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?, b: core::Object?})}.a{core::Object?}) && (let final core::Object? #t145 = c = #0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final core::bool* #t146 = #0#23#isSet = true in #0#23 = #0#0{({a: core::Object?, b: core::Object?})}.b{core::Object?} in true))
-                                                          #t98 = 27;
-                                                        else
-                                                          if(#0#0 is{ForNonNullableByDefault} ({c: core::Object?, d: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{({c: core::Object?, d: core::Object?})}.c{core::Object?} && (let final core::Object? #t147 = d = #0#0{({c: core::Object?, d: core::Object?})}.d{core::Object?} in true) && d is{ForNonNullableByDefault} core::int)
-                                                            #t98 = 28;
-                                                          else
-                                                            if(true)
-                                                              #t98 = 0;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({g: core::Object?}) && (let final core::int #t120 = #0#15#func(){() → core::Object?} as{ForNonNullableByDefault} core::int in #C6 =={core::num::==}{(core::Object) → core::bool} #0#15#func(){() → core::Object?} as{ForNonNullableByDefault} core::int)) {
+          #t98 = 4;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?}) && (let final core::Object? #t121 = (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final core::bool* #t122 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?})}.a{core::Object?})! in true)) {
+          #t98 = 5;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({b: core::Object?}) && (!((#0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final core::bool* #t123 = #0#23#isSet = true in #0#23 = #0#0{({b: core::Object?})}.b{core::Object?}) == null) ?{core::bool} true : false)) {
+          #t98 = 6;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t124 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C7 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic}) {
+          #t98 = 7;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34#func(){() → core::bool} && #C7 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic}) {
+          #t98 = 8;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38#func(){() → core::bool} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#43#func(){() → dynamic}) {
+          #t98 = 9;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34#func(){() → core::bool} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && (#0#47#func(){() → core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final core::int #t125 = #0#50#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#50#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final core::int #t126 = #0#53#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#53#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool}))) {
+          #t98 = 10;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38#func(){() → core::bool} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#30#func(){() → dynamic} && #C4 =={core::num::==}{(core::Object) → core::bool} #0#32#func(){() → dynamic} && (#0#58#func(){() → core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final core::int #t127 = #0#61#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#61#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final core::int #t128 = #0#64#func(){() → dynamic} as{ForNonNullableByDefault} core::int in (#0#64#func(){() → dynamic} as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})) && #C5 =={core::num::==}{(core::Object) → core::bool} #0#43#func(){() → dynamic}) {
+          #t98 = 11;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} self::Class && #C1 =={core::num::==}{(core::Object) → core::bool} #0#69#func(){() → core::int}) {
+          #t98 = 12;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} self::Class && #C7 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::finalField}{core::int}) {
+          #t98 = 13;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#69#func(){() → core::int} && #C8 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::getter}{core::int}) {
+          #t98 = 14;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} self::Class) {
+          #t98 = 15;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C9) {
+          #t98 = 16;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({e: core::Object?}) && !(#0#0{({e: core::Object?})}.e{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C10)) {
+          #t98 = 17;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::Map<core::int, core::int> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t129 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t130 = #0#26#isSet = true in #0#26 = #0#0{core::Map<core::int, core::int>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<core::int, core::int>}.{core::Map::containsKey}(#C3){(core::Object?) → core::bool} && #0#0{core::Map<core::int, core::int>}.{core::Map::[]}(#C3){(core::Object?) → core::int?}.{core::num::>=}(#C11){(core::num) → core::bool}) {
+          #t98 = 18;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t131 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t132 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && (let final dynamic #t133 = #0#30#func(){() → dynamic} in true)) {
+          #t98 = 19;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::bool) {
+          #t98 = 20;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t134 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C12) {
+          #t98 = 21;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t135 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t136 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C12){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C12){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::int) {
+          #t98 = 22;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t137 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::String) {
+          #t98 = 23;
+          break #L2;
+        }
+      }
+      {
+        dynamic a;
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t138 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t139 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C7){(core::Object?) → core::bool} && (let final dynamic #t140 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C7){(core::Object?) → dynamic} in true)) {
+          #t98 = 24;
+          break #L2;
+        }
+      }
+      {
+        core::int b;
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t141 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t142 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && (#0#104#func(){() → dynamic} is{ForNonNullableByDefault} core::int && (let final core::int #t143 = b = #0#104#func(){() → dynamic} as{ForNonNullableByDefault} core::int in true))) {
+          #t98 = 25;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+          #t98 = 26;
+          break #L2;
+        }
+      }
+      {
+        dynamic c;
+        if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?, b: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final core::bool* #t144 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?, b: core::Object?})}.a{core::Object?}) && (let final core::Object? #t145 = c = #0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final core::bool* #t146 = #0#23#isSet = true in #0#23 = #0#0{({a: core::Object?, b: core::Object?})}.b{core::Object?} in true)) {
+          #t98 = 27;
+          break #L2;
+        }
+      }
+      {
+        dynamic d;
+        if(#0#0 is{ForNonNullableByDefault} ({c: core::Object?, d: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{({c: core::Object?, d: core::Object?})}.c{core::Object?} && (let final core::Object? #t147 = d = #0#0{({c: core::Object?, d: core::Object?})}.d{core::Object?} in true) && d is{ForNonNullableByDefault} core::int) {
+          #t98 = 28;
+          break #L2;
+        }
+      }
+      {
+        if(true) {
+          #t98 = 0;
+          break #L2;
+        }
+      }
+    }
   } =>#t98;
 }
 static method test(dynamic expected, dynamic value) → dynamic {
diff --git a/pkg/front_end/testcases/nnbd/return_null.dart.strong.expect b/pkg/front_end/testcases/nnbd/return_null.dart.strong.expect
index 99e0e8b1abd..52bb39e3a4c 100644
--- a/pkg/front_end/testcases/nnbd/return_null.dart.strong.expect
+++ b/pkg/front_end/testcases/nnbd/return_null.dart.strong.expect
@@ -108,32 +108,30 @@ static method yieldSync() → core::Iterable<dynamic> sync* {}
 static method yieldAsync() → asy::Stream<dynamic> async* {}
 static method caseReturn1(self::Enum e) → self::Enum {
   #L1:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L2:
+    case #C3:
       {
         return e;
       }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          return e;
-        }
+    #L3:
+    case #C6:
+      {
+        return e;
       }
   }
 }
 static method caseReturn2(self::Enum e) → self::Enum {
-  #L2:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L4:
+  switch(e) {
+    #L5:
+    case #C3:
       {
         return e;
       }
-    }
-    else {
-    }
+    #L6:
+    default:
+      {}
   }
   return invalid-expression "pkg/front_end/testcases/nnbd/return_null.dart:54:6: Error: A non-null value must be returned since the return type 'Enum' doesn't allow null.
  - 'Enum' is from 'pkg/front_end/testcases/nnbd/return_null.dart'.
@@ -180,33 +178,31 @@ static method localFunctions() → dynamic {
   function yieldSync() → core::Iterable<dynamic> sync* {}
   function yieldAsync() → asy::Stream<dynamic> async* {}
   function caseReturn1(self::Enum e) → self::Enum {
-    #L3:
-    {
-      final synthesized self::Enum #0#0 = e;
-      if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+    #L7:
+    switch(e) /*isExplicitlyExhaustive*/ {
+      #L8:
+      case #C3:
         {
           return e;
         }
-      }
-      else
-        if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-          {
-            return e;
-          }
+      #L9:
+      case #C6:
+        {
+          return e;
         }
     }
   }
   function caseReturn2(self::Enum e) → self::Enum {
-    #L4:
-    {
-      final synthesized self::Enum #1#0 = e;
-      if(#C3 =={core::Object::==}{(core::Object) → core::bool} #1#0) {
+    #L10:
+    switch(e) {
+      #L11:
+      case #C3:
         {
           return e;
         }
-      }
-      else {
-      }
+      #L12:
+      default:
+        {}
     }
     return invalid-expression "pkg/front_end/testcases/nnbd/return_null.dart:108:3: Error: A non-null value must be returned since the return type 'Enum' doesn't allow null.
  - 'Enum' is from 'pkg/front_end/testcases/nnbd/return_null.dart'.
diff --git a/pkg/front_end/testcases/nnbd/return_null.dart.strong.transformed.expect b/pkg/front_end/testcases/nnbd/return_null.dart.strong.transformed.expect
index a2e8f5345ad..7318e504f82 100644
--- a/pkg/front_end/testcases/nnbd/return_null.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/nnbd/return_null.dart.strong.transformed.expect
@@ -108,32 +108,30 @@ static method yieldSync() → core::Iterable<dynamic> sync* {}
 static method yieldAsync() → asy::Stream<dynamic> async* {}
 static method caseReturn1(self::Enum e) → self::Enum {
   #L1:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L2:
+    case #C3:
       {
         return e;
       }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          return e;
-        }
+    #L3:
+    case #C6:
+      {
+        return e;
       }
   }
 }
 static method caseReturn2(self::Enum e) → self::Enum {
-  #L2:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L4:
+  switch(e) {
+    #L5:
+    case #C3:
       {
         return e;
       }
-    }
-    else {
-    }
+    #L6:
+    default:
+      {}
   }
   return invalid-expression "pkg/front_end/testcases/nnbd/return_null.dart:54:6: Error: A non-null value must be returned since the return type 'Enum' doesn't allow null.
  - 'Enum' is from 'pkg/front_end/testcases/nnbd/return_null.dart'.
@@ -180,33 +178,31 @@ static method localFunctions() → dynamic {
   function yieldSync() → core::Iterable<dynamic> sync* {}
   function yieldAsync() → asy::Stream<dynamic> async* {}
   function caseReturn1(self::Enum e) → self::Enum {
-    #L3:
-    {
-      final synthesized self::Enum #0#0 = e;
-      if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+    #L7:
+    switch(e) /*isExplicitlyExhaustive*/ {
+      #L8:
+      case #C3:
         {
           return e;
         }
-      }
-      else
-        if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-          {
-            return e;
-          }
+      #L9:
+      case #C6:
+        {
+          return e;
         }
     }
   }
   function caseReturn2(self::Enum e) → self::Enum {
-    #L4:
-    {
-      final synthesized self::Enum #1#0 = e;
-      if(#C3 =={core::Object::==}{(core::Object) → core::bool} #1#0) {
+    #L10:
+    switch(e) {
+      #L11:
+      case #C3:
         {
           return e;
         }
-      }
-      else {
-      }
+      #L12:
+      default:
+        {}
     }
     return invalid-expression "pkg/front_end/testcases/nnbd/return_null.dart:108:3: Error: A non-null value must be returned since the return type 'Enum' doesn't allow null.
  - 'Enum' is from 'pkg/front_end/testcases/nnbd/return_null.dart'.
diff --git a/pkg/front_end/testcases/nnbd/return_null.dart.weak.expect b/pkg/front_end/testcases/nnbd/return_null.dart.weak.expect
index 9aee9961f00..4d711e57ae8 100644
--- a/pkg/front_end/testcases/nnbd/return_null.dart.weak.expect
+++ b/pkg/front_end/testcases/nnbd/return_null.dart.weak.expect
@@ -108,32 +108,30 @@ static method yieldSync() → core::Iterable<dynamic> sync* {}
 static method yieldAsync() → asy::Stream<dynamic> async* {}
 static method caseReturn1(self::Enum e) → self::Enum {
   #L1:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L2:
+    case #C3:
       {
         return e;
       }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          return e;
-        }
+    #L3:
+    case #C6:
+      {
+        return e;
       }
   }
 }
 static method caseReturn2(self::Enum e) → self::Enum {
-  #L2:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L4:
+  switch(e) {
+    #L5:
+    case #C3:
       {
         return e;
       }
-    }
-    else {
-    }
+    #L6:
+    default:
+      {}
   }
   return invalid-expression "pkg/front_end/testcases/nnbd/return_null.dart:54:6: Error: A non-null value must be returned since the return type 'Enum' doesn't allow null.
  - 'Enum' is from 'pkg/front_end/testcases/nnbd/return_null.dart'.
@@ -180,33 +178,31 @@ static method localFunctions() → dynamic {
   function yieldSync() → core::Iterable<dynamic> sync* {}
   function yieldAsync() → asy::Stream<dynamic> async* {}
   function caseReturn1(self::Enum e) → self::Enum {
-    #L3:
-    {
-      final synthesized self::Enum #0#0 = e;
-      if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+    #L7:
+    switch(e) /*isExplicitlyExhaustive*/ {
+      #L8:
+      case #C3:
         {
           return e;
         }
-      }
-      else
-        if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-          {
-            return e;
-          }
+      #L9:
+      case #C6:
+        {
+          return e;
         }
     }
   }
   function caseReturn2(self::Enum e) → self::Enum {
-    #L4:
-    {
-      final synthesized self::Enum #1#0 = e;
-      if(#C3 =={core::Object::==}{(core::Object) → core::bool} #1#0) {
+    #L10:
+    switch(e) {
+      #L11:
+      case #C3:
         {
           return e;
         }
-      }
-      else {
-      }
+      #L12:
+      default:
+        {}
     }
     return invalid-expression "pkg/front_end/testcases/nnbd/return_null.dart:108:3: Error: A non-null value must be returned since the return type 'Enum' doesn't allow null.
  - 'Enum' is from 'pkg/front_end/testcases/nnbd/return_null.dart'.
diff --git a/pkg/front_end/testcases/nnbd/return_null.dart.weak.modular.expect b/pkg/front_end/testcases/nnbd/return_null.dart.weak.modular.expect
index 9aee9961f00..4d711e57ae8 100644
--- a/pkg/front_end/testcases/nnbd/return_null.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/nnbd/return_null.dart.weak.modular.expect
@@ -108,32 +108,30 @@ static method yieldSync() → core::Iterable<dynamic> sync* {}
 static method yieldAsync() → asy::Stream<dynamic> async* {}
 static method caseReturn1(self::Enum e) → self::Enum {
   #L1:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L2:
+    case #C3:
       {
         return e;
       }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          return e;
-        }
+    #L3:
+    case #C6:
+      {
+        return e;
       }
   }
 }
 static method caseReturn2(self::Enum e) → self::Enum {
-  #L2:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L4:
+  switch(e) {
+    #L5:
+    case #C3:
       {
         return e;
       }
-    }
-    else {
-    }
+    #L6:
+    default:
+      {}
   }
   return invalid-expression "pkg/front_end/testcases/nnbd/return_null.dart:54:6: Error: A non-null value must be returned since the return type 'Enum' doesn't allow null.
  - 'Enum' is from 'pkg/front_end/testcases/nnbd/return_null.dart'.
@@ -180,33 +178,31 @@ static method localFunctions() → dynamic {
   function yieldSync() → core::Iterable<dynamic> sync* {}
   function yieldAsync() → asy::Stream<dynamic> async* {}
   function caseReturn1(self::Enum e) → self::Enum {
-    #L3:
-    {
-      final synthesized self::Enum #0#0 = e;
-      if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+    #L7:
+    switch(e) /*isExplicitlyExhaustive*/ {
+      #L8:
+      case #C3:
         {
           return e;
         }
-      }
-      else
-        if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-          {
-            return e;
-          }
+      #L9:
+      case #C6:
+        {
+          return e;
         }
     }
   }
   function caseReturn2(self::Enum e) → self::Enum {
-    #L4:
-    {
-      final synthesized self::Enum #1#0 = e;
-      if(#C3 =={core::Object::==}{(core::Object) → core::bool} #1#0) {
+    #L10:
+    switch(e) {
+      #L11:
+      case #C3:
         {
           return e;
         }
-      }
-      else {
-      }
+      #L12:
+      default:
+        {}
     }
     return invalid-expression "pkg/front_end/testcases/nnbd/return_null.dart:108:3: Error: A non-null value must be returned since the return type 'Enum' doesn't allow null.
  - 'Enum' is from 'pkg/front_end/testcases/nnbd/return_null.dart'.
diff --git a/pkg/front_end/testcases/nnbd/return_null.dart.weak.transformed.expect b/pkg/front_end/testcases/nnbd/return_null.dart.weak.transformed.expect
index c8f45501de1..fbc03e798e9 100644
--- a/pkg/front_end/testcases/nnbd/return_null.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/nnbd/return_null.dart.weak.transformed.expect
@@ -108,32 +108,30 @@ static method yieldSync() → core::Iterable<dynamic> sync* {}
 static method yieldAsync() → asy::Stream<dynamic> async* {}
 static method caseReturn1(self::Enum e) → self::Enum {
   #L1:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L2:
+    case #C3:
       {
         return e;
       }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          return e;
-        }
+    #L3:
+    case #C6:
+      {
+        return e;
       }
   }
 }
 static method caseReturn2(self::Enum e) → self::Enum {
-  #L2:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L4:
+  switch(e) {
+    #L5:
+    case #C3:
       {
         return e;
       }
-    }
-    else {
-    }
+    #L6:
+    default:
+      {}
   }
   return invalid-expression "pkg/front_end/testcases/nnbd/return_null.dart:54:6: Error: A non-null value must be returned since the return type 'Enum' doesn't allow null.
  - 'Enum' is from 'pkg/front_end/testcases/nnbd/return_null.dart'.
@@ -180,33 +178,31 @@ static method localFunctions() → dynamic {
   function yieldSync() → core::Iterable<dynamic> sync* {}
   function yieldAsync() → asy::Stream<dynamic> async* {}
   function caseReturn1(self::Enum e) → self::Enum {
-    #L3:
-    {
-      final synthesized self::Enum #0#0 = e;
-      if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+    #L7:
+    switch(e) /*isExplicitlyExhaustive*/ {
+      #L8:
+      case #C3:
         {
           return e;
         }
-      }
-      else
-        if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-          {
-            return e;
-          }
+      #L9:
+      case #C6:
+        {
+          return e;
         }
     }
   }
   function caseReturn2(self::Enum e) → self::Enum {
-    #L4:
-    {
-      final synthesized self::Enum #1#0 = e;
-      if(#C3 =={core::Object::==}{(core::Object) → core::bool} #1#0) {
+    #L10:
+    switch(e) {
+      #L11:
+      case #C3:
         {
           return e;
         }
-      }
-      else {
-      }
+      #L12:
+      default:
+        {}
     }
     return invalid-expression "pkg/front_end/testcases/nnbd/return_null.dart:108:3: Error: A non-null value must be returned since the return type 'Enum' doesn't allow null.
  - 'Enum' is from 'pkg/front_end/testcases/nnbd/return_null.dart'.
diff --git a/pkg/front_end/testcases/nnbd_mixed/unsound_checks.dart.weak.expect b/pkg/front_end/testcases/nnbd_mixed/unsound_checks.dart.weak.expect
index 84c9f7fd8de..1d4b43808a3 100644
--- a/pkg/front_end/testcases/nnbd_mixed/unsound_checks.dart.weak.expect
+++ b/pkg/front_end/testcases/nnbd_mixed/unsound_checks.dart.weak.expect
@@ -524,58 +524,54 @@ static method callReturningNever(() → Never f) → dynamic {
 }
 static method switchOnEnum(uns::E e) → dynamic {
   #L1:
-  {
-    final synthesized uns::E #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L2:
+    case #C3:
       {
         return;
       }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          return;
-        }
+    #L3:
+    case #C6:
+      {
+        return;
       }
   }
 }
 static method switchOnEnumWithBreak(uns::E e) → dynamic {
-  #L2:
-  {
-    final synthesized uns::E #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L4:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L5:
+    case #C3:
       {
-        break #L2;
+        break #L4;
       }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          break #L2;
-        }
+    #L6:
+    case #C6:
+      {
+        break #L4;
       }
   }
 }
 static method switchOnEnumWithFallThrough1(uns::E e) → dynamic {
-  #L3:
-  {
-    final synthesized uns::E #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L7:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L8:
+    case #C3:
       {
-        break #L3;
-      }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+        break #L7;
       }
+    #L9:
+    case #C6:
+      {}
   }
 }
 static method switchOnEnumWithFallThrough2(uns::E e) → dynamic {
-  #L4:
-  {
-    final synthesized uns::E #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0 || #C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-    }
+  #L10:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L11:
+    case #C3:
+    case #C6:
+      {}
   }
 }
 static method handleThrow() → dynamic {
diff --git a/pkg/front_end/testcases/nnbd_mixed/unsound_checks.dart.weak.modular.expect b/pkg/front_end/testcases/nnbd_mixed/unsound_checks.dart.weak.modular.expect
index 84c9f7fd8de..1d4b43808a3 100644
--- a/pkg/front_end/testcases/nnbd_mixed/unsound_checks.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/nnbd_mixed/unsound_checks.dart.weak.modular.expect
@@ -524,58 +524,54 @@ static method callReturningNever(() → Never f) → dynamic {
 }
 static method switchOnEnum(uns::E e) → dynamic {
   #L1:
-  {
-    final synthesized uns::E #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L2:
+    case #C3:
       {
         return;
       }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          return;
-        }
+    #L3:
+    case #C6:
+      {
+        return;
       }
   }
 }
 static method switchOnEnumWithBreak(uns::E e) → dynamic {
-  #L2:
-  {
-    final synthesized uns::E #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L4:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L5:
+    case #C3:
       {
-        break #L2;
+        break #L4;
       }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          break #L2;
-        }
+    #L6:
+    case #C6:
+      {
+        break #L4;
       }
   }
 }
 static method switchOnEnumWithFallThrough1(uns::E e) → dynamic {
-  #L3:
-  {
-    final synthesized uns::E #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L7:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L8:
+    case #C3:
       {
-        break #L3;
-      }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+        break #L7;
       }
+    #L9:
+    case #C6:
+      {}
   }
 }
 static method switchOnEnumWithFallThrough2(uns::E e) → dynamic {
-  #L4:
-  {
-    final synthesized uns::E #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0 || #C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-    }
+  #L10:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L11:
+    case #C3:
+    case #C6:
+      {}
   }
 }
 static method handleThrow() → dynamic {
diff --git a/pkg/front_end/testcases/nnbd_mixed/unsound_checks.dart.weak.transformed.expect b/pkg/front_end/testcases/nnbd_mixed/unsound_checks.dart.weak.transformed.expect
index 1a00ac7df17..b8b11fa9c07 100644
--- a/pkg/front_end/testcases/nnbd_mixed/unsound_checks.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/nnbd_mixed/unsound_checks.dart.weak.transformed.expect
@@ -524,58 +524,54 @@ static method callReturningNever(() → Never f) → dynamic {
 }
 static method switchOnEnum(uns::E e) → dynamic {
   #L1:
-  {
-    final synthesized uns::E #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L2:
+    case #C3:
       {
         return;
       }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          return;
-        }
+    #L3:
+    case #C6:
+      {
+        return;
       }
   }
 }
 static method switchOnEnumWithBreak(uns::E e) → dynamic {
-  #L2:
-  {
-    final synthesized uns::E #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L4:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L5:
+    case #C3:
       {
-        break #L2;
+        break #L4;
       }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          break #L2;
-        }
+    #L6:
+    case #C6:
+      {
+        break #L4;
       }
   }
 }
 static method switchOnEnumWithFallThrough1(uns::E e) → dynamic {
-  #L3:
-  {
-    final synthesized uns::E #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L7:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L8:
+    case #C3:
       {
-        break #L3;
-      }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+        break #L7;
       }
+    #L9:
+    case #C6:
+      {}
   }
 }
 static method switchOnEnumWithFallThrough2(uns::E e) → dynamic {
-  #L4:
-  {
-    final synthesized uns::E #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0 || #C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-    }
+  #L10:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L11:
+    case #C3:
+    case #C6:
+      {}
   }
 }
 static method handleThrow() → dynamic {
@@ -626,7 +622,7 @@ Evaluated: VariableGet @ org-dartlang-testcase:///unsound_checks_lib.dart:39:56
 Evaluated: VariableGet @ org-dartlang-testcase:///unsound_checks_lib.dart:39:56 -> IntConstant(42)
 Evaluated: VariableGet @ org-dartlang-testcase:///unsound_checks_lib.dart:134:5 -> IntConstant(0)
 Evaluated: VariableGet @ org-dartlang-testcase:///unsound_checks_lib.dart:134:5 -> IntConstant(0)
-Extra constant evaluation: evaluated: 729, effectively constant: 18
+Extra constant evaluation: evaluated: 712, effectively constant: 18
 
 
 Constructor coverage from constants:
diff --git a/pkg/front_end/testcases/patterns/boolean_literal_inside_case.dart.strong.expect b/pkg/front_end/testcases/patterns/boolean_literal_inside_case.dart.strong.expect
index b2f47dc7bda..3f94f953109 100644
--- a/pkg/front_end/testcases/patterns/boolean_literal_inside_case.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/boolean_literal_inside_case.dart.strong.expect
@@ -4,13 +4,12 @@ import "dart:core" as core;
 
 static method test(dynamic x) → dynamic {
   #L1:
-  {
-    final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  switch(x) {
+    #L2:
+    case #C1:
       {
         break #L1;
       }
-    }
   }
 }
 
diff --git a/pkg/front_end/testcases/patterns/boolean_literal_inside_case.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/boolean_literal_inside_case.dart.strong.transformed.expect
index b2f47dc7bda..3f94f953109 100644
--- a/pkg/front_end/testcases/patterns/boolean_literal_inside_case.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/boolean_literal_inside_case.dart.strong.transformed.expect
@@ -4,13 +4,12 @@ import "dart:core" as core;
 
 static method test(dynamic x) → dynamic {
   #L1:
-  {
-    final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  switch(x) {
+    #L2:
+    case #C1:
       {
         break #L1;
       }
-    }
   }
 }
 
diff --git a/pkg/front_end/testcases/patterns/boolean_literal_inside_case.dart.weak.expect b/pkg/front_end/testcases/patterns/boolean_literal_inside_case.dart.weak.expect
index b2f47dc7bda..3f94f953109 100644
--- a/pkg/front_end/testcases/patterns/boolean_literal_inside_case.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/boolean_literal_inside_case.dart.weak.expect
@@ -4,13 +4,12 @@ import "dart:core" as core;
 
 static method test(dynamic x) → dynamic {
   #L1:
-  {
-    final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  switch(x) {
+    #L2:
+    case #C1:
       {
         break #L1;
       }
-    }
   }
 }
 
diff --git a/pkg/front_end/testcases/patterns/boolean_literal_inside_case.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/boolean_literal_inside_case.dart.weak.modular.expect
index b2f47dc7bda..3f94f953109 100644
--- a/pkg/front_end/testcases/patterns/boolean_literal_inside_case.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/boolean_literal_inside_case.dart.weak.modular.expect
@@ -4,13 +4,12 @@ import "dart:core" as core;
 
 static method test(dynamic x) → dynamic {
   #L1:
-  {
-    final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  switch(x) {
+    #L2:
+    case #C1:
       {
         break #L1;
       }
-    }
   }
 }
 
diff --git a/pkg/front_end/testcases/patterns/boolean_literal_inside_case.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/boolean_literal_inside_case.dart.weak.transformed.expect
index b2f47dc7bda..3f94f953109 100644
--- a/pkg/front_end/testcases/patterns/boolean_literal_inside_case.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/boolean_literal_inside_case.dart.weak.transformed.expect
@@ -4,13 +4,12 @@ import "dart:core" as core;
 
 static method test(dynamic x) → dynamic {
   #L1:
-  {
-    final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  switch(x) {
+    #L2:
+    case #C1:
       {
         break #L1;
       }
-    }
   }
 }
 
diff --git a/pkg/front_end/testcases/patterns/boolean_literal_inside_cast.dart.strong.expect b/pkg/front_end/testcases/patterns/boolean_literal_inside_cast.dart.strong.expect
index c40baf5644b..95d68cf1123 100644
--- a/pkg/front_end/testcases/patterns/boolean_literal_inside_cast.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/boolean_literal_inside_cast.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in #C1 =={core::Object::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::Object) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in #C1 =={core::Object::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::Object) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/boolean_literal_inside_cast.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/boolean_literal_inside_cast.dart.strong.transformed.expect
index d2c0ace13ef..2c4aac169de 100644
--- a/pkg/front_end/testcases/patterns/boolean_literal_inside_cast.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/boolean_literal_inside_cast.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final core::Object #t1 = let dynamic #t2 = #0#0 in #t2 == null ?{core::Object} #t2 as{ForNonNullableByDefault} core::Object : #t2{core::Object} in #C1 =={core::Object::==}{(core::Object) → core::bool} (let dynamic #t3 = #0#0 in #t3 == null ?{core::Object} #t3 as{ForNonNullableByDefault} core::Object : #t3{core::Object})) {
-      {
-        break #L1;
+    {
+      if(let final core::Object #t1 = let dynamic #t2 = #0#0 in #t2 == null ?{core::Object} #t2 as{ForNonNullableByDefault} core::Object : #t2{core::Object} in #C1 =={core::Object::==}{(core::Object) → core::bool} (let dynamic #t3 = #0#0 in #t3 == null ?{core::Object} #t3 as{ForNonNullableByDefault} core::Object : #t3{core::Object})) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/boolean_literal_inside_cast.dart.weak.expect b/pkg/front_end/testcases/patterns/boolean_literal_inside_cast.dart.weak.expect
index c40baf5644b..95d68cf1123 100644
--- a/pkg/front_end/testcases/patterns/boolean_literal_inside_cast.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/boolean_literal_inside_cast.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in #C1 =={core::Object::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::Object) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in #C1 =={core::Object::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::Object) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/boolean_literal_inside_cast.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/boolean_literal_inside_cast.dart.weak.modular.expect
index c40baf5644b..95d68cf1123 100644
--- a/pkg/front_end/testcases/patterns/boolean_literal_inside_cast.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/boolean_literal_inside_cast.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in #C1 =={core::Object::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::Object) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in #C1 =={core::Object::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::Object) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/boolean_literal_inside_cast.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/boolean_literal_inside_cast.dart.weak.transformed.expect
index 113138b4c09..10a58df6cd4 100644
--- a/pkg/front_end/testcases/patterns/boolean_literal_inside_cast.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/boolean_literal_inside_cast.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final core::Object #t1 = #0#0 in #C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-      {
-        break #L1;
+    {
+      if(let final core::Object #t1 = #0#0 in #C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/boolean_literal_inside_null_assert.dart.strong.expect b/pkg/front_end/testcases/patterns/boolean_literal_inside_null_assert.dart.strong.expect
index 65d925f859b..45ddf16a935 100644
--- a/pkg/front_end/testcases/patterns/boolean_literal_inside_null_assert.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/boolean_literal_inside_null_assert.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #C1 =={core::Object::==}{(core::Object) → core::bool} #0#0!) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #C1 =={core::Object::==}{(core::Object) → core::bool} #0#0!) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/boolean_literal_inside_null_assert.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/boolean_literal_inside_null_assert.dart.strong.transformed.expect
index 65d925f859b..45ddf16a935 100644
--- a/pkg/front_end/testcases/patterns/boolean_literal_inside_null_assert.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/boolean_literal_inside_null_assert.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #C1 =={core::Object::==}{(core::Object) → core::bool} #0#0!) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #C1 =={core::Object::==}{(core::Object) → core::bool} #0#0!) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/boolean_literal_inside_null_assert.dart.weak.expect b/pkg/front_end/testcases/patterns/boolean_literal_inside_null_assert.dart.weak.expect
index 65d925f859b..45ddf16a935 100644
--- a/pkg/front_end/testcases/patterns/boolean_literal_inside_null_assert.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/boolean_literal_inside_null_assert.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #C1 =={core::Object::==}{(core::Object) → core::bool} #0#0!) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #C1 =={core::Object::==}{(core::Object) → core::bool} #0#0!) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/boolean_literal_inside_null_assert.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/boolean_literal_inside_null_assert.dart.weak.modular.expect
index 65d925f859b..45ddf16a935 100644
--- a/pkg/front_end/testcases/patterns/boolean_literal_inside_null_assert.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/boolean_literal_inside_null_assert.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #C1 =={core::Object::==}{(core::Object) → core::bool} #0#0!) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #C1 =={core::Object::==}{(core::Object) → core::bool} #0#0!) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/boolean_literal_inside_null_assert.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/boolean_literal_inside_null_assert.dart.weak.transformed.expect
index 65d925f859b..45ddf16a935 100644
--- a/pkg/front_end/testcases/patterns/boolean_literal_inside_null_assert.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/boolean_literal_inside_null_assert.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #C1 =={core::Object::==}{(core::Object) → core::bool} #0#0!) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #C1 =={core::Object::==}{(core::Object) → core::bool} #0#0!) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/boolean_literal_inside_null_check.dart.strong.expect b/pkg/front_end/testcases/patterns/boolean_literal_inside_null_check.dart.strong.expect
index c19f10e5465..061eba1496f 100644
--- a/pkg/front_end/testcases/patterns/boolean_literal_inside_null_check.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/boolean_literal_inside_null_check.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #C1 =={core::Object::==}{(core::Object) → core::bool} #0#0 : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #C1 =={core::Object::==}{(core::Object) → core::bool} #0#0 : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/boolean_literal_inside_null_check.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/boolean_literal_inside_null_check.dart.strong.transformed.expect
index c19f10e5465..061eba1496f 100644
--- a/pkg/front_end/testcases/patterns/boolean_literal_inside_null_check.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/boolean_literal_inside_null_check.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #C1 =={core::Object::==}{(core::Object) → core::bool} #0#0 : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #C1 =={core::Object::==}{(core::Object) → core::bool} #0#0 : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/boolean_literal_inside_null_check.dart.weak.expect b/pkg/front_end/testcases/patterns/boolean_literal_inside_null_check.dart.weak.expect
index c19f10e5465..061eba1496f 100644
--- a/pkg/front_end/testcases/patterns/boolean_literal_inside_null_check.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/boolean_literal_inside_null_check.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #C1 =={core::Object::==}{(core::Object) → core::bool} #0#0 : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #C1 =={core::Object::==}{(core::Object) → core::bool} #0#0 : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/boolean_literal_inside_null_check.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/boolean_literal_inside_null_check.dart.weak.modular.expect
index c19f10e5465..061eba1496f 100644
--- a/pkg/front_end/testcases/patterns/boolean_literal_inside_null_check.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/boolean_literal_inside_null_check.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #C1 =={core::Object::==}{(core::Object) → core::bool} #0#0 : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #C1 =={core::Object::==}{(core::Object) → core::bool} #0#0 : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/boolean_literal_inside_null_check.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/boolean_literal_inside_null_check.dart.weak.transformed.expect
index c19f10e5465..061eba1496f 100644
--- a/pkg/front_end/testcases/patterns/boolean_literal_inside_null_check.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/boolean_literal_inside_null_check.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #C1 =={core::Object::==}{(core::Object) → core::bool} #0#0 : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #C1 =={core::Object::==}{(core::Object) → core::bool} #0#0 : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cache_lookups.dart.strong.expect b/pkg/front_end/testcases/patterns/cache_lookups.dart.strong.expect
index 46f7ca9a233..9819bfd7860 100644
--- a/pkg/front_end/testcases/patterns/cache_lookups.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/cache_lookups.dart.strong.expect
@@ -18,24 +18,27 @@ static field core::int counter = 0;
 static method test(dynamic o) → dynamic {
   #L1:
   {
-    core::int a;
     final synthesized dynamic #0#0 = o;
     late final synthesized core::int #0#2 = #0#0{self::Class}.{self::Class::field}{core::int};
     late final synthesized core::bool #0#10 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1;
     late final synthesized dynamic #0#12 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
     late final synthesized dynamic #0#13 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#2 || #0#0 is{ForNonNullableByDefault} self::Class && #C3 =={core::num::==}{(core::Object) → core::bool} #0#2) {
-      {
-        core::print("Class");
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#2 || #0#0 is{ForNonNullableByDefault} self::Class && #C3 =={core::num::==}{(core::Object) → core::bool} #0#2) {
+        {
+          core::print("Class");
+          break #L1;
+        }
       }
     }
-    else
+    {
+      core::int a;
       if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#10 && (#0#12 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = a = #0#12{core::int} in true)) && #C3 =={core::num::==}{(core::Object) → core::bool} #0#13 || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#10 && (#0#12 is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = a = #0#12{core::int} in true)) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#13) {
         {
           core::print("List");
         }
       }
+    }
   }
 }
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/patterns/cache_lookups.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/cache_lookups.dart.strong.transformed.expect
index 87976fb28ea..b4e7411c2d8 100644
--- a/pkg/front_end/testcases/patterns/cache_lookups.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/cache_lookups.dart.strong.transformed.expect
@@ -18,7 +18,6 @@ static field core::int counter = 0;
 static method test(dynamic o) → dynamic {
   #L1:
   {
-    core::int a;
     final synthesized dynamic #0#0 = o;
     function ##0#2#initializer() → core::int
       return #0#0{self::Class}.{self::Class::field}{core::int};
@@ -32,18 +31,22 @@ static method test(dynamic o) → dynamic {
     function ##0#13#initializer() → dynamic
       return #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic};
     late final synthesized dynamic #0#13 = ##0#13#initializer(){() → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#2 || #0#0 is{ForNonNullableByDefault} self::Class && #C3 =={core::num::==}{(core::Object) → core::bool} #0#2) {
-      {
-        core::print("Class");
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#2 || #0#0 is{ForNonNullableByDefault} self::Class && #C3 =={core::num::==}{(core::Object) → core::bool} #0#2) {
+        {
+          core::print("Class");
+          break #L1;
+        }
       }
     }
-    else
+    {
+      core::int a;
       if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#10 && (#0#12 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = a = #0#12{core::int} in true)) && #C3 =={core::num::==}{(core::Object) → core::bool} #0#13 || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#10 && (#0#12 is{ForNonNullableByDefault} core::int && (let final core::int #t2 = a = #0#12{core::int} in true)) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#13) {
         {
           core::print("List");
         }
       }
+    }
   }
 }
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/patterns/cache_lookups.dart.weak.expect b/pkg/front_end/testcases/patterns/cache_lookups.dart.weak.expect
index 46f7ca9a233..9819bfd7860 100644
--- a/pkg/front_end/testcases/patterns/cache_lookups.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/cache_lookups.dart.weak.expect
@@ -18,24 +18,27 @@ static field core::int counter = 0;
 static method test(dynamic o) → dynamic {
   #L1:
   {
-    core::int a;
     final synthesized dynamic #0#0 = o;
     late final synthesized core::int #0#2 = #0#0{self::Class}.{self::Class::field}{core::int};
     late final synthesized core::bool #0#10 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1;
     late final synthesized dynamic #0#12 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
     late final synthesized dynamic #0#13 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#2 || #0#0 is{ForNonNullableByDefault} self::Class && #C3 =={core::num::==}{(core::Object) → core::bool} #0#2) {
-      {
-        core::print("Class");
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#2 || #0#0 is{ForNonNullableByDefault} self::Class && #C3 =={core::num::==}{(core::Object) → core::bool} #0#2) {
+        {
+          core::print("Class");
+          break #L1;
+        }
       }
     }
-    else
+    {
+      core::int a;
       if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#10 && (#0#12 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = a = #0#12{core::int} in true)) && #C3 =={core::num::==}{(core::Object) → core::bool} #0#13 || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#10 && (#0#12 is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = a = #0#12{core::int} in true)) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#13) {
         {
           core::print("List");
         }
       }
+    }
   }
 }
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/patterns/cache_lookups.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/cache_lookups.dart.weak.modular.expect
index 46f7ca9a233..9819bfd7860 100644
--- a/pkg/front_end/testcases/patterns/cache_lookups.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/cache_lookups.dart.weak.modular.expect
@@ -18,24 +18,27 @@ static field core::int counter = 0;
 static method test(dynamic o) → dynamic {
   #L1:
   {
-    core::int a;
     final synthesized dynamic #0#0 = o;
     late final synthesized core::int #0#2 = #0#0{self::Class}.{self::Class::field}{core::int};
     late final synthesized core::bool #0#10 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1;
     late final synthesized dynamic #0#12 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
     late final synthesized dynamic #0#13 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#2 || #0#0 is{ForNonNullableByDefault} self::Class && #C3 =={core::num::==}{(core::Object) → core::bool} #0#2) {
-      {
-        core::print("Class");
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#2 || #0#0 is{ForNonNullableByDefault} self::Class && #C3 =={core::num::==}{(core::Object) → core::bool} #0#2) {
+        {
+          core::print("Class");
+          break #L1;
+        }
       }
     }
-    else
+    {
+      core::int a;
       if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#10 && (#0#12 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = a = #0#12{core::int} in true)) && #C3 =={core::num::==}{(core::Object) → core::bool} #0#13 || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#10 && (#0#12 is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = a = #0#12{core::int} in true)) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#13) {
         {
           core::print("List");
         }
       }
+    }
   }
 }
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/patterns/cache_lookups.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/cache_lookups.dart.weak.transformed.expect
index dc6251a9123..bba56d213e4 100644
--- a/pkg/front_end/testcases/patterns/cache_lookups.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/cache_lookups.dart.weak.transformed.expect
@@ -18,7 +18,6 @@ static field core::int counter = 0;
 static method test(dynamic o) → dynamic {
   #L1:
   {
-    core::int a;
     final synthesized dynamic #0#0 = o;
     function ##0#2#initializer() → core::int
       return #0#0{self::Class}.{self::Class::field}{core::int};
@@ -32,18 +31,22 @@ static method test(dynamic o) → dynamic {
     function ##0#13#initializer() → dynamic
       return #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic};
     late final synthesized dynamic #0#13 = ##0#13#initializer(){() → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#2 || #0#0 is{ForNonNullableByDefault} self::Class && #C3 =={core::num::==}{(core::Object) → core::bool} #0#2) {
-      {
-        core::print("Class");
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#2 || #0#0 is{ForNonNullableByDefault} self::Class && #C3 =={core::num::==}{(core::Object) → core::bool} #0#2) {
+        {
+          core::print("Class");
+          break #L1;
+        }
       }
     }
-    else
+    {
+      core::int a;
       if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#10 && (#0#12 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = a = #0#12{core::int} in true)) && #C3 =={core::num::==}{(core::Object) → core::bool} #0#13 || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#10 && (#0#12 is{ForNonNullableByDefault} core::int && (let final core::int #t2 = a = #0#12{core::int} in true)) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#13) {
         {
           core::print("List");
         }
       }
+    }
   }
 }
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/patterns/caching.dart.strong.expect b/pkg/front_end/testcases/patterns/caching.dart.strong.expect
index 7ca68f4b6f3..a0f8bb79c10 100644
--- a/pkg/front_end/testcases/patterns/caching.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/caching.dart.strong.expect
@@ -391,10 +391,6 @@ static method switchStatement(dynamic o) → core::int {
   core::print("o = ${o}");
   #L1:
   {
-    dynamic a;
-    core::int b;
-    dynamic c;
-    dynamic d;
     final synthesized dynamic #0#0 = o;
     late final synthesized core::Object? #0#4 = #0#0{({f: core::Object?})}.f{core::Object?};
     late final synthesized core::Object? #0#15 = #0#0{({g: core::Object?})}.g{core::Object?};
@@ -419,188 +415,219 @@ static method switchStatement(dynamic o) → core::int {
     synthesized core::bool #0#83;
     synthesized core::bool #0#83#isSet = false;
     late final synthesized dynamic #0#104 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic};
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        return 1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return 1;
+        }
       }
     }
-    else
+    {
       if(#0#0 is{ForNonNullableByDefault} ({f: core::Object?}) && ((let final dynamic #t31 = #0#4 as{ForNonNullableByDefault} core::int in (#0#4 as{ForNonNullableByDefault} core::int).{core::num::>=}(#C2){(core::num) → core::bool}) && (let final dynamic #t32 = #0#4 as{ForNonNullableByDefault} core::int in (#0#4 as{ForNonNullableByDefault} core::int).{core::num::<}(#C3){(core::num) → core::bool}))) {
         {
           return 2;
         }
       }
-      else
-        if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C5 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-          {
-            return 3;
-          }
+    }
+    {
+      if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C5 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return 3;
         }
-        else
-          if(#0#0 is{ForNonNullableByDefault} ({g: core::Object?}) && (let final dynamic #t33 = #0#15 as{ForNonNullableByDefault} core::int in #C6 =={core::num::==}{(core::Object) → core::bool} #0#15 as{ForNonNullableByDefault} core::int)) {
-            {
-              return 4;
-            }
-          }
-          else
-            if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?}) && (let final dynamic #t34 = (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final dynamic #t35 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?})}.a{core::Object?})! in true)) {
-              {
-                return 5;
-              }
-            }
-            else
-              if(#0#0 is{ForNonNullableByDefault} ({b: core::Object?}) && (!((#0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final dynamic #t36 = #0#23#isSet = true in #0#23 = #0#0{({b: core::Object?})}.b{core::Object?}) == null) ?{core::bool} true : false)) {
-                {
-                  return 6;
-                }
-              }
-              else
-                if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t37 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#32) {
-                  {
-                    return 7;
-                  }
-                }
-                else
-                  if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#32) {
-                    {
-                      return 8;
-                    }
-                  }
-                  else
-                    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#32 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#43) {
-                      {
-                        return 9;
-                      }
-                    }
-                    else
-                      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#32 && (#0#47.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t38 = #0#50 as{ForNonNullableByDefault} core::int in (#0#50 as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final dynamic #t39 = #0#53 as{ForNonNullableByDefault} core::int in (#0#53 as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool}))) {
-                        {
-                          return 10;
-                        }
-                      }
-                      else
-                        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C4 =={core::num::==}{(core::Object) → core::bool} #0#32 && (#0#58.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t40 = #0#61 as{ForNonNullableByDefault} core::int in (#0#61 as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final dynamic #t41 = #0#64 as{ForNonNullableByDefault} core::int in (#0#64 as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})) && #C5 =={core::num::==}{(core::Object) → core::bool} #0#43) {
-                          {
-                            return 11;
-                          }
-                        }
-                        else
-                          if(#0#0 is{ForNonNullableByDefault} self::Class && #C1 =={core::num::==}{(core::Object) → core::bool} #0#69) {
-                            {
-                              return 12;
-                            }
-                          }
-                          else
-                            if(#0#0 is{ForNonNullableByDefault} self::Class && #C7 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::finalField}{core::int}) {
-                              {
-                                return 13;
-                              }
-                            }
-                            else
-                              if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#69 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::getter}{core::int}) {
-                                {
-                                  return 14;
-                                }
-                              }
-                              else
-                                if(#0#0 is{ForNonNullableByDefault} self::Class) {
-                                  {
-                                    return 15;
-                                  }
-                                }
-                                else
-                                  if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C9) {
-                                    {
-                                      return 16;
-                                    }
-                                  }
-                                  else
-                                    if(#0#0 is{ForNonNullableByDefault} ({e: core::Object?}) && !(#0#0{({e: core::Object?})}.e{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C10)) {
-                                      {
-                                        return 17;
-                                      }
-                                    }
-                                    else
-                                      if(#0#0 is{ForNonNullableByDefault} core::Map<core::int, core::int> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t42 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t43 = #0#26#isSet = true in #0#26 = #0#0{core::Map<core::int, core::int>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<core::int, core::int>}.{core::Map::containsKey}(#C3){(core::Object?) → core::bool} && (#0#0{core::Map<core::int, core::int>}.{core::Map::[]}(#C3){(core::Object?) → core::int?} as{ForNonNullableByDefault} core::int).{core::num::>=}(#C11){(core::num) → core::bool}) {
-                                        {
-                                          return 18;
-                                        }
-                                      }
-                                      else
-                                        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t44 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t45 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && (let final dynamic #t46 = #0#30 in true)) {
-                                          {
-                                            return 19;
-                                          }
-                                        }
-                                        else
-                                          if(#0#0 is{ForNonNullableByDefault} core::bool) {
-                                            {
-                                              return 20;
-                                            }
-                                          }
-                                          else
-                                            if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t47 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C12) {
-                                              {
-                                                return 21;
-                                              }
-                                            }
-                                            else
-                                              if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t48 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t49 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C12){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C12){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::int) {
-                                                {
-                                                  return 22;
-                                                }
-                                              }
-                                              else
-                                                if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t50 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::String) {
-                                                  {
-                                                    return 23;
-                                                  }
-                                                }
-                                                else
-                                                  if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t51 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t52 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C7){(core::Object?) → core::bool} && (let final dynamic #t53 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C7){(core::Object?) → dynamic} in true)) {
-                                                    {
-                                                      return 24;
-                                                    }
-                                                  }
-                                                  else
-                                                    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t54 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t55 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && (#0#104 is{ForNonNullableByDefault} core::int && (let final dynamic #t56 = b = #0#104{core::int} in true))) {
-                                                      {
-                                                        return 25;
-                                                      }
-                                                    }
-                                                    else
-                                                      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
-                                                        {
-                                                          return 26;
-                                                        }
-                                                      }
-                                                      else
-                                                        if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?, b: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final dynamic #t57 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?, b: core::Object?})}.a{core::Object?}) && (let final dynamic #t58 = c = #0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final dynamic #t59 = #0#23#isSet = true in #0#23 = #0#0{({a: core::Object?, b: core::Object?})}.b{core::Object?} in true)) {
-                                                          {
-                                                            return 27;
-                                                          }
-                                                        }
-                                                        else
-                                                          if(#0#0 is{ForNonNullableByDefault} ({c: core::Object?, d: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{({c: core::Object?, d: core::Object?})}.c{core::Object?} && (let final dynamic #t60 = d = #0#0{({c: core::Object?, d: core::Object?})}.d{core::Object?} in true) && d is{ForNonNullableByDefault} core::int) {
-                                                            {
-                                                              return 28;
-                                                            }
-                                                          }
-                                                          else {
-                                                            {
-                                                              return 0;
-                                                            }
-                                                          }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} ({g: core::Object?}) && (let final dynamic #t33 = #0#15 as{ForNonNullableByDefault} core::int in #C6 =={core::num::==}{(core::Object) → core::bool} #0#15 as{ForNonNullableByDefault} core::int)) {
+        {
+          return 4;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?}) && (let final dynamic #t34 = (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final dynamic #t35 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?})}.a{core::Object?})! in true)) {
+        {
+          return 5;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} ({b: core::Object?}) && (!((#0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final dynamic #t36 = #0#23#isSet = true in #0#23 = #0#0{({b: core::Object?})}.b{core::Object?}) == null) ?{core::bool} true : false)) {
+        {
+          return 6;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t37 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#32) {
+        {
+          return 7;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#32) {
+        {
+          return 8;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#32 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#43) {
+        {
+          return 9;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#32 && (#0#47.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t38 = #0#50 as{ForNonNullableByDefault} core::int in (#0#50 as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final dynamic #t39 = #0#53 as{ForNonNullableByDefault} core::int in (#0#53 as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool}))) {
+        {
+          return 10;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C4 =={core::num::==}{(core::Object) → core::bool} #0#32 && (#0#58.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t40 = #0#61 as{ForNonNullableByDefault} core::int in (#0#61 as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final dynamic #t41 = #0#64 as{ForNonNullableByDefault} core::int in (#0#64 as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})) && #C5 =={core::num::==}{(core::Object) → core::bool} #0#43) {
+        {
+          return 11;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Class && #C1 =={core::num::==}{(core::Object) → core::bool} #0#69) {
+        {
+          return 12;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Class && #C7 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::finalField}{core::int}) {
+        {
+          return 13;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#69 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::getter}{core::int}) {
+        {
+          return 14;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Class) {
+        {
+          return 15;
+        }
+      }
+    }
+    {
+      if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C9) {
+        {
+          return 16;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} ({e: core::Object?}) && !(#0#0{({e: core::Object?})}.e{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C10)) {
+        {
+          return 17;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<core::int, core::int> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t42 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t43 = #0#26#isSet = true in #0#26 = #0#0{core::Map<core::int, core::int>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<core::int, core::int>}.{core::Map::containsKey}(#C3){(core::Object?) → core::bool} && (#0#0{core::Map<core::int, core::int>}.{core::Map::[]}(#C3){(core::Object?) → core::int?} as{ForNonNullableByDefault} core::int).{core::num::>=}(#C11){(core::num) → core::bool}) {
+        {
+          return 18;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t44 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t45 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && (let final dynamic #t46 = #0#30 in true)) {
+        {
+          return 19;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::bool) {
+        {
+          return 20;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t47 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C12) {
+        {
+          return 21;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t48 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t49 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C12){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C12){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::int) {
+        {
+          return 22;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t50 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::String) {
+        {
+          return 23;
+        }
+      }
+    }
+    {
+      dynamic a;
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t51 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t52 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C7){(core::Object?) → core::bool} && (let final dynamic #t53 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C7){(core::Object?) → dynamic} in true)) {
+        {
+          return 24;
+        }
+      }
+    }
+    {
+      core::int b;
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t54 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t55 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && (#0#104 is{ForNonNullableByDefault} core::int && (let final dynamic #t56 = b = #0#104{core::int} in true))) {
+        {
+          return 25;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+        {
+          return 26;
+        }
+      }
+    }
+    {
+      dynamic c;
+      if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?, b: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final dynamic #t57 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?, b: core::Object?})}.a{core::Object?}) && (let final dynamic #t58 = c = #0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final dynamic #t59 = #0#23#isSet = true in #0#23 = #0#0{({a: core::Object?, b: core::Object?})}.b{core::Object?} in true)) {
+        {
+          return 27;
+        }
+      }
+    }
+    {
+      dynamic d;
+      if(#0#0 is{ForNonNullableByDefault} ({c: core::Object?, d: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{({c: core::Object?, d: core::Object?})}.c{core::Object?} && (let final dynamic #t60 = d = #0#0{({c: core::Object?, d: core::Object?})}.d{core::Object?} in true) && d is{ForNonNullableByDefault} core::int) {
+        {
+          return 28;
+        }
+      }
+    }
+    {
+      {
+        {
+          return 0;
+        }
+      }
+    }
   }
 }
 static method switchExpression(dynamic o) → core::int {
   core::print("o = ${o}");
   return block {
     core::int #t61;
-    dynamic a;
-    core::int b;
-    dynamic c;
-    dynamic d;
     final synthesized dynamic #0#0 = o;
     late final synthesized core::Object? #0#4 = #0#0{({f: core::Object?})}.f{core::Object?};
     late final synthesized core::Object? #0#15 = #0#0{({g: core::Object?})}.g{core::Object?};
@@ -625,92 +652,187 @@ static method switchExpression(dynamic o) → core::int {
     synthesized core::bool #0#83;
     synthesized core::bool #0#83#isSet = false;
     late final synthesized dynamic #0#104 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic};
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0)
-      #t61 = 1;
-    else
-      if(#0#0 is{ForNonNullableByDefault} ({f: core::Object?}) && ((let final dynamic #t66 = #0#4 as{ForNonNullableByDefault} core::int in (#0#4 as{ForNonNullableByDefault} core::int).{core::num::>=}(#C2){(core::num) → core::bool}) && (let final dynamic #t67 = #0#4 as{ForNonNullableByDefault} core::int in (#0#4 as{ForNonNullableByDefault} core::int).{core::num::<}(#C3){(core::num) → core::bool})))
-        #t61 = 2;
-      else
-        if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C5 =={core::num::==}{(core::Object) → core::bool} #0#0)
+    #L2:
+    {
+      {
+        if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+          #t61 = 1;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({f: core::Object?}) && ((let final dynamic #t66 = #0#4 as{ForNonNullableByDefault} core::int in (#0#4 as{ForNonNullableByDefault} core::int).{core::num::>=}(#C2){(core::num) → core::bool}) && (let final dynamic #t67 = #0#4 as{ForNonNullableByDefault} core::int in (#0#4 as{ForNonNullableByDefault} core::int).{core::num::<}(#C3){(core::num) → core::bool}))) {
+          #t61 = 2;
+          break #L2;
+        }
+      }
+      {
+        if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C5 =={core::num::==}{(core::Object) → core::bool} #0#0) {
           #t61 = 3;
-        else
-          if(#0#0 is{ForNonNullableByDefault} ({g: core::Object?}) && (let final dynamic #t68 = #0#15 as{ForNonNullableByDefault} core::int in #C6 =={core::num::==}{(core::Object) → core::bool} #0#15 as{ForNonNullableByDefault} core::int))
-            #t61 = 4;
-          else
-            if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?}) && (let final dynamic #t69 = (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final dynamic #t70 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?})}.a{core::Object?})! in true))
-              #t61 = 5;
-            else
-              if(#0#0 is{ForNonNullableByDefault} ({b: core::Object?}) && (!((#0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final dynamic #t71 = #0#23#isSet = true in #0#23 = #0#0{({b: core::Object?})}.b{core::Object?}) == null) ?{core::bool} true : false))
-                #t61 = 6;
-              else
-                if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t72 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#32)
-                  #t61 = 7;
-                else
-                  if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#32)
-                    #t61 = 8;
-                  else
-                    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#32 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#43)
-                      #t61 = 9;
-                    else
-                      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#32 && (#0#47.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t73 = #0#50 as{ForNonNullableByDefault} core::int in (#0#50 as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final dynamic #t74 = #0#53 as{ForNonNullableByDefault} core::int in (#0#53 as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})))
-                        #t61 = 10;
-                      else
-                        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C4 =={core::num::==}{(core::Object) → core::bool} #0#32 && (#0#58.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t75 = #0#61 as{ForNonNullableByDefault} core::int in (#0#61 as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final dynamic #t76 = #0#64 as{ForNonNullableByDefault} core::int in (#0#64 as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})) && #C5 =={core::num::==}{(core::Object) → core::bool} #0#43)
-                          #t61 = 11;
-                        else
-                          if(#0#0 is{ForNonNullableByDefault} self::Class && #C1 =={core::num::==}{(core::Object) → core::bool} #0#69)
-                            #t61 = 12;
-                          else
-                            if(#0#0 is{ForNonNullableByDefault} self::Class && #C7 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::finalField}{core::int})
-                              #t61 = 13;
-                            else
-                              if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#69 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::getter}{core::int})
-                                #t61 = 14;
-                              else
-                                if(#0#0 is{ForNonNullableByDefault} self::Class)
-                                  #t61 = 15;
-                                else
-                                  if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C9)
-                                    #t61 = 16;
-                                  else
-                                    if(#0#0 is{ForNonNullableByDefault} ({e: core::Object?}) && !(#0#0{({e: core::Object?})}.e{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C10))
-                                      #t61 = 17;
-                                    else
-                                      if(#0#0 is{ForNonNullableByDefault} core::Map<core::int, core::int> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t77 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t78 = #0#26#isSet = true in #0#26 = #0#0{core::Map<core::int, core::int>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<core::int, core::int>}.{core::Map::containsKey}(#C3){(core::Object?) → core::bool} && (#0#0{core::Map<core::int, core::int>}.{core::Map::[]}(#C3){(core::Object?) → core::int?} as{ForNonNullableByDefault} core::int).{core::num::>=}(#C11){(core::num) → core::bool})
-                                        #t61 = 18;
-                                      else
-                                        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t79 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t80 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && (let final dynamic #t81 = #0#30 in true))
-                                          #t61 = 19;
-                                        else
-                                          if(#0#0 is{ForNonNullableByDefault} core::bool)
-                                            #t61 = 20;
-                                          else
-                                            if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t82 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C12)
-                                              #t61 = 21;
-                                            else
-                                              if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t83 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t84 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C12){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C12){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::int)
-                                                #t61 = 22;
-                                              else
-                                                if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t85 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::String)
-                                                  #t61 = 23;
-                                                else
-                                                  if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t86 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t87 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C7){(core::Object?) → core::bool} && (let final dynamic #t88 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C7){(core::Object?) → dynamic} in true))
-                                                    #t61 = 24;
-                                                  else
-                                                    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t89 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t90 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && (#0#104 is{ForNonNullableByDefault} core::int && (let final dynamic #t91 = b = #0#104{core::int} in true)))
-                                                      #t61 = 25;
-                                                    else
-                                                      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?})
-                                                        #t61 = 26;
-                                                      else
-                                                        if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?, b: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final dynamic #t92 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?, b: core::Object?})}.a{core::Object?}) && (let final dynamic #t93 = c = #0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final dynamic #t94 = #0#23#isSet = true in #0#23 = #0#0{({a: core::Object?, b: core::Object?})}.b{core::Object?} in true))
-                                                          #t61 = 27;
-                                                        else
-                                                          if(#0#0 is{ForNonNullableByDefault} ({c: core::Object?, d: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{({c: core::Object?, d: core::Object?})}.c{core::Object?} && (let final dynamic #t95 = d = #0#0{({c: core::Object?, d: core::Object?})}.d{core::Object?} in true) && d is{ForNonNullableByDefault} core::int)
-                                                            #t61 = 28;
-                                                          else
-                                                            if(true)
-                                                              #t61 = 0;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({g: core::Object?}) && (let final dynamic #t68 = #0#15 as{ForNonNullableByDefault} core::int in #C6 =={core::num::==}{(core::Object) → core::bool} #0#15 as{ForNonNullableByDefault} core::int)) {
+          #t61 = 4;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?}) && (let final dynamic #t69 = (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final dynamic #t70 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?})}.a{core::Object?})! in true)) {
+          #t61 = 5;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({b: core::Object?}) && (!((#0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final dynamic #t71 = #0#23#isSet = true in #0#23 = #0#0{({b: core::Object?})}.b{core::Object?}) == null) ?{core::bool} true : false)) {
+          #t61 = 6;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t72 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#32) {
+          #t61 = 7;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#32) {
+          #t61 = 8;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#32 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#43) {
+          #t61 = 9;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#32 && (#0#47.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t73 = #0#50 as{ForNonNullableByDefault} core::int in (#0#50 as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final dynamic #t74 = #0#53 as{ForNonNullableByDefault} core::int in (#0#53 as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool}))) {
+          #t61 = 10;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C4 =={core::num::==}{(core::Object) → core::bool} #0#32 && (#0#58.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t75 = #0#61 as{ForNonNullableByDefault} core::int in (#0#61 as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final dynamic #t76 = #0#64 as{ForNonNullableByDefault} core::int in (#0#64 as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})) && #C5 =={core::num::==}{(core::Object) → core::bool} #0#43) {
+          #t61 = 11;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} self::Class && #C1 =={core::num::==}{(core::Object) → core::bool} #0#69) {
+          #t61 = 12;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} self::Class && #C7 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::finalField}{core::int}) {
+          #t61 = 13;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#69 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::getter}{core::int}) {
+          #t61 = 14;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} self::Class) {
+          #t61 = 15;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C9) {
+          #t61 = 16;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({e: core::Object?}) && !(#0#0{({e: core::Object?})}.e{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C10)) {
+          #t61 = 17;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::Map<core::int, core::int> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t77 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t78 = #0#26#isSet = true in #0#26 = #0#0{core::Map<core::int, core::int>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<core::int, core::int>}.{core::Map::containsKey}(#C3){(core::Object?) → core::bool} && (#0#0{core::Map<core::int, core::int>}.{core::Map::[]}(#C3){(core::Object?) → core::int?} as{ForNonNullableByDefault} core::int).{core::num::>=}(#C11){(core::num) → core::bool}) {
+          #t61 = 18;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t79 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t80 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && (let final dynamic #t81 = #0#30 in true)) {
+          #t61 = 19;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::bool) {
+          #t61 = 20;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t82 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C12) {
+          #t61 = 21;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t83 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t84 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C12){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C12){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::int) {
+          #t61 = 22;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t85 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::String) {
+          #t61 = 23;
+          break #L2;
+        }
+      }
+      {
+        dynamic a;
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t86 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t87 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C7){(core::Object?) → core::bool} && (let final dynamic #t88 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C7){(core::Object?) → dynamic} in true)) {
+          #t61 = 24;
+          break #L2;
+        }
+      }
+      {
+        core::int b;
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t89 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t90 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && (#0#104 is{ForNonNullableByDefault} core::int && (let final dynamic #t91 = b = #0#104{core::int} in true))) {
+          #t61 = 25;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+          #t61 = 26;
+          break #L2;
+        }
+      }
+      {
+        dynamic c;
+        if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?, b: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final dynamic #t92 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?, b: core::Object?})}.a{core::Object?}) && (let final dynamic #t93 = c = #0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final dynamic #t94 = #0#23#isSet = true in #0#23 = #0#0{({a: core::Object?, b: core::Object?})}.b{core::Object?} in true)) {
+          #t61 = 27;
+          break #L2;
+        }
+      }
+      {
+        dynamic d;
+        if(#0#0 is{ForNonNullableByDefault} ({c: core::Object?, d: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{({c: core::Object?, d: core::Object?})}.c{core::Object?} && (let final dynamic #t95 = d = #0#0{({c: core::Object?, d: core::Object?})}.d{core::Object?} in true) && d is{ForNonNullableByDefault} core::int) {
+          #t61 = 28;
+          break #L2;
+        }
+      }
+      {
+        if(true) {
+          #t61 = 0;
+          break #L2;
+        }
+      }
+    }
   } =>#t61;
 }
 static method test(dynamic expected, dynamic value) → dynamic {
diff --git a/pkg/front_end/testcases/patterns/caching.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/caching.dart.strong.transformed.expect
index ed31f5f1f76..c5848654d4d 100644
--- a/pkg/front_end/testcases/patterns/caching.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/caching.dart.strong.transformed.expect
@@ -435,10 +435,6 @@ static method switchStatement(dynamic o) → core::int {
   core::print("o = ${o}");
   #L1:
   {
-    dynamic a;
-    core::int b;
-    dynamic c;
-    dynamic d;
     final synthesized dynamic #0#0 = o;
     function ##0#4#initializer() → core::Object?
       return #0#0{({f: core::Object?})}.f{core::Object?};
@@ -493,188 +489,219 @@ static method switchStatement(dynamic o) → core::int {
     function ##0#104#initializer() → dynamic
       return #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic};
     late final synthesized dynamic #0#104 = ##0#104#initializer(){() → dynamic};
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        return 1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return 1;
+        }
       }
     }
-    else
+    {
       if(#0#0 is{ForNonNullableByDefault} ({f: core::Object?}) && ((let final core::int #t33 = #0#4 as{ForNonNullableByDefault} core::int in (#0#4 as{ForNonNullableByDefault} core::int).{core::num::>=}(#C2){(core::num) → core::bool}) && (let final core::int #t34 = #0#4 as{ForNonNullableByDefault} core::int in (#0#4 as{ForNonNullableByDefault} core::int).{core::num::<}(#C3){(core::num) → core::bool}))) {
         {
           return 2;
         }
       }
-      else
-        if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C5 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-          {
-            return 3;
-          }
+    }
+    {
+      if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C5 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return 3;
         }
-        else
-          if(#0#0 is{ForNonNullableByDefault} ({g: core::Object?}) && (let final core::int #t35 = #0#15 as{ForNonNullableByDefault} core::int in #C6 =={core::num::==}{(core::Object) → core::bool} #0#15 as{ForNonNullableByDefault} core::int)) {
-            {
-              return 4;
-            }
-          }
-          else
-            if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?}) && (let final core::Object? #t36 = (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final core::bool* #t37 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?})}.a{core::Object?})! in true)) {
-              {
-                return 5;
-              }
-            }
-            else
-              if(#0#0 is{ForNonNullableByDefault} ({b: core::Object?}) && (!((#0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final core::bool* #t38 = #0#23#isSet = true in #0#23 = #0#0{({b: core::Object?})}.b{core::Object?}) == null) ?{core::bool} true : false)) {
-                {
-                  return 6;
-                }
-              }
-              else
-                if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t39 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#32) {
-                  {
-                    return 7;
-                  }
-                }
-                else
-                  if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#32) {
-                    {
-                      return 8;
-                    }
-                  }
-                  else
-                    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#32 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#43) {
-                      {
-                        return 9;
-                      }
-                    }
-                    else
-                      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#32 && (#0#47.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final core::int #t40 = #0#50 as{ForNonNullableByDefault} core::int in (#0#50 as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final core::int #t41 = #0#53 as{ForNonNullableByDefault} core::int in (#0#53 as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool}))) {
-                        {
-                          return 10;
-                        }
-                      }
-                      else
-                        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C4 =={core::num::==}{(core::Object) → core::bool} #0#32 && (#0#58.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final core::int #t42 = #0#61 as{ForNonNullableByDefault} core::int in (#0#61 as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final core::int #t43 = #0#64 as{ForNonNullableByDefault} core::int in (#0#64 as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})) && #C5 =={core::num::==}{(core::Object) → core::bool} #0#43) {
-                          {
-                            return 11;
-                          }
-                        }
-                        else
-                          if(#0#0 is{ForNonNullableByDefault} self::Class && #C1 =={core::num::==}{(core::Object) → core::bool} #0#69) {
-                            {
-                              return 12;
-                            }
-                          }
-                          else
-                            if(#0#0 is{ForNonNullableByDefault} self::Class && #C7 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::finalField}{core::int}) {
-                              {
-                                return 13;
-                              }
-                            }
-                            else
-                              if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#69 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::getter}{core::int}) {
-                                {
-                                  return 14;
-                                }
-                              }
-                              else
-                                if(#0#0 is{ForNonNullableByDefault} self::Class) {
-                                  {
-                                    return 15;
-                                  }
-                                }
-                                else
-                                  if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C9) {
-                                    {
-                                      return 16;
-                                    }
-                                  }
-                                  else
-                                    if(#0#0 is{ForNonNullableByDefault} ({e: core::Object?}) && !(#0#0{({e: core::Object?})}.e{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C10)) {
-                                      {
-                                        return 17;
-                                      }
-                                    }
-                                    else
-                                      if(#0#0 is{ForNonNullableByDefault} core::Map<core::int, core::int> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t44 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t45 = #0#26#isSet = true in #0#26 = #0#0{core::Map<core::int, core::int>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<core::int, core::int>}.{core::Map::containsKey}(#C3){(core::Object?) → core::bool} && (let core::int? #t46 = #0#0{core::Map<core::int, core::int>}.{core::Map::[]}(#C3){(core::Object?) → core::int?} in #t46 == null ?{core::int} #t46 as{ForNonNullableByDefault} core::int : #t46{core::int}).{core::num::>=}(#C11){(core::num) → core::bool}) {
-                                        {
-                                          return 18;
-                                        }
-                                      }
-                                      else
-                                        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t47 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t48 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && (let final dynamic #t49 = #0#30 in true)) {
-                                          {
-                                            return 19;
-                                          }
-                                        }
-                                        else
-                                          if(#0#0 is{ForNonNullableByDefault} core::bool) {
-                                            {
-                                              return 20;
-                                            }
-                                          }
-                                          else
-                                            if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t50 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C12) {
-                                              {
-                                                return 21;
-                                              }
-                                            }
-                                            else
-                                              if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t51 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t52 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C12){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C12){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::int) {
-                                                {
-                                                  return 22;
-                                                }
-                                              }
-                                              else
-                                                if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t53 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::String) {
-                                                  {
-                                                    return 23;
-                                                  }
-                                                }
-                                                else
-                                                  if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t54 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t55 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C7){(core::Object?) → core::bool} && (let final dynamic #t56 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C7){(core::Object?) → dynamic} in true)) {
-                                                    {
-                                                      return 24;
-                                                    }
-                                                  }
-                                                  else
-                                                    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t57 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t58 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && (#0#104 is{ForNonNullableByDefault} core::int && (let final core::int #t59 = b = #0#104{core::int} in true))) {
-                                                      {
-                                                        return 25;
-                                                      }
-                                                    }
-                                                    else
-                                                      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
-                                                        {
-                                                          return 26;
-                                                        }
-                                                      }
-                                                      else
-                                                        if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?, b: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final core::bool* #t60 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?, b: core::Object?})}.a{core::Object?}) && (let final core::Object? #t61 = c = #0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final core::bool* #t62 = #0#23#isSet = true in #0#23 = #0#0{({a: core::Object?, b: core::Object?})}.b{core::Object?} in true)) {
-                                                          {
-                                                            return 27;
-                                                          }
-                                                        }
-                                                        else
-                                                          if(#0#0 is{ForNonNullableByDefault} ({c: core::Object?, d: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{({c: core::Object?, d: core::Object?})}.c{core::Object?} && (let final core::Object? #t63 = d = #0#0{({c: core::Object?, d: core::Object?})}.d{core::Object?} in true) && d is{ForNonNullableByDefault} core::int) {
-                                                            {
-                                                              return 28;
-                                                            }
-                                                          }
-                                                          else {
-                                                            {
-                                                              return 0;
-                                                            }
-                                                          }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} ({g: core::Object?}) && (let final core::int #t35 = #0#15 as{ForNonNullableByDefault} core::int in #C6 =={core::num::==}{(core::Object) → core::bool} #0#15 as{ForNonNullableByDefault} core::int)) {
+        {
+          return 4;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?}) && (let final core::Object? #t36 = (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final core::bool* #t37 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?})}.a{core::Object?})! in true)) {
+        {
+          return 5;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} ({b: core::Object?}) && (!((#0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final core::bool* #t38 = #0#23#isSet = true in #0#23 = #0#0{({b: core::Object?})}.b{core::Object?}) == null) ?{core::bool} true : false)) {
+        {
+          return 6;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t39 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#32) {
+        {
+          return 7;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#32) {
+        {
+          return 8;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#32 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#43) {
+        {
+          return 9;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#32 && (#0#47.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final core::int #t40 = #0#50 as{ForNonNullableByDefault} core::int in (#0#50 as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final core::int #t41 = #0#53 as{ForNonNullableByDefault} core::int in (#0#53 as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool}))) {
+        {
+          return 10;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C4 =={core::num::==}{(core::Object) → core::bool} #0#32 && (#0#58.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final core::int #t42 = #0#61 as{ForNonNullableByDefault} core::int in (#0#61 as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final core::int #t43 = #0#64 as{ForNonNullableByDefault} core::int in (#0#64 as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})) && #C5 =={core::num::==}{(core::Object) → core::bool} #0#43) {
+        {
+          return 11;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Class && #C1 =={core::num::==}{(core::Object) → core::bool} #0#69) {
+        {
+          return 12;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Class && #C7 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::finalField}{core::int}) {
+        {
+          return 13;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#69 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::getter}{core::int}) {
+        {
+          return 14;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Class) {
+        {
+          return 15;
+        }
+      }
+    }
+    {
+      if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C9) {
+        {
+          return 16;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} ({e: core::Object?}) && !(#0#0{({e: core::Object?})}.e{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C10)) {
+        {
+          return 17;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<core::int, core::int> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t44 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t45 = #0#26#isSet = true in #0#26 = #0#0{core::Map<core::int, core::int>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<core::int, core::int>}.{core::Map::containsKey}(#C3){(core::Object?) → core::bool} && (let core::int? #t46 = #0#0{core::Map<core::int, core::int>}.{core::Map::[]}(#C3){(core::Object?) → core::int?} in #t46 == null ?{core::int} #t46 as{ForNonNullableByDefault} core::int : #t46{core::int}).{core::num::>=}(#C11){(core::num) → core::bool}) {
+        {
+          return 18;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t47 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t48 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && (let final dynamic #t49 = #0#30 in true)) {
+        {
+          return 19;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::bool) {
+        {
+          return 20;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t50 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C12) {
+        {
+          return 21;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t51 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t52 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C12){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C12){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::int) {
+        {
+          return 22;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t53 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::String) {
+        {
+          return 23;
+        }
+      }
+    }
+    {
+      dynamic a;
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t54 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t55 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C7){(core::Object?) → core::bool} && (let final dynamic #t56 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C7){(core::Object?) → dynamic} in true)) {
+        {
+          return 24;
+        }
+      }
+    }
+    {
+      core::int b;
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t57 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t58 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && (#0#104 is{ForNonNullableByDefault} core::int && (let final core::int #t59 = b = #0#104{core::int} in true))) {
+        {
+          return 25;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+        {
+          return 26;
+        }
+      }
+    }
+    {
+      dynamic c;
+      if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?, b: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final core::bool* #t60 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?, b: core::Object?})}.a{core::Object?}) && (let final core::Object? #t61 = c = #0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final core::bool* #t62 = #0#23#isSet = true in #0#23 = #0#0{({a: core::Object?, b: core::Object?})}.b{core::Object?} in true)) {
+        {
+          return 27;
+        }
+      }
+    }
+    {
+      dynamic d;
+      if(#0#0 is{ForNonNullableByDefault} ({c: core::Object?, d: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{({c: core::Object?, d: core::Object?})}.c{core::Object?} && (let final core::Object? #t63 = d = #0#0{({c: core::Object?, d: core::Object?})}.d{core::Object?} in true) && d is{ForNonNullableByDefault} core::int) {
+        {
+          return 28;
+        }
+      }
+    }
+    {
+      {
+        {
+          return 0;
+        }
+      }
+    }
   }
 }
 static method switchExpression(dynamic o) → core::int {
   core::print("o = ${o}");
   return block {
     core::int #t64;
-    dynamic a;
-    core::int b;
-    dynamic c;
-    dynamic d;
     final synthesized dynamic #0#0 = o;
     function ##0#4#initializer() → core::Object?
       return #0#0{({f: core::Object?})}.f{core::Object?};
@@ -729,92 +756,187 @@ static method switchExpression(dynamic o) → core::int {
     function ##0#104#initializer() → dynamic
       return #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic};
     late final synthesized dynamic #0#104 = ##0#104#initializer(){() → dynamic};
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0)
-      #t64 = 1;
-    else
-      if(#0#0 is{ForNonNullableByDefault} ({f: core::Object?}) && ((let final core::int #t69 = #0#4 as{ForNonNullableByDefault} core::int in (#0#4 as{ForNonNullableByDefault} core::int).{core::num::>=}(#C2){(core::num) → core::bool}) && (let final core::int #t70 = #0#4 as{ForNonNullableByDefault} core::int in (#0#4 as{ForNonNullableByDefault} core::int).{core::num::<}(#C3){(core::num) → core::bool})))
-        #t64 = 2;
-      else
-        if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C5 =={core::num::==}{(core::Object) → core::bool} #0#0)
+    #L2:
+    {
+      {
+        if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+          #t64 = 1;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({f: core::Object?}) && ((let final core::int #t69 = #0#4 as{ForNonNullableByDefault} core::int in (#0#4 as{ForNonNullableByDefault} core::int).{core::num::>=}(#C2){(core::num) → core::bool}) && (let final core::int #t70 = #0#4 as{ForNonNullableByDefault} core::int in (#0#4 as{ForNonNullableByDefault} core::int).{core::num::<}(#C3){(core::num) → core::bool}))) {
+          #t64 = 2;
+          break #L2;
+        }
+      }
+      {
+        if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C5 =={core::num::==}{(core::Object) → core::bool} #0#0) {
           #t64 = 3;
-        else
-          if(#0#0 is{ForNonNullableByDefault} ({g: core::Object?}) && (let final core::int #t71 = #0#15 as{ForNonNullableByDefault} core::int in #C6 =={core::num::==}{(core::Object) → core::bool} #0#15 as{ForNonNullableByDefault} core::int))
-            #t64 = 4;
-          else
-            if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?}) && (let final core::Object? #t72 = (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final core::bool* #t73 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?})}.a{core::Object?})! in true))
-              #t64 = 5;
-            else
-              if(#0#0 is{ForNonNullableByDefault} ({b: core::Object?}) && (!((#0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final core::bool* #t74 = #0#23#isSet = true in #0#23 = #0#0{({b: core::Object?})}.b{core::Object?}) == null) ?{core::bool} true : false))
-                #t64 = 6;
-              else
-                if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t75 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#32)
-                  #t64 = 7;
-                else
-                  if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#32)
-                    #t64 = 8;
-                  else
-                    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#32 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#43)
-                      #t64 = 9;
-                    else
-                      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#32 && (#0#47.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final core::int #t76 = #0#50 as{ForNonNullableByDefault} core::int in (#0#50 as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final core::int #t77 = #0#53 as{ForNonNullableByDefault} core::int in (#0#53 as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})))
-                        #t64 = 10;
-                      else
-                        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C4 =={core::num::==}{(core::Object) → core::bool} #0#32 && (#0#58.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final core::int #t78 = #0#61 as{ForNonNullableByDefault} core::int in (#0#61 as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final core::int #t79 = #0#64 as{ForNonNullableByDefault} core::int in (#0#64 as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})) && #C5 =={core::num::==}{(core::Object) → core::bool} #0#43)
-                          #t64 = 11;
-                        else
-                          if(#0#0 is{ForNonNullableByDefault} self::Class && #C1 =={core::num::==}{(core::Object) → core::bool} #0#69)
-                            #t64 = 12;
-                          else
-                            if(#0#0 is{ForNonNullableByDefault} self::Class && #C7 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::finalField}{core::int})
-                              #t64 = 13;
-                            else
-                              if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#69 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::getter}{core::int})
-                                #t64 = 14;
-                              else
-                                if(#0#0 is{ForNonNullableByDefault} self::Class)
-                                  #t64 = 15;
-                                else
-                                  if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C9)
-                                    #t64 = 16;
-                                  else
-                                    if(#0#0 is{ForNonNullableByDefault} ({e: core::Object?}) && !(#0#0{({e: core::Object?})}.e{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C10))
-                                      #t64 = 17;
-                                    else
-                                      if(#0#0 is{ForNonNullableByDefault} core::Map<core::int, core::int> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t80 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t81 = #0#26#isSet = true in #0#26 = #0#0{core::Map<core::int, core::int>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<core::int, core::int>}.{core::Map::containsKey}(#C3){(core::Object?) → core::bool} && (let core::int? #t82 = #0#0{core::Map<core::int, core::int>}.{core::Map::[]}(#C3){(core::Object?) → core::int?} in #t82 == null ?{core::int} #t82 as{ForNonNullableByDefault} core::int : #t82{core::int}).{core::num::>=}(#C11){(core::num) → core::bool})
-                                        #t64 = 18;
-                                      else
-                                        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t83 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t84 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && (let final dynamic #t85 = #0#30 in true))
-                                          #t64 = 19;
-                                        else
-                                          if(#0#0 is{ForNonNullableByDefault} core::bool)
-                                            #t64 = 20;
-                                          else
-                                            if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t86 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C12)
-                                              #t64 = 21;
-                                            else
-                                              if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t87 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t88 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C12){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C12){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::int)
-                                                #t64 = 22;
-                                              else
-                                                if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t89 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::String)
-                                                  #t64 = 23;
-                                                else
-                                                  if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t90 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t91 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C7){(core::Object?) → core::bool} && (let final dynamic #t92 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C7){(core::Object?) → dynamic} in true))
-                                                    #t64 = 24;
-                                                  else
-                                                    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t93 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t94 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && (#0#104 is{ForNonNullableByDefault} core::int && (let final core::int #t95 = b = #0#104{core::int} in true)))
-                                                      #t64 = 25;
-                                                    else
-                                                      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?})
-                                                        #t64 = 26;
-                                                      else
-                                                        if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?, b: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final core::bool* #t96 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?, b: core::Object?})}.a{core::Object?}) && (let final core::Object? #t97 = c = #0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final core::bool* #t98 = #0#23#isSet = true in #0#23 = #0#0{({a: core::Object?, b: core::Object?})}.b{core::Object?} in true))
-                                                          #t64 = 27;
-                                                        else
-                                                          if(#0#0 is{ForNonNullableByDefault} ({c: core::Object?, d: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{({c: core::Object?, d: core::Object?})}.c{core::Object?} && (let final core::Object? #t99 = d = #0#0{({c: core::Object?, d: core::Object?})}.d{core::Object?} in true) && d is{ForNonNullableByDefault} core::int)
-                                                            #t64 = 28;
-                                                          else
-                                                            if(true)
-                                                              #t64 = 0;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({g: core::Object?}) && (let final core::int #t71 = #0#15 as{ForNonNullableByDefault} core::int in #C6 =={core::num::==}{(core::Object) → core::bool} #0#15 as{ForNonNullableByDefault} core::int)) {
+          #t64 = 4;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?}) && (let final core::Object? #t72 = (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final core::bool* #t73 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?})}.a{core::Object?})! in true)) {
+          #t64 = 5;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({b: core::Object?}) && (!((#0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final core::bool* #t74 = #0#23#isSet = true in #0#23 = #0#0{({b: core::Object?})}.b{core::Object?}) == null) ?{core::bool} true : false)) {
+          #t64 = 6;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t75 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#32) {
+          #t64 = 7;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#32) {
+          #t64 = 8;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#32 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#43) {
+          #t64 = 9;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#32 && (#0#47.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final core::int #t76 = #0#50 as{ForNonNullableByDefault} core::int in (#0#50 as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final core::int #t77 = #0#53 as{ForNonNullableByDefault} core::int in (#0#53 as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool}))) {
+          #t64 = 10;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C4 =={core::num::==}{(core::Object) → core::bool} #0#32 && (#0#58.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final core::int #t78 = #0#61 as{ForNonNullableByDefault} core::int in (#0#61 as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final core::int #t79 = #0#64 as{ForNonNullableByDefault} core::int in (#0#64 as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})) && #C5 =={core::num::==}{(core::Object) → core::bool} #0#43) {
+          #t64 = 11;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} self::Class && #C1 =={core::num::==}{(core::Object) → core::bool} #0#69) {
+          #t64 = 12;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} self::Class && #C7 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::finalField}{core::int}) {
+          #t64 = 13;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#69 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::getter}{core::int}) {
+          #t64 = 14;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} self::Class) {
+          #t64 = 15;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C9) {
+          #t64 = 16;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({e: core::Object?}) && !(#0#0{({e: core::Object?})}.e{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C10)) {
+          #t64 = 17;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::Map<core::int, core::int> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t80 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t81 = #0#26#isSet = true in #0#26 = #0#0{core::Map<core::int, core::int>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<core::int, core::int>}.{core::Map::containsKey}(#C3){(core::Object?) → core::bool} && (let core::int? #t82 = #0#0{core::Map<core::int, core::int>}.{core::Map::[]}(#C3){(core::Object?) → core::int?} in #t82 == null ?{core::int} #t82 as{ForNonNullableByDefault} core::int : #t82{core::int}).{core::num::>=}(#C11){(core::num) → core::bool}) {
+          #t64 = 18;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t83 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t84 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && (let final dynamic #t85 = #0#30 in true)) {
+          #t64 = 19;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::bool) {
+          #t64 = 20;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t86 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C12) {
+          #t64 = 21;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t87 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t88 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C12){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C12){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::int) {
+          #t64 = 22;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t89 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::String) {
+          #t64 = 23;
+          break #L2;
+        }
+      }
+      {
+        dynamic a;
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t90 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t91 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C7){(core::Object?) → core::bool} && (let final dynamic #t92 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C7){(core::Object?) → dynamic} in true)) {
+          #t64 = 24;
+          break #L2;
+        }
+      }
+      {
+        core::int b;
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t93 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t94 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && (#0#104 is{ForNonNullableByDefault} core::int && (let final core::int #t95 = b = #0#104{core::int} in true))) {
+          #t64 = 25;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+          #t64 = 26;
+          break #L2;
+        }
+      }
+      {
+        dynamic c;
+        if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?, b: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final core::bool* #t96 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?, b: core::Object?})}.a{core::Object?}) && (let final core::Object? #t97 = c = #0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final core::bool* #t98 = #0#23#isSet = true in #0#23 = #0#0{({a: core::Object?, b: core::Object?})}.b{core::Object?} in true)) {
+          #t64 = 27;
+          break #L2;
+        }
+      }
+      {
+        dynamic d;
+        if(#0#0 is{ForNonNullableByDefault} ({c: core::Object?, d: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{({c: core::Object?, d: core::Object?})}.c{core::Object?} && (let final core::Object? #t99 = d = #0#0{({c: core::Object?, d: core::Object?})}.d{core::Object?} in true) && d is{ForNonNullableByDefault} core::int) {
+          #t64 = 28;
+          break #L2;
+        }
+      }
+      {
+        if(true) {
+          #t64 = 0;
+          break #L2;
+        }
+      }
+    }
   } =>#t64;
 }
 static method test(dynamic expected, dynamic value) → dynamic {
diff --git a/pkg/front_end/testcases/patterns/caching.dart.weak.expect b/pkg/front_end/testcases/patterns/caching.dart.weak.expect
index 7ca68f4b6f3..a0f8bb79c10 100644
--- a/pkg/front_end/testcases/patterns/caching.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/caching.dart.weak.expect
@@ -391,10 +391,6 @@ static method switchStatement(dynamic o) → core::int {
   core::print("o = ${o}");
   #L1:
   {
-    dynamic a;
-    core::int b;
-    dynamic c;
-    dynamic d;
     final synthesized dynamic #0#0 = o;
     late final synthesized core::Object? #0#4 = #0#0{({f: core::Object?})}.f{core::Object?};
     late final synthesized core::Object? #0#15 = #0#0{({g: core::Object?})}.g{core::Object?};
@@ -419,188 +415,219 @@ static method switchStatement(dynamic o) → core::int {
     synthesized core::bool #0#83;
     synthesized core::bool #0#83#isSet = false;
     late final synthesized dynamic #0#104 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic};
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        return 1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return 1;
+        }
       }
     }
-    else
+    {
       if(#0#0 is{ForNonNullableByDefault} ({f: core::Object?}) && ((let final dynamic #t31 = #0#4 as{ForNonNullableByDefault} core::int in (#0#4 as{ForNonNullableByDefault} core::int).{core::num::>=}(#C2){(core::num) → core::bool}) && (let final dynamic #t32 = #0#4 as{ForNonNullableByDefault} core::int in (#0#4 as{ForNonNullableByDefault} core::int).{core::num::<}(#C3){(core::num) → core::bool}))) {
         {
           return 2;
         }
       }
-      else
-        if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C5 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-          {
-            return 3;
-          }
+    }
+    {
+      if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C5 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return 3;
         }
-        else
-          if(#0#0 is{ForNonNullableByDefault} ({g: core::Object?}) && (let final dynamic #t33 = #0#15 as{ForNonNullableByDefault} core::int in #C6 =={core::num::==}{(core::Object) → core::bool} #0#15 as{ForNonNullableByDefault} core::int)) {
-            {
-              return 4;
-            }
-          }
-          else
-            if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?}) && (let final dynamic #t34 = (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final dynamic #t35 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?})}.a{core::Object?})! in true)) {
-              {
-                return 5;
-              }
-            }
-            else
-              if(#0#0 is{ForNonNullableByDefault} ({b: core::Object?}) && (!((#0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final dynamic #t36 = #0#23#isSet = true in #0#23 = #0#0{({b: core::Object?})}.b{core::Object?}) == null) ?{core::bool} true : false)) {
-                {
-                  return 6;
-                }
-              }
-              else
-                if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t37 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#32) {
-                  {
-                    return 7;
-                  }
-                }
-                else
-                  if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#32) {
-                    {
-                      return 8;
-                    }
-                  }
-                  else
-                    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#32 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#43) {
-                      {
-                        return 9;
-                      }
-                    }
-                    else
-                      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#32 && (#0#47.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t38 = #0#50 as{ForNonNullableByDefault} core::int in (#0#50 as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final dynamic #t39 = #0#53 as{ForNonNullableByDefault} core::int in (#0#53 as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool}))) {
-                        {
-                          return 10;
-                        }
-                      }
-                      else
-                        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C4 =={core::num::==}{(core::Object) → core::bool} #0#32 && (#0#58.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t40 = #0#61 as{ForNonNullableByDefault} core::int in (#0#61 as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final dynamic #t41 = #0#64 as{ForNonNullableByDefault} core::int in (#0#64 as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})) && #C5 =={core::num::==}{(core::Object) → core::bool} #0#43) {
-                          {
-                            return 11;
-                          }
-                        }
-                        else
-                          if(#0#0 is{ForNonNullableByDefault} self::Class && #C1 =={core::num::==}{(core::Object) → core::bool} #0#69) {
-                            {
-                              return 12;
-                            }
-                          }
-                          else
-                            if(#0#0 is{ForNonNullableByDefault} self::Class && #C7 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::finalField}{core::int}) {
-                              {
-                                return 13;
-                              }
-                            }
-                            else
-                              if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#69 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::getter}{core::int}) {
-                                {
-                                  return 14;
-                                }
-                              }
-                              else
-                                if(#0#0 is{ForNonNullableByDefault} self::Class) {
-                                  {
-                                    return 15;
-                                  }
-                                }
-                                else
-                                  if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C9) {
-                                    {
-                                      return 16;
-                                    }
-                                  }
-                                  else
-                                    if(#0#0 is{ForNonNullableByDefault} ({e: core::Object?}) && !(#0#0{({e: core::Object?})}.e{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C10)) {
-                                      {
-                                        return 17;
-                                      }
-                                    }
-                                    else
-                                      if(#0#0 is{ForNonNullableByDefault} core::Map<core::int, core::int> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t42 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t43 = #0#26#isSet = true in #0#26 = #0#0{core::Map<core::int, core::int>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<core::int, core::int>}.{core::Map::containsKey}(#C3){(core::Object?) → core::bool} && (#0#0{core::Map<core::int, core::int>}.{core::Map::[]}(#C3){(core::Object?) → core::int?} as{ForNonNullableByDefault} core::int).{core::num::>=}(#C11){(core::num) → core::bool}) {
-                                        {
-                                          return 18;
-                                        }
-                                      }
-                                      else
-                                        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t44 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t45 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && (let final dynamic #t46 = #0#30 in true)) {
-                                          {
-                                            return 19;
-                                          }
-                                        }
-                                        else
-                                          if(#0#0 is{ForNonNullableByDefault} core::bool) {
-                                            {
-                                              return 20;
-                                            }
-                                          }
-                                          else
-                                            if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t47 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C12) {
-                                              {
-                                                return 21;
-                                              }
-                                            }
-                                            else
-                                              if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t48 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t49 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C12){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C12){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::int) {
-                                                {
-                                                  return 22;
-                                                }
-                                              }
-                                              else
-                                                if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t50 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::String) {
-                                                  {
-                                                    return 23;
-                                                  }
-                                                }
-                                                else
-                                                  if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t51 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t52 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C7){(core::Object?) → core::bool} && (let final dynamic #t53 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C7){(core::Object?) → dynamic} in true)) {
-                                                    {
-                                                      return 24;
-                                                    }
-                                                  }
-                                                  else
-                                                    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t54 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t55 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && (#0#104 is{ForNonNullableByDefault} core::int && (let final dynamic #t56 = b = #0#104{core::int} in true))) {
-                                                      {
-                                                        return 25;
-                                                      }
-                                                    }
-                                                    else
-                                                      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
-                                                        {
-                                                          return 26;
-                                                        }
-                                                      }
-                                                      else
-                                                        if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?, b: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final dynamic #t57 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?, b: core::Object?})}.a{core::Object?}) && (let final dynamic #t58 = c = #0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final dynamic #t59 = #0#23#isSet = true in #0#23 = #0#0{({a: core::Object?, b: core::Object?})}.b{core::Object?} in true)) {
-                                                          {
-                                                            return 27;
-                                                          }
-                                                        }
-                                                        else
-                                                          if(#0#0 is{ForNonNullableByDefault} ({c: core::Object?, d: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{({c: core::Object?, d: core::Object?})}.c{core::Object?} && (let final dynamic #t60 = d = #0#0{({c: core::Object?, d: core::Object?})}.d{core::Object?} in true) && d is{ForNonNullableByDefault} core::int) {
-                                                            {
-                                                              return 28;
-                                                            }
-                                                          }
-                                                          else {
-                                                            {
-                                                              return 0;
-                                                            }
-                                                          }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} ({g: core::Object?}) && (let final dynamic #t33 = #0#15 as{ForNonNullableByDefault} core::int in #C6 =={core::num::==}{(core::Object) → core::bool} #0#15 as{ForNonNullableByDefault} core::int)) {
+        {
+          return 4;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?}) && (let final dynamic #t34 = (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final dynamic #t35 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?})}.a{core::Object?})! in true)) {
+        {
+          return 5;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} ({b: core::Object?}) && (!((#0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final dynamic #t36 = #0#23#isSet = true in #0#23 = #0#0{({b: core::Object?})}.b{core::Object?}) == null) ?{core::bool} true : false)) {
+        {
+          return 6;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t37 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#32) {
+        {
+          return 7;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#32) {
+        {
+          return 8;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#32 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#43) {
+        {
+          return 9;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#32 && (#0#47.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t38 = #0#50 as{ForNonNullableByDefault} core::int in (#0#50 as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final dynamic #t39 = #0#53 as{ForNonNullableByDefault} core::int in (#0#53 as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool}))) {
+        {
+          return 10;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C4 =={core::num::==}{(core::Object) → core::bool} #0#32 && (#0#58.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t40 = #0#61 as{ForNonNullableByDefault} core::int in (#0#61 as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final dynamic #t41 = #0#64 as{ForNonNullableByDefault} core::int in (#0#64 as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})) && #C5 =={core::num::==}{(core::Object) → core::bool} #0#43) {
+        {
+          return 11;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Class && #C1 =={core::num::==}{(core::Object) → core::bool} #0#69) {
+        {
+          return 12;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Class && #C7 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::finalField}{core::int}) {
+        {
+          return 13;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#69 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::getter}{core::int}) {
+        {
+          return 14;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Class) {
+        {
+          return 15;
+        }
+      }
+    }
+    {
+      if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C9) {
+        {
+          return 16;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} ({e: core::Object?}) && !(#0#0{({e: core::Object?})}.e{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C10)) {
+        {
+          return 17;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<core::int, core::int> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t42 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t43 = #0#26#isSet = true in #0#26 = #0#0{core::Map<core::int, core::int>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<core::int, core::int>}.{core::Map::containsKey}(#C3){(core::Object?) → core::bool} && (#0#0{core::Map<core::int, core::int>}.{core::Map::[]}(#C3){(core::Object?) → core::int?} as{ForNonNullableByDefault} core::int).{core::num::>=}(#C11){(core::num) → core::bool}) {
+        {
+          return 18;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t44 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t45 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && (let final dynamic #t46 = #0#30 in true)) {
+        {
+          return 19;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::bool) {
+        {
+          return 20;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t47 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C12) {
+        {
+          return 21;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t48 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t49 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C12){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C12){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::int) {
+        {
+          return 22;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t50 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::String) {
+        {
+          return 23;
+        }
+      }
+    }
+    {
+      dynamic a;
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t51 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t52 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C7){(core::Object?) → core::bool} && (let final dynamic #t53 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C7){(core::Object?) → dynamic} in true)) {
+        {
+          return 24;
+        }
+      }
+    }
+    {
+      core::int b;
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t54 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t55 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && (#0#104 is{ForNonNullableByDefault} core::int && (let final dynamic #t56 = b = #0#104{core::int} in true))) {
+        {
+          return 25;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+        {
+          return 26;
+        }
+      }
+    }
+    {
+      dynamic c;
+      if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?, b: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final dynamic #t57 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?, b: core::Object?})}.a{core::Object?}) && (let final dynamic #t58 = c = #0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final dynamic #t59 = #0#23#isSet = true in #0#23 = #0#0{({a: core::Object?, b: core::Object?})}.b{core::Object?} in true)) {
+        {
+          return 27;
+        }
+      }
+    }
+    {
+      dynamic d;
+      if(#0#0 is{ForNonNullableByDefault} ({c: core::Object?, d: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{({c: core::Object?, d: core::Object?})}.c{core::Object?} && (let final dynamic #t60 = d = #0#0{({c: core::Object?, d: core::Object?})}.d{core::Object?} in true) && d is{ForNonNullableByDefault} core::int) {
+        {
+          return 28;
+        }
+      }
+    }
+    {
+      {
+        {
+          return 0;
+        }
+      }
+    }
   }
 }
 static method switchExpression(dynamic o) → core::int {
   core::print("o = ${o}");
   return block {
     core::int #t61;
-    dynamic a;
-    core::int b;
-    dynamic c;
-    dynamic d;
     final synthesized dynamic #0#0 = o;
     late final synthesized core::Object? #0#4 = #0#0{({f: core::Object?})}.f{core::Object?};
     late final synthesized core::Object? #0#15 = #0#0{({g: core::Object?})}.g{core::Object?};
@@ -625,92 +652,187 @@ static method switchExpression(dynamic o) → core::int {
     synthesized core::bool #0#83;
     synthesized core::bool #0#83#isSet = false;
     late final synthesized dynamic #0#104 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic};
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0)
-      #t61 = 1;
-    else
-      if(#0#0 is{ForNonNullableByDefault} ({f: core::Object?}) && ((let final dynamic #t66 = #0#4 as{ForNonNullableByDefault} core::int in (#0#4 as{ForNonNullableByDefault} core::int).{core::num::>=}(#C2){(core::num) → core::bool}) && (let final dynamic #t67 = #0#4 as{ForNonNullableByDefault} core::int in (#0#4 as{ForNonNullableByDefault} core::int).{core::num::<}(#C3){(core::num) → core::bool})))
-        #t61 = 2;
-      else
-        if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C5 =={core::num::==}{(core::Object) → core::bool} #0#0)
+    #L2:
+    {
+      {
+        if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+          #t61 = 1;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({f: core::Object?}) && ((let final dynamic #t66 = #0#4 as{ForNonNullableByDefault} core::int in (#0#4 as{ForNonNullableByDefault} core::int).{core::num::>=}(#C2){(core::num) → core::bool}) && (let final dynamic #t67 = #0#4 as{ForNonNullableByDefault} core::int in (#0#4 as{ForNonNullableByDefault} core::int).{core::num::<}(#C3){(core::num) → core::bool}))) {
+          #t61 = 2;
+          break #L2;
+        }
+      }
+      {
+        if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C5 =={core::num::==}{(core::Object) → core::bool} #0#0) {
           #t61 = 3;
-        else
-          if(#0#0 is{ForNonNullableByDefault} ({g: core::Object?}) && (let final dynamic #t68 = #0#15 as{ForNonNullableByDefault} core::int in #C6 =={core::num::==}{(core::Object) → core::bool} #0#15 as{ForNonNullableByDefault} core::int))
-            #t61 = 4;
-          else
-            if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?}) && (let final dynamic #t69 = (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final dynamic #t70 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?})}.a{core::Object?})! in true))
-              #t61 = 5;
-            else
-              if(#0#0 is{ForNonNullableByDefault} ({b: core::Object?}) && (!((#0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final dynamic #t71 = #0#23#isSet = true in #0#23 = #0#0{({b: core::Object?})}.b{core::Object?}) == null) ?{core::bool} true : false))
-                #t61 = 6;
-              else
-                if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t72 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#32)
-                  #t61 = 7;
-                else
-                  if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#32)
-                    #t61 = 8;
-                  else
-                    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#32 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#43)
-                      #t61 = 9;
-                    else
-                      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#32 && (#0#47.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t73 = #0#50 as{ForNonNullableByDefault} core::int in (#0#50 as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final dynamic #t74 = #0#53 as{ForNonNullableByDefault} core::int in (#0#53 as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})))
-                        #t61 = 10;
-                      else
-                        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C4 =={core::num::==}{(core::Object) → core::bool} #0#32 && (#0#58.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t75 = #0#61 as{ForNonNullableByDefault} core::int in (#0#61 as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final dynamic #t76 = #0#64 as{ForNonNullableByDefault} core::int in (#0#64 as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})) && #C5 =={core::num::==}{(core::Object) → core::bool} #0#43)
-                          #t61 = 11;
-                        else
-                          if(#0#0 is{ForNonNullableByDefault} self::Class && #C1 =={core::num::==}{(core::Object) → core::bool} #0#69)
-                            #t61 = 12;
-                          else
-                            if(#0#0 is{ForNonNullableByDefault} self::Class && #C7 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::finalField}{core::int})
-                              #t61 = 13;
-                            else
-                              if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#69 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::getter}{core::int})
-                                #t61 = 14;
-                              else
-                                if(#0#0 is{ForNonNullableByDefault} self::Class)
-                                  #t61 = 15;
-                                else
-                                  if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C9)
-                                    #t61 = 16;
-                                  else
-                                    if(#0#0 is{ForNonNullableByDefault} ({e: core::Object?}) && !(#0#0{({e: core::Object?})}.e{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C10))
-                                      #t61 = 17;
-                                    else
-                                      if(#0#0 is{ForNonNullableByDefault} core::Map<core::int, core::int> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t77 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t78 = #0#26#isSet = true in #0#26 = #0#0{core::Map<core::int, core::int>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<core::int, core::int>}.{core::Map::containsKey}(#C3){(core::Object?) → core::bool} && (#0#0{core::Map<core::int, core::int>}.{core::Map::[]}(#C3){(core::Object?) → core::int?} as{ForNonNullableByDefault} core::int).{core::num::>=}(#C11){(core::num) → core::bool})
-                                        #t61 = 18;
-                                      else
-                                        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t79 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t80 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && (let final dynamic #t81 = #0#30 in true))
-                                          #t61 = 19;
-                                        else
-                                          if(#0#0 is{ForNonNullableByDefault} core::bool)
-                                            #t61 = 20;
-                                          else
-                                            if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t82 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C12)
-                                              #t61 = 21;
-                                            else
-                                              if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t83 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t84 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C12){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C12){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::int)
-                                                #t61 = 22;
-                                              else
-                                                if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t85 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::String)
-                                                  #t61 = 23;
-                                                else
-                                                  if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t86 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t87 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C7){(core::Object?) → core::bool} && (let final dynamic #t88 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C7){(core::Object?) → dynamic} in true))
-                                                    #t61 = 24;
-                                                  else
-                                                    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t89 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t90 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && (#0#104 is{ForNonNullableByDefault} core::int && (let final dynamic #t91 = b = #0#104{core::int} in true)))
-                                                      #t61 = 25;
-                                                    else
-                                                      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?})
-                                                        #t61 = 26;
-                                                      else
-                                                        if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?, b: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final dynamic #t92 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?, b: core::Object?})}.a{core::Object?}) && (let final dynamic #t93 = c = #0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final dynamic #t94 = #0#23#isSet = true in #0#23 = #0#0{({a: core::Object?, b: core::Object?})}.b{core::Object?} in true))
-                                                          #t61 = 27;
-                                                        else
-                                                          if(#0#0 is{ForNonNullableByDefault} ({c: core::Object?, d: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{({c: core::Object?, d: core::Object?})}.c{core::Object?} && (let final dynamic #t95 = d = #0#0{({c: core::Object?, d: core::Object?})}.d{core::Object?} in true) && d is{ForNonNullableByDefault} core::int)
-                                                            #t61 = 28;
-                                                          else
-                                                            if(true)
-                                                              #t61 = 0;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({g: core::Object?}) && (let final dynamic #t68 = #0#15 as{ForNonNullableByDefault} core::int in #C6 =={core::num::==}{(core::Object) → core::bool} #0#15 as{ForNonNullableByDefault} core::int)) {
+          #t61 = 4;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?}) && (let final dynamic #t69 = (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final dynamic #t70 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?})}.a{core::Object?})! in true)) {
+          #t61 = 5;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({b: core::Object?}) && (!((#0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final dynamic #t71 = #0#23#isSet = true in #0#23 = #0#0{({b: core::Object?})}.b{core::Object?}) == null) ?{core::bool} true : false)) {
+          #t61 = 6;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t72 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#32) {
+          #t61 = 7;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#32) {
+          #t61 = 8;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#32 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#43) {
+          #t61 = 9;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#32 && (#0#47.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t73 = #0#50 as{ForNonNullableByDefault} core::int in (#0#50 as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final dynamic #t74 = #0#53 as{ForNonNullableByDefault} core::int in (#0#53 as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool}))) {
+          #t61 = 10;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C4 =={core::num::==}{(core::Object) → core::bool} #0#32 && (#0#58.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t75 = #0#61 as{ForNonNullableByDefault} core::int in (#0#61 as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final dynamic #t76 = #0#64 as{ForNonNullableByDefault} core::int in (#0#64 as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})) && #C5 =={core::num::==}{(core::Object) → core::bool} #0#43) {
+          #t61 = 11;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} self::Class && #C1 =={core::num::==}{(core::Object) → core::bool} #0#69) {
+          #t61 = 12;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} self::Class && #C7 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::finalField}{core::int}) {
+          #t61 = 13;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#69 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::getter}{core::int}) {
+          #t61 = 14;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} self::Class) {
+          #t61 = 15;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C9) {
+          #t61 = 16;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({e: core::Object?}) && !(#0#0{({e: core::Object?})}.e{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C10)) {
+          #t61 = 17;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::Map<core::int, core::int> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t77 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t78 = #0#26#isSet = true in #0#26 = #0#0{core::Map<core::int, core::int>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<core::int, core::int>}.{core::Map::containsKey}(#C3){(core::Object?) → core::bool} && (#0#0{core::Map<core::int, core::int>}.{core::Map::[]}(#C3){(core::Object?) → core::int?} as{ForNonNullableByDefault} core::int).{core::num::>=}(#C11){(core::num) → core::bool}) {
+          #t61 = 18;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t79 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t80 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && (let final dynamic #t81 = #0#30 in true)) {
+          #t61 = 19;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::bool) {
+          #t61 = 20;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t82 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C12) {
+          #t61 = 21;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t83 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t84 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C12){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C12){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::int) {
+          #t61 = 22;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t85 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::String) {
+          #t61 = 23;
+          break #L2;
+        }
+      }
+      {
+        dynamic a;
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t86 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t87 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C7){(core::Object?) → core::bool} && (let final dynamic #t88 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C7){(core::Object?) → dynamic} in true)) {
+          #t61 = 24;
+          break #L2;
+        }
+      }
+      {
+        core::int b;
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t89 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t90 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && (#0#104 is{ForNonNullableByDefault} core::int && (let final dynamic #t91 = b = #0#104{core::int} in true))) {
+          #t61 = 25;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+          #t61 = 26;
+          break #L2;
+        }
+      }
+      {
+        dynamic c;
+        if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?, b: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final dynamic #t92 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?, b: core::Object?})}.a{core::Object?}) && (let final dynamic #t93 = c = #0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final dynamic #t94 = #0#23#isSet = true in #0#23 = #0#0{({a: core::Object?, b: core::Object?})}.b{core::Object?} in true)) {
+          #t61 = 27;
+          break #L2;
+        }
+      }
+      {
+        dynamic d;
+        if(#0#0 is{ForNonNullableByDefault} ({c: core::Object?, d: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{({c: core::Object?, d: core::Object?})}.c{core::Object?} && (let final dynamic #t95 = d = #0#0{({c: core::Object?, d: core::Object?})}.d{core::Object?} in true) && d is{ForNonNullableByDefault} core::int) {
+          #t61 = 28;
+          break #L2;
+        }
+      }
+      {
+        if(true) {
+          #t61 = 0;
+          break #L2;
+        }
+      }
+    }
   } =>#t61;
 }
 static method test(dynamic expected, dynamic value) → dynamic {
diff --git a/pkg/front_end/testcases/patterns/caching.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/caching.dart.weak.modular.expect
index 7ca68f4b6f3..a0f8bb79c10 100644
--- a/pkg/front_end/testcases/patterns/caching.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/caching.dart.weak.modular.expect
@@ -391,10 +391,6 @@ static method switchStatement(dynamic o) → core::int {
   core::print("o = ${o}");
   #L1:
   {
-    dynamic a;
-    core::int b;
-    dynamic c;
-    dynamic d;
     final synthesized dynamic #0#0 = o;
     late final synthesized core::Object? #0#4 = #0#0{({f: core::Object?})}.f{core::Object?};
     late final synthesized core::Object? #0#15 = #0#0{({g: core::Object?})}.g{core::Object?};
@@ -419,188 +415,219 @@ static method switchStatement(dynamic o) → core::int {
     synthesized core::bool #0#83;
     synthesized core::bool #0#83#isSet = false;
     late final synthesized dynamic #0#104 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic};
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        return 1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return 1;
+        }
       }
     }
-    else
+    {
       if(#0#0 is{ForNonNullableByDefault} ({f: core::Object?}) && ((let final dynamic #t31 = #0#4 as{ForNonNullableByDefault} core::int in (#0#4 as{ForNonNullableByDefault} core::int).{core::num::>=}(#C2){(core::num) → core::bool}) && (let final dynamic #t32 = #0#4 as{ForNonNullableByDefault} core::int in (#0#4 as{ForNonNullableByDefault} core::int).{core::num::<}(#C3){(core::num) → core::bool}))) {
         {
           return 2;
         }
       }
-      else
-        if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C5 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-          {
-            return 3;
-          }
+    }
+    {
+      if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C5 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return 3;
         }
-        else
-          if(#0#0 is{ForNonNullableByDefault} ({g: core::Object?}) && (let final dynamic #t33 = #0#15 as{ForNonNullableByDefault} core::int in #C6 =={core::num::==}{(core::Object) → core::bool} #0#15 as{ForNonNullableByDefault} core::int)) {
-            {
-              return 4;
-            }
-          }
-          else
-            if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?}) && (let final dynamic #t34 = (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final dynamic #t35 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?})}.a{core::Object?})! in true)) {
-              {
-                return 5;
-              }
-            }
-            else
-              if(#0#0 is{ForNonNullableByDefault} ({b: core::Object?}) && (!((#0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final dynamic #t36 = #0#23#isSet = true in #0#23 = #0#0{({b: core::Object?})}.b{core::Object?}) == null) ?{core::bool} true : false)) {
-                {
-                  return 6;
-                }
-              }
-              else
-                if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t37 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#32) {
-                  {
-                    return 7;
-                  }
-                }
-                else
-                  if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#32) {
-                    {
-                      return 8;
-                    }
-                  }
-                  else
-                    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#32 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#43) {
-                      {
-                        return 9;
-                      }
-                    }
-                    else
-                      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#32 && (#0#47.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t38 = #0#50 as{ForNonNullableByDefault} core::int in (#0#50 as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final dynamic #t39 = #0#53 as{ForNonNullableByDefault} core::int in (#0#53 as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool}))) {
-                        {
-                          return 10;
-                        }
-                      }
-                      else
-                        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C4 =={core::num::==}{(core::Object) → core::bool} #0#32 && (#0#58.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t40 = #0#61 as{ForNonNullableByDefault} core::int in (#0#61 as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final dynamic #t41 = #0#64 as{ForNonNullableByDefault} core::int in (#0#64 as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})) && #C5 =={core::num::==}{(core::Object) → core::bool} #0#43) {
-                          {
-                            return 11;
-                          }
-                        }
-                        else
-                          if(#0#0 is{ForNonNullableByDefault} self::Class && #C1 =={core::num::==}{(core::Object) → core::bool} #0#69) {
-                            {
-                              return 12;
-                            }
-                          }
-                          else
-                            if(#0#0 is{ForNonNullableByDefault} self::Class && #C7 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::finalField}{core::int}) {
-                              {
-                                return 13;
-                              }
-                            }
-                            else
-                              if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#69 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::getter}{core::int}) {
-                                {
-                                  return 14;
-                                }
-                              }
-                              else
-                                if(#0#0 is{ForNonNullableByDefault} self::Class) {
-                                  {
-                                    return 15;
-                                  }
-                                }
-                                else
-                                  if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C9) {
-                                    {
-                                      return 16;
-                                    }
-                                  }
-                                  else
-                                    if(#0#0 is{ForNonNullableByDefault} ({e: core::Object?}) && !(#0#0{({e: core::Object?})}.e{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C10)) {
-                                      {
-                                        return 17;
-                                      }
-                                    }
-                                    else
-                                      if(#0#0 is{ForNonNullableByDefault} core::Map<core::int, core::int> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t42 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t43 = #0#26#isSet = true in #0#26 = #0#0{core::Map<core::int, core::int>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<core::int, core::int>}.{core::Map::containsKey}(#C3){(core::Object?) → core::bool} && (#0#0{core::Map<core::int, core::int>}.{core::Map::[]}(#C3){(core::Object?) → core::int?} as{ForNonNullableByDefault} core::int).{core::num::>=}(#C11){(core::num) → core::bool}) {
-                                        {
-                                          return 18;
-                                        }
-                                      }
-                                      else
-                                        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t44 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t45 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && (let final dynamic #t46 = #0#30 in true)) {
-                                          {
-                                            return 19;
-                                          }
-                                        }
-                                        else
-                                          if(#0#0 is{ForNonNullableByDefault} core::bool) {
-                                            {
-                                              return 20;
-                                            }
-                                          }
-                                          else
-                                            if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t47 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C12) {
-                                              {
-                                                return 21;
-                                              }
-                                            }
-                                            else
-                                              if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t48 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t49 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C12){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C12){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::int) {
-                                                {
-                                                  return 22;
-                                                }
-                                              }
-                                              else
-                                                if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t50 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::String) {
-                                                  {
-                                                    return 23;
-                                                  }
-                                                }
-                                                else
-                                                  if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t51 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t52 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C7){(core::Object?) → core::bool} && (let final dynamic #t53 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C7){(core::Object?) → dynamic} in true)) {
-                                                    {
-                                                      return 24;
-                                                    }
-                                                  }
-                                                  else
-                                                    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t54 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t55 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && (#0#104 is{ForNonNullableByDefault} core::int && (let final dynamic #t56 = b = #0#104{core::int} in true))) {
-                                                      {
-                                                        return 25;
-                                                      }
-                                                    }
-                                                    else
-                                                      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
-                                                        {
-                                                          return 26;
-                                                        }
-                                                      }
-                                                      else
-                                                        if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?, b: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final dynamic #t57 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?, b: core::Object?})}.a{core::Object?}) && (let final dynamic #t58 = c = #0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final dynamic #t59 = #0#23#isSet = true in #0#23 = #0#0{({a: core::Object?, b: core::Object?})}.b{core::Object?} in true)) {
-                                                          {
-                                                            return 27;
-                                                          }
-                                                        }
-                                                        else
-                                                          if(#0#0 is{ForNonNullableByDefault} ({c: core::Object?, d: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{({c: core::Object?, d: core::Object?})}.c{core::Object?} && (let final dynamic #t60 = d = #0#0{({c: core::Object?, d: core::Object?})}.d{core::Object?} in true) && d is{ForNonNullableByDefault} core::int) {
-                                                            {
-                                                              return 28;
-                                                            }
-                                                          }
-                                                          else {
-                                                            {
-                                                              return 0;
-                                                            }
-                                                          }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} ({g: core::Object?}) && (let final dynamic #t33 = #0#15 as{ForNonNullableByDefault} core::int in #C6 =={core::num::==}{(core::Object) → core::bool} #0#15 as{ForNonNullableByDefault} core::int)) {
+        {
+          return 4;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?}) && (let final dynamic #t34 = (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final dynamic #t35 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?})}.a{core::Object?})! in true)) {
+        {
+          return 5;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} ({b: core::Object?}) && (!((#0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final dynamic #t36 = #0#23#isSet = true in #0#23 = #0#0{({b: core::Object?})}.b{core::Object?}) == null) ?{core::bool} true : false)) {
+        {
+          return 6;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t37 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#32) {
+        {
+          return 7;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#32) {
+        {
+          return 8;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#32 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#43) {
+        {
+          return 9;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#32 && (#0#47.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t38 = #0#50 as{ForNonNullableByDefault} core::int in (#0#50 as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final dynamic #t39 = #0#53 as{ForNonNullableByDefault} core::int in (#0#53 as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool}))) {
+        {
+          return 10;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C4 =={core::num::==}{(core::Object) → core::bool} #0#32 && (#0#58.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t40 = #0#61 as{ForNonNullableByDefault} core::int in (#0#61 as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final dynamic #t41 = #0#64 as{ForNonNullableByDefault} core::int in (#0#64 as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})) && #C5 =={core::num::==}{(core::Object) → core::bool} #0#43) {
+        {
+          return 11;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Class && #C1 =={core::num::==}{(core::Object) → core::bool} #0#69) {
+        {
+          return 12;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Class && #C7 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::finalField}{core::int}) {
+        {
+          return 13;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#69 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::getter}{core::int}) {
+        {
+          return 14;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Class) {
+        {
+          return 15;
+        }
+      }
+    }
+    {
+      if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C9) {
+        {
+          return 16;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} ({e: core::Object?}) && !(#0#0{({e: core::Object?})}.e{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C10)) {
+        {
+          return 17;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<core::int, core::int> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t42 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t43 = #0#26#isSet = true in #0#26 = #0#0{core::Map<core::int, core::int>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<core::int, core::int>}.{core::Map::containsKey}(#C3){(core::Object?) → core::bool} && (#0#0{core::Map<core::int, core::int>}.{core::Map::[]}(#C3){(core::Object?) → core::int?} as{ForNonNullableByDefault} core::int).{core::num::>=}(#C11){(core::num) → core::bool}) {
+        {
+          return 18;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t44 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t45 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && (let final dynamic #t46 = #0#30 in true)) {
+        {
+          return 19;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::bool) {
+        {
+          return 20;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t47 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C12) {
+        {
+          return 21;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t48 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t49 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C12){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C12){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::int) {
+        {
+          return 22;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t50 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::String) {
+        {
+          return 23;
+        }
+      }
+    }
+    {
+      dynamic a;
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t51 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t52 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C7){(core::Object?) → core::bool} && (let final dynamic #t53 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C7){(core::Object?) → dynamic} in true)) {
+        {
+          return 24;
+        }
+      }
+    }
+    {
+      core::int b;
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t54 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t55 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && (#0#104 is{ForNonNullableByDefault} core::int && (let final dynamic #t56 = b = #0#104{core::int} in true))) {
+        {
+          return 25;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+        {
+          return 26;
+        }
+      }
+    }
+    {
+      dynamic c;
+      if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?, b: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final dynamic #t57 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?, b: core::Object?})}.a{core::Object?}) && (let final dynamic #t58 = c = #0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final dynamic #t59 = #0#23#isSet = true in #0#23 = #0#0{({a: core::Object?, b: core::Object?})}.b{core::Object?} in true)) {
+        {
+          return 27;
+        }
+      }
+    }
+    {
+      dynamic d;
+      if(#0#0 is{ForNonNullableByDefault} ({c: core::Object?, d: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{({c: core::Object?, d: core::Object?})}.c{core::Object?} && (let final dynamic #t60 = d = #0#0{({c: core::Object?, d: core::Object?})}.d{core::Object?} in true) && d is{ForNonNullableByDefault} core::int) {
+        {
+          return 28;
+        }
+      }
+    }
+    {
+      {
+        {
+          return 0;
+        }
+      }
+    }
   }
 }
 static method switchExpression(dynamic o) → core::int {
   core::print("o = ${o}");
   return block {
     core::int #t61;
-    dynamic a;
-    core::int b;
-    dynamic c;
-    dynamic d;
     final synthesized dynamic #0#0 = o;
     late final synthesized core::Object? #0#4 = #0#0{({f: core::Object?})}.f{core::Object?};
     late final synthesized core::Object? #0#15 = #0#0{({g: core::Object?})}.g{core::Object?};
@@ -625,92 +652,187 @@ static method switchExpression(dynamic o) → core::int {
     synthesized core::bool #0#83;
     synthesized core::bool #0#83#isSet = false;
     late final synthesized dynamic #0#104 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic};
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0)
-      #t61 = 1;
-    else
-      if(#0#0 is{ForNonNullableByDefault} ({f: core::Object?}) && ((let final dynamic #t66 = #0#4 as{ForNonNullableByDefault} core::int in (#0#4 as{ForNonNullableByDefault} core::int).{core::num::>=}(#C2){(core::num) → core::bool}) && (let final dynamic #t67 = #0#4 as{ForNonNullableByDefault} core::int in (#0#4 as{ForNonNullableByDefault} core::int).{core::num::<}(#C3){(core::num) → core::bool})))
-        #t61 = 2;
-      else
-        if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C5 =={core::num::==}{(core::Object) → core::bool} #0#0)
+    #L2:
+    {
+      {
+        if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+          #t61 = 1;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({f: core::Object?}) && ((let final dynamic #t66 = #0#4 as{ForNonNullableByDefault} core::int in (#0#4 as{ForNonNullableByDefault} core::int).{core::num::>=}(#C2){(core::num) → core::bool}) && (let final dynamic #t67 = #0#4 as{ForNonNullableByDefault} core::int in (#0#4 as{ForNonNullableByDefault} core::int).{core::num::<}(#C3){(core::num) → core::bool}))) {
+          #t61 = 2;
+          break #L2;
+        }
+      }
+      {
+        if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C5 =={core::num::==}{(core::Object) → core::bool} #0#0) {
           #t61 = 3;
-        else
-          if(#0#0 is{ForNonNullableByDefault} ({g: core::Object?}) && (let final dynamic #t68 = #0#15 as{ForNonNullableByDefault} core::int in #C6 =={core::num::==}{(core::Object) → core::bool} #0#15 as{ForNonNullableByDefault} core::int))
-            #t61 = 4;
-          else
-            if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?}) && (let final dynamic #t69 = (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final dynamic #t70 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?})}.a{core::Object?})! in true))
-              #t61 = 5;
-            else
-              if(#0#0 is{ForNonNullableByDefault} ({b: core::Object?}) && (!((#0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final dynamic #t71 = #0#23#isSet = true in #0#23 = #0#0{({b: core::Object?})}.b{core::Object?}) == null) ?{core::bool} true : false))
-                #t61 = 6;
-              else
-                if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t72 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#32)
-                  #t61 = 7;
-                else
-                  if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#32)
-                    #t61 = 8;
-                  else
-                    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#32 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#43)
-                      #t61 = 9;
-                    else
-                      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#32 && (#0#47.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t73 = #0#50 as{ForNonNullableByDefault} core::int in (#0#50 as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final dynamic #t74 = #0#53 as{ForNonNullableByDefault} core::int in (#0#53 as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})))
-                        #t61 = 10;
-                      else
-                        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C4 =={core::num::==}{(core::Object) → core::bool} #0#32 && (#0#58.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t75 = #0#61 as{ForNonNullableByDefault} core::int in (#0#61 as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final dynamic #t76 = #0#64 as{ForNonNullableByDefault} core::int in (#0#64 as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})) && #C5 =={core::num::==}{(core::Object) → core::bool} #0#43)
-                          #t61 = 11;
-                        else
-                          if(#0#0 is{ForNonNullableByDefault} self::Class && #C1 =={core::num::==}{(core::Object) → core::bool} #0#69)
-                            #t61 = 12;
-                          else
-                            if(#0#0 is{ForNonNullableByDefault} self::Class && #C7 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::finalField}{core::int})
-                              #t61 = 13;
-                            else
-                              if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#69 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::getter}{core::int})
-                                #t61 = 14;
-                              else
-                                if(#0#0 is{ForNonNullableByDefault} self::Class)
-                                  #t61 = 15;
-                                else
-                                  if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C9)
-                                    #t61 = 16;
-                                  else
-                                    if(#0#0 is{ForNonNullableByDefault} ({e: core::Object?}) && !(#0#0{({e: core::Object?})}.e{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C10))
-                                      #t61 = 17;
-                                    else
-                                      if(#0#0 is{ForNonNullableByDefault} core::Map<core::int, core::int> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t77 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t78 = #0#26#isSet = true in #0#26 = #0#0{core::Map<core::int, core::int>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<core::int, core::int>}.{core::Map::containsKey}(#C3){(core::Object?) → core::bool} && (#0#0{core::Map<core::int, core::int>}.{core::Map::[]}(#C3){(core::Object?) → core::int?} as{ForNonNullableByDefault} core::int).{core::num::>=}(#C11){(core::num) → core::bool})
-                                        #t61 = 18;
-                                      else
-                                        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t79 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t80 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && (let final dynamic #t81 = #0#30 in true))
-                                          #t61 = 19;
-                                        else
-                                          if(#0#0 is{ForNonNullableByDefault} core::bool)
-                                            #t61 = 20;
-                                          else
-                                            if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t82 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C12)
-                                              #t61 = 21;
-                                            else
-                                              if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t83 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t84 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C12){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C12){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::int)
-                                                #t61 = 22;
-                                              else
-                                                if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t85 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::String)
-                                                  #t61 = 23;
-                                                else
-                                                  if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t86 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t87 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C7){(core::Object?) → core::bool} && (let final dynamic #t88 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C7){(core::Object?) → dynamic} in true))
-                                                    #t61 = 24;
-                                                  else
-                                                    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t89 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t90 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && (#0#104 is{ForNonNullableByDefault} core::int && (let final dynamic #t91 = b = #0#104{core::int} in true)))
-                                                      #t61 = 25;
-                                                    else
-                                                      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?})
-                                                        #t61 = 26;
-                                                      else
-                                                        if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?, b: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final dynamic #t92 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?, b: core::Object?})}.a{core::Object?}) && (let final dynamic #t93 = c = #0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final dynamic #t94 = #0#23#isSet = true in #0#23 = #0#0{({a: core::Object?, b: core::Object?})}.b{core::Object?} in true))
-                                                          #t61 = 27;
-                                                        else
-                                                          if(#0#0 is{ForNonNullableByDefault} ({c: core::Object?, d: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{({c: core::Object?, d: core::Object?})}.c{core::Object?} && (let final dynamic #t95 = d = #0#0{({c: core::Object?, d: core::Object?})}.d{core::Object?} in true) && d is{ForNonNullableByDefault} core::int)
-                                                            #t61 = 28;
-                                                          else
-                                                            if(true)
-                                                              #t61 = 0;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({g: core::Object?}) && (let final dynamic #t68 = #0#15 as{ForNonNullableByDefault} core::int in #C6 =={core::num::==}{(core::Object) → core::bool} #0#15 as{ForNonNullableByDefault} core::int)) {
+          #t61 = 4;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?}) && (let final dynamic #t69 = (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final dynamic #t70 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?})}.a{core::Object?})! in true)) {
+          #t61 = 5;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({b: core::Object?}) && (!((#0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final dynamic #t71 = #0#23#isSet = true in #0#23 = #0#0{({b: core::Object?})}.b{core::Object?}) == null) ?{core::bool} true : false)) {
+          #t61 = 6;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t72 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#32) {
+          #t61 = 7;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#32) {
+          #t61 = 8;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#32 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#43) {
+          #t61 = 9;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#32 && (#0#47.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t73 = #0#50 as{ForNonNullableByDefault} core::int in (#0#50 as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final dynamic #t74 = #0#53 as{ForNonNullableByDefault} core::int in (#0#53 as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool}))) {
+          #t61 = 10;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C4 =={core::num::==}{(core::Object) → core::bool} #0#32 && (#0#58.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t75 = #0#61 as{ForNonNullableByDefault} core::int in (#0#61 as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final dynamic #t76 = #0#64 as{ForNonNullableByDefault} core::int in (#0#64 as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})) && #C5 =={core::num::==}{(core::Object) → core::bool} #0#43) {
+          #t61 = 11;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} self::Class && #C1 =={core::num::==}{(core::Object) → core::bool} #0#69) {
+          #t61 = 12;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} self::Class && #C7 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::finalField}{core::int}) {
+          #t61 = 13;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#69 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::getter}{core::int}) {
+          #t61 = 14;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} self::Class) {
+          #t61 = 15;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C9) {
+          #t61 = 16;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({e: core::Object?}) && !(#0#0{({e: core::Object?})}.e{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C10)) {
+          #t61 = 17;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::Map<core::int, core::int> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t77 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t78 = #0#26#isSet = true in #0#26 = #0#0{core::Map<core::int, core::int>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<core::int, core::int>}.{core::Map::containsKey}(#C3){(core::Object?) → core::bool} && (#0#0{core::Map<core::int, core::int>}.{core::Map::[]}(#C3){(core::Object?) → core::int?} as{ForNonNullableByDefault} core::int).{core::num::>=}(#C11){(core::num) → core::bool}) {
+          #t61 = 18;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t79 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t80 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && (let final dynamic #t81 = #0#30 in true)) {
+          #t61 = 19;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::bool) {
+          #t61 = 20;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t82 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C12) {
+          #t61 = 21;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t83 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t84 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C12){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C12){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::int) {
+          #t61 = 22;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t85 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::String) {
+          #t61 = 23;
+          break #L2;
+        }
+      }
+      {
+        dynamic a;
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t86 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t87 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C7){(core::Object?) → core::bool} && (let final dynamic #t88 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C7){(core::Object?) → dynamic} in true)) {
+          #t61 = 24;
+          break #L2;
+        }
+      }
+      {
+        core::int b;
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final dynamic #t89 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final dynamic #t90 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && (#0#104 is{ForNonNullableByDefault} core::int && (let final dynamic #t91 = b = #0#104{core::int} in true))) {
+          #t61 = 25;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+          #t61 = 26;
+          break #L2;
+        }
+      }
+      {
+        dynamic c;
+        if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?, b: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final dynamic #t92 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?, b: core::Object?})}.a{core::Object?}) && (let final dynamic #t93 = c = #0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final dynamic #t94 = #0#23#isSet = true in #0#23 = #0#0{({a: core::Object?, b: core::Object?})}.b{core::Object?} in true)) {
+          #t61 = 27;
+          break #L2;
+        }
+      }
+      {
+        dynamic d;
+        if(#0#0 is{ForNonNullableByDefault} ({c: core::Object?, d: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{({c: core::Object?, d: core::Object?})}.c{core::Object?} && (let final dynamic #t95 = d = #0#0{({c: core::Object?, d: core::Object?})}.d{core::Object?} in true) && d is{ForNonNullableByDefault} core::int) {
+          #t61 = 28;
+          break #L2;
+        }
+      }
+      {
+        if(true) {
+          #t61 = 0;
+          break #L2;
+        }
+      }
+    }
   } =>#t61;
 }
 static method test(dynamic expected, dynamic value) → dynamic {
diff --git a/pkg/front_end/testcases/patterns/caching.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/caching.dart.weak.transformed.expect
index bc72e25494b..2f31400f943 100644
--- a/pkg/front_end/testcases/patterns/caching.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/caching.dart.weak.transformed.expect
@@ -435,10 +435,6 @@ static method switchStatement(dynamic o) → core::int {
   core::print("o = ${o}");
   #L1:
   {
-    dynamic a;
-    core::int b;
-    dynamic c;
-    dynamic d;
     final synthesized dynamic #0#0 = o;
     function ##0#4#initializer() → core::Object?
       return #0#0{({f: core::Object?})}.f{core::Object?};
@@ -493,188 +489,219 @@ static method switchStatement(dynamic o) → core::int {
     function ##0#104#initializer() → dynamic
       return #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic};
     late final synthesized dynamic #0#104 = ##0#104#initializer(){() → dynamic};
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        return 1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return 1;
+        }
       }
     }
-    else
+    {
       if(#0#0 is{ForNonNullableByDefault} ({f: core::Object?}) && ((let final core::int #t31 = #0#4 as{ForNonNullableByDefault} core::int in (#0#4 as{ForNonNullableByDefault} core::int).{core::num::>=}(#C2){(core::num) → core::bool}) && (let final core::int #t32 = #0#4 as{ForNonNullableByDefault} core::int in (#0#4 as{ForNonNullableByDefault} core::int).{core::num::<}(#C3){(core::num) → core::bool}))) {
         {
           return 2;
         }
       }
-      else
-        if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C5 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-          {
-            return 3;
-          }
+    }
+    {
+      if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C5 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return 3;
         }
-        else
-          if(#0#0 is{ForNonNullableByDefault} ({g: core::Object?}) && (let final core::int #t33 = #0#15 as{ForNonNullableByDefault} core::int in #C6 =={core::num::==}{(core::Object) → core::bool} #0#15 as{ForNonNullableByDefault} core::int)) {
-            {
-              return 4;
-            }
-          }
-          else
-            if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?}) && (let final core::Object? #t34 = (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final core::bool* #t35 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?})}.a{core::Object?})! in true)) {
-              {
-                return 5;
-              }
-            }
-            else
-              if(#0#0 is{ForNonNullableByDefault} ({b: core::Object?}) && (!((#0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final core::bool* #t36 = #0#23#isSet = true in #0#23 = #0#0{({b: core::Object?})}.b{core::Object?}) == null) ?{core::bool} true : false)) {
-                {
-                  return 6;
-                }
-              }
-              else
-                if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t37 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#32) {
-                  {
-                    return 7;
-                  }
-                }
-                else
-                  if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#32) {
-                    {
-                      return 8;
-                    }
-                  }
-                  else
-                    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#32 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#43) {
-                      {
-                        return 9;
-                      }
-                    }
-                    else
-                      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#32 && (#0#47.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final core::int #t38 = #0#50 as{ForNonNullableByDefault} core::int in (#0#50 as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final core::int #t39 = #0#53 as{ForNonNullableByDefault} core::int in (#0#53 as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool}))) {
-                        {
-                          return 10;
-                        }
-                      }
-                      else
-                        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C4 =={core::num::==}{(core::Object) → core::bool} #0#32 && (#0#58.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final core::int #t40 = #0#61 as{ForNonNullableByDefault} core::int in (#0#61 as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final core::int #t41 = #0#64 as{ForNonNullableByDefault} core::int in (#0#64 as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})) && #C5 =={core::num::==}{(core::Object) → core::bool} #0#43) {
-                          {
-                            return 11;
-                          }
-                        }
-                        else
-                          if(#0#0 is{ForNonNullableByDefault} self::Class && #C1 =={core::num::==}{(core::Object) → core::bool} #0#69) {
-                            {
-                              return 12;
-                            }
-                          }
-                          else
-                            if(#0#0 is{ForNonNullableByDefault} self::Class && #C7 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::finalField}{core::int}) {
-                              {
-                                return 13;
-                              }
-                            }
-                            else
-                              if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#69 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::getter}{core::int}) {
-                                {
-                                  return 14;
-                                }
-                              }
-                              else
-                                if(#0#0 is{ForNonNullableByDefault} self::Class) {
-                                  {
-                                    return 15;
-                                  }
-                                }
-                                else
-                                  if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C9) {
-                                    {
-                                      return 16;
-                                    }
-                                  }
-                                  else
-                                    if(#0#0 is{ForNonNullableByDefault} ({e: core::Object?}) && !(#0#0{({e: core::Object?})}.e{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C10)) {
-                                      {
-                                        return 17;
-                                      }
-                                    }
-                                    else
-                                      if(#0#0 is{ForNonNullableByDefault} core::Map<core::int, core::int> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t42 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t43 = #0#26#isSet = true in #0#26 = #0#0{core::Map<core::int, core::int>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<core::int, core::int>}.{core::Map::containsKey}(#C3){(core::Object?) → core::bool} && #0#0{core::Map<core::int, core::int>}.{core::Map::[]}(#C3){(core::Object?) → core::int?}.{core::num::>=}(#C11){(core::num) → core::bool}) {
-                                        {
-                                          return 18;
-                                        }
-                                      }
-                                      else
-                                        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t44 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t45 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && (let final dynamic #t46 = #0#30 in true)) {
-                                          {
-                                            return 19;
-                                          }
-                                        }
-                                        else
-                                          if(#0#0 is{ForNonNullableByDefault} core::bool) {
-                                            {
-                                              return 20;
-                                            }
-                                          }
-                                          else
-                                            if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t47 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C12) {
-                                              {
-                                                return 21;
-                                              }
-                                            }
-                                            else
-                                              if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t48 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t49 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C12){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C12){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::int) {
-                                                {
-                                                  return 22;
-                                                }
-                                              }
-                                              else
-                                                if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t50 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::String) {
-                                                  {
-                                                    return 23;
-                                                  }
-                                                }
-                                                else
-                                                  if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t51 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t52 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C7){(core::Object?) → core::bool} && (let final dynamic #t53 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C7){(core::Object?) → dynamic} in true)) {
-                                                    {
-                                                      return 24;
-                                                    }
-                                                  }
-                                                  else
-                                                    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t54 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t55 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && (#0#104 is{ForNonNullableByDefault} core::int && (let final core::int #t56 = b = #0#104{core::int} in true))) {
-                                                      {
-                                                        return 25;
-                                                      }
-                                                    }
-                                                    else
-                                                      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
-                                                        {
-                                                          return 26;
-                                                        }
-                                                      }
-                                                      else
-                                                        if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?, b: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final core::bool* #t57 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?, b: core::Object?})}.a{core::Object?}) && (let final core::Object? #t58 = c = #0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final core::bool* #t59 = #0#23#isSet = true in #0#23 = #0#0{({a: core::Object?, b: core::Object?})}.b{core::Object?} in true)) {
-                                                          {
-                                                            return 27;
-                                                          }
-                                                        }
-                                                        else
-                                                          if(#0#0 is{ForNonNullableByDefault} ({c: core::Object?, d: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{({c: core::Object?, d: core::Object?})}.c{core::Object?} && (let final core::Object? #t60 = d = #0#0{({c: core::Object?, d: core::Object?})}.d{core::Object?} in true) && d is{ForNonNullableByDefault} core::int) {
-                                                            {
-                                                              return 28;
-                                                            }
-                                                          }
-                                                          else {
-                                                            {
-                                                              return 0;
-                                                            }
-                                                          }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} ({g: core::Object?}) && (let final core::int #t33 = #0#15 as{ForNonNullableByDefault} core::int in #C6 =={core::num::==}{(core::Object) → core::bool} #0#15 as{ForNonNullableByDefault} core::int)) {
+        {
+          return 4;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?}) && (let final core::Object? #t34 = (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final core::bool* #t35 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?})}.a{core::Object?})! in true)) {
+        {
+          return 5;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} ({b: core::Object?}) && (!((#0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final core::bool* #t36 = #0#23#isSet = true in #0#23 = #0#0{({b: core::Object?})}.b{core::Object?}) == null) ?{core::bool} true : false)) {
+        {
+          return 6;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t37 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#32) {
+        {
+          return 7;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#32) {
+        {
+          return 8;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#32 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#43) {
+        {
+          return 9;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#32 && (#0#47.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final core::int #t38 = #0#50 as{ForNonNullableByDefault} core::int in (#0#50 as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final core::int #t39 = #0#53 as{ForNonNullableByDefault} core::int in (#0#53 as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool}))) {
+        {
+          return 10;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C4 =={core::num::==}{(core::Object) → core::bool} #0#32 && (#0#58.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final core::int #t40 = #0#61 as{ForNonNullableByDefault} core::int in (#0#61 as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final core::int #t41 = #0#64 as{ForNonNullableByDefault} core::int in (#0#64 as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})) && #C5 =={core::num::==}{(core::Object) → core::bool} #0#43) {
+        {
+          return 11;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Class && #C1 =={core::num::==}{(core::Object) → core::bool} #0#69) {
+        {
+          return 12;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Class && #C7 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::finalField}{core::int}) {
+        {
+          return 13;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#69 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::getter}{core::int}) {
+        {
+          return 14;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Class) {
+        {
+          return 15;
+        }
+      }
+    }
+    {
+      if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C9) {
+        {
+          return 16;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} ({e: core::Object?}) && !(#0#0{({e: core::Object?})}.e{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C10)) {
+        {
+          return 17;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<core::int, core::int> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t42 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t43 = #0#26#isSet = true in #0#26 = #0#0{core::Map<core::int, core::int>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<core::int, core::int>}.{core::Map::containsKey}(#C3){(core::Object?) → core::bool} && #0#0{core::Map<core::int, core::int>}.{core::Map::[]}(#C3){(core::Object?) → core::int?}.{core::num::>=}(#C11){(core::num) → core::bool}) {
+        {
+          return 18;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t44 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t45 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && (let final dynamic #t46 = #0#30 in true)) {
+        {
+          return 19;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::bool) {
+        {
+          return 20;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t47 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C12) {
+        {
+          return 21;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t48 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t49 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C12){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C12){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::int) {
+        {
+          return 22;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t50 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::String) {
+        {
+          return 23;
+        }
+      }
+    }
+    {
+      dynamic a;
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t51 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t52 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C7){(core::Object?) → core::bool} && (let final dynamic #t53 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C7){(core::Object?) → dynamic} in true)) {
+        {
+          return 24;
+        }
+      }
+    }
+    {
+      core::int b;
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t54 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t55 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && (#0#104 is{ForNonNullableByDefault} core::int && (let final core::int #t56 = b = #0#104{core::int} in true))) {
+        {
+          return 25;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+        {
+          return 26;
+        }
+      }
+    }
+    {
+      dynamic c;
+      if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?, b: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final core::bool* #t57 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?, b: core::Object?})}.a{core::Object?}) && (let final core::Object? #t58 = c = #0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final core::bool* #t59 = #0#23#isSet = true in #0#23 = #0#0{({a: core::Object?, b: core::Object?})}.b{core::Object?} in true)) {
+        {
+          return 27;
+        }
+      }
+    }
+    {
+      dynamic d;
+      if(#0#0 is{ForNonNullableByDefault} ({c: core::Object?, d: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{({c: core::Object?, d: core::Object?})}.c{core::Object?} && (let final core::Object? #t60 = d = #0#0{({c: core::Object?, d: core::Object?})}.d{core::Object?} in true) && d is{ForNonNullableByDefault} core::int) {
+        {
+          return 28;
+        }
+      }
+    }
+    {
+      {
+        {
+          return 0;
+        }
+      }
+    }
   }
 }
 static method switchExpression(dynamic o) → core::int {
   core::print("o = ${o}");
   return block {
     core::int #t61;
-    dynamic a;
-    core::int b;
-    dynamic c;
-    dynamic d;
     final synthesized dynamic #0#0 = o;
     function ##0#4#initializer() → core::Object?
       return #0#0{({f: core::Object?})}.f{core::Object?};
@@ -729,92 +756,187 @@ static method switchExpression(dynamic o) → core::int {
     function ##0#104#initializer() → dynamic
       return #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic};
     late final synthesized dynamic #0#104 = ##0#104#initializer(){() → dynamic};
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0)
-      #t61 = 1;
-    else
-      if(#0#0 is{ForNonNullableByDefault} ({f: core::Object?}) && ((let final core::int #t66 = #0#4 as{ForNonNullableByDefault} core::int in (#0#4 as{ForNonNullableByDefault} core::int).{core::num::>=}(#C2){(core::num) → core::bool}) && (let final core::int #t67 = #0#4 as{ForNonNullableByDefault} core::int in (#0#4 as{ForNonNullableByDefault} core::int).{core::num::<}(#C3){(core::num) → core::bool})))
-        #t61 = 2;
-      else
-        if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C5 =={core::num::==}{(core::Object) → core::bool} #0#0)
+    #L2:
+    {
+      {
+        if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+          #t61 = 1;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({f: core::Object?}) && ((let final core::int #t66 = #0#4 as{ForNonNullableByDefault} core::int in (#0#4 as{ForNonNullableByDefault} core::int).{core::num::>=}(#C2){(core::num) → core::bool}) && (let final core::int #t67 = #0#4 as{ForNonNullableByDefault} core::int in (#0#4 as{ForNonNullableByDefault} core::int).{core::num::<}(#C3){(core::num) → core::bool}))) {
+          #t61 = 2;
+          break #L2;
+        }
+      }
+      {
+        if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C5 =={core::num::==}{(core::Object) → core::bool} #0#0) {
           #t61 = 3;
-        else
-          if(#0#0 is{ForNonNullableByDefault} ({g: core::Object?}) && (let final core::int #t68 = #0#15 as{ForNonNullableByDefault} core::int in #C6 =={core::num::==}{(core::Object) → core::bool} #0#15 as{ForNonNullableByDefault} core::int))
-            #t61 = 4;
-          else
-            if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?}) && (let final core::Object? #t69 = (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final core::bool* #t70 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?})}.a{core::Object?})! in true))
-              #t61 = 5;
-            else
-              if(#0#0 is{ForNonNullableByDefault} ({b: core::Object?}) && (!((#0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final core::bool* #t71 = #0#23#isSet = true in #0#23 = #0#0{({b: core::Object?})}.b{core::Object?}) == null) ?{core::bool} true : false))
-                #t61 = 6;
-              else
-                if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t72 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#32)
-                  #t61 = 7;
-                else
-                  if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#32)
-                    #t61 = 8;
-                  else
-                    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#32 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#43)
-                      #t61 = 9;
-                    else
-                      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#32 && (#0#47.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final core::int #t73 = #0#50 as{ForNonNullableByDefault} core::int in (#0#50 as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final core::int #t74 = #0#53 as{ForNonNullableByDefault} core::int in (#0#53 as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})))
-                        #t61 = 10;
-                      else
-                        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C4 =={core::num::==}{(core::Object) → core::bool} #0#32 && (#0#58.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final core::int #t75 = #0#61 as{ForNonNullableByDefault} core::int in (#0#61 as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final core::int #t76 = #0#64 as{ForNonNullableByDefault} core::int in (#0#64 as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})) && #C5 =={core::num::==}{(core::Object) → core::bool} #0#43)
-                          #t61 = 11;
-                        else
-                          if(#0#0 is{ForNonNullableByDefault} self::Class && #C1 =={core::num::==}{(core::Object) → core::bool} #0#69)
-                            #t61 = 12;
-                          else
-                            if(#0#0 is{ForNonNullableByDefault} self::Class && #C7 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::finalField}{core::int})
-                              #t61 = 13;
-                            else
-                              if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#69 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::getter}{core::int})
-                                #t61 = 14;
-                              else
-                                if(#0#0 is{ForNonNullableByDefault} self::Class)
-                                  #t61 = 15;
-                                else
-                                  if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C9)
-                                    #t61 = 16;
-                                  else
-                                    if(#0#0 is{ForNonNullableByDefault} ({e: core::Object?}) && !(#0#0{({e: core::Object?})}.e{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C10))
-                                      #t61 = 17;
-                                    else
-                                      if(#0#0 is{ForNonNullableByDefault} core::Map<core::int, core::int> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t77 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t78 = #0#26#isSet = true in #0#26 = #0#0{core::Map<core::int, core::int>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<core::int, core::int>}.{core::Map::containsKey}(#C3){(core::Object?) → core::bool} && #0#0{core::Map<core::int, core::int>}.{core::Map::[]}(#C3){(core::Object?) → core::int?}.{core::num::>=}(#C11){(core::num) → core::bool})
-                                        #t61 = 18;
-                                      else
-                                        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t79 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t80 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && (let final dynamic #t81 = #0#30 in true))
-                                          #t61 = 19;
-                                        else
-                                          if(#0#0 is{ForNonNullableByDefault} core::bool)
-                                            #t61 = 20;
-                                          else
-                                            if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t82 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C12)
-                                              #t61 = 21;
-                                            else
-                                              if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t83 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t84 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C12){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C12){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::int)
-                                                #t61 = 22;
-                                              else
-                                                if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t85 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::String)
-                                                  #t61 = 23;
-                                                else
-                                                  if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t86 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t87 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C7){(core::Object?) → core::bool} && (let final dynamic #t88 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C7){(core::Object?) → dynamic} in true))
-                                                    #t61 = 24;
-                                                  else
-                                                    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t89 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t90 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && (#0#104 is{ForNonNullableByDefault} core::int && (let final core::int #t91 = b = #0#104{core::int} in true)))
-                                                      #t61 = 25;
-                                                    else
-                                                      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?})
-                                                        #t61 = 26;
-                                                      else
-                                                        if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?, b: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final core::bool* #t92 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?, b: core::Object?})}.a{core::Object?}) && (let final core::Object? #t93 = c = #0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final core::bool* #t94 = #0#23#isSet = true in #0#23 = #0#0{({a: core::Object?, b: core::Object?})}.b{core::Object?} in true))
-                                                          #t61 = 27;
-                                                        else
-                                                          if(#0#0 is{ForNonNullableByDefault} ({c: core::Object?, d: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{({c: core::Object?, d: core::Object?})}.c{core::Object?} && (let final core::Object? #t95 = d = #0#0{({c: core::Object?, d: core::Object?})}.d{core::Object?} in true) && d is{ForNonNullableByDefault} core::int)
-                                                            #t61 = 28;
-                                                          else
-                                                            if(true)
-                                                              #t61 = 0;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({g: core::Object?}) && (let final core::int #t68 = #0#15 as{ForNonNullableByDefault} core::int in #C6 =={core::num::==}{(core::Object) → core::bool} #0#15 as{ForNonNullableByDefault} core::int)) {
+          #t61 = 4;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?}) && (let final core::Object? #t69 = (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final core::bool* #t70 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?})}.a{core::Object?})! in true)) {
+          #t61 = 5;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({b: core::Object?}) && (!((#0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final core::bool* #t71 = #0#23#isSet = true in #0#23 = #0#0{({b: core::Object?})}.b{core::Object?}) == null) ?{core::bool} true : false)) {
+          #t61 = 6;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t72 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#32) {
+          #t61 = 7;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#32) {
+          #t61 = 8;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#32 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#43) {
+          #t61 = 9;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#34 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#32 && (#0#47.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final core::int #t73 = #0#50 as{ForNonNullableByDefault} core::int in (#0#50 as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final core::int #t74 = #0#53 as{ForNonNullableByDefault} core::int in (#0#53 as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool}))) {
+          #t61 = 10;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#38 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#30 && #C4 =={core::num::==}{(core::Object) → core::bool} #0#32 && (#0#58.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C7 && (let final core::int #t75 = #0#61 as{ForNonNullableByDefault} core::int in (#0#61 as{ForNonNullableByDefault} core::int).{core::num::<}(#C1){(core::num) → core::bool}) && (let final core::int #t76 = #0#64 as{ForNonNullableByDefault} core::int in (#0#64 as{ForNonNullableByDefault} core::int).{core::num::>}(#C7){(core::num) → core::bool})) && #C5 =={core::num::==}{(core::Object) → core::bool} #0#43) {
+          #t61 = 11;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} self::Class && #C1 =={core::num::==}{(core::Object) → core::bool} #0#69) {
+          #t61 = 12;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} self::Class && #C7 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::finalField}{core::int}) {
+          #t61 = 13;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#69 && #C8 =={core::num::==}{(core::Object) → core::bool} #0#0{self::Class}.{self::Class::getter}{core::int}) {
+          #t61 = 14;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} self::Class) {
+          #t61 = 15;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C9) {
+          #t61 = 16;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} ({e: core::Object?}) && !(#0#0{({e: core::Object?})}.e{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C10)) {
+          #t61 = 17;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::Map<core::int, core::int> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t77 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t78 = #0#26#isSet = true in #0#26 = #0#0{core::Map<core::int, core::int>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<core::int, core::int>}.{core::Map::containsKey}(#C3){(core::Object?) → core::bool} && #0#0{core::Map<core::int, core::int>}.{core::Map::[]}(#C3){(core::Object?) → core::int?}.{core::num::>=}(#C11){(core::num) → core::bool}) {
+          #t61 = 18;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t79 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t80 = #0#26#isSet = true in #0#26 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && (let final dynamic #t81 = #0#30 in true)) {
+          #t61 = 19;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::bool) {
+          #t61 = 20;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t82 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C12) {
+          #t61 = 21;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t83 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t84 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C12){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C12){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::int) {
+          #t61 = 22;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t85 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic} is{ForNonNullableByDefault} core::String) {
+          #t61 = 23;
+          break #L2;
+        }
+      }
+      {
+        dynamic a;
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t86 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t87 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C7){(core::Object?) → core::bool} && (let final dynamic #t88 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C7){(core::Object?) → dynamic} in true)) {
+          #t61 = 24;
+          break #L2;
+        }
+      }
+      {
+        core::int b;
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#83#isSet ?{core::bool} #0#83{core::bool} : let final core::bool* #t89 = #0#83#isSet = true in #0#83 = (#0#26#isSet ?{core::int} #0#26{core::int} : let final core::bool* #t90 = #0#26#isSet = true in #0#26 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && (#0#104 is{ForNonNullableByDefault} core::int && (let final core::int #t91 = b = #0#104{core::int} in true))) {
+          #t61 = 25;
+          break #L2;
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+          #t61 = 26;
+          break #L2;
+        }
+      }
+      {
+        dynamic c;
+        if(#0#0 is{ForNonNullableByDefault} ({a: core::Object?, b: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} (#0#20#isSet ?{core::Object?} #0#20{core::Object?} : let final core::bool* #t92 = #0#20#isSet = true in #0#20 = #0#0{({a: core::Object?, b: core::Object?})}.a{core::Object?}) && (let final core::Object? #t93 = c = #0#23#isSet ?{core::Object?} #0#23{core::Object?} : let final core::bool* #t94 = #0#23#isSet = true in #0#23 = #0#0{({a: core::Object?, b: core::Object?})}.b{core::Object?} in true)) {
+          #t61 = 27;
+          break #L2;
+        }
+      }
+      {
+        dynamic d;
+        if(#0#0 is{ForNonNullableByDefault} ({c: core::Object?, d: core::Object?}) && #C12 =={core::num::==}{(core::Object) → core::bool} #0#0{({c: core::Object?, d: core::Object?})}.c{core::Object?} && (let final core::Object? #t95 = d = #0#0{({c: core::Object?, d: core::Object?})}.d{core::Object?} in true) && d is{ForNonNullableByDefault} core::int) {
+          #t61 = 28;
+          break #L2;
+        }
+      }
+      {
+        if(true) {
+          #t61 = 0;
+          break #L2;
+        }
+      }
+    }
   } =>#t61;
 }
 static method test(dynamic expected, dynamic value) → dynamic {
diff --git a/pkg/front_end/testcases/patterns/caching_constants.dart.strong.expect b/pkg/front_end/testcases/patterns/caching_constants.dart.strong.expect
index 82dc7fb523d..a1ea337e12c 100644
--- a/pkg/front_end/testcases/patterns/caching_constants.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/caching_constants.dart.strong.expect
@@ -80,17 +80,20 @@ static method method(core::Map<core::int, core::String> m) → core::int {
     late final synthesized core::bool #0#3 = #0#0.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2;
     late final synthesized core::bool #0#4 = #0#0.{core::Map::containsKey}(#C2){(core::Object?) → core::bool};
     late final synthesized core::String? #0#5 = #0#0.{core::Map::[]}(#C2){(core::Object?) → core::String?};
-    if(#0#3 && #0#4 && #C3 =={core::String::==}{(core::Object) → core::bool} #0#5) {
-      {
-        return 0;
+    {
+      if(#0#3 && #0#4 && #C3 =={core::String::==}{(core::Object) → core::bool} #0#5) {
+        {
+          return 0;
+        }
       }
     }
-    else
+    {
       if(#0#3 && #0#4 && #C4 =={core::String::==}{(core::Object) → core::bool} #0#5) {
         {
           return 1;
         }
       }
+    }
   }
   return 2;
 }
diff --git a/pkg/front_end/testcases/patterns/caching_constants.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/caching_constants.dart.strong.transformed.expect
index 92d3c831904..19fc0214f3e 100644
--- a/pkg/front_end/testcases/patterns/caching_constants.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/caching_constants.dart.strong.transformed.expect
@@ -171,17 +171,20 @@ static method method(core::Map<core::int, core::String> m) → core::int {
     function ##0#5#initializer() → core::String?
       return #0#0.{core::Map::[]}(#C2){(core::Object?) → core::String?};
     late final synthesized core::String? #0#5 = ##0#5#initializer(){() → core::String?};
-    if(#0#3 && #0#4 && #C3 =={core::String::==}{(core::Object) → core::bool} #0#5) {
-      {
-        return 0;
+    {
+      if(#0#3 && #0#4 && #C3 =={core::String::==}{(core::Object) → core::bool} #0#5) {
+        {
+          return 0;
+        }
       }
     }
-    else
+    {
       if(#0#3 && #0#4 && #C4 =={core::String::==}{(core::Object) → core::bool} #0#5) {
         {
           return 1;
         }
       }
+    }
   }
   return 2;
 }
diff --git a/pkg/front_end/testcases/patterns/caching_constants.dart.weak.expect b/pkg/front_end/testcases/patterns/caching_constants.dart.weak.expect
index 82dc7fb523d..a1ea337e12c 100644
--- a/pkg/front_end/testcases/patterns/caching_constants.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/caching_constants.dart.weak.expect
@@ -80,17 +80,20 @@ static method method(core::Map<core::int, core::String> m) → core::int {
     late final synthesized core::bool #0#3 = #0#0.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2;
     late final synthesized core::bool #0#4 = #0#0.{core::Map::containsKey}(#C2){(core::Object?) → core::bool};
     late final synthesized core::String? #0#5 = #0#0.{core::Map::[]}(#C2){(core::Object?) → core::String?};
-    if(#0#3 && #0#4 && #C3 =={core::String::==}{(core::Object) → core::bool} #0#5) {
-      {
-        return 0;
+    {
+      if(#0#3 && #0#4 && #C3 =={core::String::==}{(core::Object) → core::bool} #0#5) {
+        {
+          return 0;
+        }
       }
     }
-    else
+    {
       if(#0#3 && #0#4 && #C4 =={core::String::==}{(core::Object) → core::bool} #0#5) {
         {
           return 1;
         }
       }
+    }
   }
   return 2;
 }
diff --git a/pkg/front_end/testcases/patterns/caching_constants.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/caching_constants.dart.weak.modular.expect
index 82dc7fb523d..a1ea337e12c 100644
--- a/pkg/front_end/testcases/patterns/caching_constants.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/caching_constants.dart.weak.modular.expect
@@ -80,17 +80,20 @@ static method method(core::Map<core::int, core::String> m) → core::int {
     late final synthesized core::bool #0#3 = #0#0.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2;
     late final synthesized core::bool #0#4 = #0#0.{core::Map::containsKey}(#C2){(core::Object?) → core::bool};
     late final synthesized core::String? #0#5 = #0#0.{core::Map::[]}(#C2){(core::Object?) → core::String?};
-    if(#0#3 && #0#4 && #C3 =={core::String::==}{(core::Object) → core::bool} #0#5) {
-      {
-        return 0;
+    {
+      if(#0#3 && #0#4 && #C3 =={core::String::==}{(core::Object) → core::bool} #0#5) {
+        {
+          return 0;
+        }
       }
     }
-    else
+    {
       if(#0#3 && #0#4 && #C4 =={core::String::==}{(core::Object) → core::bool} #0#5) {
         {
           return 1;
         }
       }
+    }
   }
   return 2;
 }
diff --git a/pkg/front_end/testcases/patterns/caching_constants.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/caching_constants.dart.weak.transformed.expect
index 64e772a3afd..b9c52333fe1 100644
--- a/pkg/front_end/testcases/patterns/caching_constants.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/caching_constants.dart.weak.transformed.expect
@@ -171,17 +171,20 @@ static method method(core::Map<core::int, core::String> m) → core::int {
     function ##0#5#initializer() → core::String?
       return #0#0.{core::Map::[]}(#C2){(core::Object?) → core::String?};
     late final synthesized core::String? #0#5 = ##0#5#initializer(){() → core::String?};
-    if(#0#3 && #0#4 && #C3 =={core::String::==}{(core::Object) → core::bool} #0#5) {
-      {
-        return 0;
+    {
+      if(#0#3 && #0#4 && #C3 =={core::String::==}{(core::Object) → core::bool} #0#5) {
+        {
+          return 0;
+        }
       }
     }
-    else
+    {
       if(#0#3 && #0#4 && #C4 =={core::String::==}{(core::Object) → core::bool} #0#5) {
         {
           return 1;
         }
       }
+    }
   }
   return 2;
 }
diff --git a/pkg/front_end/testcases/patterns/caseHead_withClassicPattern_guarded_insideSwitchStatement.dart.strong.expect b/pkg/front_end/testcases/patterns/caseHead_withClassicPattern_guarded_insideSwitchStatement.dart.strong.expect
index 4e32c0da626..0d36f8d0d94 100644
--- a/pkg/front_end/testcases/patterns/caseHead_withClassicPattern_guarded_insideSwitchStatement.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/caseHead_withClassicPattern_guarded_insideSwitchStatement.dart.strong.expect
@@ -6,9 +6,11 @@ static method f(dynamic x) → void {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && true) {
-      {
-        break #L1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && true) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/caseHead_withClassicPattern_guarded_insideSwitchStatement.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/caseHead_withClassicPattern_guarded_insideSwitchStatement.dart.strong.transformed.expect
index 4e32c0da626..0d36f8d0d94 100644
--- a/pkg/front_end/testcases/patterns/caseHead_withClassicPattern_guarded_insideSwitchStatement.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/caseHead_withClassicPattern_guarded_insideSwitchStatement.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method f(dynamic x) → void {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && true) {
-      {
-        break #L1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && true) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/caseHead_withClassicPattern_guarded_insideSwitchStatement.dart.weak.expect b/pkg/front_end/testcases/patterns/caseHead_withClassicPattern_guarded_insideSwitchStatement.dart.weak.expect
index 4e32c0da626..0d36f8d0d94 100644
--- a/pkg/front_end/testcases/patterns/caseHead_withClassicPattern_guarded_insideSwitchStatement.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/caseHead_withClassicPattern_guarded_insideSwitchStatement.dart.weak.expect
@@ -6,9 +6,11 @@ static method f(dynamic x) → void {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && true) {
-      {
-        break #L1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && true) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/caseHead_withClassicPattern_guarded_insideSwitchStatement.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/caseHead_withClassicPattern_guarded_insideSwitchStatement.dart.weak.modular.expect
index 4e32c0da626..0d36f8d0d94 100644
--- a/pkg/front_end/testcases/patterns/caseHead_withClassicPattern_guarded_insideSwitchStatement.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/caseHead_withClassicPattern_guarded_insideSwitchStatement.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method f(dynamic x) → void {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && true) {
-      {
-        break #L1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && true) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/caseHead_withClassicPattern_guarded_insideSwitchStatement.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/caseHead_withClassicPattern_guarded_insideSwitchStatement.dart.weak.transformed.expect
index 4e32c0da626..0d36f8d0d94 100644
--- a/pkg/front_end/testcases/patterns/caseHead_withClassicPattern_guarded_insideSwitchStatement.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/caseHead_withClassicPattern_guarded_insideSwitchStatement.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method f(dynamic x) → void {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && true) {
-      {
-        break #L1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && true) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/caseHead_withNewPattern_guarded_insideSwitchStatement.dart.strong.expect b/pkg/front_end/testcases/patterns/caseHead_withNewPattern_guarded_insideSwitchStatement.dart.strong.expect
index c863ea95b17..52e2afa2399 100644
--- a/pkg/front_end/testcases/patterns/caseHead_withNewPattern_guarded_insideSwitchStatement.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/caseHead_withNewPattern_guarded_insideSwitchStatement.dart.strong.expect
@@ -6,9 +6,11 @@ static method f(dynamic x) → void {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if((let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::int) && true) {
-      {
-        break #L1;
+    {
+      if((let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::int) && true) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/caseHead_withNewPattern_guarded_insideSwitchStatement.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/caseHead_withNewPattern_guarded_insideSwitchStatement.dart.strong.transformed.expect
index 6458c66a949..b8bfb25302a 100644
--- a/pkg/front_end/testcases/patterns/caseHead_withNewPattern_guarded_insideSwitchStatement.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/caseHead_withNewPattern_guarded_insideSwitchStatement.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method f(dynamic x) → void {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if((let final core::int #t1 = #0#0 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::int) && true) {
-      {
-        break #L1;
+    {
+      if((let final core::int #t1 = #0#0 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::int) && true) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/caseHead_withNewPattern_guarded_insideSwitchStatement.dart.weak.expect b/pkg/front_end/testcases/patterns/caseHead_withNewPattern_guarded_insideSwitchStatement.dart.weak.expect
index c863ea95b17..52e2afa2399 100644
--- a/pkg/front_end/testcases/patterns/caseHead_withNewPattern_guarded_insideSwitchStatement.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/caseHead_withNewPattern_guarded_insideSwitchStatement.dart.weak.expect
@@ -6,9 +6,11 @@ static method f(dynamic x) → void {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if((let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::int) && true) {
-      {
-        break #L1;
+    {
+      if((let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::int) && true) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/caseHead_withNewPattern_guarded_insideSwitchStatement.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/caseHead_withNewPattern_guarded_insideSwitchStatement.dart.weak.modular.expect
index c863ea95b17..52e2afa2399 100644
--- a/pkg/front_end/testcases/patterns/caseHead_withNewPattern_guarded_insideSwitchStatement.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/caseHead_withNewPattern_guarded_insideSwitchStatement.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method f(dynamic x) → void {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if((let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::int) && true) {
-      {
-        break #L1;
+    {
+      if((let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::int) && true) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/caseHead_withNewPattern_guarded_insideSwitchStatement.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/caseHead_withNewPattern_guarded_insideSwitchStatement.dart.weak.transformed.expect
index 6458c66a949..b8bfb25302a 100644
--- a/pkg/front_end/testcases/patterns/caseHead_withNewPattern_guarded_insideSwitchStatement.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/caseHead_withNewPattern_guarded_insideSwitchStatement.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method f(dynamic x) → void {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if((let final core::int #t1 = #0#0 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::int) && true) {
-      {
-        break #L1;
+    {
+      if((let final core::int #t1 = #0#0 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::int) && true) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_case.dart.strong.expect b/pkg/front_end/testcases/patterns/cast_inside_case.dart.strong.expect
index 7c52fffea33..6d39333c864 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_case.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_case.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::int) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::int) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_case.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/cast_inside_case.dart.strong.transformed.expect
index d93be5574f1..533d8b04876 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_case.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_case.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final core::int #t1 = #0#0 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::int) {
-      {
-        break #L1;
+    {
+      if(let final core::int #t1 = #0#0 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::int) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_case.dart.weak.expect b/pkg/front_end/testcases/patterns/cast_inside_case.dart.weak.expect
index 7c52fffea33..6d39333c864 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_case.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_case.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::int) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::int) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_case.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/cast_inside_case.dart.weak.modular.expect
index 7c52fffea33..6d39333c864 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_case.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_case.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::int) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::int) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_case.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/cast_inside_case.dart.weak.transformed.expect
index d93be5574f1..533d8b04876 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_case.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_case.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final core::int #t1 = #0#0 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::int) {
-      {
-        break #L1;
+    {
+      if(let final core::int #t1 = #0#0 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::int) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_extractor_pattern.dart.strong.expect b/pkg/front_end/testcases/patterns/cast_inside_extractor_pattern.dart.strong.expect
index ecfbbc23e57..00bad226977 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_extractor_pattern.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_extractor_pattern.dart.strong.expect
@@ -13,9 +13,11 @@ static method test(dynamic x) → dynamic {
   {
     final synthesized dynamic #0#0 = x;
     late final synthesized core::int? #0#2 = #0#0{self::C}.{self::C::f}{core::int?};
-    if(#0#0 is{ForNonNullableByDefault} self::C && (let final dynamic #t1 = #0#2 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 as{ForNonNullableByDefault} core::int)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::C && (let final dynamic #t1 = #0#2 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 as{ForNonNullableByDefault} core::int)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_extractor_pattern.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/cast_inside_extractor_pattern.dart.strong.transformed.expect
index 59e830877aa..06f0995fdab 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_extractor_pattern.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_extractor_pattern.dart.strong.transformed.expect
@@ -15,9 +15,11 @@ static method test(dynamic x) → dynamic {
     function ##0#2#initializer() → core::int?
       return #0#0{self::C}.{self::C::f}{core::int?};
     late final synthesized core::int? #0#2 = ##0#2#initializer(){() → core::int?};
-    if(#0#0 is{ForNonNullableByDefault} self::C && (let final core::int #t1 = let core::int? #t2 = #0#2 in #t2 == null ?{core::int} #t2 as{ForNonNullableByDefault} core::int : #t2{core::int} in #C1 =={core::num::==}{(core::Object) → core::bool} (let core::int? #t3 = #0#2 in #t3 == null ?{core::int} #t3 as{ForNonNullableByDefault} core::int : #t3{core::int}))) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::C && (let final core::int #t1 = let core::int? #t2 = #0#2 in #t2 == null ?{core::int} #t2 as{ForNonNullableByDefault} core::int : #t2{core::int} in #C1 =={core::num::==}{(core::Object) → core::bool} (let core::int? #t3 = #0#2 in #t3 == null ?{core::int} #t3 as{ForNonNullableByDefault} core::int : #t3{core::int}))) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_extractor_pattern.dart.weak.expect b/pkg/front_end/testcases/patterns/cast_inside_extractor_pattern.dart.weak.expect
index ecfbbc23e57..00bad226977 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_extractor_pattern.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_extractor_pattern.dart.weak.expect
@@ -13,9 +13,11 @@ static method test(dynamic x) → dynamic {
   {
     final synthesized dynamic #0#0 = x;
     late final synthesized core::int? #0#2 = #0#0{self::C}.{self::C::f}{core::int?};
-    if(#0#0 is{ForNonNullableByDefault} self::C && (let final dynamic #t1 = #0#2 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 as{ForNonNullableByDefault} core::int)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::C && (let final dynamic #t1 = #0#2 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 as{ForNonNullableByDefault} core::int)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_extractor_pattern.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/cast_inside_extractor_pattern.dart.weak.modular.expect
index ecfbbc23e57..00bad226977 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_extractor_pattern.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_extractor_pattern.dart.weak.modular.expect
@@ -13,9 +13,11 @@ static method test(dynamic x) → dynamic {
   {
     final synthesized dynamic #0#0 = x;
     late final synthesized core::int? #0#2 = #0#0{self::C}.{self::C::f}{core::int?};
-    if(#0#0 is{ForNonNullableByDefault} self::C && (let final dynamic #t1 = #0#2 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 as{ForNonNullableByDefault} core::int)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::C && (let final dynamic #t1 = #0#2 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 as{ForNonNullableByDefault} core::int)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_extractor_pattern.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/cast_inside_extractor_pattern.dart.weak.transformed.expect
index 2e22af11778..c05a7d64c23 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_extractor_pattern.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_extractor_pattern.dart.weak.transformed.expect
@@ -15,9 +15,11 @@ static method test(dynamic x) → dynamic {
     function ##0#2#initializer() → core::int?
       return #0#0{self::C}.{self::C::f}{core::int?};
     late final synthesized core::int? #0#2 = ##0#2#initializer(){() → core::int?};
-    if(#0#0 is{ForNonNullableByDefault} self::C && (let final core::int #t1 = #0#2 in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::C && (let final core::int #t1 = #0#2 in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_extractor_pattern_implicitly_named.dart.strong.expect b/pkg/front_end/testcases/patterns/cast_inside_extractor_pattern_implicitly_named.dart.strong.expect
index a56ca6fccd9..61c117e54b9 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_extractor_pattern_implicitly_named.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_extractor_pattern_implicitly_named.dart.strong.expect
@@ -11,12 +11,14 @@ class C extends core::Object {
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int f;
     final synthesized dynamic #0#0 = x;
     late final synthesized core::int? #0#2 = #0#0{self::C}.{self::C::f}{core::int?};
-    if(#0#0 is{ForNonNullableByDefault} self::C && (let final dynamic #t1 = #0#2 as{ForNonNullableByDefault} core::int in let final dynamic #t2 = f = #0#2 as{ForNonNullableByDefault} core::int in true)) {
-      {
-        break #L1;
+    {
+      core::int f;
+      if(#0#0 is{ForNonNullableByDefault} self::C && (let final dynamic #t1 = #0#2 as{ForNonNullableByDefault} core::int in let final dynamic #t2 = f = #0#2 as{ForNonNullableByDefault} core::int in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_extractor_pattern_implicitly_named.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/cast_inside_extractor_pattern_implicitly_named.dart.strong.transformed.expect
index a172c5a5d41..4ed7196fd13 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_extractor_pattern_implicitly_named.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_extractor_pattern_implicitly_named.dart.strong.transformed.expect
@@ -11,14 +11,16 @@ class C extends core::Object {
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int f;
     final synthesized dynamic #0#0 = x;
     function ##0#2#initializer() → core::int?
       return #0#0{self::C}.{self::C::f}{core::int?};
     late final synthesized core::int? #0#2 = ##0#2#initializer(){() → core::int?};
-    if(#0#0 is{ForNonNullableByDefault} self::C && (let final core::int #t1 = let core::int? #t2 = #0#2 in #t2 == null ?{core::int} #t2 as{ForNonNullableByDefault} core::int : #t2{core::int} in let final core::int #t3 = f = let core::int? #t4 = #0#2 in #t4 == null ?{core::int} #t4 as{ForNonNullableByDefault} core::int : #t4{core::int} in true)) {
-      {
-        break #L1;
+    {
+      core::int f;
+      if(#0#0 is{ForNonNullableByDefault} self::C && (let final core::int #t1 = let core::int? #t2 = #0#2 in #t2 == null ?{core::int} #t2 as{ForNonNullableByDefault} core::int : #t2{core::int} in let final core::int #t3 = f = let core::int? #t4 = #0#2 in #t4 == null ?{core::int} #t4 as{ForNonNullableByDefault} core::int : #t4{core::int} in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_extractor_pattern_implicitly_named.dart.weak.expect b/pkg/front_end/testcases/patterns/cast_inside_extractor_pattern_implicitly_named.dart.weak.expect
index a56ca6fccd9..61c117e54b9 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_extractor_pattern_implicitly_named.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_extractor_pattern_implicitly_named.dart.weak.expect
@@ -11,12 +11,14 @@ class C extends core::Object {
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int f;
     final synthesized dynamic #0#0 = x;
     late final synthesized core::int? #0#2 = #0#0{self::C}.{self::C::f}{core::int?};
-    if(#0#0 is{ForNonNullableByDefault} self::C && (let final dynamic #t1 = #0#2 as{ForNonNullableByDefault} core::int in let final dynamic #t2 = f = #0#2 as{ForNonNullableByDefault} core::int in true)) {
-      {
-        break #L1;
+    {
+      core::int f;
+      if(#0#0 is{ForNonNullableByDefault} self::C && (let final dynamic #t1 = #0#2 as{ForNonNullableByDefault} core::int in let final dynamic #t2 = f = #0#2 as{ForNonNullableByDefault} core::int in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_extractor_pattern_implicitly_named.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/cast_inside_extractor_pattern_implicitly_named.dart.weak.modular.expect
index a56ca6fccd9..61c117e54b9 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_extractor_pattern_implicitly_named.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_extractor_pattern_implicitly_named.dart.weak.modular.expect
@@ -11,12 +11,14 @@ class C extends core::Object {
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int f;
     final synthesized dynamic #0#0 = x;
     late final synthesized core::int? #0#2 = #0#0{self::C}.{self::C::f}{core::int?};
-    if(#0#0 is{ForNonNullableByDefault} self::C && (let final dynamic #t1 = #0#2 as{ForNonNullableByDefault} core::int in let final dynamic #t2 = f = #0#2 as{ForNonNullableByDefault} core::int in true)) {
-      {
-        break #L1;
+    {
+      core::int f;
+      if(#0#0 is{ForNonNullableByDefault} self::C && (let final dynamic #t1 = #0#2 as{ForNonNullableByDefault} core::int in let final dynamic #t2 = f = #0#2 as{ForNonNullableByDefault} core::int in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_extractor_pattern_implicitly_named.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/cast_inside_extractor_pattern_implicitly_named.dart.weak.transformed.expect
index 76ab18be348..7bf916fb962 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_extractor_pattern_implicitly_named.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_extractor_pattern_implicitly_named.dart.weak.transformed.expect
@@ -11,14 +11,16 @@ class C extends core::Object {
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int f;
     final synthesized dynamic #0#0 = x;
     function ##0#2#initializer() → core::int?
       return #0#0{self::C}.{self::C::f}{core::int?};
     late final synthesized core::int? #0#2 = ##0#2#initializer(){() → core::int?};
-    if(#0#0 is{ForNonNullableByDefault} self::C && (let final core::int #t1 = #0#2 in let final core::int #t2 = f = #0#2 in true)) {
-      {
-        break #L1;
+    {
+      core::int f;
+      if(#0#0 is{ForNonNullableByDefault} self::C && (let final core::int #t1 = #0#2 in let final core::int #t2 = f = #0#2 in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_list_pattern.dart.strong.expect b/pkg/front_end/testcases/patterns/cast_inside_list_pattern.dart.strong.expect
index e5426a5cca5..f50b02c2ddc 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_list_pattern.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_list_pattern.dart.strong.expect
@@ -7,9 +7,11 @@ static method test(dynamic x) → dynamic {
   {
     final synthesized dynamic #0#0 = x;
     late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final dynamic #t1 = #0#6 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#6 as{ForNonNullableByDefault} core::int)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final dynamic #t1 = #0#6 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#6 as{ForNonNullableByDefault} core::int)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_list_pattern.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/cast_inside_list_pattern.dart.strong.transformed.expect
index 3d504dc6b57..82ce67b4225 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_list_pattern.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_list_pattern.dart.strong.transformed.expect
@@ -9,9 +9,11 @@ static method test(dynamic x) → dynamic {
     function ##0#6#initializer() → dynamic
       return #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
     late final synthesized dynamic #0#6 = ##0#6#initializer(){() → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final core::int #t1 = #0#6 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#6 as{ForNonNullableByDefault} core::int)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final core::int #t1 = #0#6 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#6 as{ForNonNullableByDefault} core::int)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_list_pattern.dart.weak.expect b/pkg/front_end/testcases/patterns/cast_inside_list_pattern.dart.weak.expect
index e5426a5cca5..f50b02c2ddc 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_list_pattern.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_list_pattern.dart.weak.expect
@@ -7,9 +7,11 @@ static method test(dynamic x) → dynamic {
   {
     final synthesized dynamic #0#0 = x;
     late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final dynamic #t1 = #0#6 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#6 as{ForNonNullableByDefault} core::int)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final dynamic #t1 = #0#6 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#6 as{ForNonNullableByDefault} core::int)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_list_pattern.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/cast_inside_list_pattern.dart.weak.modular.expect
index e5426a5cca5..f50b02c2ddc 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_list_pattern.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_list_pattern.dart.weak.modular.expect
@@ -7,9 +7,11 @@ static method test(dynamic x) → dynamic {
   {
     final synthesized dynamic #0#0 = x;
     late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final dynamic #t1 = #0#6 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#6 as{ForNonNullableByDefault} core::int)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final dynamic #t1 = #0#6 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#6 as{ForNonNullableByDefault} core::int)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_list_pattern.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/cast_inside_list_pattern.dart.weak.transformed.expect
index 3d504dc6b57..82ce67b4225 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_list_pattern.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_list_pattern.dart.weak.transformed.expect
@@ -9,9 +9,11 @@ static method test(dynamic x) → dynamic {
     function ##0#6#initializer() → dynamic
       return #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
     late final synthesized dynamic #0#6 = ##0#6#initializer(){() → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final core::int #t1 = #0#6 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#6 as{ForNonNullableByDefault} core::int)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final core::int #t1 = #0#6 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#6 as{ForNonNullableByDefault} core::int)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_logical_and_lhs.dart.strong.expect b/pkg/front_end/testcases/patterns/cast_inside_logical_and_lhs.dart.strong.expect
index 2b838bc4fdc..805c8757e17 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_logical_and_lhs.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_logical_and_lhs.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if((let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::double? in (#0#0 as{ForNonNullableByDefault} core::double?) is{ForNonNullableByDefault} core::int?) && #0#0 is{ForNonNullableByDefault} core::Object?) {
-      {
-        break #L1;
+    {
+      if((let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::double? in (#0#0 as{ForNonNullableByDefault} core::double?) is{ForNonNullableByDefault} core::int?) && #0#0 is{ForNonNullableByDefault} core::Object?) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_logical_and_lhs.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/cast_inside_logical_and_lhs.dart.strong.transformed.expect
index a73a8e0e148..f8a6aa30f71 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_logical_and_lhs.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_logical_and_lhs.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if((let final core::double? #t1 = #0#0 as{ForNonNullableByDefault} core::double? in (#0#0 as{ForNonNullableByDefault} core::double?) is{ForNonNullableByDefault} core::int?) && #0#0 is{ForNonNullableByDefault} core::Object?) {
-      {
-        break #L1;
+    {
+      if((let final core::double? #t1 = #0#0 as{ForNonNullableByDefault} core::double? in (#0#0 as{ForNonNullableByDefault} core::double?) is{ForNonNullableByDefault} core::int?) && #0#0 is{ForNonNullableByDefault} core::Object?) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_logical_and_lhs.dart.weak.expect b/pkg/front_end/testcases/patterns/cast_inside_logical_and_lhs.dart.weak.expect
index 2b838bc4fdc..805c8757e17 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_logical_and_lhs.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_logical_and_lhs.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if((let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::double? in (#0#0 as{ForNonNullableByDefault} core::double?) is{ForNonNullableByDefault} core::int?) && #0#0 is{ForNonNullableByDefault} core::Object?) {
-      {
-        break #L1;
+    {
+      if((let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::double? in (#0#0 as{ForNonNullableByDefault} core::double?) is{ForNonNullableByDefault} core::int?) && #0#0 is{ForNonNullableByDefault} core::Object?) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_logical_and_lhs.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/cast_inside_logical_and_lhs.dart.weak.modular.expect
index 2b838bc4fdc..805c8757e17 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_logical_and_lhs.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_logical_and_lhs.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if((let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::double? in (#0#0 as{ForNonNullableByDefault} core::double?) is{ForNonNullableByDefault} core::int?) && #0#0 is{ForNonNullableByDefault} core::Object?) {
-      {
-        break #L1;
+    {
+      if((let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::double? in (#0#0 as{ForNonNullableByDefault} core::double?) is{ForNonNullableByDefault} core::int?) && #0#0 is{ForNonNullableByDefault} core::Object?) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_logical_and_lhs.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/cast_inside_logical_and_lhs.dart.weak.transformed.expect
index a73a8e0e148..f8a6aa30f71 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_logical_and_lhs.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_logical_and_lhs.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if((let final core::double? #t1 = #0#0 as{ForNonNullableByDefault} core::double? in (#0#0 as{ForNonNullableByDefault} core::double?) is{ForNonNullableByDefault} core::int?) && #0#0 is{ForNonNullableByDefault} core::Object?) {
-      {
-        break #L1;
+    {
+      if((let final core::double? #t1 = #0#0 as{ForNonNullableByDefault} core::double? in (#0#0 as{ForNonNullableByDefault} core::double?) is{ForNonNullableByDefault} core::int?) && #0#0 is{ForNonNullableByDefault} core::Object?) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_logical_and_rhs.dart.strong.expect b/pkg/front_end/testcases/patterns/cast_inside_logical_and_rhs.dart.strong.expect
index ba3b79a78b6..706dc0fac95 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_logical_and_rhs.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_logical_and_rhs.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int? && (let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object? in (#0#0 as{ForNonNullableByDefault} core::Object?) is{ForNonNullableByDefault} core::double?)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::int? && (let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object? in (#0#0 as{ForNonNullableByDefault} core::Object?) is{ForNonNullableByDefault} core::double?)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_logical_and_rhs.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/cast_inside_logical_and_rhs.dart.strong.transformed.expect
index f5ded0a7b99..e9d6b2ff93f 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_logical_and_rhs.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_logical_and_rhs.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int? && (let final core::Object? #t1 = #0#0 in #0#0 is{ForNonNullableByDefault} core::double?)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::int? && (let final core::Object? #t1 = #0#0 in #0#0 is{ForNonNullableByDefault} core::double?)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_logical_and_rhs.dart.weak.expect b/pkg/front_end/testcases/patterns/cast_inside_logical_and_rhs.dart.weak.expect
index ba3b79a78b6..706dc0fac95 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_logical_and_rhs.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_logical_and_rhs.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int? && (let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object? in (#0#0 as{ForNonNullableByDefault} core::Object?) is{ForNonNullableByDefault} core::double?)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::int? && (let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object? in (#0#0 as{ForNonNullableByDefault} core::Object?) is{ForNonNullableByDefault} core::double?)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_logical_and_rhs.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/cast_inside_logical_and_rhs.dart.weak.modular.expect
index ba3b79a78b6..706dc0fac95 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_logical_and_rhs.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_logical_and_rhs.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int? && (let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object? in (#0#0 as{ForNonNullableByDefault} core::Object?) is{ForNonNullableByDefault} core::double?)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::int? && (let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object? in (#0#0 as{ForNonNullableByDefault} core::Object?) is{ForNonNullableByDefault} core::double?)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_logical_and_rhs.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/cast_inside_logical_and_rhs.dart.weak.transformed.expect
index f5ded0a7b99..e9d6b2ff93f 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_logical_and_rhs.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_logical_and_rhs.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int? && (let final core::Object? #t1 = #0#0 in #0#0 is{ForNonNullableByDefault} core::double?)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::int? && (let final core::Object? #t1 = #0#0 in #0#0 is{ForNonNullableByDefault} core::double?)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_logical_or_lhs.dart.strong.expect b/pkg/front_end/testcases/patterns/cast_inside_logical_or_lhs.dart.strong.expect
index e38817aba39..ee4aae153c5 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_logical_or_lhs.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_logical_or_lhs.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if((let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::double? in (#0#0 as{ForNonNullableByDefault} core::double?) is{ForNonNullableByDefault} core::int?) || #0#0 is{ForNonNullableByDefault} core::Object?) {
-      {
-        break #L1;
+    {
+      if((let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::double? in (#0#0 as{ForNonNullableByDefault} core::double?) is{ForNonNullableByDefault} core::int?) || #0#0 is{ForNonNullableByDefault} core::Object?) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_logical_or_lhs.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/cast_inside_logical_or_lhs.dart.strong.transformed.expect
index 920720ae9dd..fedc63367f6 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_logical_or_lhs.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_logical_or_lhs.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if((let final core::double? #t1 = #0#0 as{ForNonNullableByDefault} core::double? in (#0#0 as{ForNonNullableByDefault} core::double?) is{ForNonNullableByDefault} core::int?) || #0#0 is{ForNonNullableByDefault} core::Object?) {
-      {
-        break #L1;
+    {
+      if((let final core::double? #t1 = #0#0 as{ForNonNullableByDefault} core::double? in (#0#0 as{ForNonNullableByDefault} core::double?) is{ForNonNullableByDefault} core::int?) || #0#0 is{ForNonNullableByDefault} core::Object?) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_logical_or_lhs.dart.weak.expect b/pkg/front_end/testcases/patterns/cast_inside_logical_or_lhs.dart.weak.expect
index e38817aba39..ee4aae153c5 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_logical_or_lhs.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_logical_or_lhs.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if((let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::double? in (#0#0 as{ForNonNullableByDefault} core::double?) is{ForNonNullableByDefault} core::int?) || #0#0 is{ForNonNullableByDefault} core::Object?) {
-      {
-        break #L1;
+    {
+      if((let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::double? in (#0#0 as{ForNonNullableByDefault} core::double?) is{ForNonNullableByDefault} core::int?) || #0#0 is{ForNonNullableByDefault} core::Object?) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_logical_or_lhs.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/cast_inside_logical_or_lhs.dart.weak.modular.expect
index e38817aba39..ee4aae153c5 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_logical_or_lhs.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_logical_or_lhs.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if((let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::double? in (#0#0 as{ForNonNullableByDefault} core::double?) is{ForNonNullableByDefault} core::int?) || #0#0 is{ForNonNullableByDefault} core::Object?) {
-      {
-        break #L1;
+    {
+      if((let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::double? in (#0#0 as{ForNonNullableByDefault} core::double?) is{ForNonNullableByDefault} core::int?) || #0#0 is{ForNonNullableByDefault} core::Object?) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_logical_or_lhs.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/cast_inside_logical_or_lhs.dart.weak.transformed.expect
index 920720ae9dd..fedc63367f6 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_logical_or_lhs.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_logical_or_lhs.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if((let final core::double? #t1 = #0#0 as{ForNonNullableByDefault} core::double? in (#0#0 as{ForNonNullableByDefault} core::double?) is{ForNonNullableByDefault} core::int?) || #0#0 is{ForNonNullableByDefault} core::Object?) {
-      {
-        break #L1;
+    {
+      if((let final core::double? #t1 = #0#0 as{ForNonNullableByDefault} core::double? in (#0#0 as{ForNonNullableByDefault} core::double?) is{ForNonNullableByDefault} core::int?) || #0#0 is{ForNonNullableByDefault} core::Object?) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_logical_or_rhs.dart.strong.expect b/pkg/front_end/testcases/patterns/cast_inside_logical_or_rhs.dart.strong.expect
index b8f88253809..fe7b4660490 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_logical_or_rhs.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_logical_or_rhs.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int? || (let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object? in (#0#0 as{ForNonNullableByDefault} core::Object?) is{ForNonNullableByDefault} core::double?)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::int? || (let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object? in (#0#0 as{ForNonNullableByDefault} core::Object?) is{ForNonNullableByDefault} core::double?)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_logical_or_rhs.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/cast_inside_logical_or_rhs.dart.strong.transformed.expect
index d10d14a46a5..1dd7626fcb6 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_logical_or_rhs.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_logical_or_rhs.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int? || (let final core::Object? #t1 = #0#0 in #0#0 is{ForNonNullableByDefault} core::double?)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::int? || (let final core::Object? #t1 = #0#0 in #0#0 is{ForNonNullableByDefault} core::double?)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_logical_or_rhs.dart.weak.expect b/pkg/front_end/testcases/patterns/cast_inside_logical_or_rhs.dart.weak.expect
index b8f88253809..fe7b4660490 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_logical_or_rhs.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_logical_or_rhs.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int? || (let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object? in (#0#0 as{ForNonNullableByDefault} core::Object?) is{ForNonNullableByDefault} core::double?)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::int? || (let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object? in (#0#0 as{ForNonNullableByDefault} core::Object?) is{ForNonNullableByDefault} core::double?)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_logical_or_rhs.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/cast_inside_logical_or_rhs.dart.weak.modular.expect
index b8f88253809..fe7b4660490 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_logical_or_rhs.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_logical_or_rhs.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int? || (let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object? in (#0#0 as{ForNonNullableByDefault} core::Object?) is{ForNonNullableByDefault} core::double?)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::int? || (let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object? in (#0#0 as{ForNonNullableByDefault} core::Object?) is{ForNonNullableByDefault} core::double?)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_logical_or_rhs.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/cast_inside_logical_or_rhs.dart.weak.transformed.expect
index d10d14a46a5..1dd7626fcb6 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_logical_or_rhs.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_logical_or_rhs.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int? || (let final core::Object? #t1 = #0#0 in #0#0 is{ForNonNullableByDefault} core::double?)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::int? || (let final core::Object? #t1 = #0#0 in #0#0 is{ForNonNullableByDefault} core::double?)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_map_pattern.dart.strong.expect b/pkg/front_end/testcases/patterns/cast_inside_map_pattern.dart.strong.expect
index 8050981ee56..a0db99816c2 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_map_pattern.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_map_pattern.dart.strong.expect
@@ -7,9 +7,11 @@ static method test(dynamic x) → dynamic {
   {
     final synthesized dynamic #0#0 = x;
     late final synthesized dynamic #0#8 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (let final dynamic #t1 = #0#8 as{ForNonNullableByDefault} core::int in #C2 =={core::num::==}{(core::Object) → core::bool} #0#8 as{ForNonNullableByDefault} core::int)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (let final dynamic #t1 = #0#8 as{ForNonNullableByDefault} core::int in #C2 =={core::num::==}{(core::Object) → core::bool} #0#8 as{ForNonNullableByDefault} core::int)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_map_pattern.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/cast_inside_map_pattern.dart.strong.transformed.expect
index 240d3ef4100..433bdc9f76d 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_map_pattern.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_map_pattern.dart.strong.transformed.expect
@@ -9,9 +9,11 @@ static method test(dynamic x) → dynamic {
     function ##0#8#initializer() → dynamic
       return #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic};
     late final synthesized dynamic #0#8 = ##0#8#initializer(){() → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (let final core::int #t1 = #0#8 as{ForNonNullableByDefault} core::int in #C2 =={core::num::==}{(core::Object) → core::bool} #0#8 as{ForNonNullableByDefault} core::int)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (let final core::int #t1 = #0#8 as{ForNonNullableByDefault} core::int in #C2 =={core::num::==}{(core::Object) → core::bool} #0#8 as{ForNonNullableByDefault} core::int)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_map_pattern.dart.weak.expect b/pkg/front_end/testcases/patterns/cast_inside_map_pattern.dart.weak.expect
index 8050981ee56..a0db99816c2 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_map_pattern.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_map_pattern.dart.weak.expect
@@ -7,9 +7,11 @@ static method test(dynamic x) → dynamic {
   {
     final synthesized dynamic #0#0 = x;
     late final synthesized dynamic #0#8 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (let final dynamic #t1 = #0#8 as{ForNonNullableByDefault} core::int in #C2 =={core::num::==}{(core::Object) → core::bool} #0#8 as{ForNonNullableByDefault} core::int)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (let final dynamic #t1 = #0#8 as{ForNonNullableByDefault} core::int in #C2 =={core::num::==}{(core::Object) → core::bool} #0#8 as{ForNonNullableByDefault} core::int)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_map_pattern.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/cast_inside_map_pattern.dart.weak.modular.expect
index 8050981ee56..a0db99816c2 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_map_pattern.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_map_pattern.dart.weak.modular.expect
@@ -7,9 +7,11 @@ static method test(dynamic x) → dynamic {
   {
     final synthesized dynamic #0#0 = x;
     late final synthesized dynamic #0#8 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (let final dynamic #t1 = #0#8 as{ForNonNullableByDefault} core::int in #C2 =={core::num::==}{(core::Object) → core::bool} #0#8 as{ForNonNullableByDefault} core::int)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (let final dynamic #t1 = #0#8 as{ForNonNullableByDefault} core::int in #C2 =={core::num::==}{(core::Object) → core::bool} #0#8 as{ForNonNullableByDefault} core::int)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_map_pattern.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/cast_inside_map_pattern.dart.weak.transformed.expect
index 240d3ef4100..433bdc9f76d 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_map_pattern.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_map_pattern.dart.weak.transformed.expect
@@ -9,9 +9,11 @@ static method test(dynamic x) → dynamic {
     function ##0#8#initializer() → dynamic
       return #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic};
     late final synthesized dynamic #0#8 = ##0#8#initializer(){() → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (let final core::int #t1 = #0#8 as{ForNonNullableByDefault} core::int in #C2 =={core::num::==}{(core::Object) → core::bool} #0#8 as{ForNonNullableByDefault} core::int)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (let final core::int #t1 = #0#8 as{ForNonNullableByDefault} core::int in #C2 =={core::num::==}{(core::Object) → core::bool} #0#8 as{ForNonNullableByDefault} core::int)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_parenthesized_pattern.dart.strong.expect b/pkg/front_end/testcases/patterns/cast_inside_parenthesized_pattern.dart.strong.expect
index 7c52fffea33..6d39333c864 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_parenthesized_pattern.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_parenthesized_pattern.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::int) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::int) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_parenthesized_pattern.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/cast_inside_parenthesized_pattern.dart.strong.transformed.expect
index d93be5574f1..533d8b04876 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_parenthesized_pattern.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_parenthesized_pattern.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final core::int #t1 = #0#0 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::int) {
-      {
-        break #L1;
+    {
+      if(let final core::int #t1 = #0#0 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::int) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_parenthesized_pattern.dart.weak.expect b/pkg/front_end/testcases/patterns/cast_inside_parenthesized_pattern.dart.weak.expect
index 7c52fffea33..6d39333c864 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_parenthesized_pattern.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_parenthesized_pattern.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::int) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::int) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_parenthesized_pattern.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/cast_inside_parenthesized_pattern.dart.weak.modular.expect
index 7c52fffea33..6d39333c864 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_parenthesized_pattern.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_parenthesized_pattern.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::int) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::int) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_parenthesized_pattern.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/cast_inside_parenthesized_pattern.dart.weak.transformed.expect
index d93be5574f1..533d8b04876 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_parenthesized_pattern.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_parenthesized_pattern.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final core::int #t1 = #0#0 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::int) {
-      {
-        break #L1;
+    {
+      if(let final core::int #t1 = #0#0 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::int) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_record_pattern_implicitly_named.dart.strong.expect b/pkg/front_end/testcases/patterns/cast_inside_record_pattern_implicitly_named.dart.strong.expect
index f6ed021e3e6..4b2c8c6fcd8 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_record_pattern_implicitly_named.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_record_pattern_implicitly_named.dart.strong.expect
@@ -5,12 +5,14 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int n;
     final synthesized dynamic #0#0 = x;
     late final synthesized core::Object? #0#2 = #0#0{(core::Object?, {n: core::Object?})}.n{core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (let final dynamic #t1 = #0#2 as{ForNonNullableByDefault} core::int in let final dynamic #t2 = n = #0#2 as{ForNonNullableByDefault} core::int in true) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      core::int n;
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (let final dynamic #t1 = #0#2 as{ForNonNullableByDefault} core::int in let final dynamic #t2 = n = #0#2 as{ForNonNullableByDefault} core::int in true) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_record_pattern_implicitly_named.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/cast_inside_record_pattern_implicitly_named.dart.strong.transformed.expect
index afe44132ed4..4b7b5c8fdec 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_record_pattern_implicitly_named.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_record_pattern_implicitly_named.dart.strong.transformed.expect
@@ -5,14 +5,16 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int n;
     final synthesized dynamic #0#0 = x;
     function ##0#2#initializer() → core::Object?
       return #0#0{(core::Object?, {n: core::Object?})}.n{core::Object?};
     late final synthesized core::Object? #0#2 = ##0#2#initializer(){() → core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (let final core::int #t1 = #0#2 as{ForNonNullableByDefault} core::int in let final core::int #t2 = n = #0#2 as{ForNonNullableByDefault} core::int in true) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      core::int n;
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (let final core::int #t1 = #0#2 as{ForNonNullableByDefault} core::int in let final core::int #t2 = n = #0#2 as{ForNonNullableByDefault} core::int in true) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_record_pattern_implicitly_named.dart.weak.expect b/pkg/front_end/testcases/patterns/cast_inside_record_pattern_implicitly_named.dart.weak.expect
index f6ed021e3e6..4b2c8c6fcd8 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_record_pattern_implicitly_named.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_record_pattern_implicitly_named.dart.weak.expect
@@ -5,12 +5,14 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int n;
     final synthesized dynamic #0#0 = x;
     late final synthesized core::Object? #0#2 = #0#0{(core::Object?, {n: core::Object?})}.n{core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (let final dynamic #t1 = #0#2 as{ForNonNullableByDefault} core::int in let final dynamic #t2 = n = #0#2 as{ForNonNullableByDefault} core::int in true) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      core::int n;
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (let final dynamic #t1 = #0#2 as{ForNonNullableByDefault} core::int in let final dynamic #t2 = n = #0#2 as{ForNonNullableByDefault} core::int in true) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_record_pattern_implicitly_named.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/cast_inside_record_pattern_implicitly_named.dart.weak.modular.expect
index f6ed021e3e6..4b2c8c6fcd8 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_record_pattern_implicitly_named.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_record_pattern_implicitly_named.dart.weak.modular.expect
@@ -5,12 +5,14 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int n;
     final synthesized dynamic #0#0 = x;
     late final synthesized core::Object? #0#2 = #0#0{(core::Object?, {n: core::Object?})}.n{core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (let final dynamic #t1 = #0#2 as{ForNonNullableByDefault} core::int in let final dynamic #t2 = n = #0#2 as{ForNonNullableByDefault} core::int in true) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      core::int n;
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (let final dynamic #t1 = #0#2 as{ForNonNullableByDefault} core::int in let final dynamic #t2 = n = #0#2 as{ForNonNullableByDefault} core::int in true) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_record_pattern_implicitly_named.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/cast_inside_record_pattern_implicitly_named.dart.weak.transformed.expect
index afe44132ed4..4b7b5c8fdec 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_record_pattern_implicitly_named.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_record_pattern_implicitly_named.dart.weak.transformed.expect
@@ -5,14 +5,16 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int n;
     final synthesized dynamic #0#0 = x;
     function ##0#2#initializer() → core::Object?
       return #0#0{(core::Object?, {n: core::Object?})}.n{core::Object?};
     late final synthesized core::Object? #0#2 = ##0#2#initializer(){() → core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (let final core::int #t1 = #0#2 as{ForNonNullableByDefault} core::int in let final core::int #t2 = n = #0#2 as{ForNonNullableByDefault} core::int in true) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      core::int n;
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (let final core::int #t1 = #0#2 as{ForNonNullableByDefault} core::int in let final core::int #t2 = n = #0#2 as{ForNonNullableByDefault} core::int in true) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_record_pattern_named.dart.strong.expect b/pkg/front_end/testcases/patterns/cast_inside_record_pattern_named.dart.strong.expect
index 05029c0aca3..31bc80c737c 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_record_pattern_named.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_record_pattern_named.dart.strong.expect
@@ -7,9 +7,11 @@ static method test(dynamic x) → dynamic {
   {
     final synthesized dynamic #0#0 = x;
     late final synthesized core::Object? #0#2 = #0#0{(core::Object?, {n: core::Object?})}.n{core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (let final dynamic #t1 = #0#2 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 as{ForNonNullableByDefault} core::int) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (let final dynamic #t1 = #0#2 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 as{ForNonNullableByDefault} core::int) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_record_pattern_named.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/cast_inside_record_pattern_named.dart.strong.transformed.expect
index e6db5c384e6..c9ffc244781 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_record_pattern_named.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_record_pattern_named.dart.strong.transformed.expect
@@ -9,9 +9,11 @@ static method test(dynamic x) → dynamic {
     function ##0#2#initializer() → core::Object?
       return #0#0{(core::Object?, {n: core::Object?})}.n{core::Object?};
     late final synthesized core::Object? #0#2 = ##0#2#initializer(){() → core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (let final core::int #t1 = #0#2 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 as{ForNonNullableByDefault} core::int) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (let final core::int #t1 = #0#2 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 as{ForNonNullableByDefault} core::int) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_record_pattern_named.dart.weak.expect b/pkg/front_end/testcases/patterns/cast_inside_record_pattern_named.dart.weak.expect
index 05029c0aca3..31bc80c737c 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_record_pattern_named.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_record_pattern_named.dart.weak.expect
@@ -7,9 +7,11 @@ static method test(dynamic x) → dynamic {
   {
     final synthesized dynamic #0#0 = x;
     late final synthesized core::Object? #0#2 = #0#0{(core::Object?, {n: core::Object?})}.n{core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (let final dynamic #t1 = #0#2 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 as{ForNonNullableByDefault} core::int) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (let final dynamic #t1 = #0#2 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 as{ForNonNullableByDefault} core::int) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_record_pattern_named.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/cast_inside_record_pattern_named.dart.weak.modular.expect
index 05029c0aca3..31bc80c737c 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_record_pattern_named.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_record_pattern_named.dart.weak.modular.expect
@@ -7,9 +7,11 @@ static method test(dynamic x) → dynamic {
   {
     final synthesized dynamic #0#0 = x;
     late final synthesized core::Object? #0#2 = #0#0{(core::Object?, {n: core::Object?})}.n{core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (let final dynamic #t1 = #0#2 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 as{ForNonNullableByDefault} core::int) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (let final dynamic #t1 = #0#2 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 as{ForNonNullableByDefault} core::int) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_record_pattern_named.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/cast_inside_record_pattern_named.dart.weak.transformed.expect
index e6db5c384e6..c9ffc244781 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_record_pattern_named.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_record_pattern_named.dart.weak.transformed.expect
@@ -9,9 +9,11 @@ static method test(dynamic x) → dynamic {
     function ##0#2#initializer() → core::Object?
       return #0#0{(core::Object?, {n: core::Object?})}.n{core::Object?};
     late final synthesized core::Object? #0#2 = ##0#2#initializer(){() → core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (let final core::int #t1 = #0#2 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 as{ForNonNullableByDefault} core::int) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (let final core::int #t1 = #0#2 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 as{ForNonNullableByDefault} core::int) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_record_pattern_unnamed.dart.strong.expect b/pkg/front_end/testcases/patterns/cast_inside_record_pattern_unnamed.dart.strong.expect
index 420c192a5b2..fba7a52d807 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_record_pattern_unnamed.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_record_pattern_unnamed.dart.strong.expect
@@ -7,9 +7,11 @@ static method test(dynamic x) → dynamic {
   {
     final synthesized dynamic #0#0 = x;
     late final synthesized core::Object? #0#2 = #0#0{(core::Object?, core::Object?)}.$1{core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && (let final dynamic #t1 = #0#2 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 as{ForNonNullableByDefault} core::int) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && (let final dynamic #t1 = #0#2 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 as{ForNonNullableByDefault} core::int) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_record_pattern_unnamed.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/cast_inside_record_pattern_unnamed.dart.strong.transformed.expect
index 836f8f9cd3e..123fa3c2b13 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_record_pattern_unnamed.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_record_pattern_unnamed.dart.strong.transformed.expect
@@ -9,9 +9,11 @@ static method test(dynamic x) → dynamic {
     function ##0#2#initializer() → core::Object?
       return #0#0{(core::Object?, core::Object?)}.$1{core::Object?};
     late final synthesized core::Object? #0#2 = ##0#2#initializer(){() → core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && (let final core::int #t1 = #0#2 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 as{ForNonNullableByDefault} core::int) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && (let final core::int #t1 = #0#2 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 as{ForNonNullableByDefault} core::int) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_record_pattern_unnamed.dart.weak.expect b/pkg/front_end/testcases/patterns/cast_inside_record_pattern_unnamed.dart.weak.expect
index 420c192a5b2..fba7a52d807 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_record_pattern_unnamed.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_record_pattern_unnamed.dart.weak.expect
@@ -7,9 +7,11 @@ static method test(dynamic x) → dynamic {
   {
     final synthesized dynamic #0#0 = x;
     late final synthesized core::Object? #0#2 = #0#0{(core::Object?, core::Object?)}.$1{core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && (let final dynamic #t1 = #0#2 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 as{ForNonNullableByDefault} core::int) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && (let final dynamic #t1 = #0#2 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 as{ForNonNullableByDefault} core::int) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_record_pattern_unnamed.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/cast_inside_record_pattern_unnamed.dart.weak.modular.expect
index 420c192a5b2..fba7a52d807 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_record_pattern_unnamed.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_record_pattern_unnamed.dart.weak.modular.expect
@@ -7,9 +7,11 @@ static method test(dynamic x) → dynamic {
   {
     final synthesized dynamic #0#0 = x;
     late final synthesized core::Object? #0#2 = #0#0{(core::Object?, core::Object?)}.$1{core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && (let final dynamic #t1 = #0#2 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 as{ForNonNullableByDefault} core::int) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && (let final dynamic #t1 = #0#2 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 as{ForNonNullableByDefault} core::int) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/cast_inside_record_pattern_unnamed.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/cast_inside_record_pattern_unnamed.dart.weak.transformed.expect
index 836f8f9cd3e..123fa3c2b13 100644
--- a/pkg/front_end/testcases/patterns/cast_inside_record_pattern_unnamed.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/cast_inside_record_pattern_unnamed.dart.weak.transformed.expect
@@ -9,9 +9,11 @@ static method test(dynamic x) → dynamic {
     function ##0#2#initializer() → core::Object?
       return #0#0{(core::Object?, core::Object?)}.$1{core::Object?};
     late final synthesized core::Object? #0#2 = ##0#2#initializer(){() → core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && (let final core::int #t1 = #0#2 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 as{ForNonNullableByDefault} core::int) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && (let final core::int #t1 = #0#2 as{ForNonNullableByDefault} core::int in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 as{ForNonNullableByDefault} core::int) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/const_patterns.dart.strong.expect b/pkg/front_end/testcases/patterns/const_patterns.dart.strong.expect
index 6e1647bd722..04ea7f5c807 100644
--- a/pkg/front_end/testcases/patterns/const_patterns.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/const_patterns.dart.strong.expect
@@ -321,7 +321,6 @@ class Class extends core::Object /*hasConstConstructor*/  {
     dynamic variable = 0;
     #L1:
     {
-      void fun;
       final synthesized dynamic #2#0 = o;
       late final synthesized core::bool #2#2 = #C2 =={core::Object::==}{(core::Object) → core::bool} #2#0;
       late final synthesized core::bool #2#4 = #2#0 == null;
@@ -368,18 +367,21 @@ class Class extends core::Object /*hasConstConstructor*/  {
       late final synthesized core::bool #2#83 = #C17 =={core::Object::==}{(core::Object) → core::bool} #2#0;
       late final synthesized core::bool #2#87 = #C18 =={core::Type::==}{(core::Object) → core::bool} #2#0;
       late final synthesized core::bool #2#89 = #C20 =={core::Object::==}{(core::Object) → core::bool} #2#0;
-      if(#2#2 || #2#4 || invalid-expression "Not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #2#0 || invalid-expression "Not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #2#0 || invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:26:12: Error: Method invocation is not a constant expression.
+      {
+        void fun;
+        if(#2#2 || #2#4 || invalid-expression "Not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #2#0 || invalid-expression "Not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #2#0 || invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:26:12: Error: Method invocation is not a constant expression.
       case super(): // Error
            ^^^^" =={core::Object::==}{(core::Object) → core::bool} #2#0 || #2#12 || #2#14 || #C21 =={core::num::==}{(core::Object) → core::bool} #2#0 || #C22 =={core::num::==}{(core::Object) → core::bool} #2#0 || #2#20 || #C23 =={core::String::==}{(core::Object) → core::bool} #2#0 || #2#12 || (let final dynamic #t1 = #2#0! in #2#24) || (!(#2#0 == null) ?{core::bool} #2#12 : false) || (let final dynamic #t2 = #2#0! in !(#2#0! == null) ?{core::bool} #2#24 : false) || (!(#2#0 == null) ?{core::bool} let final dynamic #t3 = #2#0! in #2#24 : false) || (let final dynamic #t4 = #2#0! in #2#27) || (!(#2#0 == null) ?{core::bool} #2#14 : false) || (!(#2#0 == null) ?{core::bool} let final dynamic #t5 = #2#0! in #2#27 : false) || (let final dynamic #t6 = #2#0! in !(#2#0! == null) ?{core::bool} #2#27 : false) || (let final dynamic #t7 = #2#0 as{ForNonNullableByDefault} core::int in #C3 =={core::num::==}{(core::Object) → core::bool} #2#0 as{ForNonNullableByDefault} core::int) || #2#14 || #2#31 || #2#31 || #C24 =={core::Object::==}{(core::Object) → core::bool} #2#0 || #2#12 || #2#14 || #2#35 || #2#37 || #C25 =={core::num::==}{(core::Object) → core::bool} #2#0 || #2#0{core::int} is{ForNonNullableByDefault} void && (let final dynamic #t8 = fun = #2#0{core::int} in true)) {
-        {
-          () → Null {};
-          invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:52:25: Error: This couldn't be parsed.
+          {
+            () → Null {};
+            invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:52:25: Error: This couldn't be parsed.
       case void fun() {}: // Error
                         ^";
-          break #L1;
+            break #L1;
+          }
         }
       }
-      else
+      {
         if(invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:53:12: Error: `assert` can't be used as an expression.
       case assert(false): // Error
            ^^^^^^" =={core::Object::==}{(core::Object) → core::bool} #2#0 || invalid-expression "Not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #2#0 || invalid-expression "Not a constant expression." =={core::num::==}{(core::Object) → core::bool} #2#0 || #2#2 || #2#47 || invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:58:14: Error: Not a constant expression.
@@ -393,6 +395,7 @@ class Class extends core::Object /*hasConstConstructor*/  {
             core::print(0);
           }
         }
+      }
     }
   }
 }
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
index 6ac00a41699..209ca89dc66 100644
--- a/pkg/front_end/testcases/patterns/const_patterns.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/const_patterns.dart.strong.transformed.expect
@@ -321,7 +321,6 @@ class Class extends core::Object /*hasConstConstructor*/  {
     dynamic variable = 0;
     #L1:
     {
-      void fun;
       final synthesized dynamic #2#0 = o;
       function ##2#2#initializer() → core::bool
         return #C2 =={core::Object::==}{(core::Object) → core::bool} #2#0;
@@ -410,18 +409,21 @@ class Class extends core::Object /*hasConstConstructor*/  {
       function ##2#89#initializer() → core::bool
         return #C20 =={core::Object::==}{(core::Object) → core::bool} #2#0;
       late final synthesized core::bool #2#89 = ##2#89#initializer(){() → core::bool};
-      if(#2#2 || #2#4 || invalid-expression "Not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #2#0 || invalid-expression "Not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #2#0 || invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:26:12: Error: Method invocation is not a constant expression.
+      {
+        void fun;
+        if(#2#2 || #2#4 || invalid-expression "Not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #2#0 || invalid-expression "Not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #2#0 || invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:26:12: Error: Method invocation is not a constant expression.
       case super(): // Error
            ^^^^" =={core::Object::==}{(core::Object) → core::bool} #2#0 || #2#12 || #2#14 || #C21 =={core::num::==}{(core::Object) → core::bool} #2#0 || #C22 =={core::num::==}{(core::Object) → core::bool} #2#0 || #2#20 || #C23 =={core::String::==}{(core::Object) → core::bool} #2#0 || #2#12 || (let final dynamic #t1 = #2#0! in #2#24) || (!(#2#0 == null) ?{core::bool} #2#12 : false) || (let final dynamic #t2 = #2#0! in !(#2#0! == null) ?{core::bool} #2#24 : false) || (!(#2#0 == null) ?{core::bool} let final dynamic #t3 = #2#0! in #2#24 : false) || (let final dynamic #t4 = #2#0! in #2#27) || (!(#2#0 == null) ?{core::bool} #2#14 : false) || (!(#2#0 == null) ?{core::bool} let final dynamic #t5 = #2#0! in #2#27 : false) || (let final dynamic #t6 = #2#0! in !(#2#0! == null) ?{core::bool} #2#27 : false) || (let final core::int #t7 = #2#0 as{ForNonNullableByDefault} core::int in #C3 =={core::num::==}{(core::Object) → core::bool} #2#0 as{ForNonNullableByDefault} core::int) || #2#14 || #2#31 || #2#31 || #C24 =={core::Object::==}{(core::Object) → core::bool} #2#0 || #2#12 || #2#14 || #2#35 || #2#37 || #C25 =={core::num::==}{(core::Object) → core::bool} #2#0 || #2#0{core::int} is{ForNonNullableByDefault} void && (let final core::int #t8 = fun = #2#0{core::int} in true)) {
-        {
-          () → Null {};
-          invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:52:25: Error: This couldn't be parsed.
+          {
+            () → Null {};
+            invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:52:25: Error: This couldn't be parsed.
       case void fun() {}: // Error
                         ^";
-          break #L1;
+            break #L1;
+          }
         }
       }
-      else
+      {
         if(invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:53:12: Error: `assert` can't be used as an expression.
       case assert(false): // Error
            ^^^^^^" =={core::Object::==}{(core::Object) → core::bool} #2#0 || invalid-expression "Not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #2#0 || invalid-expression "Not a constant expression." =={core::num::==}{(core::Object) → core::bool} #2#0 || #2#2 || #2#47 || invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:58:14: Error: Not a constant expression.
@@ -435,6 +437,7 @@ class Class extends core::Object /*hasConstConstructor*/  {
             core::print(0);
           }
         }
+      }
     }
   }
 }
diff --git a/pkg/front_end/testcases/patterns/const_patterns.dart.weak.expect b/pkg/front_end/testcases/patterns/const_patterns.dart.weak.expect
index b17159c3301..17d54d551d9 100644
--- a/pkg/front_end/testcases/patterns/const_patterns.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/const_patterns.dart.weak.expect
@@ -321,7 +321,6 @@ class Class extends core::Object /*hasConstConstructor*/  {
     dynamic variable = 0;
     #L1:
     {
-      void fun;
       final synthesized dynamic #2#0 = o;
       late final synthesized core::bool #2#2 = #C2 =={core::Object::==}{(core::Object) → core::bool} #2#0;
       late final synthesized core::bool #2#4 = #2#0 == null;
@@ -368,18 +367,21 @@ class Class extends core::Object /*hasConstConstructor*/  {
       late final synthesized core::bool #2#83 = #C17 =={core::Object::==}{(core::Object) → core::bool} #2#0;
       late final synthesized core::bool #2#87 = #C18 =={core::Type::==}{(core::Object) → core::bool} #2#0;
       late final synthesized core::bool #2#89 = #C20 =={core::Object::==}{(core::Object) → core::bool} #2#0;
-      if(#2#2 || #2#4 || invalid-expression "Not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #2#0 || invalid-expression "Not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #2#0 || invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:26:12: Error: Method invocation is not a constant expression.
+      {
+        void fun;
+        if(#2#2 || #2#4 || invalid-expression "Not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #2#0 || invalid-expression "Not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #2#0 || invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:26:12: Error: Method invocation is not a constant expression.
       case super(): // Error
            ^^^^" =={core::Object::==}{(core::Object) → core::bool} #2#0 || #2#12 || #2#14 || #C21 =={core::num::==}{(core::Object) → core::bool} #2#0 || #C22 =={core::num::==}{(core::Object) → core::bool} #2#0 || #2#20 || #C23 =={core::String::==}{(core::Object) → core::bool} #2#0 || #2#12 || (let final dynamic #t1 = #2#0! in #2#24) || (!(#2#0 == null) ?{core::bool} #2#12 : false) || (let final dynamic #t2 = #2#0! in !(#2#0! == null) ?{core::bool} #2#24 : false) || (!(#2#0 == null) ?{core::bool} let final dynamic #t3 = #2#0! in #2#24 : false) || (let final dynamic #t4 = #2#0! in #2#27) || (!(#2#0 == null) ?{core::bool} #2#14 : false) || (!(#2#0 == null) ?{core::bool} let final dynamic #t5 = #2#0! in #2#27 : false) || (let final dynamic #t6 = #2#0! in !(#2#0! == null) ?{core::bool} #2#27 : false) || (let final dynamic #t7 = #2#0 as{ForNonNullableByDefault} core::int in #C3 =={core::num::==}{(core::Object) → core::bool} #2#0 as{ForNonNullableByDefault} core::int) || #2#14 || #2#31 || #2#31 || #C24 =={core::Object::==}{(core::Object) → core::bool} #2#0 || #2#12 || #2#14 || #2#35 || #2#37 || #C25 =={core::num::==}{(core::Object) → core::bool} #2#0 || #2#0{core::int} is{ForNonNullableByDefault} void && (let final dynamic #t8 = fun = #2#0{core::int} in true)) {
-        {
-          () → Null {};
-          invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:52:25: Error: This couldn't be parsed.
+          {
+            () → Null {};
+            invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:52:25: Error: This couldn't be parsed.
       case void fun() {}: // Error
                         ^";
-          break #L1;
+            break #L1;
+          }
         }
       }
-      else
+      {
         if(invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:53:12: Error: `assert` can't be used as an expression.
       case assert(false): // Error
            ^^^^^^" =={core::Object::==}{(core::Object) → core::bool} #2#0 || invalid-expression "Not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #2#0 || invalid-expression "Not a constant expression." =={core::num::==}{(core::Object) → core::bool} #2#0 || #2#2 || #2#47 || invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:58:14: Error: Not a constant expression.
@@ -393,6 +395,7 @@ class Class extends core::Object /*hasConstConstructor*/  {
             core::print(0);
           }
         }
+      }
     }
   }
 }
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
index b17159c3301..17d54d551d9 100644
--- a/pkg/front_end/testcases/patterns/const_patterns.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/const_patterns.dart.weak.modular.expect
@@ -321,7 +321,6 @@ class Class extends core::Object /*hasConstConstructor*/  {
     dynamic variable = 0;
     #L1:
     {
-      void fun;
       final synthesized dynamic #2#0 = o;
       late final synthesized core::bool #2#2 = #C2 =={core::Object::==}{(core::Object) → core::bool} #2#0;
       late final synthesized core::bool #2#4 = #2#0 == null;
@@ -368,18 +367,21 @@ class Class extends core::Object /*hasConstConstructor*/  {
       late final synthesized core::bool #2#83 = #C17 =={core::Object::==}{(core::Object) → core::bool} #2#0;
       late final synthesized core::bool #2#87 = #C18 =={core::Type::==}{(core::Object) → core::bool} #2#0;
       late final synthesized core::bool #2#89 = #C20 =={core::Object::==}{(core::Object) → core::bool} #2#0;
-      if(#2#2 || #2#4 || invalid-expression "Not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #2#0 || invalid-expression "Not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #2#0 || invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:26:12: Error: Method invocation is not a constant expression.
+      {
+        void fun;
+        if(#2#2 || #2#4 || invalid-expression "Not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #2#0 || invalid-expression "Not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #2#0 || invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:26:12: Error: Method invocation is not a constant expression.
       case super(): // Error
            ^^^^" =={core::Object::==}{(core::Object) → core::bool} #2#0 || #2#12 || #2#14 || #C21 =={core::num::==}{(core::Object) → core::bool} #2#0 || #C22 =={core::num::==}{(core::Object) → core::bool} #2#0 || #2#20 || #C23 =={core::String::==}{(core::Object) → core::bool} #2#0 || #2#12 || (let final dynamic #t1 = #2#0! in #2#24) || (!(#2#0 == null) ?{core::bool} #2#12 : false) || (let final dynamic #t2 = #2#0! in !(#2#0! == null) ?{core::bool} #2#24 : false) || (!(#2#0 == null) ?{core::bool} let final dynamic #t3 = #2#0! in #2#24 : false) || (let final dynamic #t4 = #2#0! in #2#27) || (!(#2#0 == null) ?{core::bool} #2#14 : false) || (!(#2#0 == null) ?{core::bool} let final dynamic #t5 = #2#0! in #2#27 : false) || (let final dynamic #t6 = #2#0! in !(#2#0! == null) ?{core::bool} #2#27 : false) || (let final dynamic #t7 = #2#0 as{ForNonNullableByDefault} core::int in #C3 =={core::num::==}{(core::Object) → core::bool} #2#0 as{ForNonNullableByDefault} core::int) || #2#14 || #2#31 || #2#31 || #C24 =={core::Object::==}{(core::Object) → core::bool} #2#0 || #2#12 || #2#14 || #2#35 || #2#37 || #C25 =={core::num::==}{(core::Object) → core::bool} #2#0 || #2#0{core::int} is{ForNonNullableByDefault} void && (let final dynamic #t8 = fun = #2#0{core::int} in true)) {
-        {
-          () → Null {};
-          invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:52:25: Error: This couldn't be parsed.
+          {
+            () → Null {};
+            invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:52:25: Error: This couldn't be parsed.
       case void fun() {}: // Error
                         ^";
-          break #L1;
+            break #L1;
+          }
         }
       }
-      else
+      {
         if(invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:53:12: Error: `assert` can't be used as an expression.
       case assert(false): // Error
            ^^^^^^" =={core::Object::==}{(core::Object) → core::bool} #2#0 || invalid-expression "Not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #2#0 || invalid-expression "Not a constant expression." =={core::num::==}{(core::Object) → core::bool} #2#0 || #2#2 || #2#47 || invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:58:14: Error: Not a constant expression.
@@ -393,6 +395,7 @@ class Class extends core::Object /*hasConstConstructor*/  {
             core::print(0);
           }
         }
+      }
     }
   }
 }
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
index 562e106d1fd..adb1e0672dc 100644
--- a/pkg/front_end/testcases/patterns/const_patterns.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/const_patterns.dart.weak.transformed.expect
@@ -321,7 +321,6 @@ class Class extends core::Object /*hasConstConstructor*/  {
     dynamic variable = 0;
     #L1:
     {
-      void fun;
       final synthesized dynamic #2#0 = o;
       function ##2#2#initializer() → core::bool
         return #C2 =={core::Object::==}{(core::Object) → core::bool} #2#0;
@@ -410,18 +409,21 @@ class Class extends core::Object /*hasConstConstructor*/  {
       function ##2#89#initializer() → core::bool
         return #C20 =={core::Object::==}{(core::Object) → core::bool} #2#0;
       late final synthesized core::bool #2#89 = ##2#89#initializer(){() → core::bool};
-      if(#2#2 || #2#4 || invalid-expression "Not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #2#0 || invalid-expression "Not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #2#0 || invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:26:12: Error: Method invocation is not a constant expression.
+      {
+        void fun;
+        if(#2#2 || #2#4 || invalid-expression "Not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #2#0 || invalid-expression "Not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #2#0 || invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:26:12: Error: Method invocation is not a constant expression.
       case super(): // Error
            ^^^^" =={core::Object::==}{(core::Object) → core::bool} #2#0 || #2#12 || #2#14 || #C21 =={core::num::==}{(core::Object) → core::bool} #2#0 || #C22 =={core::num::==}{(core::Object) → core::bool} #2#0 || #2#20 || #C23 =={core::String::==}{(core::Object) → core::bool} #2#0 || #2#12 || (let final dynamic #t1 = #2#0! in #2#24) || (!(#2#0 == null) ?{core::bool} #2#12 : false) || (let final dynamic #t2 = #2#0! in !(#2#0! == null) ?{core::bool} #2#24 : false) || (!(#2#0 == null) ?{core::bool} let final dynamic #t3 = #2#0! in #2#24 : false) || (let final dynamic #t4 = #2#0! in #2#27) || (!(#2#0 == null) ?{core::bool} #2#14 : false) || (!(#2#0 == null) ?{core::bool} let final dynamic #t5 = #2#0! in #2#27 : false) || (let final dynamic #t6 = #2#0! in !(#2#0! == null) ?{core::bool} #2#27 : false) || (let final core::int #t7 = #2#0 as{ForNonNullableByDefault} core::int in #C3 =={core::num::==}{(core::Object) → core::bool} #2#0 as{ForNonNullableByDefault} core::int) || #2#14 || #2#31 || #2#31 || #C24 =={core::Object::==}{(core::Object) → core::bool} #2#0 || #2#12 || #2#14 || #2#35 || #2#37 || #C25 =={core::num::==}{(core::Object) → core::bool} #2#0 || #2#0{core::int} is{ForNonNullableByDefault} void && (let final core::int #t8 = fun = #2#0{core::int} in true)) {
-        {
-          () → Null {};
-          invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:52:25: Error: This couldn't be parsed.
+          {
+            () → Null {};
+            invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:52:25: Error: This couldn't be parsed.
       case void fun() {}: // Error
                         ^";
-          break #L1;
+            break #L1;
+          }
         }
       }
-      else
+      {
         if(invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:53:12: Error: `assert` can't be used as an expression.
       case assert(false): // Error
            ^^^^^^" =={core::Object::==}{(core::Object) → core::bool} #2#0 || invalid-expression "Not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #2#0 || invalid-expression "Not a constant expression." =={core::num::==}{(core::Object) → core::bool} #2#0 || #2#2 || #2#47 || invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:58:14: Error: Not a constant expression.
@@ -435,6 +437,7 @@ class Class extends core::Object /*hasConstConstructor*/  {
             core::print(0);
           }
         }
+      }
     }
   }
 }
diff --git a/pkg/front_end/testcases/patterns/const_patterns_binary.dart.strong.expect b/pkg/front_end/testcases/patterns/const_patterns_binary.dart.strong.expect
index 94e6abd45dd..6a2df92f9c4 100644
--- a/pkg/front_end/testcases/patterns/const_patterns_binary.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/const_patterns_binary.dart.strong.expect
@@ -292,19 +292,21 @@ static method method<T extends core::Object? = dynamic>(dynamic o) → dynamic {
     final const synthesized invalid-type #0#39 = invalid-expression "pkg/front_end/testcases/patterns/const_patterns_binary.dart:85:12: Error: Not a constant expression.
     case --o: // Error
            ^";
-    if(#0#2 || #0#4 || #0#2 && #0#4 || (let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} self::method::T% in #0#6) || #C11 =={core::Object::==}{(core::Object) → core::bool} #0#0 || #0#10 || #0#12 || #0#4 || #0#14 || #0#16 || #0#2 || #0#18 || #0#20 || #0#10 || #0#16 || #0#10 || #0#20 || #0#20 || #0#18 || #0#18 || #0#22 || #0#16 || #0#16 || #0#24 || (let final dynamic #t2 = #0#0 as{ForNonNullableByDefault} self::method::T% in #0#6) || (let final dynamic #t3 = #0#0 as{ForNonNullableByDefault} self::method::T% in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} self::method::T%) || (let final dynamic #t4 = #0#0 as{ForNonNullableByDefault} core::int in #C2 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::int) || #0#10 || #0#12 || #0#4 || #0#14 || #0#16 || #0#2 || #0#18 || #0#20 || #0#10 || #0#16 || #0#10 || #0#20 || #0#20 || #0#18 || #0#18 || #0#22 || #0#16 || #0#16 || #0#24 || invalid-expression "Binary operator '==' requires receiver constant 'Object {}' of type 'Null', 'bool', 'int', 'double', or 'String', but was of type 'Object'.
+    {
+      if(#0#2 || #0#4 || #0#2 && #0#4 || (let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} self::method::T% in #0#6) || #C11 =={core::Object::==}{(core::Object) → core::bool} #0#0 || #0#10 || #0#12 || #0#4 || #0#14 || #0#16 || #0#2 || #0#18 || #0#20 || #0#10 || #0#16 || #0#10 || #0#20 || #0#20 || #0#18 || #0#18 || #0#22 || #0#16 || #0#16 || #0#24 || (let final dynamic #t2 = #0#0 as{ForNonNullableByDefault} self::method::T% in #0#6) || (let final dynamic #t3 = #0#0 as{ForNonNullableByDefault} self::method::T% in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} self::method::T%) || (let final dynamic #t4 = #0#0 as{ForNonNullableByDefault} core::int in #C2 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::int) || #0#10 || #0#12 || #0#4 || #0#14 || #0#16 || #0#2 || #0#18 || #0#20 || #0#10 || #0#16 || #0#10 || #0#20 || #0#20 || #0#18 || #0#18 || #0#22 || #0#16 || #0#16 || #0#24 || invalid-expression "Binary operator '==' requires receiver constant 'Object {}' of type 'Null', 'bool', 'int', 'double', or 'String', but was of type 'Object'.
  - 'Object' is from 'dart:core'." =={core::Object::==}{(core::Object) → core::bool} #0#0 || (let final dynamic #t5 = #0#0 as{ForNonNullableByDefault} core::List<self::method::T%> in #C12 =={core::List::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::List<self::method::T%>) || #0#10 || #0#12 || #0#4 || #0#14 || #0#16 || #0#2 || #0#18 || #0#20 || #0#10 || #0#16 || #0#10 || #0#20 || #0#20 || #0#18 || #0#18 || #0#22 || #0#16 || #0#16 || #0#24 || #0#2) {
-      {
-        let final invalid-type #t6 = invalid-expression "pkg/front_end/testcases/patterns/const_patterns_binary.dart:81:12: Error: This couldn't be parsed.
+        {
+          let final invalid-type #t6 = invalid-expression "pkg/front_end/testcases/patterns/const_patterns_binary.dart:81:12: Error: This couldn't be parsed.
     case 1 ?? 2: // Error
            ^" in #t6 == null ?{invalid-type} 2 : #t6;
-        invalid-expression "pkg/front_end/testcases/patterns/const_patterns_binary.dart:81:16: Error: This couldn't be parsed.
+          invalid-expression "pkg/front_end/testcases/patterns/const_patterns_binary.dart:81:16: Error: This couldn't be parsed.
     case 1 ?? 2: // Error
                ^";
-        break #L1;
+          break #L1;
+        }
       }
     }
-    else
+    {
       if(invalid-expression "pkg/front_end/testcases/patterns/const_patterns_binary.dart:82:10: Error: Not a constant expression.
     case o++: // Error
          ^" =={core::Object::==}{(core::Object) → core::bool} #0#0 || invalid-expression "pkg/front_end/testcases/patterns/const_patterns_binary.dart:83:10: Error: Not a constant expression.
@@ -315,6 +317,7 @@ static method method<T extends core::Object? = dynamic>(dynamic o) → dynamic {
     case --o: // Error
            ^" =={core::Object::==}{(core::Object) → core::bool} #0#0) {
       }
+    }
   }
 }
 
diff --git a/pkg/front_end/testcases/patterns/const_patterns_binary.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/const_patterns_binary.dart.strong.transformed.expect
index 3326ba0ab7e..8ac6bd7f2ba 100644
--- a/pkg/front_end/testcases/patterns/const_patterns_binary.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/const_patterns_binary.dart.strong.transformed.expect
@@ -314,19 +314,21 @@ static method method<T extends core::Object? = dynamic>(dynamic o) → dynamic {
     final const synthesized invalid-type #0#39 = invalid-expression "pkg/front_end/testcases/patterns/const_patterns_binary.dart:85:12: Error: Not a constant expression.
     case --o: // Error
            ^";
-    if(#0#2 || #0#4 || #0#2 && #0#4 || (let final self::method::T% #t1 = #0#0 as{ForNonNullableByDefault} self::method::T% in #0#6) || #C11 =={core::Object::==}{(core::Object) → core::bool} #0#0 || #0#10 || #0#12 || #0#4 || #0#14 || #0#16 || #0#2 || #0#18 || #0#20 || #0#10 || #0#16 || #0#10 || #0#20 || #0#20 || #0#18 || #0#18 || #0#22 || #0#16 || #0#16 || #0#24 || (let final self::method::T% #t2 = #0#0 as{ForNonNullableByDefault} self::method::T% in #0#6) || (let final self::method::T% #t3 = #0#0 as{ForNonNullableByDefault} self::method::T% in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} self::method::T%) || (let final core::int #t4 = #0#0 as{ForNonNullableByDefault} core::int in #C2 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::int) || #0#10 || #0#12 || #0#4 || #0#14 || #0#16 || #0#2 || #0#18 || #0#20 || #0#10 || #0#16 || #0#10 || #0#20 || #0#20 || #0#18 || #0#18 || #0#22 || #0#16 || #0#16 || #0#24 || invalid-expression "Binary operator '==' requires receiver constant 'Object {}' of type 'Null', 'bool', 'int', 'double', or 'String', but was of type 'Object'.
+    {
+      if(#0#2 || #0#4 || #0#2 && #0#4 || (let final self::method::T% #t1 = #0#0 as{ForNonNullableByDefault} self::method::T% in #0#6) || #C11 =={core::Object::==}{(core::Object) → core::bool} #0#0 || #0#10 || #0#12 || #0#4 || #0#14 || #0#16 || #0#2 || #0#18 || #0#20 || #0#10 || #0#16 || #0#10 || #0#20 || #0#20 || #0#18 || #0#18 || #0#22 || #0#16 || #0#16 || #0#24 || (let final self::method::T% #t2 = #0#0 as{ForNonNullableByDefault} self::method::T% in #0#6) || (let final self::method::T% #t3 = #0#0 as{ForNonNullableByDefault} self::method::T% in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} self::method::T%) || (let final core::int #t4 = #0#0 as{ForNonNullableByDefault} core::int in #C2 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::int) || #0#10 || #0#12 || #0#4 || #0#14 || #0#16 || #0#2 || #0#18 || #0#20 || #0#10 || #0#16 || #0#10 || #0#20 || #0#20 || #0#18 || #0#18 || #0#22 || #0#16 || #0#16 || #0#24 || invalid-expression "Binary operator '==' requires receiver constant 'Object {}' of type 'Null', 'bool', 'int', 'double', or 'String', but was of type 'Object'.
  - 'Object' is from 'dart:core'." =={core::Object::==}{(core::Object) → core::bool} #0#0 || (let final core::List<self::method::T%> #t5 = #0#0 as{ForNonNullableByDefault} core::List<self::method::T%> in #C12 =={core::List::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::List<self::method::T%>) || #0#10 || #0#12 || #0#4 || #0#14 || #0#16 || #0#2 || #0#18 || #0#20 || #0#10 || #0#16 || #0#10 || #0#20 || #0#20 || #0#18 || #0#18 || #0#22 || #0#16 || #0#16 || #0#24 || #0#2) {
-      {
-        let final invalid-type #t6 = invalid-expression "pkg/front_end/testcases/patterns/const_patterns_binary.dart:81:12: Error: This couldn't be parsed.
+        {
+          let final invalid-type #t6 = invalid-expression "pkg/front_end/testcases/patterns/const_patterns_binary.dart:81:12: Error: This couldn't be parsed.
     case 1 ?? 2: // Error
            ^" in #t6 == null ?{invalid-type} 2 : #t6;
-        invalid-expression "pkg/front_end/testcases/patterns/const_patterns_binary.dart:81:16: Error: This couldn't be parsed.
+          invalid-expression "pkg/front_end/testcases/patterns/const_patterns_binary.dart:81:16: Error: This couldn't be parsed.
     case 1 ?? 2: // Error
                ^";
-        break #L1;
+          break #L1;
+        }
       }
     }
-    else
+    {
       if(invalid-expression "pkg/front_end/testcases/patterns/const_patterns_binary.dart:82:10: Error: Not a constant expression.
     case o++: // Error
          ^" =={core::Object::==}{(core::Object) → core::bool} #0#0 || invalid-expression "pkg/front_end/testcases/patterns/const_patterns_binary.dart:83:10: Error: Not a constant expression.
@@ -337,6 +339,7 @@ static method method<T extends core::Object? = dynamic>(dynamic o) → dynamic {
     case --o: // Error
            ^" =={core::Object::==}{(core::Object) → core::bool} #0#0) {
       }
+    }
   }
 }
 
diff --git a/pkg/front_end/testcases/patterns/const_patterns_binary.dart.weak.expect b/pkg/front_end/testcases/patterns/const_patterns_binary.dart.weak.expect
index 75c3cec594d..1a727926512 100644
--- a/pkg/front_end/testcases/patterns/const_patterns_binary.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/const_patterns_binary.dart.weak.expect
@@ -292,19 +292,21 @@ static method method<T extends core::Object? = dynamic>(dynamic o) → dynamic {
     final const synthesized invalid-type #0#39 = invalid-expression "pkg/front_end/testcases/patterns/const_patterns_binary.dart:85:12: Error: Not a constant expression.
     case --o: // Error
            ^";
-    if(#0#2 || #0#4 || #0#2 && #0#4 || (let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} self::method::T% in #0#6) || #C11 =={core::Object::==}{(core::Object) → core::bool} #0#0 || #0#10 || #0#12 || #0#4 || #0#14 || #0#16 || #0#2 || #0#18 || #0#20 || #0#10 || #0#16 || #0#10 || #0#20 || #0#20 || #0#18 || #0#18 || #0#22 || #0#16 || #0#16 || #0#24 || (let final dynamic #t2 = #0#0 as{ForNonNullableByDefault} self::method::T% in #0#6) || (let final dynamic #t3 = #0#0 as{ForNonNullableByDefault} self::method::T% in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} self::method::T%) || (let final dynamic #t4 = #0#0 as{ForNonNullableByDefault} core::int in #C2 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::int) || #0#10 || #0#12 || #0#4 || #0#14 || #0#16 || #0#2 || #0#18 || #0#20 || #0#10 || #0#16 || #0#10 || #0#20 || #0#20 || #0#18 || #0#18 || #0#22 || #0#16 || #0#16 || #0#24 || invalid-expression "Binary operator '==' requires receiver constant 'Object {}' of type 'Null', 'bool', 'int', 'double', or 'String', but was of type 'Object'.
+    {
+      if(#0#2 || #0#4 || #0#2 && #0#4 || (let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} self::method::T% in #0#6) || #C11 =={core::Object::==}{(core::Object) → core::bool} #0#0 || #0#10 || #0#12 || #0#4 || #0#14 || #0#16 || #0#2 || #0#18 || #0#20 || #0#10 || #0#16 || #0#10 || #0#20 || #0#20 || #0#18 || #0#18 || #0#22 || #0#16 || #0#16 || #0#24 || (let final dynamic #t2 = #0#0 as{ForNonNullableByDefault} self::method::T% in #0#6) || (let final dynamic #t3 = #0#0 as{ForNonNullableByDefault} self::method::T% in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} self::method::T%) || (let final dynamic #t4 = #0#0 as{ForNonNullableByDefault} core::int in #C2 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::int) || #0#10 || #0#12 || #0#4 || #0#14 || #0#16 || #0#2 || #0#18 || #0#20 || #0#10 || #0#16 || #0#10 || #0#20 || #0#20 || #0#18 || #0#18 || #0#22 || #0#16 || #0#16 || #0#24 || invalid-expression "Binary operator '==' requires receiver constant 'Object {}' of type 'Null', 'bool', 'int', 'double', or 'String', but was of type 'Object'.
  - 'Object' is from 'dart:core'." =={core::Object::==}{(core::Object) → core::bool} #0#0 || (let final dynamic #t5 = #0#0 as{ForNonNullableByDefault} core::List<self::method::T%> in #C12 =={core::List::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::List<self::method::T%>) || #0#10 || #0#12 || #0#4 || #0#14 || #0#16 || #0#2 || #0#18 || #0#20 || #0#10 || #0#16 || #0#10 || #0#20 || #0#20 || #0#18 || #0#18 || #0#22 || #0#16 || #0#16 || #0#24 || #0#2) {
-      {
-        let final invalid-type #t6 = invalid-expression "pkg/front_end/testcases/patterns/const_patterns_binary.dart:81:12: Error: This couldn't be parsed.
+        {
+          let final invalid-type #t6 = invalid-expression "pkg/front_end/testcases/patterns/const_patterns_binary.dart:81:12: Error: This couldn't be parsed.
     case 1 ?? 2: // Error
            ^" in #t6 == null ?{invalid-type} 2 : #t6;
-        invalid-expression "pkg/front_end/testcases/patterns/const_patterns_binary.dart:81:16: Error: This couldn't be parsed.
+          invalid-expression "pkg/front_end/testcases/patterns/const_patterns_binary.dart:81:16: Error: This couldn't be parsed.
     case 1 ?? 2: // Error
                ^";
-        break #L1;
+          break #L1;
+        }
       }
     }
-    else
+    {
       if(invalid-expression "pkg/front_end/testcases/patterns/const_patterns_binary.dart:82:10: Error: Not a constant expression.
     case o++: // Error
          ^" =={core::Object::==}{(core::Object) → core::bool} #0#0 || invalid-expression "pkg/front_end/testcases/patterns/const_patterns_binary.dart:83:10: Error: Not a constant expression.
@@ -315,6 +317,7 @@ static method method<T extends core::Object? = dynamic>(dynamic o) → dynamic {
     case --o: // Error
            ^" =={core::Object::==}{(core::Object) → core::bool} #0#0) {
       }
+    }
   }
 }
 
diff --git a/pkg/front_end/testcases/patterns/const_patterns_binary.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/const_patterns_binary.dart.weak.modular.expect
index 75c3cec594d..1a727926512 100644
--- a/pkg/front_end/testcases/patterns/const_patterns_binary.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/const_patterns_binary.dart.weak.modular.expect
@@ -292,19 +292,21 @@ static method method<T extends core::Object? = dynamic>(dynamic o) → dynamic {
     final const synthesized invalid-type #0#39 = invalid-expression "pkg/front_end/testcases/patterns/const_patterns_binary.dart:85:12: Error: Not a constant expression.
     case --o: // Error
            ^";
-    if(#0#2 || #0#4 || #0#2 && #0#4 || (let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} self::method::T% in #0#6) || #C11 =={core::Object::==}{(core::Object) → core::bool} #0#0 || #0#10 || #0#12 || #0#4 || #0#14 || #0#16 || #0#2 || #0#18 || #0#20 || #0#10 || #0#16 || #0#10 || #0#20 || #0#20 || #0#18 || #0#18 || #0#22 || #0#16 || #0#16 || #0#24 || (let final dynamic #t2 = #0#0 as{ForNonNullableByDefault} self::method::T% in #0#6) || (let final dynamic #t3 = #0#0 as{ForNonNullableByDefault} self::method::T% in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} self::method::T%) || (let final dynamic #t4 = #0#0 as{ForNonNullableByDefault} core::int in #C2 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::int) || #0#10 || #0#12 || #0#4 || #0#14 || #0#16 || #0#2 || #0#18 || #0#20 || #0#10 || #0#16 || #0#10 || #0#20 || #0#20 || #0#18 || #0#18 || #0#22 || #0#16 || #0#16 || #0#24 || invalid-expression "Binary operator '==' requires receiver constant 'Object {}' of type 'Null', 'bool', 'int', 'double', or 'String', but was of type 'Object'.
+    {
+      if(#0#2 || #0#4 || #0#2 && #0#4 || (let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} self::method::T% in #0#6) || #C11 =={core::Object::==}{(core::Object) → core::bool} #0#0 || #0#10 || #0#12 || #0#4 || #0#14 || #0#16 || #0#2 || #0#18 || #0#20 || #0#10 || #0#16 || #0#10 || #0#20 || #0#20 || #0#18 || #0#18 || #0#22 || #0#16 || #0#16 || #0#24 || (let final dynamic #t2 = #0#0 as{ForNonNullableByDefault} self::method::T% in #0#6) || (let final dynamic #t3 = #0#0 as{ForNonNullableByDefault} self::method::T% in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} self::method::T%) || (let final dynamic #t4 = #0#0 as{ForNonNullableByDefault} core::int in #C2 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::int) || #0#10 || #0#12 || #0#4 || #0#14 || #0#16 || #0#2 || #0#18 || #0#20 || #0#10 || #0#16 || #0#10 || #0#20 || #0#20 || #0#18 || #0#18 || #0#22 || #0#16 || #0#16 || #0#24 || invalid-expression "Binary operator '==' requires receiver constant 'Object {}' of type 'Null', 'bool', 'int', 'double', or 'String', but was of type 'Object'.
  - 'Object' is from 'dart:core'." =={core::Object::==}{(core::Object) → core::bool} #0#0 || (let final dynamic #t5 = #0#0 as{ForNonNullableByDefault} core::List<self::method::T%> in #C12 =={core::List::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::List<self::method::T%>) || #0#10 || #0#12 || #0#4 || #0#14 || #0#16 || #0#2 || #0#18 || #0#20 || #0#10 || #0#16 || #0#10 || #0#20 || #0#20 || #0#18 || #0#18 || #0#22 || #0#16 || #0#16 || #0#24 || #0#2) {
-      {
-        let final invalid-type #t6 = invalid-expression "pkg/front_end/testcases/patterns/const_patterns_binary.dart:81:12: Error: This couldn't be parsed.
+        {
+          let final invalid-type #t6 = invalid-expression "pkg/front_end/testcases/patterns/const_patterns_binary.dart:81:12: Error: This couldn't be parsed.
     case 1 ?? 2: // Error
            ^" in #t6 == null ?{invalid-type} 2 : #t6;
-        invalid-expression "pkg/front_end/testcases/patterns/const_patterns_binary.dart:81:16: Error: This couldn't be parsed.
+          invalid-expression "pkg/front_end/testcases/patterns/const_patterns_binary.dart:81:16: Error: This couldn't be parsed.
     case 1 ?? 2: // Error
                ^";
-        break #L1;
+          break #L1;
+        }
       }
     }
-    else
+    {
       if(invalid-expression "pkg/front_end/testcases/patterns/const_patterns_binary.dart:82:10: Error: Not a constant expression.
     case o++: // Error
          ^" =={core::Object::==}{(core::Object) → core::bool} #0#0 || invalid-expression "pkg/front_end/testcases/patterns/const_patterns_binary.dart:83:10: Error: Not a constant expression.
@@ -315,6 +317,7 @@ static method method<T extends core::Object? = dynamic>(dynamic o) → dynamic {
     case --o: // Error
            ^" =={core::Object::==}{(core::Object) → core::bool} #0#0) {
       }
+    }
   }
 }
 
diff --git a/pkg/front_end/testcases/patterns/const_patterns_binary.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/const_patterns_binary.dart.weak.transformed.expect
index e9be82ada9f..9306e4a030a 100644
--- a/pkg/front_end/testcases/patterns/const_patterns_binary.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/const_patterns_binary.dart.weak.transformed.expect
@@ -314,19 +314,21 @@ static method method<T extends core::Object? = dynamic>(dynamic o) → dynamic {
     final const synthesized invalid-type #0#39 = invalid-expression "pkg/front_end/testcases/patterns/const_patterns_binary.dart:85:12: Error: Not a constant expression.
     case --o: // Error
            ^";
-    if(#0#2 || #0#4 || #0#2 && #0#4 || (let final self::method::T% #t1 = #0#0 as{ForNonNullableByDefault} self::method::T% in #0#6) || #C11 =={core::Object::==}{(core::Object) → core::bool} #0#0 || #0#10 || #0#12 || #0#4 || #0#14 || #0#16 || #0#2 || #0#18 || #0#20 || #0#10 || #0#16 || #0#10 || #0#20 || #0#20 || #0#18 || #0#18 || #0#22 || #0#16 || #0#16 || #0#24 || (let final self::method::T% #t2 = #0#0 as{ForNonNullableByDefault} self::method::T% in #0#6) || (let final self::method::T% #t3 = #0#0 as{ForNonNullableByDefault} self::method::T% in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} self::method::T%) || (let final core::int #t4 = #0#0 as{ForNonNullableByDefault} core::int in #C2 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::int) || #0#10 || #0#12 || #0#4 || #0#14 || #0#16 || #0#2 || #0#18 || #0#20 || #0#10 || #0#16 || #0#10 || #0#20 || #0#20 || #0#18 || #0#18 || #0#22 || #0#16 || #0#16 || #0#24 || invalid-expression "Binary operator '==' requires receiver constant 'Object {}' of type 'Null', 'bool', 'int', 'double', or 'String', but was of type 'Object'.
+    {
+      if(#0#2 || #0#4 || #0#2 && #0#4 || (let final self::method::T% #t1 = #0#0 as{ForNonNullableByDefault} self::method::T% in #0#6) || #C11 =={core::Object::==}{(core::Object) → core::bool} #0#0 || #0#10 || #0#12 || #0#4 || #0#14 || #0#16 || #0#2 || #0#18 || #0#20 || #0#10 || #0#16 || #0#10 || #0#20 || #0#20 || #0#18 || #0#18 || #0#22 || #0#16 || #0#16 || #0#24 || (let final self::method::T% #t2 = #0#0 as{ForNonNullableByDefault} self::method::T% in #0#6) || (let final self::method::T% #t3 = #0#0 as{ForNonNullableByDefault} self::method::T% in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} self::method::T%) || (let final core::int #t4 = #0#0 as{ForNonNullableByDefault} core::int in #C2 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::int) || #0#10 || #0#12 || #0#4 || #0#14 || #0#16 || #0#2 || #0#18 || #0#20 || #0#10 || #0#16 || #0#10 || #0#20 || #0#20 || #0#18 || #0#18 || #0#22 || #0#16 || #0#16 || #0#24 || invalid-expression "Binary operator '==' requires receiver constant 'Object {}' of type 'Null', 'bool', 'int', 'double', or 'String', but was of type 'Object'.
  - 'Object' is from 'dart:core'." =={core::Object::==}{(core::Object) → core::bool} #0#0 || (let final core::List<self::method::T%> #t5 = #0#0 as{ForNonNullableByDefault} core::List<self::method::T%> in #C12 =={core::List::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::List<self::method::T%>) || #0#10 || #0#12 || #0#4 || #0#14 || #0#16 || #0#2 || #0#18 || #0#20 || #0#10 || #0#16 || #0#10 || #0#20 || #0#20 || #0#18 || #0#18 || #0#22 || #0#16 || #0#16 || #0#24 || #0#2) {
-      {
-        let final invalid-type #t6 = invalid-expression "pkg/front_end/testcases/patterns/const_patterns_binary.dart:81:12: Error: This couldn't be parsed.
+        {
+          let final invalid-type #t6 = invalid-expression "pkg/front_end/testcases/patterns/const_patterns_binary.dart:81:12: Error: This couldn't be parsed.
     case 1 ?? 2: // Error
            ^" in #t6 == null ?{invalid-type} 2 : #t6;
-        invalid-expression "pkg/front_end/testcases/patterns/const_patterns_binary.dart:81:16: Error: This couldn't be parsed.
+          invalid-expression "pkg/front_end/testcases/patterns/const_patterns_binary.dart:81:16: Error: This couldn't be parsed.
     case 1 ?? 2: // Error
                ^";
-        break #L1;
+          break #L1;
+        }
       }
     }
-    else
+    {
       if(invalid-expression "pkg/front_end/testcases/patterns/const_patterns_binary.dart:82:10: Error: Not a constant expression.
     case o++: // Error
          ^" =={core::Object::==}{(core::Object) → core::bool} #0#0 || invalid-expression "pkg/front_end/testcases/patterns/const_patterns_binary.dart:83:10: Error: Not a constant expression.
@@ -337,6 +339,7 @@ static method method<T extends core::Object? = dynamic>(dynamic o) → dynamic {
     case --o: // Error
            ^" =={core::Object::==}{(core::Object) → core::bool} #0#0) {
       }
+    }
   }
 }
 
diff --git a/pkg/front_end/testcases/patterns/constant_identifier_inside_case.dart.strong.expect b/pkg/front_end/testcases/patterns/constant_identifier_inside_case.dart.strong.expect
index 345f852ec43..78d52d9158e 100644
--- a/pkg/front_end/testcases/patterns/constant_identifier_inside_case.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/constant_identifier_inside_case.dart.strong.expect
@@ -4,13 +4,12 @@ import "dart:core" as core;
 
 static method test(dynamic x) → dynamic {
   #L1:
-  {
-    final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+  switch(x) {
+    #L2:
+    case #C1:
       {
         break #L1;
       }
-    }
   }
 }
 
diff --git a/pkg/front_end/testcases/patterns/constant_identifier_inside_case.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/constant_identifier_inside_case.dart.strong.transformed.expect
index 345f852ec43..78d52d9158e 100644
--- a/pkg/front_end/testcases/patterns/constant_identifier_inside_case.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/constant_identifier_inside_case.dart.strong.transformed.expect
@@ -4,13 +4,12 @@ import "dart:core" as core;
 
 static method test(dynamic x) → dynamic {
   #L1:
-  {
-    final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+  switch(x) {
+    #L2:
+    case #C1:
       {
         break #L1;
       }
-    }
   }
 }
 
diff --git a/pkg/front_end/testcases/patterns/constant_identifier_inside_case.dart.weak.expect b/pkg/front_end/testcases/patterns/constant_identifier_inside_case.dart.weak.expect
index 345f852ec43..78d52d9158e 100644
--- a/pkg/front_end/testcases/patterns/constant_identifier_inside_case.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/constant_identifier_inside_case.dart.weak.expect
@@ -4,13 +4,12 @@ import "dart:core" as core;
 
 static method test(dynamic x) → dynamic {
   #L1:
-  {
-    final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+  switch(x) {
+    #L2:
+    case #C1:
       {
         break #L1;
       }
-    }
   }
 }
 
diff --git a/pkg/front_end/testcases/patterns/constant_identifier_inside_case.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/constant_identifier_inside_case.dart.weak.modular.expect
index 345f852ec43..78d52d9158e 100644
--- a/pkg/front_end/testcases/patterns/constant_identifier_inside_case.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/constant_identifier_inside_case.dart.weak.modular.expect
@@ -4,13 +4,12 @@ import "dart:core" as core;
 
 static method test(dynamic x) → dynamic {
   #L1:
-  {
-    final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+  switch(x) {
+    #L2:
+    case #C1:
       {
         break #L1;
       }
-    }
   }
 }
 
diff --git a/pkg/front_end/testcases/patterns/constant_identifier_inside_case.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/constant_identifier_inside_case.dart.weak.transformed.expect
index 345f852ec43..78d52d9158e 100644
--- a/pkg/front_end/testcases/patterns/constant_identifier_inside_case.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/constant_identifier_inside_case.dart.weak.transformed.expect
@@ -4,13 +4,12 @@ import "dart:core" as core;
 
 static method test(dynamic x) → dynamic {
   #L1:
-  {
-    final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+  switch(x) {
+    #L2:
+    case #C1:
       {
         break #L1;
       }
-    }
   }
 }
 
diff --git a/pkg/front_end/testcases/patterns/constant_identifier_inside_cast.dart.strong.expect b/pkg/front_end/testcases/patterns/constant_identifier_inside_cast.dart.strong.expect
index 663e02f4ddf..d77d21dfa9c 100644
--- a/pkg/front_end/testcases/patterns/constant_identifier_inside_cast.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/constant_identifier_inside_cast.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::Object) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::Object) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/constant_identifier_inside_cast.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/constant_identifier_inside_cast.dart.strong.transformed.expect
index b4a55240812..488b36eee35 100644
--- a/pkg/front_end/testcases/patterns/constant_identifier_inside_cast.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/constant_identifier_inside_cast.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final core::Object #t1 = let dynamic #t2 = #0#0 in #t2 == null ?{core::Object} #t2 as{ForNonNullableByDefault} core::Object : #t2{core::Object} in #C1 =={core::num::==}{(core::Object) → core::bool} (let dynamic #t3 = #0#0 in #t3 == null ?{core::Object} #t3 as{ForNonNullableByDefault} core::Object : #t3{core::Object})) {
-      {
-        break #L1;
+    {
+      if(let final core::Object #t1 = let dynamic #t2 = #0#0 in #t2 == null ?{core::Object} #t2 as{ForNonNullableByDefault} core::Object : #t2{core::Object} in #C1 =={core::num::==}{(core::Object) → core::bool} (let dynamic #t3 = #0#0 in #t3 == null ?{core::Object} #t3 as{ForNonNullableByDefault} core::Object : #t3{core::Object})) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/constant_identifier_inside_cast.dart.weak.expect b/pkg/front_end/testcases/patterns/constant_identifier_inside_cast.dart.weak.expect
index 663e02f4ddf..d77d21dfa9c 100644
--- a/pkg/front_end/testcases/patterns/constant_identifier_inside_cast.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/constant_identifier_inside_cast.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::Object) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::Object) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/constant_identifier_inside_cast.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/constant_identifier_inside_cast.dart.weak.modular.expect
index 663e02f4ddf..d77d21dfa9c 100644
--- a/pkg/front_end/testcases/patterns/constant_identifier_inside_cast.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/constant_identifier_inside_cast.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::Object) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::Object) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/constant_identifier_inside_cast.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/constant_identifier_inside_cast.dart.weak.transformed.expect
index 6f92fed796f..5053cc6fde4 100644
--- a/pkg/front_end/testcases/patterns/constant_identifier_inside_cast.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/constant_identifier_inside_cast.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final core::Object #t1 = #0#0 in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        break #L1;
+    {
+      if(let final core::Object #t1 = #0#0 in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/constant_identifier_inside_null_assert.dart.strong.expect b/pkg/front_end/testcases/patterns/constant_identifier_inside_null_assert.dart.strong.expect
index 7d8550841b3..b2bc2051445 100644
--- a/pkg/front_end/testcases/patterns/constant_identifier_inside_null_assert.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/constant_identifier_inside_null_assert.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/constant_identifier_inside_null_assert.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/constant_identifier_inside_null_assert.dart.strong.transformed.expect
index 7d8550841b3..b2bc2051445 100644
--- a/pkg/front_end/testcases/patterns/constant_identifier_inside_null_assert.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/constant_identifier_inside_null_assert.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/constant_identifier_inside_null_assert.dart.weak.expect b/pkg/front_end/testcases/patterns/constant_identifier_inside_null_assert.dart.weak.expect
index 7d8550841b3..b2bc2051445 100644
--- a/pkg/front_end/testcases/patterns/constant_identifier_inside_null_assert.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/constant_identifier_inside_null_assert.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/constant_identifier_inside_null_assert.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/constant_identifier_inside_null_assert.dart.weak.modular.expect
index 7d8550841b3..b2bc2051445 100644
--- a/pkg/front_end/testcases/patterns/constant_identifier_inside_null_assert.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/constant_identifier_inside_null_assert.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/constant_identifier_inside_null_assert.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/constant_identifier_inside_null_assert.dart.weak.transformed.expect
index 7d8550841b3..b2bc2051445 100644
--- a/pkg/front_end/testcases/patterns/constant_identifier_inside_null_assert.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/constant_identifier_inside_null_assert.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/constant_identifier_inside_null_check.dart.strong.expect b/pkg/front_end/testcases/patterns/constant_identifier_inside_null_check.dart.strong.expect
index bce0857c6fe..0217a608547 100644
--- a/pkg/front_end/testcases/patterns/constant_identifier_inside_null_check.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/constant_identifier_inside_null_check.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/constant_identifier_inside_null_check.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/constant_identifier_inside_null_check.dart.strong.transformed.expect
index bce0857c6fe..0217a608547 100644
--- a/pkg/front_end/testcases/patterns/constant_identifier_inside_null_check.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/constant_identifier_inside_null_check.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/constant_identifier_inside_null_check.dart.weak.expect b/pkg/front_end/testcases/patterns/constant_identifier_inside_null_check.dart.weak.expect
index bce0857c6fe..0217a608547 100644
--- a/pkg/front_end/testcases/patterns/constant_identifier_inside_null_check.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/constant_identifier_inside_null_check.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/constant_identifier_inside_null_check.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/constant_identifier_inside_null_check.dart.weak.modular.expect
index bce0857c6fe..0217a608547 100644
--- a/pkg/front_end/testcases/patterns/constant_identifier_inside_null_check.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/constant_identifier_inside_null_check.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/constant_identifier_inside_null_check.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/constant_identifier_inside_null_check.dart.weak.transformed.expect
index bce0857c6fe..0217a608547 100644
--- a/pkg/front_end/testcases/patterns/constant_identifier_inside_null_check.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/constant_identifier_inside_null_check.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/constant_pattern_in_switch.dart.strong.expect b/pkg/front_end/testcases/patterns/constant_pattern_in_switch.dart.strong.expect
index 5a2d4dd2c3e..394c8d124eb 100644
--- a/pkg/front_end/testcases/patterns/constant_pattern_in_switch.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/constant_pattern_in_switch.dart.strong.expect
@@ -28,69 +28,61 @@ static method main() → dynamic {
 static method test(dynamic value, core::bool expected) → void {
   core::bool matched;
   #L1:
-  {
-    final synthesized dynamic #0#0 = value;
-    if(#C2 =={core::List::==}{(core::Object) → core::bool} #0#0) {
+  switch(value) {
+    #L2:
+    case #C2:
       {
         matched = true;
         break #L1;
       }
-    }
-    else
-      if(#C3 =={core::List::==}{(core::Object) → core::bool} #0#0) {
-        {
-          matched = true;
-          break #L1;
-        }
+    #L3:
+    case #C3:
+      {
+        matched = true;
+        break #L1;
+      }
+    #L4:
+    case #C4:
+      {
+        matched = true;
+        break #L1;
+      }
+    #L5:
+    case #C5:
+      {
+        matched = true;
+        break #L1;
+      }
+    #L6:
+    case #C7:
+      {
+        matched = true;
+        break #L1;
+      }
+    #L7:
+    case #C8:
+      {
+        matched = true;
+        break #L1;
+      }
+    #L8:
+    case #C9:
+      {
+        matched = true;
+        break #L1;
+      }
+    #L9:
+    case #C10:
+      {
+        matched = true;
+        break #L1;
+      }
+    #L10:
+    default:
+      {
+        matched = false;
+        break #L1;
       }
-      else
-        if(#C4 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-          {
-            matched = true;
-            break #L1;
-          }
-        }
-        else
-          if(#C5 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-            {
-              matched = true;
-              break #L1;
-            }
-          }
-          else
-            if(#C7 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-              {
-                matched = true;
-                break #L1;
-              }
-            }
-            else
-              if(#C8 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-                {
-                  matched = true;
-                  break #L1;
-                }
-              }
-              else
-                if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-                  {
-                    matched = true;
-                    break #L1;
-                  }
-                }
-                else
-                  if(#C10 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-                    {
-                      matched = true;
-                      break #L1;
-                    }
-                  }
-                  else {
-                    {
-                      matched = false;
-                      break #L1;
-                    }
-                  }
   }
   if(!(matched =={core::Object::==}{(core::Object) → core::bool} expected)) {
     core::print("FAIL: ${value} ${matched ?{core::String} "matched" : "didn't match"}");
diff --git a/pkg/front_end/testcases/patterns/constant_pattern_in_switch.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/constant_pattern_in_switch.dart.strong.transformed.expect
index 245505e2894..62c92cb1ec1 100644
--- a/pkg/front_end/testcases/patterns/constant_pattern_in_switch.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/constant_pattern_in_switch.dart.strong.transformed.expect
@@ -28,69 +28,61 @@ static method main() → dynamic {
 static method test(dynamic value, core::bool expected) → void {
   core::bool matched;
   #L1:
-  {
-    final synthesized dynamic #0#0 = value;
-    if(#C2 =={core::List::==}{(core::Object) → core::bool} #0#0) {
+  switch(value) {
+    #L2:
+    case #C2:
       {
         matched = true;
         break #L1;
       }
-    }
-    else
-      if(#C3 =={core::List::==}{(core::Object) → core::bool} #0#0) {
-        {
-          matched = true;
-          break #L1;
-        }
+    #L3:
+    case #C3:
+      {
+        matched = true;
+        break #L1;
+      }
+    #L4:
+    case #C4:
+      {
+        matched = true;
+        break #L1;
+      }
+    #L5:
+    case #C5:
+      {
+        matched = true;
+        break #L1;
+      }
+    #L6:
+    case #C7:
+      {
+        matched = true;
+        break #L1;
+      }
+    #L7:
+    case #C8:
+      {
+        matched = true;
+        break #L1;
+      }
+    #L8:
+    case #C9:
+      {
+        matched = true;
+        break #L1;
+      }
+    #L9:
+    case #C10:
+      {
+        matched = true;
+        break #L1;
+      }
+    #L10:
+    default:
+      {
+        matched = false;
+        break #L1;
       }
-      else
-        if(#C4 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-          {
-            matched = true;
-            break #L1;
-          }
-        }
-        else
-          if(#C5 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-            {
-              matched = true;
-              break #L1;
-            }
-          }
-          else
-            if(#C7 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-              {
-                matched = true;
-                break #L1;
-              }
-            }
-            else
-              if(#C8 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-                {
-                  matched = true;
-                  break #L1;
-                }
-              }
-              else
-                if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-                  {
-                    matched = true;
-                    break #L1;
-                  }
-                }
-                else
-                  if(#C10 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-                    {
-                      matched = true;
-                      break #L1;
-                    }
-                  }
-                  else {
-                    {
-                      matched = false;
-                      break #L1;
-                    }
-                  }
   }
   if(!(matched =={core::Object::==}{(core::Object) → core::bool} expected)) {
     core::print("FAIL: ${value} ${matched ?{core::String} "matched" : "didn't match"}");
diff --git a/pkg/front_end/testcases/patterns/constant_pattern_in_switch.dart.weak.expect b/pkg/front_end/testcases/patterns/constant_pattern_in_switch.dart.weak.expect
index b886905cbd3..55efb91e84b 100644
--- a/pkg/front_end/testcases/patterns/constant_pattern_in_switch.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/constant_pattern_in_switch.dart.weak.expect
@@ -28,69 +28,61 @@ static method main() → dynamic {
 static method test(dynamic value, core::bool expected) → void {
   core::bool matched;
   #L1:
-  {
-    final synthesized dynamic #0#0 = value;
-    if(#C2 =={core::List::==}{(core::Object) → core::bool} #0#0) {
+  switch(value) {
+    #L2:
+    case #C2:
       {
         matched = true;
         break #L1;
       }
-    }
-    else
-      if(#C3 =={core::List::==}{(core::Object) → core::bool} #0#0) {
-        {
-          matched = true;
-          break #L1;
-        }
+    #L3:
+    case #C3:
+      {
+        matched = true;
+        break #L1;
+      }
+    #L4:
+    case #C4:
+      {
+        matched = true;
+        break #L1;
+      }
+    #L5:
+    case #C5:
+      {
+        matched = true;
+        break #L1;
+      }
+    #L6:
+    case #C7:
+      {
+        matched = true;
+        break #L1;
+      }
+    #L7:
+    case #C8:
+      {
+        matched = true;
+        break #L1;
+      }
+    #L8:
+    case #C9:
+      {
+        matched = true;
+        break #L1;
+      }
+    #L9:
+    case #C10:
+      {
+        matched = true;
+        break #L1;
+      }
+    #L10:
+    default:
+      {
+        matched = false;
+        break #L1;
       }
-      else
-        if(#C4 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-          {
-            matched = true;
-            break #L1;
-          }
-        }
-        else
-          if(#C5 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-            {
-              matched = true;
-              break #L1;
-            }
-          }
-          else
-            if(#C7 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-              {
-                matched = true;
-                break #L1;
-              }
-            }
-            else
-              if(#C8 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-                {
-                  matched = true;
-                  break #L1;
-                }
-              }
-              else
-                if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-                  {
-                    matched = true;
-                    break #L1;
-                  }
-                }
-                else
-                  if(#C10 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-                    {
-                      matched = true;
-                      break #L1;
-                    }
-                  }
-                  else {
-                    {
-                      matched = false;
-                      break #L1;
-                    }
-                  }
   }
   if(!(matched =={core::Object::==}{(core::Object) → core::bool} expected)) {
     core::print("FAIL: ${value} ${matched ?{core::String} "matched" : "didn't match"}");
diff --git a/pkg/front_end/testcases/patterns/constant_pattern_in_switch.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/constant_pattern_in_switch.dart.weak.modular.expect
index b886905cbd3..55efb91e84b 100644
--- a/pkg/front_end/testcases/patterns/constant_pattern_in_switch.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/constant_pattern_in_switch.dart.weak.modular.expect
@@ -28,69 +28,61 @@ static method main() → dynamic {
 static method test(dynamic value, core::bool expected) → void {
   core::bool matched;
   #L1:
-  {
-    final synthesized dynamic #0#0 = value;
-    if(#C2 =={core::List::==}{(core::Object) → core::bool} #0#0) {
+  switch(value) {
+    #L2:
+    case #C2:
       {
         matched = true;
         break #L1;
       }
-    }
-    else
-      if(#C3 =={core::List::==}{(core::Object) → core::bool} #0#0) {
-        {
-          matched = true;
-          break #L1;
-        }
+    #L3:
+    case #C3:
+      {
+        matched = true;
+        break #L1;
+      }
+    #L4:
+    case #C4:
+      {
+        matched = true;
+        break #L1;
+      }
+    #L5:
+    case #C5:
+      {
+        matched = true;
+        break #L1;
+      }
+    #L6:
+    case #C7:
+      {
+        matched = true;
+        break #L1;
+      }
+    #L7:
+    case #C8:
+      {
+        matched = true;
+        break #L1;
+      }
+    #L8:
+    case #C9:
+      {
+        matched = true;
+        break #L1;
+      }
+    #L9:
+    case #C10:
+      {
+        matched = true;
+        break #L1;
+      }
+    #L10:
+    default:
+      {
+        matched = false;
+        break #L1;
       }
-      else
-        if(#C4 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-          {
-            matched = true;
-            break #L1;
-          }
-        }
-        else
-          if(#C5 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-            {
-              matched = true;
-              break #L1;
-            }
-          }
-          else
-            if(#C7 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-              {
-                matched = true;
-                break #L1;
-              }
-            }
-            else
-              if(#C8 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-                {
-                  matched = true;
-                  break #L1;
-                }
-              }
-              else
-                if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-                  {
-                    matched = true;
-                    break #L1;
-                  }
-                }
-                else
-                  if(#C10 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-                    {
-                      matched = true;
-                      break #L1;
-                    }
-                  }
-                  else {
-                    {
-                      matched = false;
-                      break #L1;
-                    }
-                  }
   }
   if(!(matched =={core::Object::==}{(core::Object) → core::bool} expected)) {
     core::print("FAIL: ${value} ${matched ?{core::String} "matched" : "didn't match"}");
diff --git a/pkg/front_end/testcases/patterns/constant_pattern_in_switch.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/constant_pattern_in_switch.dart.weak.transformed.expect
index aef7e38d3ef..252c3a70560 100644
--- a/pkg/front_end/testcases/patterns/constant_pattern_in_switch.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/constant_pattern_in_switch.dart.weak.transformed.expect
@@ -28,69 +28,61 @@ static method main() → dynamic {
 static method test(dynamic value, core::bool expected) → void {
   core::bool matched;
   #L1:
-  {
-    final synthesized dynamic #0#0 = value;
-    if(#C2 =={core::List::==}{(core::Object) → core::bool} #0#0) {
+  switch(value) {
+    #L2:
+    case #C2:
       {
         matched = true;
         break #L1;
       }
-    }
-    else
-      if(#C3 =={core::List::==}{(core::Object) → core::bool} #0#0) {
-        {
-          matched = true;
-          break #L1;
-        }
+    #L3:
+    case #C3:
+      {
+        matched = true;
+        break #L1;
+      }
+    #L4:
+    case #C4:
+      {
+        matched = true;
+        break #L1;
+      }
+    #L5:
+    case #C5:
+      {
+        matched = true;
+        break #L1;
+      }
+    #L6:
+    case #C7:
+      {
+        matched = true;
+        break #L1;
+      }
+    #L7:
+    case #C8:
+      {
+        matched = true;
+        break #L1;
+      }
+    #L8:
+    case #C9:
+      {
+        matched = true;
+        break #L1;
+      }
+    #L9:
+    case #C10:
+      {
+        matched = true;
+        break #L1;
+      }
+    #L10:
+    default:
+      {
+        matched = false;
+        break #L1;
       }
-      else
-        if(#C4 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-          {
-            matched = true;
-            break #L1;
-          }
-        }
-        else
-          if(#C5 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-            {
-              matched = true;
-              break #L1;
-            }
-          }
-          else
-            if(#C7 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-              {
-                matched = true;
-                break #L1;
-              }
-            }
-            else
-              if(#C8 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-                {
-                  matched = true;
-                  break #L1;
-                }
-              }
-              else
-                if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-                  {
-                    matched = true;
-                    break #L1;
-                  }
-                }
-                else
-                  if(#C10 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-                    {
-                      matched = true;
-                      break #L1;
-                    }
-                  }
-                  else {
-                    {
-                      matched = false;
-                      break #L1;
-                    }
-                  }
   }
   if(!(matched =={core::Object::==}{(core::Object) → core::bool} expected)) {
     core::print("FAIL: ${value} ${matched ?{core::String} "matched" : "didn't match"}");
diff --git a/pkg/front_end/testcases/patterns/double_literal_inside_case.dart.strong.expect b/pkg/front_end/testcases/patterns/double_literal_inside_case.dart.strong.expect
index 1fe9acd6da4..84c8a67826c 100644
--- a/pkg/front_end/testcases/patterns/double_literal_inside_case.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/double_literal_inside_case.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        break #L1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/double_literal_inside_case.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/double_literal_inside_case.dart.strong.transformed.expect
index 1fe9acd6da4..84c8a67826c 100644
--- a/pkg/front_end/testcases/patterns/double_literal_inside_case.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/double_literal_inside_case.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        break #L1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/double_literal_inside_case.dart.weak.expect b/pkg/front_end/testcases/patterns/double_literal_inside_case.dart.weak.expect
index 1fe9acd6da4..84c8a67826c 100644
--- a/pkg/front_end/testcases/patterns/double_literal_inside_case.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/double_literal_inside_case.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        break #L1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/double_literal_inside_case.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/double_literal_inside_case.dart.weak.modular.expect
index 1fe9acd6da4..84c8a67826c 100644
--- a/pkg/front_end/testcases/patterns/double_literal_inside_case.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/double_literal_inside_case.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        break #L1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/double_literal_inside_case.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/double_literal_inside_case.dart.weak.transformed.expect
index 1fe9acd6da4..84c8a67826c 100644
--- a/pkg/front_end/testcases/patterns/double_literal_inside_case.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/double_literal_inside_case.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        break #L1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/double_literal_inside_cast.dart.strong.expect b/pkg/front_end/testcases/patterns/double_literal_inside_cast.dart.strong.expect
index 9f1ea0a1521..6beb9c6fe6e 100644
--- a/pkg/front_end/testcases/patterns/double_literal_inside_cast.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/double_literal_inside_cast.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::Object) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::Object) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/double_literal_inside_cast.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/double_literal_inside_cast.dart.strong.transformed.expect
index 4551609d0b3..4d3cd30ec0f 100644
--- a/pkg/front_end/testcases/patterns/double_literal_inside_cast.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/double_literal_inside_cast.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final core::Object #t1 = let dynamic #t2 = #0#0 in #t2 == null ?{core::Object} #t2 as{ForNonNullableByDefault} core::Object : #t2{core::Object} in #C1 =={core::num::==}{(core::Object) → core::bool} (let dynamic #t3 = #0#0 in #t3 == null ?{core::Object} #t3 as{ForNonNullableByDefault} core::Object : #t3{core::Object})) {
-      {
-        break #L1;
+    {
+      if(let final core::Object #t1 = let dynamic #t2 = #0#0 in #t2 == null ?{core::Object} #t2 as{ForNonNullableByDefault} core::Object : #t2{core::Object} in #C1 =={core::num::==}{(core::Object) → core::bool} (let dynamic #t3 = #0#0 in #t3 == null ?{core::Object} #t3 as{ForNonNullableByDefault} core::Object : #t3{core::Object})) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/double_literal_inside_cast.dart.weak.expect b/pkg/front_end/testcases/patterns/double_literal_inside_cast.dart.weak.expect
index 9f1ea0a1521..6beb9c6fe6e 100644
--- a/pkg/front_end/testcases/patterns/double_literal_inside_cast.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/double_literal_inside_cast.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::Object) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::Object) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/double_literal_inside_cast.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/double_literal_inside_cast.dart.weak.modular.expect
index 9f1ea0a1521..6beb9c6fe6e 100644
--- a/pkg/front_end/testcases/patterns/double_literal_inside_cast.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/double_literal_inside_cast.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::Object) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::Object) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/double_literal_inside_cast.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/double_literal_inside_cast.dart.weak.transformed.expect
index 1a95272039a..e940763b306 100644
--- a/pkg/front_end/testcases/patterns/double_literal_inside_cast.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/double_literal_inside_cast.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final core::Object #t1 = #0#0 in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        break #L1;
+    {
+      if(let final core::Object #t1 = #0#0 in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/double_literal_inside_null_assert.dart.strong.expect b/pkg/front_end/testcases/patterns/double_literal_inside_null_assert.dart.strong.expect
index d110d58add9..4ab708c869f 100644
--- a/pkg/front_end/testcases/patterns/double_literal_inside_null_assert.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/double_literal_inside_null_assert.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/double_literal_inside_null_assert.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/double_literal_inside_null_assert.dart.strong.transformed.expect
index d110d58add9..4ab708c869f 100644
--- a/pkg/front_end/testcases/patterns/double_literal_inside_null_assert.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/double_literal_inside_null_assert.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/double_literal_inside_null_assert.dart.weak.expect b/pkg/front_end/testcases/patterns/double_literal_inside_null_assert.dart.weak.expect
index d110d58add9..4ab708c869f 100644
--- a/pkg/front_end/testcases/patterns/double_literal_inside_null_assert.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/double_literal_inside_null_assert.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/double_literal_inside_null_assert.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/double_literal_inside_null_assert.dart.weak.modular.expect
index d110d58add9..4ab708c869f 100644
--- a/pkg/front_end/testcases/patterns/double_literal_inside_null_assert.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/double_literal_inside_null_assert.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/double_literal_inside_null_assert.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/double_literal_inside_null_assert.dart.weak.transformed.expect
index d110d58add9..4ab708c869f 100644
--- a/pkg/front_end/testcases/patterns/double_literal_inside_null_assert.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/double_literal_inside_null_assert.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/double_literal_inside_null_check.dart.strong.expect b/pkg/front_end/testcases/patterns/double_literal_inside_null_check.dart.strong.expect
index 1a3a571f79a..f368d191237 100644
--- a/pkg/front_end/testcases/patterns/double_literal_inside_null_check.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/double_literal_inside_null_check.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/double_literal_inside_null_check.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/double_literal_inside_null_check.dart.strong.transformed.expect
index 1a3a571f79a..f368d191237 100644
--- a/pkg/front_end/testcases/patterns/double_literal_inside_null_check.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/double_literal_inside_null_check.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/double_literal_inside_null_check.dart.weak.expect b/pkg/front_end/testcases/patterns/double_literal_inside_null_check.dart.weak.expect
index 1a3a571f79a..f368d191237 100644
--- a/pkg/front_end/testcases/patterns/double_literal_inside_null_check.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/double_literal_inside_null_check.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/double_literal_inside_null_check.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/double_literal_inside_null_check.dart.weak.modular.expect
index 1a3a571f79a..f368d191237 100644
--- a/pkg/front_end/testcases/patterns/double_literal_inside_null_check.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/double_literal_inside_null_check.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/double_literal_inside_null_check.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/double_literal_inside_null_check.dart.weak.transformed.expect
index 1a3a571f79a..f368d191237 100644
--- a/pkg/front_end/testcases/patterns/double_literal_inside_null_check.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/double_literal_inside_null_check.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart.strong.expect b/pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart.strong.expect
index f7f26940be7..77579fd7795 100644
--- a/pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart.strong.expect
@@ -33,226 +33,203 @@ import "dart:core" as core;
 
 static method exhaustiveSwitch(core::bool b) → void {
   #L1:
-  {
-    final synthesized core::bool #0#0 = b;
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  switch(b) /*isExplicitlyExhaustive*/ {
+    #L2:
+    case #C1:
       {
         core::print("true");
         break #L1;
       }
-    }
-    else
-      if(#C2 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("false");
-          break #L1;
-        }
+    #L3:
+    case #C2:
+      {
+        core::print("false");
+        break #L1;
       }
   }
 }
 static method nonExhaustiveSwitch1(core::bool b) → void {
-  #L2:
-  {
-    final synthesized core::bool #0#0 = b;
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L4:
+  switch(b) /*isExplicitlyExhaustive*/ {
+    #L5:
+    case #C1:
       {
         core::print("true");
-        break #L2;
+        break #L4;
       }
-    }
   }
 }
 static method nonExhaustiveSwitch2(core::bool b) → void {
-  #L3:
-  {
-    final synthesized core::bool #0#0 = b;
-    if(#C2 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L6:
+  switch(b) /*isExplicitlyExhaustive*/ {
+    #L7:
+    case #C2:
       {
         core::print("false");
-        break #L3;
+        break #L6;
       }
-    }
   }
 }
 static method nonExhaustiveSwitchWithDefault(core::bool b) → void {
-  #L4:
-  {
-    final synthesized invalid-type #0#0 = invalid-expression "pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart:33:11: Error: Undefined name 'e'.
+  #L8:
+  switch(invalid-expression "pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart:33:11: Error: Undefined name 'e'.
   switch (e) /* Ok */ {
-          ^";
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+          ^") {
+    #L9:
+    case #C1:
       {
         core::print("true");
-        break #L4;
+        break #L8;
       }
-    }
-    else {
+    #L10:
+    default:
       {
         core::print("default");
-        break #L4;
+        break #L8;
       }
-    }
   }
 }
 static method exhaustiveNullableSwitch(core::bool? b) → void {
-  #L5:
-  {
-    final synthesized core::bool? #0#0 = b;
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L11:
+  switch(b) /*isExplicitlyExhaustive*/ {
+    #L12:
+    case #C1:
       {
         core::print("true");
-        break #L5;
+        break #L11;
       }
-    }
-    else
-      if(#C2 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("false");
-          break #L5;
-        }
+    #L13:
+    case #C2:
+      {
+        core::print("false");
+        break #L11;
+      }
+    #L14:
+    case #C3:
+      {
+        core::print("null");
+        break #L11;
       }
-      else
-        if(#0#0 == null) {
-          {
-            core::print("null");
-            break #L5;
-          }
-        }
   }
 }
 static method nonExhaustiveNullableSwitch1(core::bool? e) → void {
-  #L6:
-  {
-    final synthesized invalid-type #0#0 = invalid-expression "pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart:58:11: Error: Undefined name 'b'.
+  #L15:
+  switch(invalid-expression "pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart:58:11: Error: Undefined name 'b'.
   switch (b) /* Error */ {
-          ^";
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+          ^") {
+    #L16:
+    case #C1:
       {
         core::print("true");
-        break #L6;
+        break #L15;
       }
-    }
-    else
-      if(#C2 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("false");
-          break #L6;
-        }
+    #L17:
+    case #C2:
+      {
+        core::print("false");
+        break #L15;
       }
   }
 }
 static method nonExhaustiveNullableSwitch2(core::bool? e) → void {
-  #L7:
-  {
-    final synthesized invalid-type #0#0 = invalid-expression "pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart:69:11: Error: Undefined name 'b'.
+  #L18:
+  switch(invalid-expression "pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart:69:11: Error: Undefined name 'b'.
   switch (b) /* Error */ {
-          ^";
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+          ^") {
+    #L19:
+    case #C1:
       {
         core::print("true");
-        break #L7;
+        break #L18;
       }
-    }
-    else
-      if(#0#0 == null) {
-        {
-          core::print("null");
-          break #L7;
-        }
+    #L20:
+    case #C3:
+      {
+        core::print("null");
+        break #L18;
       }
   }
 }
 static method unreachableCase1(core::bool b) → void {
-  #L8:
-  {
-    final synthesized invalid-type #0#0 = invalid-expression "pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart:80:11: Error: Undefined name 'e'.
+  #L21:
+  switch(invalid-expression "pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart:80:11: Error: Undefined name 'e'.
   switch (e) /* Ok */ {
-          ^";
-    late final synthesized core::bool #0#2 = #C1 =={core::Object::==}{(core::Object) → core::bool} #0#0;
-    if(#0#2) {
+          ^") {
+    #L22:
+    case #C1:
       {
         core::print("true1");
-        break #L8;
+        break #L21;
       }
-    }
-    else
-      if(#C2 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("false");
-          break #L8;
-        }
+    #L23:
+    case #C2:
+      {
+        core::print("false");
+        break #L21;
+      }
+    #L24:
+    case #C1:
+      {
+        core::print("true2");
+        break #L21;
       }
-      else
-        if(#0#2) {
-          {
-            core::print("true2");
-            break #L8;
-          }
-        }
   }
 }
 static method unreachableCase2(core::bool b) → void {
-  #L9:
-  {
-    final synthesized core::bool #0#0 = b;
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L25:
+  switch(b) /*isExplicitlyExhaustive*/ {
+    #L26:
+    case #C1:
       {
         core::print("true");
-        break #L9;
+        break #L25;
       }
-    }
-    else
-      if(#C2 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("false");
-          break #L9;
-        }
+    #L27:
+    case #C2:
+      {
+        core::print("false");
+        break #L25;
+      }
+    #L28:
+    case #C3:
+      {
+        core::print("null");
+        break #L25;
       }
-      else
-        if(#0#0 == null) {
-          {
-            core::print("null");
-            break #L9;
-          }
-        }
   }
 }
 static method unreachableCase3(core::bool? b) → void {
-  #L10:
-  {
-    final synthesized core::bool? #0#0 = b;
-    late final synthesized core::bool #0#6 = #0#0 == null;
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L29:
+  switch(b) /*isExplicitlyExhaustive*/ {
+    #L30:
+    case #C1:
       {
         core::print("true");
-        break #L10;
+        break #L29;
       }
-    }
-    else
-      if(#C2 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("false");
-          break #L10;
-        }
+    #L31:
+    case #C2:
+      {
+        core::print("false");
+        break #L29;
+      }
+    #L32:
+    case #C3:
+      {
+        core::print("null1");
+        break #L29;
+      }
+    #L33:
+    case #C3:
+      {
+        core::print("null2");
+        break #L29;
       }
-      else
-        if(#0#6) {
-          {
-            core::print("null1");
-            break #L10;
-          }
-        }
-        else
-          if(#0#6) {
-            {
-              core::print("null2");
-              break #L10;
-            }
-          }
   }
 }
 
 constants  {
   #C1 = true
   #C2 = false
+  #C3 = null
 }
diff --git a/pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart.strong.transformed.expect
index b5f51d4690d..77579fd7795 100644
--- a/pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart.strong.transformed.expect
@@ -33,230 +33,203 @@ import "dart:core" as core;
 
 static method exhaustiveSwitch(core::bool b) → void {
   #L1:
-  {
-    final synthesized core::bool #0#0 = b;
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  switch(b) /*isExplicitlyExhaustive*/ {
+    #L2:
+    case #C1:
       {
         core::print("true");
         break #L1;
       }
-    }
-    else
-      if(#C2 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("false");
-          break #L1;
-        }
+    #L3:
+    case #C2:
+      {
+        core::print("false");
+        break #L1;
       }
   }
 }
 static method nonExhaustiveSwitch1(core::bool b) → void {
-  #L2:
-  {
-    final synthesized core::bool #0#0 = b;
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L4:
+  switch(b) /*isExplicitlyExhaustive*/ {
+    #L5:
+    case #C1:
       {
         core::print("true");
-        break #L2;
+        break #L4;
       }
-    }
   }
 }
 static method nonExhaustiveSwitch2(core::bool b) → void {
-  #L3:
-  {
-    final synthesized core::bool #0#0 = b;
-    if(#C2 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L6:
+  switch(b) /*isExplicitlyExhaustive*/ {
+    #L7:
+    case #C2:
       {
         core::print("false");
-        break #L3;
+        break #L6;
       }
-    }
   }
 }
 static method nonExhaustiveSwitchWithDefault(core::bool b) → void {
-  #L4:
-  {
-    final synthesized invalid-type #0#0 = invalid-expression "pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart:33:11: Error: Undefined name 'e'.
+  #L8:
+  switch(invalid-expression "pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart:33:11: Error: Undefined name 'e'.
   switch (e) /* Ok */ {
-          ^";
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+          ^") {
+    #L9:
+    case #C1:
       {
         core::print("true");
-        break #L4;
+        break #L8;
       }
-    }
-    else {
+    #L10:
+    default:
       {
         core::print("default");
-        break #L4;
+        break #L8;
       }
-    }
   }
 }
 static method exhaustiveNullableSwitch(core::bool? b) → void {
-  #L5:
-  {
-    final synthesized core::bool? #0#0 = b;
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L11:
+  switch(b) /*isExplicitlyExhaustive*/ {
+    #L12:
+    case #C1:
       {
         core::print("true");
-        break #L5;
+        break #L11;
       }
-    }
-    else
-      if(#C2 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("false");
-          break #L5;
-        }
+    #L13:
+    case #C2:
+      {
+        core::print("false");
+        break #L11;
+      }
+    #L14:
+    case #C3:
+      {
+        core::print("null");
+        break #L11;
       }
-      else
-        if(#0#0 == null) {
-          {
-            core::print("null");
-            break #L5;
-          }
-        }
   }
 }
 static method nonExhaustiveNullableSwitch1(core::bool? e) → void {
-  #L6:
-  {
-    final synthesized invalid-type #0#0 = invalid-expression "pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart:58:11: Error: Undefined name 'b'.
+  #L15:
+  switch(invalid-expression "pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart:58:11: Error: Undefined name 'b'.
   switch (b) /* Error */ {
-          ^";
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+          ^") {
+    #L16:
+    case #C1:
       {
         core::print("true");
-        break #L6;
+        break #L15;
       }
-    }
-    else
-      if(#C2 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("false");
-          break #L6;
-        }
+    #L17:
+    case #C2:
+      {
+        core::print("false");
+        break #L15;
       }
   }
 }
 static method nonExhaustiveNullableSwitch2(core::bool? e) → void {
-  #L7:
-  {
-    final synthesized invalid-type #0#0 = invalid-expression "pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart:69:11: Error: Undefined name 'b'.
+  #L18:
+  switch(invalid-expression "pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart:69:11: Error: Undefined name 'b'.
   switch (b) /* Error */ {
-          ^";
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+          ^") {
+    #L19:
+    case #C1:
       {
         core::print("true");
-        break #L7;
+        break #L18;
       }
-    }
-    else
-      if(#0#0 == null) {
-        {
-          core::print("null");
-          break #L7;
-        }
+    #L20:
+    case #C3:
+      {
+        core::print("null");
+        break #L18;
       }
   }
 }
 static method unreachableCase1(core::bool b) → void {
-  #L8:
-  {
-    final synthesized invalid-type #0#0 = invalid-expression "pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart:80:11: Error: Undefined name 'e'.
+  #L21:
+  switch(invalid-expression "pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart:80:11: Error: Undefined name 'e'.
   switch (e) /* Ok */ {
-          ^";
-    function ##0#2#initializer() → core::bool
-      return #C1 =={core::Object::==}{(core::Object) → core::bool} #0#0;
-    late final synthesized core::bool #0#2 = ##0#2#initializer(){() → core::bool};
-    if(#0#2) {
+          ^") {
+    #L22:
+    case #C1:
       {
         core::print("true1");
-        break #L8;
+        break #L21;
       }
-    }
-    else
-      if(#C2 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("false");
-          break #L8;
-        }
+    #L23:
+    case #C2:
+      {
+        core::print("false");
+        break #L21;
+      }
+    #L24:
+    case #C1:
+      {
+        core::print("true2");
+        break #L21;
       }
-      else
-        if(#0#2) {
-          {
-            core::print("true2");
-            break #L8;
-          }
-        }
   }
 }
 static method unreachableCase2(core::bool b) → void {
-  #L9:
-  {
-    final synthesized core::bool #0#0 = b;
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L25:
+  switch(b) /*isExplicitlyExhaustive*/ {
+    #L26:
+    case #C1:
       {
         core::print("true");
-        break #L9;
+        break #L25;
       }
-    }
-    else
-      if(#C2 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("false");
-          break #L9;
-        }
+    #L27:
+    case #C2:
+      {
+        core::print("false");
+        break #L25;
+      }
+    #L28:
+    case #C3:
+      {
+        core::print("null");
+        break #L25;
       }
-      else
-        if(#0#0 == null) {
-          {
-            core::print("null");
-            break #L9;
-          }
-        }
   }
 }
 static method unreachableCase3(core::bool? b) → void {
-  #L10:
-  {
-    final synthesized core::bool? #0#0 = b;
-    function ##0#6#initializer() → core::bool
-      return #0#0 == null;
-    late final synthesized core::bool #0#6 = ##0#6#initializer(){() → core::bool};
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L29:
+  switch(b) /*isExplicitlyExhaustive*/ {
+    #L30:
+    case #C1:
       {
         core::print("true");
-        break #L10;
+        break #L29;
       }
-    }
-    else
-      if(#C2 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("false");
-          break #L10;
-        }
+    #L31:
+    case #C2:
+      {
+        core::print("false");
+        break #L29;
+      }
+    #L32:
+    case #C3:
+      {
+        core::print("null1");
+        break #L29;
+      }
+    #L33:
+    case #C3:
+      {
+        core::print("null2");
+        break #L29;
       }
-      else
-        if(#0#6) {
-          {
-            core::print("null1");
-            break #L10;
-          }
-        }
-        else
-          if(#0#6) {
-            {
-              core::print("null2");
-              break #L10;
-            }
-          }
   }
 }
 
 constants  {
   #C1 = true
   #C2 = false
+  #C3 = null
 }
diff --git a/pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart.weak.expect b/pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart.weak.expect
index f7f26940be7..77579fd7795 100644
--- a/pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart.weak.expect
@@ -33,226 +33,203 @@ import "dart:core" as core;
 
 static method exhaustiveSwitch(core::bool b) → void {
   #L1:
-  {
-    final synthesized core::bool #0#0 = b;
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  switch(b) /*isExplicitlyExhaustive*/ {
+    #L2:
+    case #C1:
       {
         core::print("true");
         break #L1;
       }
-    }
-    else
-      if(#C2 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("false");
-          break #L1;
-        }
+    #L3:
+    case #C2:
+      {
+        core::print("false");
+        break #L1;
       }
   }
 }
 static method nonExhaustiveSwitch1(core::bool b) → void {
-  #L2:
-  {
-    final synthesized core::bool #0#0 = b;
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L4:
+  switch(b) /*isExplicitlyExhaustive*/ {
+    #L5:
+    case #C1:
       {
         core::print("true");
-        break #L2;
+        break #L4;
       }
-    }
   }
 }
 static method nonExhaustiveSwitch2(core::bool b) → void {
-  #L3:
-  {
-    final synthesized core::bool #0#0 = b;
-    if(#C2 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L6:
+  switch(b) /*isExplicitlyExhaustive*/ {
+    #L7:
+    case #C2:
       {
         core::print("false");
-        break #L3;
+        break #L6;
       }
-    }
   }
 }
 static method nonExhaustiveSwitchWithDefault(core::bool b) → void {
-  #L4:
-  {
-    final synthesized invalid-type #0#0 = invalid-expression "pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart:33:11: Error: Undefined name 'e'.
+  #L8:
+  switch(invalid-expression "pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart:33:11: Error: Undefined name 'e'.
   switch (e) /* Ok */ {
-          ^";
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+          ^") {
+    #L9:
+    case #C1:
       {
         core::print("true");
-        break #L4;
+        break #L8;
       }
-    }
-    else {
+    #L10:
+    default:
       {
         core::print("default");
-        break #L4;
+        break #L8;
       }
-    }
   }
 }
 static method exhaustiveNullableSwitch(core::bool? b) → void {
-  #L5:
-  {
-    final synthesized core::bool? #0#0 = b;
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L11:
+  switch(b) /*isExplicitlyExhaustive*/ {
+    #L12:
+    case #C1:
       {
         core::print("true");
-        break #L5;
+        break #L11;
       }
-    }
-    else
-      if(#C2 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("false");
-          break #L5;
-        }
+    #L13:
+    case #C2:
+      {
+        core::print("false");
+        break #L11;
+      }
+    #L14:
+    case #C3:
+      {
+        core::print("null");
+        break #L11;
       }
-      else
-        if(#0#0 == null) {
-          {
-            core::print("null");
-            break #L5;
-          }
-        }
   }
 }
 static method nonExhaustiveNullableSwitch1(core::bool? e) → void {
-  #L6:
-  {
-    final synthesized invalid-type #0#0 = invalid-expression "pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart:58:11: Error: Undefined name 'b'.
+  #L15:
+  switch(invalid-expression "pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart:58:11: Error: Undefined name 'b'.
   switch (b) /* Error */ {
-          ^";
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+          ^") {
+    #L16:
+    case #C1:
       {
         core::print("true");
-        break #L6;
+        break #L15;
       }
-    }
-    else
-      if(#C2 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("false");
-          break #L6;
-        }
+    #L17:
+    case #C2:
+      {
+        core::print("false");
+        break #L15;
       }
   }
 }
 static method nonExhaustiveNullableSwitch2(core::bool? e) → void {
-  #L7:
-  {
-    final synthesized invalid-type #0#0 = invalid-expression "pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart:69:11: Error: Undefined name 'b'.
+  #L18:
+  switch(invalid-expression "pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart:69:11: Error: Undefined name 'b'.
   switch (b) /* Error */ {
-          ^";
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+          ^") {
+    #L19:
+    case #C1:
       {
         core::print("true");
-        break #L7;
+        break #L18;
       }
-    }
-    else
-      if(#0#0 == null) {
-        {
-          core::print("null");
-          break #L7;
-        }
+    #L20:
+    case #C3:
+      {
+        core::print("null");
+        break #L18;
       }
   }
 }
 static method unreachableCase1(core::bool b) → void {
-  #L8:
-  {
-    final synthesized invalid-type #0#0 = invalid-expression "pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart:80:11: Error: Undefined name 'e'.
+  #L21:
+  switch(invalid-expression "pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart:80:11: Error: Undefined name 'e'.
   switch (e) /* Ok */ {
-          ^";
-    late final synthesized core::bool #0#2 = #C1 =={core::Object::==}{(core::Object) → core::bool} #0#0;
-    if(#0#2) {
+          ^") {
+    #L22:
+    case #C1:
       {
         core::print("true1");
-        break #L8;
+        break #L21;
       }
-    }
-    else
-      if(#C2 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("false");
-          break #L8;
-        }
+    #L23:
+    case #C2:
+      {
+        core::print("false");
+        break #L21;
+      }
+    #L24:
+    case #C1:
+      {
+        core::print("true2");
+        break #L21;
       }
-      else
-        if(#0#2) {
-          {
-            core::print("true2");
-            break #L8;
-          }
-        }
   }
 }
 static method unreachableCase2(core::bool b) → void {
-  #L9:
-  {
-    final synthesized core::bool #0#0 = b;
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L25:
+  switch(b) /*isExplicitlyExhaustive*/ {
+    #L26:
+    case #C1:
       {
         core::print("true");
-        break #L9;
+        break #L25;
       }
-    }
-    else
-      if(#C2 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("false");
-          break #L9;
-        }
+    #L27:
+    case #C2:
+      {
+        core::print("false");
+        break #L25;
+      }
+    #L28:
+    case #C3:
+      {
+        core::print("null");
+        break #L25;
       }
-      else
-        if(#0#0 == null) {
-          {
-            core::print("null");
-            break #L9;
-          }
-        }
   }
 }
 static method unreachableCase3(core::bool? b) → void {
-  #L10:
-  {
-    final synthesized core::bool? #0#0 = b;
-    late final synthesized core::bool #0#6 = #0#0 == null;
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L29:
+  switch(b) /*isExplicitlyExhaustive*/ {
+    #L30:
+    case #C1:
       {
         core::print("true");
-        break #L10;
+        break #L29;
       }
-    }
-    else
-      if(#C2 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("false");
-          break #L10;
-        }
+    #L31:
+    case #C2:
+      {
+        core::print("false");
+        break #L29;
+      }
+    #L32:
+    case #C3:
+      {
+        core::print("null1");
+        break #L29;
+      }
+    #L33:
+    case #C3:
+      {
+        core::print("null2");
+        break #L29;
       }
-      else
-        if(#0#6) {
-          {
-            core::print("null1");
-            break #L10;
-          }
-        }
-        else
-          if(#0#6) {
-            {
-              core::print("null2");
-              break #L10;
-            }
-          }
   }
 }
 
 constants  {
   #C1 = true
   #C2 = false
+  #C3 = null
 }
diff --git a/pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart.weak.modular.expect
index f7f26940be7..77579fd7795 100644
--- a/pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart.weak.modular.expect
@@ -33,226 +33,203 @@ import "dart:core" as core;
 
 static method exhaustiveSwitch(core::bool b) → void {
   #L1:
-  {
-    final synthesized core::bool #0#0 = b;
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  switch(b) /*isExplicitlyExhaustive*/ {
+    #L2:
+    case #C1:
       {
         core::print("true");
         break #L1;
       }
-    }
-    else
-      if(#C2 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("false");
-          break #L1;
-        }
+    #L3:
+    case #C2:
+      {
+        core::print("false");
+        break #L1;
       }
   }
 }
 static method nonExhaustiveSwitch1(core::bool b) → void {
-  #L2:
-  {
-    final synthesized core::bool #0#0 = b;
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L4:
+  switch(b) /*isExplicitlyExhaustive*/ {
+    #L5:
+    case #C1:
       {
         core::print("true");
-        break #L2;
+        break #L4;
       }
-    }
   }
 }
 static method nonExhaustiveSwitch2(core::bool b) → void {
-  #L3:
-  {
-    final synthesized core::bool #0#0 = b;
-    if(#C2 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L6:
+  switch(b) /*isExplicitlyExhaustive*/ {
+    #L7:
+    case #C2:
       {
         core::print("false");
-        break #L3;
+        break #L6;
       }
-    }
   }
 }
 static method nonExhaustiveSwitchWithDefault(core::bool b) → void {
-  #L4:
-  {
-    final synthesized invalid-type #0#0 = invalid-expression "pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart:33:11: Error: Undefined name 'e'.
+  #L8:
+  switch(invalid-expression "pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart:33:11: Error: Undefined name 'e'.
   switch (e) /* Ok */ {
-          ^";
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+          ^") {
+    #L9:
+    case #C1:
       {
         core::print("true");
-        break #L4;
+        break #L8;
       }
-    }
-    else {
+    #L10:
+    default:
       {
         core::print("default");
-        break #L4;
+        break #L8;
       }
-    }
   }
 }
 static method exhaustiveNullableSwitch(core::bool? b) → void {
-  #L5:
-  {
-    final synthesized core::bool? #0#0 = b;
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L11:
+  switch(b) /*isExplicitlyExhaustive*/ {
+    #L12:
+    case #C1:
       {
         core::print("true");
-        break #L5;
+        break #L11;
       }
-    }
-    else
-      if(#C2 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("false");
-          break #L5;
-        }
+    #L13:
+    case #C2:
+      {
+        core::print("false");
+        break #L11;
+      }
+    #L14:
+    case #C3:
+      {
+        core::print("null");
+        break #L11;
       }
-      else
-        if(#0#0 == null) {
-          {
-            core::print("null");
-            break #L5;
-          }
-        }
   }
 }
 static method nonExhaustiveNullableSwitch1(core::bool? e) → void {
-  #L6:
-  {
-    final synthesized invalid-type #0#0 = invalid-expression "pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart:58:11: Error: Undefined name 'b'.
+  #L15:
+  switch(invalid-expression "pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart:58:11: Error: Undefined name 'b'.
   switch (b) /* Error */ {
-          ^";
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+          ^") {
+    #L16:
+    case #C1:
       {
         core::print("true");
-        break #L6;
+        break #L15;
       }
-    }
-    else
-      if(#C2 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("false");
-          break #L6;
-        }
+    #L17:
+    case #C2:
+      {
+        core::print("false");
+        break #L15;
       }
   }
 }
 static method nonExhaustiveNullableSwitch2(core::bool? e) → void {
-  #L7:
-  {
-    final synthesized invalid-type #0#0 = invalid-expression "pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart:69:11: Error: Undefined name 'b'.
+  #L18:
+  switch(invalid-expression "pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart:69:11: Error: Undefined name 'b'.
   switch (b) /* Error */ {
-          ^";
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+          ^") {
+    #L19:
+    case #C1:
       {
         core::print("true");
-        break #L7;
+        break #L18;
       }
-    }
-    else
-      if(#0#0 == null) {
-        {
-          core::print("null");
-          break #L7;
-        }
+    #L20:
+    case #C3:
+      {
+        core::print("null");
+        break #L18;
       }
   }
 }
 static method unreachableCase1(core::bool b) → void {
-  #L8:
-  {
-    final synthesized invalid-type #0#0 = invalid-expression "pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart:80:11: Error: Undefined name 'e'.
+  #L21:
+  switch(invalid-expression "pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart:80:11: Error: Undefined name 'e'.
   switch (e) /* Ok */ {
-          ^";
-    late final synthesized core::bool #0#2 = #C1 =={core::Object::==}{(core::Object) → core::bool} #0#0;
-    if(#0#2) {
+          ^") {
+    #L22:
+    case #C1:
       {
         core::print("true1");
-        break #L8;
+        break #L21;
       }
-    }
-    else
-      if(#C2 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("false");
-          break #L8;
-        }
+    #L23:
+    case #C2:
+      {
+        core::print("false");
+        break #L21;
+      }
+    #L24:
+    case #C1:
+      {
+        core::print("true2");
+        break #L21;
       }
-      else
-        if(#0#2) {
-          {
-            core::print("true2");
-            break #L8;
-          }
-        }
   }
 }
 static method unreachableCase2(core::bool b) → void {
-  #L9:
-  {
-    final synthesized core::bool #0#0 = b;
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L25:
+  switch(b) /*isExplicitlyExhaustive*/ {
+    #L26:
+    case #C1:
       {
         core::print("true");
-        break #L9;
+        break #L25;
       }
-    }
-    else
-      if(#C2 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("false");
-          break #L9;
-        }
+    #L27:
+    case #C2:
+      {
+        core::print("false");
+        break #L25;
+      }
+    #L28:
+    case #C3:
+      {
+        core::print("null");
+        break #L25;
       }
-      else
-        if(#0#0 == null) {
-          {
-            core::print("null");
-            break #L9;
-          }
-        }
   }
 }
 static method unreachableCase3(core::bool? b) → void {
-  #L10:
-  {
-    final synthesized core::bool? #0#0 = b;
-    late final synthesized core::bool #0#6 = #0#0 == null;
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L29:
+  switch(b) /*isExplicitlyExhaustive*/ {
+    #L30:
+    case #C1:
       {
         core::print("true");
-        break #L10;
+        break #L29;
       }
-    }
-    else
-      if(#C2 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("false");
-          break #L10;
-        }
+    #L31:
+    case #C2:
+      {
+        core::print("false");
+        break #L29;
+      }
+    #L32:
+    case #C3:
+      {
+        core::print("null1");
+        break #L29;
+      }
+    #L33:
+    case #C3:
+      {
+        core::print("null2");
+        break #L29;
       }
-      else
-        if(#0#6) {
-          {
-            core::print("null1");
-            break #L10;
-          }
-        }
-        else
-          if(#0#6) {
-            {
-              core::print("null2");
-              break #L10;
-            }
-          }
   }
 }
 
 constants  {
   #C1 = true
   #C2 = false
+  #C3 = null
 }
diff --git a/pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart.weak.transformed.expect
index b5f51d4690d..77579fd7795 100644
--- a/pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart.weak.transformed.expect
@@ -33,230 +33,203 @@ import "dart:core" as core;
 
 static method exhaustiveSwitch(core::bool b) → void {
   #L1:
-  {
-    final synthesized core::bool #0#0 = b;
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  switch(b) /*isExplicitlyExhaustive*/ {
+    #L2:
+    case #C1:
       {
         core::print("true");
         break #L1;
       }
-    }
-    else
-      if(#C2 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("false");
-          break #L1;
-        }
+    #L3:
+    case #C2:
+      {
+        core::print("false");
+        break #L1;
       }
   }
 }
 static method nonExhaustiveSwitch1(core::bool b) → void {
-  #L2:
-  {
-    final synthesized core::bool #0#0 = b;
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L4:
+  switch(b) /*isExplicitlyExhaustive*/ {
+    #L5:
+    case #C1:
       {
         core::print("true");
-        break #L2;
+        break #L4;
       }
-    }
   }
 }
 static method nonExhaustiveSwitch2(core::bool b) → void {
-  #L3:
-  {
-    final synthesized core::bool #0#0 = b;
-    if(#C2 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L6:
+  switch(b) /*isExplicitlyExhaustive*/ {
+    #L7:
+    case #C2:
       {
         core::print("false");
-        break #L3;
+        break #L6;
       }
-    }
   }
 }
 static method nonExhaustiveSwitchWithDefault(core::bool b) → void {
-  #L4:
-  {
-    final synthesized invalid-type #0#0 = invalid-expression "pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart:33:11: Error: Undefined name 'e'.
+  #L8:
+  switch(invalid-expression "pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart:33:11: Error: Undefined name 'e'.
   switch (e) /* Ok */ {
-          ^";
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+          ^") {
+    #L9:
+    case #C1:
       {
         core::print("true");
-        break #L4;
+        break #L8;
       }
-    }
-    else {
+    #L10:
+    default:
       {
         core::print("default");
-        break #L4;
+        break #L8;
       }
-    }
   }
 }
 static method exhaustiveNullableSwitch(core::bool? b) → void {
-  #L5:
-  {
-    final synthesized core::bool? #0#0 = b;
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L11:
+  switch(b) /*isExplicitlyExhaustive*/ {
+    #L12:
+    case #C1:
       {
         core::print("true");
-        break #L5;
+        break #L11;
       }
-    }
-    else
-      if(#C2 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("false");
-          break #L5;
-        }
+    #L13:
+    case #C2:
+      {
+        core::print("false");
+        break #L11;
+      }
+    #L14:
+    case #C3:
+      {
+        core::print("null");
+        break #L11;
       }
-      else
-        if(#0#0 == null) {
-          {
-            core::print("null");
-            break #L5;
-          }
-        }
   }
 }
 static method nonExhaustiveNullableSwitch1(core::bool? e) → void {
-  #L6:
-  {
-    final synthesized invalid-type #0#0 = invalid-expression "pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart:58:11: Error: Undefined name 'b'.
+  #L15:
+  switch(invalid-expression "pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart:58:11: Error: Undefined name 'b'.
   switch (b) /* Error */ {
-          ^";
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+          ^") {
+    #L16:
+    case #C1:
       {
         core::print("true");
-        break #L6;
+        break #L15;
       }
-    }
-    else
-      if(#C2 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("false");
-          break #L6;
-        }
+    #L17:
+    case #C2:
+      {
+        core::print("false");
+        break #L15;
       }
   }
 }
 static method nonExhaustiveNullableSwitch2(core::bool? e) → void {
-  #L7:
-  {
-    final synthesized invalid-type #0#0 = invalid-expression "pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart:69:11: Error: Undefined name 'b'.
+  #L18:
+  switch(invalid-expression "pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart:69:11: Error: Undefined name 'b'.
   switch (b) /* Error */ {
-          ^";
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+          ^") {
+    #L19:
+    case #C1:
       {
         core::print("true");
-        break #L7;
+        break #L18;
       }
-    }
-    else
-      if(#0#0 == null) {
-        {
-          core::print("null");
-          break #L7;
-        }
+    #L20:
+    case #C3:
+      {
+        core::print("null");
+        break #L18;
       }
   }
 }
 static method unreachableCase1(core::bool b) → void {
-  #L8:
-  {
-    final synthesized invalid-type #0#0 = invalid-expression "pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart:80:11: Error: Undefined name 'e'.
+  #L21:
+  switch(invalid-expression "pkg/front_end/testcases/patterns/exhaustiveness/bool_switch.dart:80:11: Error: Undefined name 'e'.
   switch (e) /* Ok */ {
-          ^";
-    function ##0#2#initializer() → core::bool
-      return #C1 =={core::Object::==}{(core::Object) → core::bool} #0#0;
-    late final synthesized core::bool #0#2 = ##0#2#initializer(){() → core::bool};
-    if(#0#2) {
+          ^") {
+    #L22:
+    case #C1:
       {
         core::print("true1");
-        break #L8;
+        break #L21;
       }
-    }
-    else
-      if(#C2 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("false");
-          break #L8;
-        }
+    #L23:
+    case #C2:
+      {
+        core::print("false");
+        break #L21;
+      }
+    #L24:
+    case #C1:
+      {
+        core::print("true2");
+        break #L21;
       }
-      else
-        if(#0#2) {
-          {
-            core::print("true2");
-            break #L8;
-          }
-        }
   }
 }
 static method unreachableCase2(core::bool b) → void {
-  #L9:
-  {
-    final synthesized core::bool #0#0 = b;
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L25:
+  switch(b) /*isExplicitlyExhaustive*/ {
+    #L26:
+    case #C1:
       {
         core::print("true");
-        break #L9;
+        break #L25;
       }
-    }
-    else
-      if(#C2 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("false");
-          break #L9;
-        }
+    #L27:
+    case #C2:
+      {
+        core::print("false");
+        break #L25;
+      }
+    #L28:
+    case #C3:
+      {
+        core::print("null");
+        break #L25;
       }
-      else
-        if(#0#0 == null) {
-          {
-            core::print("null");
-            break #L9;
-          }
-        }
   }
 }
 static method unreachableCase3(core::bool? b) → void {
-  #L10:
-  {
-    final synthesized core::bool? #0#0 = b;
-    function ##0#6#initializer() → core::bool
-      return #0#0 == null;
-    late final synthesized core::bool #0#6 = ##0#6#initializer(){() → core::bool};
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L29:
+  switch(b) /*isExplicitlyExhaustive*/ {
+    #L30:
+    case #C1:
       {
         core::print("true");
-        break #L10;
+        break #L29;
       }
-    }
-    else
-      if(#C2 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("false");
-          break #L10;
-        }
+    #L31:
+    case #C2:
+      {
+        core::print("false");
+        break #L29;
+      }
+    #L32:
+    case #C3:
+      {
+        core::print("null1");
+        break #L29;
+      }
+    #L33:
+    case #C3:
+      {
+        core::print("null2");
+        break #L29;
       }
-      else
-        if(#0#6) {
-          {
-            core::print("null1");
-            break #L10;
-          }
-        }
-        else
-          if(#0#6) {
-            {
-              core::print("null2");
-              break #L10;
-            }
-          }
   }
 }
 
 constants  {
   #C1 = true
   #C2 = false
+  #C3 = null
 }
diff --git a/pkg/front_end/testcases/patterns/exhaustiveness/enum_switch.dart.strong.expect b/pkg/front_end/testcases/patterns/exhaustiveness/enum_switch.dart.strong.expect
index a3a18ffa6b3..7f43335e9cf 100644
--- a/pkg/front_end/testcases/patterns/exhaustiveness/enum_switch.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/exhaustiveness/enum_switch.dart.strong.expect
@@ -71,373 +71,329 @@ class GenericEnum<T extends core::Object? = dynamic> extends core::_Enum /*isEnu
 }
 static method exhaustiveSwitch(self::Enum e) → void {
   #L1:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L2:
+    case #C3:
       {
         core::print("a");
         break #L1;
       }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("b");
-          break #L1;
-        }
+    #L3:
+    case #C6:
+      {
+        core::print("b");
+        break #L1;
+      }
+    #L4:
+    case #C9:
+      {
+        core::print("c");
+        break #L1;
       }
-      else
-        if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-          {
-            core::print("c");
-            break #L1;
-          }
-        }
   }
 }
 static method nonExhaustiveSwitch1(self::Enum e) → void {
-  #L2:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-      {
-        core::print("a");
-        break #L2;
-      }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("b");
-          break #L2;
-        }
-      }
-  }
-}
-static method nonExhaustiveSwitch2(self::Enum e) → void {
-  #L3:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-      {
-        core::print("a");
-        break #L3;
-      }
-    }
-    else
-      if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("c");
-          break #L3;
-        }
-      }
-  }
-}
-static method nonExhaustiveSwitch3(self::Enum e) → void {
-  #L4:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-      {
-        core::print("b");
-        break #L4;
-      }
-    }
-    else
-      if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("c");
-          break #L4;
-        }
-      }
-  }
-}
-static method nonExhaustiveSwitch4(self::Enum e) → void {
   #L5:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L6:
+    case #C3:
+      {
+        core::print("a");
+        break #L5;
+      }
+    #L7:
+    case #C6:
       {
         core::print("b");
         break #L5;
       }
-    }
   }
 }
-static method nonExhaustiveSwitchWithDefault(self::Enum e) → void {
-  #L6:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-      {
-        core::print("b");
-        break #L6;
-      }
-    }
-    else {
-      {
-        core::print("a|c");
-        break #L6;
-      }
-    }
-  }
-}
-static method exhaustiveNullableSwitch(self::Enum? e) → void {
-  #L7:
-  {
-    final synthesized self::Enum? #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-      {
-        core::print("a");
-        break #L7;
-      }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("b");
-          break #L7;
-        }
-      }
-      else
-        if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-          {
-            core::print("c");
-            break #L7;
-          }
-        }
-        else
-          if(#0#0 == null) {
-            {
-              core::print("null");
-              break #L7;
-            }
-          }
-  }
-}
-static method nonExhaustiveNullableSwitch1(self::Enum? e) → void {
+static method nonExhaustiveSwitch2(self::Enum e) → void {
   #L8:
-  {
-    final synthesized self::Enum? #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L9:
+    case #C3:
       {
         core::print("a");
         break #L8;
       }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("b");
-          break #L8;
-        }
+    #L10:
+    case #C9:
+      {
+        core::print("c");
+        break #L8;
+      }
+  }
+}
+static method nonExhaustiveSwitch3(self::Enum e) → void {
+  #L11:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L12:
+    case #C6:
+      {
+        core::print("b");
+        break #L11;
+      }
+    #L13:
+    case #C9:
+      {
+        core::print("c");
+        break #L11;
+      }
+  }
+}
+static method nonExhaustiveSwitch4(self::Enum e) → void {
+  #L14:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L15:
+    case #C6:
+      {
+        core::print("b");
+        break #L14;
+      }
+  }
+}
+static method nonExhaustiveSwitchWithDefault(self::Enum e) → void {
+  #L16:
+  switch(e) {
+    #L17:
+    case #C6:
+      {
+        core::print("b");
+        break #L16;
+      }
+    #L18:
+    default:
+      {
+        core::print("a|c");
+        break #L16;
+      }
+  }
+}
+static method exhaustiveNullableSwitch(self::Enum? e) → void {
+  #L19:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L20:
+    case #C3:
+      {
+        core::print("a");
+        break #L19;
+      }
+    #L21:
+    case #C6:
+      {
+        core::print("b");
+        break #L19;
+      }
+    #L22:
+    case #C9:
+      {
+        core::print("c");
+        break #L19;
+      }
+    #L23:
+    case #C15:
+      {
+        core::print("null");
+        break #L19;
+      }
+  }
+}
+static method nonExhaustiveNullableSwitch1(self::Enum? e) → void {
+  #L24:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L25:
+    case #C3:
+      {
+        core::print("a");
+        break #L24;
+      }
+    #L26:
+    case #C6:
+      {
+        core::print("b");
+        break #L24;
+      }
+    #L27:
+    case #C9:
+      {
+        core::print("c");
+        break #L24;
       }
-      else
-        if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-          {
-            core::print("c");
-            break #L8;
-          }
-        }
   }
 }
 static method nonExhaustiveNullableSwitch2(self::Enum? e) → void {
-  #L9:
-  {
-    final synthesized self::Enum? #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L28:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L29:
+    case #C3:
       {
         core::print("a");
-        break #L9;
+        break #L28;
       }
-    }
-    else
-      if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("c");
-          break #L9;
-        }
+    #L30:
+    case #C9:
+      {
+        core::print("c");
+        break #L28;
+      }
+    #L31:
+    case #C15:
+      {
+        core::print("null");
+        break #L28;
       }
-      else
-        if(#0#0 == null) {
-          {
-            core::print("null");
-            break #L9;
-          }
-        }
   }
 }
 static method unreachableCase1(self::Enum e) → void {
-  #L10:
-  {
-    final synthesized self::Enum #0#0 = e;
-    late final synthesized core::bool #0#2 = #C3 =={core::Object::==}{(core::Object) → core::bool} #0#0;
-    if(#0#2) {
+  #L32:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L33:
+    case #C3:
       {
         core::print("a1");
-        break #L10;
+        break #L32;
       }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("b");
-          break #L10;
-        }
+    #L34:
+    case #C6:
+      {
+        core::print("b");
+        break #L32;
+      }
+    #L35:
+    case #C3:
+      {
+        core::print("a2");
+        break #L32;
+      }
+    #L36:
+    case #C9:
+      {
+        core::print("c");
+        break #L32;
       }
-      else
-        if(#0#2) {
-          {
-            core::print("a2");
-            break #L10;
-          }
-        }
-        else
-          if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-            {
-              core::print("c");
-              break #L10;
-            }
-          }
   }
 }
 static method unreachableCase2(self::Enum e) → void {
-  #L11:
-  {
-    final synthesized self::Enum #0#0 = e;
-    late final synthesized core::bool #0#2 = #C3 =={core::Object::==}{(core::Object) → core::bool} #0#0;
-    if(#0#2) {
+  #L37:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L38:
+    case #C3:
       {
         core::print("a1");
-        break #L11;
+        break #L37;
       }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("b");
-          break #L11;
-        }
+    #L39:
+    case #C6:
+      {
+        core::print("b");
+        break #L37;
+      }
+    #L40:
+    case #C3:
+      {
+        core::print("a2");
+        break #L37;
       }
-      else
-        if(#0#2) {
-          {
-            core::print("a2");
-            break #L11;
-          }
-        }
   }
 }
 static method unreachableCase3(self::Enum e) → void {
-  #L12:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L41:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L42:
+    case #C3:
       {
         core::print("a");
-        break #L12;
+        break #L41;
       }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("b");
-          break #L12;
-        }
+    #L43:
+    case #C6:
+      {
+        core::print("b");
+        break #L41;
+      }
+    #L44:
+    case #C9:
+      {
+        core::print("c");
+        break #L41;
+      }
+    #L45:
+    case #C15:
+      {
+        core::print("null");
+        break #L41;
       }
-      else
-        if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-          {
-            core::print("c");
-            break #L12;
-          }
-        }
-        else
-          if(#0#0 == null) {
-            {
-              core::print("null");
-              break #L12;
-            }
-          }
   }
 }
 static method unreachableCase4(self::Enum? e) → void {
-  #L13:
-  {
-    final synthesized self::Enum? #0#0 = e;
-    late final synthesized core::bool #0#8 = #0#0 == null;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L46:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L47:
+    case #C3:
       {
         core::print("a");
-        break #L13;
+        break #L46;
       }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("b");
-          break #L13;
-        }
+    #L48:
+    case #C6:
+      {
+        core::print("b");
+        break #L46;
+      }
+    #L49:
+    case #C9:
+      {
+        core::print("c");
+        break #L46;
+      }
+    #L50:
+    case #C15:
+      {
+        core::print("null1");
+        break #L46;
+      }
+    #L51:
+    case #C15:
+      {
+        core::print("null2");
+        break #L46;
       }
-      else
-        if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-          {
-            core::print("c");
-            break #L13;
-          }
-        }
-        else
-          if(#0#8) {
-            {
-              core::print("null1");
-              break #L13;
-            }
-          }
-          else
-            if(#0#8) {
-              {
-                core::print("null2");
-                break #L13;
-              }
-            }
   }
 }
 static method exhaustiveGenericSwitch(self::GenericEnum<dynamic> e) → void {
-  #L14:
-  {
-    final synthesized self::GenericEnum<dynamic> #0#0 = e;
-    if(#C11 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L52:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L53:
+    case #C11:
       {
         core::print("a");
-        break #L14;
+        break #L52;
       }
-    }
-    else
-      if(#C12 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("b");
-          break #L14;
-        }
+    #L54:
+    case #C12:
+      {
+        core::print("b");
+        break #L52;
+      }
+    #L55:
+    case #C13:
+      {
+        core::print("c");
+        break #L52;
       }
-      else
-        if(#C13 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-          {
-            core::print("c");
-            break #L14;
-          }
-        }
   }
 }
 static method exhaustiveGenericSwitchTyped(self::GenericEnum<core::int> e) → void {
-  #L15:
-  {
-    final synthesized self::GenericEnum<core::int> #0#0 = e;
-    if(#C11 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L56:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L57:
+    case #C11:
       {
         core::print("a");
-        break #L15;
+        break #L56;
       }
-    }
   }
 }
 
@@ -456,6 +412,7 @@ constants  {
   #C12 = self::GenericEnum<core::String> {index:#C4, _name:#C5}
   #C13 = self::GenericEnum<core::bool> {index:#C7, _name:#C8}
   #C14 = <self::GenericEnum<dynamic>>[#C11, #C12, #C13]
+  #C15 = null
 }
 
 
diff --git a/pkg/front_end/testcases/patterns/exhaustiveness/enum_switch.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/exhaustiveness/enum_switch.dart.strong.transformed.expect
index e35a84ee983..7f43335e9cf 100644
--- a/pkg/front_end/testcases/patterns/exhaustiveness/enum_switch.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/exhaustiveness/enum_switch.dart.strong.transformed.expect
@@ -71,379 +71,329 @@ class GenericEnum<T extends core::Object? = dynamic> extends core::_Enum /*isEnu
 }
 static method exhaustiveSwitch(self::Enum e) → void {
   #L1:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L2:
+    case #C3:
       {
         core::print("a");
         break #L1;
       }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("b");
-          break #L1;
-        }
+    #L3:
+    case #C6:
+      {
+        core::print("b");
+        break #L1;
+      }
+    #L4:
+    case #C9:
+      {
+        core::print("c");
+        break #L1;
       }
-      else
-        if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-          {
-            core::print("c");
-            break #L1;
-          }
-        }
   }
 }
 static method nonExhaustiveSwitch1(self::Enum e) → void {
-  #L2:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-      {
-        core::print("a");
-        break #L2;
-      }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("b");
-          break #L2;
-        }
-      }
-  }
-}
-static method nonExhaustiveSwitch2(self::Enum e) → void {
-  #L3:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-      {
-        core::print("a");
-        break #L3;
-      }
-    }
-    else
-      if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("c");
-          break #L3;
-        }
-      }
-  }
-}
-static method nonExhaustiveSwitch3(self::Enum e) → void {
-  #L4:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-      {
-        core::print("b");
-        break #L4;
-      }
-    }
-    else
-      if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("c");
-          break #L4;
-        }
-      }
-  }
-}
-static method nonExhaustiveSwitch4(self::Enum e) → void {
   #L5:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L6:
+    case #C3:
+      {
+        core::print("a");
+        break #L5;
+      }
+    #L7:
+    case #C6:
       {
         core::print("b");
         break #L5;
       }
-    }
   }
 }
-static method nonExhaustiveSwitchWithDefault(self::Enum e) → void {
-  #L6:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-      {
-        core::print("b");
-        break #L6;
-      }
-    }
-    else {
-      {
-        core::print("a|c");
-        break #L6;
-      }
-    }
-  }
-}
-static method exhaustiveNullableSwitch(self::Enum? e) → void {
-  #L7:
-  {
-    final synthesized self::Enum? #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-      {
-        core::print("a");
-        break #L7;
-      }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("b");
-          break #L7;
-        }
-      }
-      else
-        if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-          {
-            core::print("c");
-            break #L7;
-          }
-        }
-        else
-          if(#0#0 == null) {
-            {
-              core::print("null");
-              break #L7;
-            }
-          }
-  }
-}
-static method nonExhaustiveNullableSwitch1(self::Enum? e) → void {
+static method nonExhaustiveSwitch2(self::Enum e) → void {
   #L8:
-  {
-    final synthesized self::Enum? #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L9:
+    case #C3:
       {
         core::print("a");
         break #L8;
       }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("b");
-          break #L8;
-        }
+    #L10:
+    case #C9:
+      {
+        core::print("c");
+        break #L8;
+      }
+  }
+}
+static method nonExhaustiveSwitch3(self::Enum e) → void {
+  #L11:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L12:
+    case #C6:
+      {
+        core::print("b");
+        break #L11;
+      }
+    #L13:
+    case #C9:
+      {
+        core::print("c");
+        break #L11;
+      }
+  }
+}
+static method nonExhaustiveSwitch4(self::Enum e) → void {
+  #L14:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L15:
+    case #C6:
+      {
+        core::print("b");
+        break #L14;
+      }
+  }
+}
+static method nonExhaustiveSwitchWithDefault(self::Enum e) → void {
+  #L16:
+  switch(e) {
+    #L17:
+    case #C6:
+      {
+        core::print("b");
+        break #L16;
+      }
+    #L18:
+    default:
+      {
+        core::print("a|c");
+        break #L16;
+      }
+  }
+}
+static method exhaustiveNullableSwitch(self::Enum? e) → void {
+  #L19:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L20:
+    case #C3:
+      {
+        core::print("a");
+        break #L19;
+      }
+    #L21:
+    case #C6:
+      {
+        core::print("b");
+        break #L19;
+      }
+    #L22:
+    case #C9:
+      {
+        core::print("c");
+        break #L19;
+      }
+    #L23:
+    case #C15:
+      {
+        core::print("null");
+        break #L19;
+      }
+  }
+}
+static method nonExhaustiveNullableSwitch1(self::Enum? e) → void {
+  #L24:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L25:
+    case #C3:
+      {
+        core::print("a");
+        break #L24;
+      }
+    #L26:
+    case #C6:
+      {
+        core::print("b");
+        break #L24;
+      }
+    #L27:
+    case #C9:
+      {
+        core::print("c");
+        break #L24;
       }
-      else
-        if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-          {
-            core::print("c");
-            break #L8;
-          }
-        }
   }
 }
 static method nonExhaustiveNullableSwitch2(self::Enum? e) → void {
-  #L9:
-  {
-    final synthesized self::Enum? #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L28:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L29:
+    case #C3:
       {
         core::print("a");
-        break #L9;
+        break #L28;
       }
-    }
-    else
-      if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("c");
-          break #L9;
-        }
+    #L30:
+    case #C9:
+      {
+        core::print("c");
+        break #L28;
+      }
+    #L31:
+    case #C15:
+      {
+        core::print("null");
+        break #L28;
       }
-      else
-        if(#0#0 == null) {
-          {
-            core::print("null");
-            break #L9;
-          }
-        }
   }
 }
 static method unreachableCase1(self::Enum e) → void {
-  #L10:
-  {
-    final synthesized self::Enum #0#0 = e;
-    function ##0#2#initializer() → core::bool
-      return #C3 =={core::Object::==}{(core::Object) → core::bool} #0#0;
-    late final synthesized core::bool #0#2 = ##0#2#initializer(){() → core::bool};
-    if(#0#2) {
+  #L32:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L33:
+    case #C3:
       {
         core::print("a1");
-        break #L10;
+        break #L32;
       }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("b");
-          break #L10;
-        }
+    #L34:
+    case #C6:
+      {
+        core::print("b");
+        break #L32;
+      }
+    #L35:
+    case #C3:
+      {
+        core::print("a2");
+        break #L32;
+      }
+    #L36:
+    case #C9:
+      {
+        core::print("c");
+        break #L32;
       }
-      else
-        if(#0#2) {
-          {
-            core::print("a2");
-            break #L10;
-          }
-        }
-        else
-          if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-            {
-              core::print("c");
-              break #L10;
-            }
-          }
   }
 }
 static method unreachableCase2(self::Enum e) → void {
-  #L11:
-  {
-    final synthesized self::Enum #0#0 = e;
-    function ##0#2#initializer() → core::bool
-      return #C3 =={core::Object::==}{(core::Object) → core::bool} #0#0;
-    late final synthesized core::bool #0#2 = ##0#2#initializer(){() → core::bool};
-    if(#0#2) {
+  #L37:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L38:
+    case #C3:
       {
         core::print("a1");
-        break #L11;
+        break #L37;
       }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("b");
-          break #L11;
-        }
+    #L39:
+    case #C6:
+      {
+        core::print("b");
+        break #L37;
+      }
+    #L40:
+    case #C3:
+      {
+        core::print("a2");
+        break #L37;
       }
-      else
-        if(#0#2) {
-          {
-            core::print("a2");
-            break #L11;
-          }
-        }
   }
 }
 static method unreachableCase3(self::Enum e) → void {
-  #L12:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L41:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L42:
+    case #C3:
       {
         core::print("a");
-        break #L12;
+        break #L41;
       }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("b");
-          break #L12;
-        }
+    #L43:
+    case #C6:
+      {
+        core::print("b");
+        break #L41;
+      }
+    #L44:
+    case #C9:
+      {
+        core::print("c");
+        break #L41;
+      }
+    #L45:
+    case #C15:
+      {
+        core::print("null");
+        break #L41;
       }
-      else
-        if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-          {
-            core::print("c");
-            break #L12;
-          }
-        }
-        else
-          if(#0#0 == null) {
-            {
-              core::print("null");
-              break #L12;
-            }
-          }
   }
 }
 static method unreachableCase4(self::Enum? e) → void {
-  #L13:
-  {
-    final synthesized self::Enum? #0#0 = e;
-    function ##0#8#initializer() → core::bool
-      return #0#0 == null;
-    late final synthesized core::bool #0#8 = ##0#8#initializer(){() → core::bool};
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L46:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L47:
+    case #C3:
       {
         core::print("a");
-        break #L13;
+        break #L46;
       }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("b");
-          break #L13;
-        }
+    #L48:
+    case #C6:
+      {
+        core::print("b");
+        break #L46;
+      }
+    #L49:
+    case #C9:
+      {
+        core::print("c");
+        break #L46;
+      }
+    #L50:
+    case #C15:
+      {
+        core::print("null1");
+        break #L46;
+      }
+    #L51:
+    case #C15:
+      {
+        core::print("null2");
+        break #L46;
       }
-      else
-        if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-          {
-            core::print("c");
-            break #L13;
-          }
-        }
-        else
-          if(#0#8) {
-            {
-              core::print("null1");
-              break #L13;
-            }
-          }
-          else
-            if(#0#8) {
-              {
-                core::print("null2");
-                break #L13;
-              }
-            }
   }
 }
 static method exhaustiveGenericSwitch(self::GenericEnum<dynamic> e) → void {
-  #L14:
-  {
-    final synthesized self::GenericEnum<dynamic> #0#0 = e;
-    if(#C11 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L52:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L53:
+    case #C11:
       {
         core::print("a");
-        break #L14;
+        break #L52;
       }
-    }
-    else
-      if(#C12 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("b");
-          break #L14;
-        }
+    #L54:
+    case #C12:
+      {
+        core::print("b");
+        break #L52;
+      }
+    #L55:
+    case #C13:
+      {
+        core::print("c");
+        break #L52;
       }
-      else
-        if(#C13 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-          {
-            core::print("c");
-            break #L14;
-          }
-        }
   }
 }
 static method exhaustiveGenericSwitchTyped(self::GenericEnum<core::int> e) → void {
-  #L15:
-  {
-    final synthesized self::GenericEnum<core::int> #0#0 = e;
-    if(#C11 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L56:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L57:
+    case #C11:
       {
         core::print("a");
-        break #L15;
+        break #L56;
       }
-    }
   }
 }
 
@@ -462,6 +412,7 @@ constants  {
   #C12 = self::GenericEnum<core::String> {index:#C4, _name:#C5}
   #C13 = self::GenericEnum<core::bool> {index:#C7, _name:#C8}
   #C14 = <self::GenericEnum<dynamic>>[#C11, #C12, #C13]
+  #C15 = null
 }
 
 
diff --git a/pkg/front_end/testcases/patterns/exhaustiveness/enum_switch.dart.weak.expect b/pkg/front_end/testcases/patterns/exhaustiveness/enum_switch.dart.weak.expect
index 13048f07f94..5ed18ca31fa 100644
--- a/pkg/front_end/testcases/patterns/exhaustiveness/enum_switch.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/exhaustiveness/enum_switch.dart.weak.expect
@@ -71,373 +71,329 @@ class GenericEnum<T extends core::Object? = dynamic> extends core::_Enum /*isEnu
 }
 static method exhaustiveSwitch(self::Enum e) → void {
   #L1:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L2:
+    case #C3:
       {
         core::print("a");
         break #L1;
       }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("b");
-          break #L1;
-        }
+    #L3:
+    case #C6:
+      {
+        core::print("b");
+        break #L1;
+      }
+    #L4:
+    case #C9:
+      {
+        core::print("c");
+        break #L1;
       }
-      else
-        if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-          {
-            core::print("c");
-            break #L1;
-          }
-        }
   }
 }
 static method nonExhaustiveSwitch1(self::Enum e) → void {
-  #L2:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-      {
-        core::print("a");
-        break #L2;
-      }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("b");
-          break #L2;
-        }
-      }
-  }
-}
-static method nonExhaustiveSwitch2(self::Enum e) → void {
-  #L3:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-      {
-        core::print("a");
-        break #L3;
-      }
-    }
-    else
-      if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("c");
-          break #L3;
-        }
-      }
-  }
-}
-static method nonExhaustiveSwitch3(self::Enum e) → void {
-  #L4:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-      {
-        core::print("b");
-        break #L4;
-      }
-    }
-    else
-      if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("c");
-          break #L4;
-        }
-      }
-  }
-}
-static method nonExhaustiveSwitch4(self::Enum e) → void {
   #L5:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L6:
+    case #C3:
+      {
+        core::print("a");
+        break #L5;
+      }
+    #L7:
+    case #C6:
       {
         core::print("b");
         break #L5;
       }
-    }
   }
 }
-static method nonExhaustiveSwitchWithDefault(self::Enum e) → void {
-  #L6:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-      {
-        core::print("b");
-        break #L6;
-      }
-    }
-    else {
-      {
-        core::print("a|c");
-        break #L6;
-      }
-    }
-  }
-}
-static method exhaustiveNullableSwitch(self::Enum? e) → void {
-  #L7:
-  {
-    final synthesized self::Enum? #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-      {
-        core::print("a");
-        break #L7;
-      }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("b");
-          break #L7;
-        }
-      }
-      else
-        if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-          {
-            core::print("c");
-            break #L7;
-          }
-        }
-        else
-          if(#0#0 == null) {
-            {
-              core::print("null");
-              break #L7;
-            }
-          }
-  }
-}
-static method nonExhaustiveNullableSwitch1(self::Enum? e) → void {
+static method nonExhaustiveSwitch2(self::Enum e) → void {
   #L8:
-  {
-    final synthesized self::Enum? #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L9:
+    case #C3:
       {
         core::print("a");
         break #L8;
       }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("b");
-          break #L8;
-        }
+    #L10:
+    case #C9:
+      {
+        core::print("c");
+        break #L8;
+      }
+  }
+}
+static method nonExhaustiveSwitch3(self::Enum e) → void {
+  #L11:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L12:
+    case #C6:
+      {
+        core::print("b");
+        break #L11;
+      }
+    #L13:
+    case #C9:
+      {
+        core::print("c");
+        break #L11;
+      }
+  }
+}
+static method nonExhaustiveSwitch4(self::Enum e) → void {
+  #L14:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L15:
+    case #C6:
+      {
+        core::print("b");
+        break #L14;
+      }
+  }
+}
+static method nonExhaustiveSwitchWithDefault(self::Enum e) → void {
+  #L16:
+  switch(e) {
+    #L17:
+    case #C6:
+      {
+        core::print("b");
+        break #L16;
+      }
+    #L18:
+    default:
+      {
+        core::print("a|c");
+        break #L16;
+      }
+  }
+}
+static method exhaustiveNullableSwitch(self::Enum? e) → void {
+  #L19:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L20:
+    case #C3:
+      {
+        core::print("a");
+        break #L19;
+      }
+    #L21:
+    case #C6:
+      {
+        core::print("b");
+        break #L19;
+      }
+    #L22:
+    case #C9:
+      {
+        core::print("c");
+        break #L19;
+      }
+    #L23:
+    case #C15:
+      {
+        core::print("null");
+        break #L19;
+      }
+  }
+}
+static method nonExhaustiveNullableSwitch1(self::Enum? e) → void {
+  #L24:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L25:
+    case #C3:
+      {
+        core::print("a");
+        break #L24;
+      }
+    #L26:
+    case #C6:
+      {
+        core::print("b");
+        break #L24;
+      }
+    #L27:
+    case #C9:
+      {
+        core::print("c");
+        break #L24;
       }
-      else
-        if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-          {
-            core::print("c");
-            break #L8;
-          }
-        }
   }
 }
 static method nonExhaustiveNullableSwitch2(self::Enum? e) → void {
-  #L9:
-  {
-    final synthesized self::Enum? #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L28:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L29:
+    case #C3:
       {
         core::print("a");
-        break #L9;
+        break #L28;
       }
-    }
-    else
-      if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("c");
-          break #L9;
-        }
+    #L30:
+    case #C9:
+      {
+        core::print("c");
+        break #L28;
+      }
+    #L31:
+    case #C15:
+      {
+        core::print("null");
+        break #L28;
       }
-      else
-        if(#0#0 == null) {
-          {
-            core::print("null");
-            break #L9;
-          }
-        }
   }
 }
 static method unreachableCase1(self::Enum e) → void {
-  #L10:
-  {
-    final synthesized self::Enum #0#0 = e;
-    late final synthesized core::bool #0#2 = #C3 =={core::Object::==}{(core::Object) → core::bool} #0#0;
-    if(#0#2) {
+  #L32:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L33:
+    case #C3:
       {
         core::print("a1");
-        break #L10;
+        break #L32;
       }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("b");
-          break #L10;
-        }
+    #L34:
+    case #C6:
+      {
+        core::print("b");
+        break #L32;
+      }
+    #L35:
+    case #C3:
+      {
+        core::print("a2");
+        break #L32;
+      }
+    #L36:
+    case #C9:
+      {
+        core::print("c");
+        break #L32;
       }
-      else
-        if(#0#2) {
-          {
-            core::print("a2");
-            break #L10;
-          }
-        }
-        else
-          if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-            {
-              core::print("c");
-              break #L10;
-            }
-          }
   }
 }
 static method unreachableCase2(self::Enum e) → void {
-  #L11:
-  {
-    final synthesized self::Enum #0#0 = e;
-    late final synthesized core::bool #0#2 = #C3 =={core::Object::==}{(core::Object) → core::bool} #0#0;
-    if(#0#2) {
+  #L37:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L38:
+    case #C3:
       {
         core::print("a1");
-        break #L11;
+        break #L37;
       }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("b");
-          break #L11;
-        }
+    #L39:
+    case #C6:
+      {
+        core::print("b");
+        break #L37;
+      }
+    #L40:
+    case #C3:
+      {
+        core::print("a2");
+        break #L37;
       }
-      else
-        if(#0#2) {
-          {
-            core::print("a2");
-            break #L11;
-          }
-        }
   }
 }
 static method unreachableCase3(self::Enum e) → void {
-  #L12:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L41:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L42:
+    case #C3:
       {
         core::print("a");
-        break #L12;
+        break #L41;
       }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("b");
-          break #L12;
-        }
+    #L43:
+    case #C6:
+      {
+        core::print("b");
+        break #L41;
+      }
+    #L44:
+    case #C9:
+      {
+        core::print("c");
+        break #L41;
+      }
+    #L45:
+    case #C15:
+      {
+        core::print("null");
+        break #L41;
       }
-      else
-        if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-          {
-            core::print("c");
-            break #L12;
-          }
-        }
-        else
-          if(#0#0 == null) {
-            {
-              core::print("null");
-              break #L12;
-            }
-          }
   }
 }
 static method unreachableCase4(self::Enum? e) → void {
-  #L13:
-  {
-    final synthesized self::Enum? #0#0 = e;
-    late final synthesized core::bool #0#8 = #0#0 == null;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L46:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L47:
+    case #C3:
       {
         core::print("a");
-        break #L13;
+        break #L46;
       }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("b");
-          break #L13;
-        }
+    #L48:
+    case #C6:
+      {
+        core::print("b");
+        break #L46;
+      }
+    #L49:
+    case #C9:
+      {
+        core::print("c");
+        break #L46;
+      }
+    #L50:
+    case #C15:
+      {
+        core::print("null1");
+        break #L46;
+      }
+    #L51:
+    case #C15:
+      {
+        core::print("null2");
+        break #L46;
       }
-      else
-        if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-          {
-            core::print("c");
-            break #L13;
-          }
-        }
-        else
-          if(#0#8) {
-            {
-              core::print("null1");
-              break #L13;
-            }
-          }
-          else
-            if(#0#8) {
-              {
-                core::print("null2");
-                break #L13;
-              }
-            }
   }
 }
 static method exhaustiveGenericSwitch(self::GenericEnum<dynamic> e) → void {
-  #L14:
-  {
-    final synthesized self::GenericEnum<dynamic> #0#0 = e;
-    if(#C11 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L52:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L53:
+    case #C11:
       {
         core::print("a");
-        break #L14;
+        break #L52;
       }
-    }
-    else
-      if(#C12 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("b");
-          break #L14;
-        }
+    #L54:
+    case #C12:
+      {
+        core::print("b");
+        break #L52;
+      }
+    #L55:
+    case #C13:
+      {
+        core::print("c");
+        break #L52;
       }
-      else
-        if(#C13 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-          {
-            core::print("c");
-            break #L14;
-          }
-        }
   }
 }
 static method exhaustiveGenericSwitchTyped(self::GenericEnum<core::int> e) → void {
-  #L15:
-  {
-    final synthesized self::GenericEnum<core::int> #0#0 = e;
-    if(#C11 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L56:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L57:
+    case #C11:
       {
         core::print("a");
-        break #L15;
+        break #L56;
       }
-    }
   }
 }
 
@@ -456,6 +412,7 @@ constants  {
   #C12 = self::GenericEnum<core::String*> {index:#C4, _name:#C5}
   #C13 = self::GenericEnum<core::bool*> {index:#C7, _name:#C8}
   #C14 = <self::GenericEnum<dynamic>*>[#C11, #C12, #C13]
+  #C15 = null
 }
 
 
diff --git a/pkg/front_end/testcases/patterns/exhaustiveness/enum_switch.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/exhaustiveness/enum_switch.dart.weak.modular.expect
index 13048f07f94..5ed18ca31fa 100644
--- a/pkg/front_end/testcases/patterns/exhaustiveness/enum_switch.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/exhaustiveness/enum_switch.dart.weak.modular.expect
@@ -71,373 +71,329 @@ class GenericEnum<T extends core::Object? = dynamic> extends core::_Enum /*isEnu
 }
 static method exhaustiveSwitch(self::Enum e) → void {
   #L1:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L2:
+    case #C3:
       {
         core::print("a");
         break #L1;
       }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("b");
-          break #L1;
-        }
+    #L3:
+    case #C6:
+      {
+        core::print("b");
+        break #L1;
+      }
+    #L4:
+    case #C9:
+      {
+        core::print("c");
+        break #L1;
       }
-      else
-        if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-          {
-            core::print("c");
-            break #L1;
-          }
-        }
   }
 }
 static method nonExhaustiveSwitch1(self::Enum e) → void {
-  #L2:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-      {
-        core::print("a");
-        break #L2;
-      }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("b");
-          break #L2;
-        }
-      }
-  }
-}
-static method nonExhaustiveSwitch2(self::Enum e) → void {
-  #L3:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-      {
-        core::print("a");
-        break #L3;
-      }
-    }
-    else
-      if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("c");
-          break #L3;
-        }
-      }
-  }
-}
-static method nonExhaustiveSwitch3(self::Enum e) → void {
-  #L4:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-      {
-        core::print("b");
-        break #L4;
-      }
-    }
-    else
-      if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("c");
-          break #L4;
-        }
-      }
-  }
-}
-static method nonExhaustiveSwitch4(self::Enum e) → void {
   #L5:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L6:
+    case #C3:
+      {
+        core::print("a");
+        break #L5;
+      }
+    #L7:
+    case #C6:
       {
         core::print("b");
         break #L5;
       }
-    }
   }
 }
-static method nonExhaustiveSwitchWithDefault(self::Enum e) → void {
-  #L6:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-      {
-        core::print("b");
-        break #L6;
-      }
-    }
-    else {
-      {
-        core::print("a|c");
-        break #L6;
-      }
-    }
-  }
-}
-static method exhaustiveNullableSwitch(self::Enum? e) → void {
-  #L7:
-  {
-    final synthesized self::Enum? #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-      {
-        core::print("a");
-        break #L7;
-      }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("b");
-          break #L7;
-        }
-      }
-      else
-        if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-          {
-            core::print("c");
-            break #L7;
-          }
-        }
-        else
-          if(#0#0 == null) {
-            {
-              core::print("null");
-              break #L7;
-            }
-          }
-  }
-}
-static method nonExhaustiveNullableSwitch1(self::Enum? e) → void {
+static method nonExhaustiveSwitch2(self::Enum e) → void {
   #L8:
-  {
-    final synthesized self::Enum? #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L9:
+    case #C3:
       {
         core::print("a");
         break #L8;
       }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("b");
-          break #L8;
-        }
+    #L10:
+    case #C9:
+      {
+        core::print("c");
+        break #L8;
+      }
+  }
+}
+static method nonExhaustiveSwitch3(self::Enum e) → void {
+  #L11:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L12:
+    case #C6:
+      {
+        core::print("b");
+        break #L11;
+      }
+    #L13:
+    case #C9:
+      {
+        core::print("c");
+        break #L11;
+      }
+  }
+}
+static method nonExhaustiveSwitch4(self::Enum e) → void {
+  #L14:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L15:
+    case #C6:
+      {
+        core::print("b");
+        break #L14;
+      }
+  }
+}
+static method nonExhaustiveSwitchWithDefault(self::Enum e) → void {
+  #L16:
+  switch(e) {
+    #L17:
+    case #C6:
+      {
+        core::print("b");
+        break #L16;
+      }
+    #L18:
+    default:
+      {
+        core::print("a|c");
+        break #L16;
+      }
+  }
+}
+static method exhaustiveNullableSwitch(self::Enum? e) → void {
+  #L19:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L20:
+    case #C3:
+      {
+        core::print("a");
+        break #L19;
+      }
+    #L21:
+    case #C6:
+      {
+        core::print("b");
+        break #L19;
+      }
+    #L22:
+    case #C9:
+      {
+        core::print("c");
+        break #L19;
+      }
+    #L23:
+    case #C15:
+      {
+        core::print("null");
+        break #L19;
+      }
+  }
+}
+static method nonExhaustiveNullableSwitch1(self::Enum? e) → void {
+  #L24:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L25:
+    case #C3:
+      {
+        core::print("a");
+        break #L24;
+      }
+    #L26:
+    case #C6:
+      {
+        core::print("b");
+        break #L24;
+      }
+    #L27:
+    case #C9:
+      {
+        core::print("c");
+        break #L24;
       }
-      else
-        if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-          {
-            core::print("c");
-            break #L8;
-          }
-        }
   }
 }
 static method nonExhaustiveNullableSwitch2(self::Enum? e) → void {
-  #L9:
-  {
-    final synthesized self::Enum? #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L28:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L29:
+    case #C3:
       {
         core::print("a");
-        break #L9;
+        break #L28;
       }
-    }
-    else
-      if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("c");
-          break #L9;
-        }
+    #L30:
+    case #C9:
+      {
+        core::print("c");
+        break #L28;
+      }
+    #L31:
+    case #C15:
+      {
+        core::print("null");
+        break #L28;
       }
-      else
-        if(#0#0 == null) {
-          {
-            core::print("null");
-            break #L9;
-          }
-        }
   }
 }
 static method unreachableCase1(self::Enum e) → void {
-  #L10:
-  {
-    final synthesized self::Enum #0#0 = e;
-    late final synthesized core::bool #0#2 = #C3 =={core::Object::==}{(core::Object) → core::bool} #0#0;
-    if(#0#2) {
+  #L32:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L33:
+    case #C3:
       {
         core::print("a1");
-        break #L10;
+        break #L32;
       }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("b");
-          break #L10;
-        }
+    #L34:
+    case #C6:
+      {
+        core::print("b");
+        break #L32;
+      }
+    #L35:
+    case #C3:
+      {
+        core::print("a2");
+        break #L32;
+      }
+    #L36:
+    case #C9:
+      {
+        core::print("c");
+        break #L32;
       }
-      else
-        if(#0#2) {
-          {
-            core::print("a2");
-            break #L10;
-          }
-        }
-        else
-          if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-            {
-              core::print("c");
-              break #L10;
-            }
-          }
   }
 }
 static method unreachableCase2(self::Enum e) → void {
-  #L11:
-  {
-    final synthesized self::Enum #0#0 = e;
-    late final synthesized core::bool #0#2 = #C3 =={core::Object::==}{(core::Object) → core::bool} #0#0;
-    if(#0#2) {
+  #L37:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L38:
+    case #C3:
       {
         core::print("a1");
-        break #L11;
+        break #L37;
       }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("b");
-          break #L11;
-        }
+    #L39:
+    case #C6:
+      {
+        core::print("b");
+        break #L37;
+      }
+    #L40:
+    case #C3:
+      {
+        core::print("a2");
+        break #L37;
       }
-      else
-        if(#0#2) {
-          {
-            core::print("a2");
-            break #L11;
-          }
-        }
   }
 }
 static method unreachableCase3(self::Enum e) → void {
-  #L12:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L41:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L42:
+    case #C3:
       {
         core::print("a");
-        break #L12;
+        break #L41;
       }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("b");
-          break #L12;
-        }
+    #L43:
+    case #C6:
+      {
+        core::print("b");
+        break #L41;
+      }
+    #L44:
+    case #C9:
+      {
+        core::print("c");
+        break #L41;
+      }
+    #L45:
+    case #C15:
+      {
+        core::print("null");
+        break #L41;
       }
-      else
-        if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-          {
-            core::print("c");
-            break #L12;
-          }
-        }
-        else
-          if(#0#0 == null) {
-            {
-              core::print("null");
-              break #L12;
-            }
-          }
   }
 }
 static method unreachableCase4(self::Enum? e) → void {
-  #L13:
-  {
-    final synthesized self::Enum? #0#0 = e;
-    late final synthesized core::bool #0#8 = #0#0 == null;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L46:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L47:
+    case #C3:
       {
         core::print("a");
-        break #L13;
+        break #L46;
       }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("b");
-          break #L13;
-        }
+    #L48:
+    case #C6:
+      {
+        core::print("b");
+        break #L46;
+      }
+    #L49:
+    case #C9:
+      {
+        core::print("c");
+        break #L46;
+      }
+    #L50:
+    case #C15:
+      {
+        core::print("null1");
+        break #L46;
+      }
+    #L51:
+    case #C15:
+      {
+        core::print("null2");
+        break #L46;
       }
-      else
-        if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-          {
-            core::print("c");
-            break #L13;
-          }
-        }
-        else
-          if(#0#8) {
-            {
-              core::print("null1");
-              break #L13;
-            }
-          }
-          else
-            if(#0#8) {
-              {
-                core::print("null2");
-                break #L13;
-              }
-            }
   }
 }
 static method exhaustiveGenericSwitch(self::GenericEnum<dynamic> e) → void {
-  #L14:
-  {
-    final synthesized self::GenericEnum<dynamic> #0#0 = e;
-    if(#C11 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L52:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L53:
+    case #C11:
       {
         core::print("a");
-        break #L14;
+        break #L52;
       }
-    }
-    else
-      if(#C12 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("b");
-          break #L14;
-        }
+    #L54:
+    case #C12:
+      {
+        core::print("b");
+        break #L52;
+      }
+    #L55:
+    case #C13:
+      {
+        core::print("c");
+        break #L52;
       }
-      else
-        if(#C13 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-          {
-            core::print("c");
-            break #L14;
-          }
-        }
   }
 }
 static method exhaustiveGenericSwitchTyped(self::GenericEnum<core::int> e) → void {
-  #L15:
-  {
-    final synthesized self::GenericEnum<core::int> #0#0 = e;
-    if(#C11 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L56:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L57:
+    case #C11:
       {
         core::print("a");
-        break #L15;
+        break #L56;
       }
-    }
   }
 }
 
@@ -456,6 +412,7 @@ constants  {
   #C12 = self::GenericEnum<core::String*> {index:#C4, _name:#C5}
   #C13 = self::GenericEnum<core::bool*> {index:#C7, _name:#C8}
   #C14 = <self::GenericEnum<dynamic>*>[#C11, #C12, #C13]
+  #C15 = null
 }
 
 
diff --git a/pkg/front_end/testcases/patterns/exhaustiveness/enum_switch.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/exhaustiveness/enum_switch.dart.weak.transformed.expect
index 7863e3a7d59..5ed18ca31fa 100644
--- a/pkg/front_end/testcases/patterns/exhaustiveness/enum_switch.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/exhaustiveness/enum_switch.dart.weak.transformed.expect
@@ -71,379 +71,329 @@ class GenericEnum<T extends core::Object? = dynamic> extends core::_Enum /*isEnu
 }
 static method exhaustiveSwitch(self::Enum e) → void {
   #L1:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L2:
+    case #C3:
       {
         core::print("a");
         break #L1;
       }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("b");
-          break #L1;
-        }
+    #L3:
+    case #C6:
+      {
+        core::print("b");
+        break #L1;
+      }
+    #L4:
+    case #C9:
+      {
+        core::print("c");
+        break #L1;
       }
-      else
-        if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-          {
-            core::print("c");
-            break #L1;
-          }
-        }
   }
 }
 static method nonExhaustiveSwitch1(self::Enum e) → void {
-  #L2:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-      {
-        core::print("a");
-        break #L2;
-      }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("b");
-          break #L2;
-        }
-      }
-  }
-}
-static method nonExhaustiveSwitch2(self::Enum e) → void {
-  #L3:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-      {
-        core::print("a");
-        break #L3;
-      }
-    }
-    else
-      if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("c");
-          break #L3;
-        }
-      }
-  }
-}
-static method nonExhaustiveSwitch3(self::Enum e) → void {
-  #L4:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-      {
-        core::print("b");
-        break #L4;
-      }
-    }
-    else
-      if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("c");
-          break #L4;
-        }
-      }
-  }
-}
-static method nonExhaustiveSwitch4(self::Enum e) → void {
   #L5:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L6:
+    case #C3:
+      {
+        core::print("a");
+        break #L5;
+      }
+    #L7:
+    case #C6:
       {
         core::print("b");
         break #L5;
       }
-    }
   }
 }
-static method nonExhaustiveSwitchWithDefault(self::Enum e) → void {
-  #L6:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-      {
-        core::print("b");
-        break #L6;
-      }
-    }
-    else {
-      {
-        core::print("a|c");
-        break #L6;
-      }
-    }
-  }
-}
-static method exhaustiveNullableSwitch(self::Enum? e) → void {
-  #L7:
-  {
-    final synthesized self::Enum? #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-      {
-        core::print("a");
-        break #L7;
-      }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("b");
-          break #L7;
-        }
-      }
-      else
-        if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-          {
-            core::print("c");
-            break #L7;
-          }
-        }
-        else
-          if(#0#0 == null) {
-            {
-              core::print("null");
-              break #L7;
-            }
-          }
-  }
-}
-static method nonExhaustiveNullableSwitch1(self::Enum? e) → void {
+static method nonExhaustiveSwitch2(self::Enum e) → void {
   #L8:
-  {
-    final synthesized self::Enum? #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L9:
+    case #C3:
       {
         core::print("a");
         break #L8;
       }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("b");
-          break #L8;
-        }
+    #L10:
+    case #C9:
+      {
+        core::print("c");
+        break #L8;
+      }
+  }
+}
+static method nonExhaustiveSwitch3(self::Enum e) → void {
+  #L11:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L12:
+    case #C6:
+      {
+        core::print("b");
+        break #L11;
+      }
+    #L13:
+    case #C9:
+      {
+        core::print("c");
+        break #L11;
+      }
+  }
+}
+static method nonExhaustiveSwitch4(self::Enum e) → void {
+  #L14:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L15:
+    case #C6:
+      {
+        core::print("b");
+        break #L14;
+      }
+  }
+}
+static method nonExhaustiveSwitchWithDefault(self::Enum e) → void {
+  #L16:
+  switch(e) {
+    #L17:
+    case #C6:
+      {
+        core::print("b");
+        break #L16;
+      }
+    #L18:
+    default:
+      {
+        core::print("a|c");
+        break #L16;
+      }
+  }
+}
+static method exhaustiveNullableSwitch(self::Enum? e) → void {
+  #L19:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L20:
+    case #C3:
+      {
+        core::print("a");
+        break #L19;
+      }
+    #L21:
+    case #C6:
+      {
+        core::print("b");
+        break #L19;
+      }
+    #L22:
+    case #C9:
+      {
+        core::print("c");
+        break #L19;
+      }
+    #L23:
+    case #C15:
+      {
+        core::print("null");
+        break #L19;
+      }
+  }
+}
+static method nonExhaustiveNullableSwitch1(self::Enum? e) → void {
+  #L24:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L25:
+    case #C3:
+      {
+        core::print("a");
+        break #L24;
+      }
+    #L26:
+    case #C6:
+      {
+        core::print("b");
+        break #L24;
+      }
+    #L27:
+    case #C9:
+      {
+        core::print("c");
+        break #L24;
       }
-      else
-        if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-          {
-            core::print("c");
-            break #L8;
-          }
-        }
   }
 }
 static method nonExhaustiveNullableSwitch2(self::Enum? e) → void {
-  #L9:
-  {
-    final synthesized self::Enum? #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L28:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L29:
+    case #C3:
       {
         core::print("a");
-        break #L9;
+        break #L28;
       }
-    }
-    else
-      if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("c");
-          break #L9;
-        }
+    #L30:
+    case #C9:
+      {
+        core::print("c");
+        break #L28;
+      }
+    #L31:
+    case #C15:
+      {
+        core::print("null");
+        break #L28;
       }
-      else
-        if(#0#0 == null) {
-          {
-            core::print("null");
-            break #L9;
-          }
-        }
   }
 }
 static method unreachableCase1(self::Enum e) → void {
-  #L10:
-  {
-    final synthesized self::Enum #0#0 = e;
-    function ##0#2#initializer() → core::bool
-      return #C3 =={core::Object::==}{(core::Object) → core::bool} #0#0;
-    late final synthesized core::bool #0#2 = ##0#2#initializer(){() → core::bool};
-    if(#0#2) {
+  #L32:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L33:
+    case #C3:
       {
         core::print("a1");
-        break #L10;
+        break #L32;
       }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("b");
-          break #L10;
-        }
+    #L34:
+    case #C6:
+      {
+        core::print("b");
+        break #L32;
+      }
+    #L35:
+    case #C3:
+      {
+        core::print("a2");
+        break #L32;
+      }
+    #L36:
+    case #C9:
+      {
+        core::print("c");
+        break #L32;
       }
-      else
-        if(#0#2) {
-          {
-            core::print("a2");
-            break #L10;
-          }
-        }
-        else
-          if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-            {
-              core::print("c");
-              break #L10;
-            }
-          }
   }
 }
 static method unreachableCase2(self::Enum e) → void {
-  #L11:
-  {
-    final synthesized self::Enum #0#0 = e;
-    function ##0#2#initializer() → core::bool
-      return #C3 =={core::Object::==}{(core::Object) → core::bool} #0#0;
-    late final synthesized core::bool #0#2 = ##0#2#initializer(){() → core::bool};
-    if(#0#2) {
+  #L37:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L38:
+    case #C3:
       {
         core::print("a1");
-        break #L11;
+        break #L37;
       }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("b");
-          break #L11;
-        }
+    #L39:
+    case #C6:
+      {
+        core::print("b");
+        break #L37;
+      }
+    #L40:
+    case #C3:
+      {
+        core::print("a2");
+        break #L37;
       }
-      else
-        if(#0#2) {
-          {
-            core::print("a2");
-            break #L11;
-          }
-        }
   }
 }
 static method unreachableCase3(self::Enum e) → void {
-  #L12:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L41:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L42:
+    case #C3:
       {
         core::print("a");
-        break #L12;
+        break #L41;
       }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("b");
-          break #L12;
-        }
+    #L43:
+    case #C6:
+      {
+        core::print("b");
+        break #L41;
+      }
+    #L44:
+    case #C9:
+      {
+        core::print("c");
+        break #L41;
+      }
+    #L45:
+    case #C15:
+      {
+        core::print("null");
+        break #L41;
       }
-      else
-        if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-          {
-            core::print("c");
-            break #L12;
-          }
-        }
-        else
-          if(#0#0 == null) {
-            {
-              core::print("null");
-              break #L12;
-            }
-          }
   }
 }
 static method unreachableCase4(self::Enum? e) → void {
-  #L13:
-  {
-    final synthesized self::Enum? #0#0 = e;
-    function ##0#8#initializer() → core::bool
-      return #0#0 == null;
-    late final synthesized core::bool #0#8 = ##0#8#initializer(){() → core::bool};
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L46:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L47:
+    case #C3:
       {
         core::print("a");
-        break #L13;
+        break #L46;
       }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("b");
-          break #L13;
-        }
+    #L48:
+    case #C6:
+      {
+        core::print("b");
+        break #L46;
+      }
+    #L49:
+    case #C9:
+      {
+        core::print("c");
+        break #L46;
+      }
+    #L50:
+    case #C15:
+      {
+        core::print("null1");
+        break #L46;
+      }
+    #L51:
+    case #C15:
+      {
+        core::print("null2");
+        break #L46;
       }
-      else
-        if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-          {
-            core::print("c");
-            break #L13;
-          }
-        }
-        else
-          if(#0#8) {
-            {
-              core::print("null1");
-              break #L13;
-            }
-          }
-          else
-            if(#0#8) {
-              {
-                core::print("null2");
-                break #L13;
-              }
-            }
   }
 }
 static method exhaustiveGenericSwitch(self::GenericEnum<dynamic> e) → void {
-  #L14:
-  {
-    final synthesized self::GenericEnum<dynamic> #0#0 = e;
-    if(#C11 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L52:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L53:
+    case #C11:
       {
         core::print("a");
-        break #L14;
+        break #L52;
       }
-    }
-    else
-      if(#C12 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print("b");
-          break #L14;
-        }
+    #L54:
+    case #C12:
+      {
+        core::print("b");
+        break #L52;
+      }
+    #L55:
+    case #C13:
+      {
+        core::print("c");
+        break #L52;
       }
-      else
-        if(#C13 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-          {
-            core::print("c");
-            break #L14;
-          }
-        }
   }
 }
 static method exhaustiveGenericSwitchTyped(self::GenericEnum<core::int> e) → void {
-  #L15:
-  {
-    final synthesized self::GenericEnum<core::int> #0#0 = e;
-    if(#C11 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L56:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L57:
+    case #C11:
       {
         core::print("a");
-        break #L15;
+        break #L56;
       }
-    }
   }
 }
 
@@ -462,6 +412,7 @@ constants  {
   #C12 = self::GenericEnum<core::String*> {index:#C4, _name:#C5}
   #C13 = self::GenericEnum<core::bool*> {index:#C7, _name:#C8}
   #C14 = <self::GenericEnum<dynamic>*>[#C11, #C12, #C13]
+  #C15 = null
 }
 
 
diff --git a/pkg/front_end/testcases/patterns/extractor_pattern_inside_cast.dart.strong.expect b/pkg/front_end/testcases/patterns/extractor_pattern_inside_cast.dart.strong.expect
index 08102983885..2ca47b934c8 100644
--- a/pkg/front_end/testcases/patterns/extractor_pattern_inside_cast.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/extractor_pattern_inside_cast.dart.strong.expect
@@ -12,9 +12,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in (#0#0 as{ForNonNullableByDefault} core::Object) is{ForNonNullableByDefault} self::C && #C1 =={core::num::==}{(core::Object) → core::bool} ((#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} self::C).{self::C::f}{core::int?}) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in (#0#0 as{ForNonNullableByDefault} core::Object) is{ForNonNullableByDefault} self::C && #C1 =={core::num::==}{(core::Object) → core::bool} ((#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} self::C).{self::C::f}{core::int?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/extractor_pattern_inside_cast.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/extractor_pattern_inside_cast.dart.strong.transformed.expect
index fbd27b85841..6daee2ba48f 100644
--- a/pkg/front_end/testcases/patterns/extractor_pattern_inside_cast.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/extractor_pattern_inside_cast.dart.strong.transformed.expect
@@ -12,9 +12,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final core::Object #t1 = let dynamic #t2 = #0#0 in #t2 == null ?{core::Object} #t2 as{ForNonNullableByDefault} core::Object : #t2{core::Object} in (let dynamic #t3 = #0#0 in #t3 == null ?{core::Object} #t3 as{ForNonNullableByDefault} core::Object : #t3{core::Object}) is{ForNonNullableByDefault} self::C && #C1 =={core::num::==}{(core::Object) → core::bool} ((let dynamic #t4 = #0#0 in #t4 == null ?{core::Object} #t4 as{ForNonNullableByDefault} core::Object : #t4{core::Object}) as{ForNonNullableByDefault} self::C).{self::C::f}{core::int?}) {
-      {
-        break #L1;
+    {
+      if(let final core::Object #t1 = let dynamic #t2 = #0#0 in #t2 == null ?{core::Object} #t2 as{ForNonNullableByDefault} core::Object : #t2{core::Object} in (let dynamic #t3 = #0#0 in #t3 == null ?{core::Object} #t3 as{ForNonNullableByDefault} core::Object : #t3{core::Object}) is{ForNonNullableByDefault} self::C && #C1 =={core::num::==}{(core::Object) → core::bool} ((let dynamic #t4 = #0#0 in #t4 == null ?{core::Object} #t4 as{ForNonNullableByDefault} core::Object : #t4{core::Object}) as{ForNonNullableByDefault} self::C).{self::C::f}{core::int?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/extractor_pattern_inside_cast.dart.weak.expect b/pkg/front_end/testcases/patterns/extractor_pattern_inside_cast.dart.weak.expect
index 08102983885..2ca47b934c8 100644
--- a/pkg/front_end/testcases/patterns/extractor_pattern_inside_cast.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/extractor_pattern_inside_cast.dart.weak.expect
@@ -12,9 +12,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in (#0#0 as{ForNonNullableByDefault} core::Object) is{ForNonNullableByDefault} self::C && #C1 =={core::num::==}{(core::Object) → core::bool} ((#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} self::C).{self::C::f}{core::int?}) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in (#0#0 as{ForNonNullableByDefault} core::Object) is{ForNonNullableByDefault} self::C && #C1 =={core::num::==}{(core::Object) → core::bool} ((#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} self::C).{self::C::f}{core::int?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/extractor_pattern_inside_cast.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/extractor_pattern_inside_cast.dart.weak.modular.expect
index 08102983885..2ca47b934c8 100644
--- a/pkg/front_end/testcases/patterns/extractor_pattern_inside_cast.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/extractor_pattern_inside_cast.dart.weak.modular.expect
@@ -12,9 +12,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in (#0#0 as{ForNonNullableByDefault} core::Object) is{ForNonNullableByDefault} self::C && #C1 =={core::num::==}{(core::Object) → core::bool} ((#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} self::C).{self::C::f}{core::int?}) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in (#0#0 as{ForNonNullableByDefault} core::Object) is{ForNonNullableByDefault} self::C && #C1 =={core::num::==}{(core::Object) → core::bool} ((#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} self::C).{self::C::f}{core::int?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/extractor_pattern_inside_cast.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/extractor_pattern_inside_cast.dart.weak.transformed.expect
index 05c6860f3f0..61e183f4318 100644
--- a/pkg/front_end/testcases/patterns/extractor_pattern_inside_cast.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/extractor_pattern_inside_cast.dart.weak.transformed.expect
@@ -12,9 +12,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final core::Object #t1 = #0#0 in #0#0 is{ForNonNullableByDefault} self::C && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0 as{ForNonNullableByDefault} self::C).{self::C::f}{core::int?}) {
-      {
-        break #L1;
+    {
+      if(let final core::Object #t1 = #0#0 in #0#0 is{ForNonNullableByDefault} self::C && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0 as{ForNonNullableByDefault} self::C).{self::C::f}{core::int?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/extractor_pattern_inside_null_assert.dart.strong.expect b/pkg/front_end/testcases/patterns/extractor_pattern_inside_null_assert.dart.strong.expect
index d2d8dab242c..75e9368aae0 100644
--- a/pkg/front_end/testcases/patterns/extractor_pattern_inside_null_assert.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/extractor_pattern_inside_null_assert.dart.strong.expect
@@ -12,9 +12,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} self::C && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} self::C).{self::C::f}{core::int?}) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} self::C && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} self::C).{self::C::f}{core::int?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/extractor_pattern_inside_null_assert.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/extractor_pattern_inside_null_assert.dart.strong.transformed.expect
index d2d8dab242c..75e9368aae0 100644
--- a/pkg/front_end/testcases/patterns/extractor_pattern_inside_null_assert.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/extractor_pattern_inside_null_assert.dart.strong.transformed.expect
@@ -12,9 +12,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} self::C && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} self::C).{self::C::f}{core::int?}) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} self::C && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} self::C).{self::C::f}{core::int?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/extractor_pattern_inside_null_assert.dart.weak.expect b/pkg/front_end/testcases/patterns/extractor_pattern_inside_null_assert.dart.weak.expect
index d2d8dab242c..75e9368aae0 100644
--- a/pkg/front_end/testcases/patterns/extractor_pattern_inside_null_assert.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/extractor_pattern_inside_null_assert.dart.weak.expect
@@ -12,9 +12,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} self::C && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} self::C).{self::C::f}{core::int?}) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} self::C && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} self::C).{self::C::f}{core::int?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/extractor_pattern_inside_null_assert.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/extractor_pattern_inside_null_assert.dart.weak.modular.expect
index d2d8dab242c..75e9368aae0 100644
--- a/pkg/front_end/testcases/patterns/extractor_pattern_inside_null_assert.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/extractor_pattern_inside_null_assert.dart.weak.modular.expect
@@ -12,9 +12,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} self::C && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} self::C).{self::C::f}{core::int?}) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} self::C && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} self::C).{self::C::f}{core::int?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/extractor_pattern_inside_null_assert.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/extractor_pattern_inside_null_assert.dart.weak.transformed.expect
index d2d8dab242c..75e9368aae0 100644
--- a/pkg/front_end/testcases/patterns/extractor_pattern_inside_null_assert.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/extractor_pattern_inside_null_assert.dart.weak.transformed.expect
@@ -12,9 +12,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} self::C && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} self::C).{self::C::f}{core::int?}) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} self::C && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} self::C).{self::C::f}{core::int?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/extractor_pattern_inside_null_check.dart.strong.expect b/pkg/front_end/testcases/patterns/extractor_pattern_inside_null_check.dart.strong.expect
index 9ca5be30359..6af6424a772 100644
--- a/pkg/front_end/testcases/patterns/extractor_pattern_inside_null_check.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/extractor_pattern_inside_null_check.dart.strong.expect
@@ -12,9 +12,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} self::C && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{self::C}.{self::C::f}{core::int?} : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} self::C && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{self::C}.{self::C::f}{core::int?} : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/extractor_pattern_inside_null_check.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/extractor_pattern_inside_null_check.dart.strong.transformed.expect
index 9ca5be30359..6af6424a772 100644
--- a/pkg/front_end/testcases/patterns/extractor_pattern_inside_null_check.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/extractor_pattern_inside_null_check.dart.strong.transformed.expect
@@ -12,9 +12,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} self::C && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{self::C}.{self::C::f}{core::int?} : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} self::C && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{self::C}.{self::C::f}{core::int?} : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/extractor_pattern_inside_null_check.dart.weak.expect b/pkg/front_end/testcases/patterns/extractor_pattern_inside_null_check.dart.weak.expect
index 9ca5be30359..6af6424a772 100644
--- a/pkg/front_end/testcases/patterns/extractor_pattern_inside_null_check.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/extractor_pattern_inside_null_check.dart.weak.expect
@@ -12,9 +12,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} self::C && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{self::C}.{self::C::f}{core::int?} : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} self::C && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{self::C}.{self::C::f}{core::int?} : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/extractor_pattern_inside_null_check.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/extractor_pattern_inside_null_check.dart.weak.modular.expect
index 9ca5be30359..6af6424a772 100644
--- a/pkg/front_end/testcases/patterns/extractor_pattern_inside_null_check.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/extractor_pattern_inside_null_check.dart.weak.modular.expect
@@ -12,9 +12,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} self::C && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{self::C}.{self::C::f}{core::int?} : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} self::C && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{self::C}.{self::C::f}{core::int?} : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/extractor_pattern_inside_null_check.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/extractor_pattern_inside_null_check.dart.weak.transformed.expect
index 9ca5be30359..6af6424a772 100644
--- a/pkg/front_end/testcases/patterns/extractor_pattern_inside_null_check.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/extractor_pattern_inside_null_check.dart.weak.transformed.expect
@@ -12,9 +12,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} self::C && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{self::C}.{self::C::f}{core::int?} : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} self::C && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{self::C}.{self::C::f}{core::int?} : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/extractor_pattern_with_type_args.dart.strong.expect b/pkg/front_end/testcases/patterns/extractor_pattern_with_type_args.dart.strong.expect
index 6c7ffa1f767..c923e211dfa 100644
--- a/pkg/front_end/testcases/patterns/extractor_pattern_with_type_args.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/extractor_pattern_with_type_args.dart.strong.expect
@@ -11,9 +11,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} self::C<core::int>) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::C<core::int>) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/extractor_pattern_with_type_args.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/extractor_pattern_with_type_args.dart.strong.transformed.expect
index 6c7ffa1f767..c923e211dfa 100644
--- a/pkg/front_end/testcases/patterns/extractor_pattern_with_type_args.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/extractor_pattern_with_type_args.dart.strong.transformed.expect
@@ -11,9 +11,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} self::C<core::int>) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::C<core::int>) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/extractor_pattern_with_type_args.dart.weak.expect b/pkg/front_end/testcases/patterns/extractor_pattern_with_type_args.dart.weak.expect
index 6c7ffa1f767..c923e211dfa 100644
--- a/pkg/front_end/testcases/patterns/extractor_pattern_with_type_args.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/extractor_pattern_with_type_args.dart.weak.expect
@@ -11,9 +11,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} self::C<core::int>) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::C<core::int>) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/extractor_pattern_with_type_args.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/extractor_pattern_with_type_args.dart.weak.modular.expect
index 6c7ffa1f767..c923e211dfa 100644
--- a/pkg/front_end/testcases/patterns/extractor_pattern_with_type_args.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/extractor_pattern_with_type_args.dart.weak.modular.expect
@@ -11,9 +11,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} self::C<core::int>) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::C<core::int>) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/extractor_pattern_with_type_args.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/extractor_pattern_with_type_args.dart.weak.transformed.expect
index 6c7ffa1f767..c923e211dfa 100644
--- a/pkg/front_end/testcases/patterns/extractor_pattern_with_type_args.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/extractor_pattern_with_type_args.dart.weak.transformed.expect
@@ -11,9 +11,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} self::C<core::int>) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::C<core::int>) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/extractor_pattern_with_type_args_inside_null_assert.dart.strong.expect b/pkg/front_end/testcases/patterns/extractor_pattern_with_type_args_inside_null_assert.dart.strong.expect
index 265c0184038..88988fffcee 100644
--- a/pkg/front_end/testcases/patterns/extractor_pattern_with_type_args_inside_null_assert.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/extractor_pattern_with_type_args_inside_null_assert.dart.strong.expect
@@ -12,9 +12,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} self::C<core::int> && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} self::C<core::int>).{self::C::f}{core::int?}) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} self::C<core::int> && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} self::C<core::int>).{self::C::f}{core::int?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/extractor_pattern_with_type_args_inside_null_assert.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/extractor_pattern_with_type_args_inside_null_assert.dart.strong.transformed.expect
index 265c0184038..88988fffcee 100644
--- a/pkg/front_end/testcases/patterns/extractor_pattern_with_type_args_inside_null_assert.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/extractor_pattern_with_type_args_inside_null_assert.dart.strong.transformed.expect
@@ -12,9 +12,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} self::C<core::int> && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} self::C<core::int>).{self::C::f}{core::int?}) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} self::C<core::int> && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} self::C<core::int>).{self::C::f}{core::int?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/extractor_pattern_with_type_args_inside_null_assert.dart.weak.expect b/pkg/front_end/testcases/patterns/extractor_pattern_with_type_args_inside_null_assert.dart.weak.expect
index 265c0184038..88988fffcee 100644
--- a/pkg/front_end/testcases/patterns/extractor_pattern_with_type_args_inside_null_assert.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/extractor_pattern_with_type_args_inside_null_assert.dart.weak.expect
@@ -12,9 +12,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} self::C<core::int> && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} self::C<core::int>).{self::C::f}{core::int?}) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} self::C<core::int> && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} self::C<core::int>).{self::C::f}{core::int?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/extractor_pattern_with_type_args_inside_null_assert.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/extractor_pattern_with_type_args_inside_null_assert.dart.weak.modular.expect
index 265c0184038..88988fffcee 100644
--- a/pkg/front_end/testcases/patterns/extractor_pattern_with_type_args_inside_null_assert.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/extractor_pattern_with_type_args_inside_null_assert.dart.weak.modular.expect
@@ -12,9 +12,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} self::C<core::int> && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} self::C<core::int>).{self::C::f}{core::int?}) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} self::C<core::int> && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} self::C<core::int>).{self::C::f}{core::int?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/extractor_pattern_with_type_args_inside_null_assert.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/extractor_pattern_with_type_args_inside_null_assert.dart.weak.transformed.expect
index 265c0184038..88988fffcee 100644
--- a/pkg/front_end/testcases/patterns/extractor_pattern_with_type_args_inside_null_assert.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/extractor_pattern_with_type_args_inside_null_assert.dart.weak.transformed.expect
@@ -12,9 +12,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} self::C<core::int> && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} self::C<core::int>).{self::C::f}{core::int?}) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} self::C<core::int> && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} self::C<core::int>).{self::C::f}{core::int?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/final_joint_variables.dart.strong.expect b/pkg/front_end/testcases/patterns/final_joint_variables.dart.strong.expect
index fcbebfbeab0..d2ae9044e08 100644
--- a/pkg/front_end/testcases/patterns/final_joint_variables.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/final_joint_variables.dart.strong.expect
@@ -5,30 +5,35 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final core::int a;
-    final core::int a#1;
-    final core::String a#2;
     final synthesized dynamic #0#0 = x;
     late final synthesized core::bool #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1;
     late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
     dynamic #t1;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = a = #0#6{core::int} in true)) && (let final dynamic #t3 = #t1 = a in true) || #0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t4 = a#1 = #0#0{core::int} in true) && (let final dynamic #t5 = #t1 = a#1 in true)) {
-      final core::int a = #t1{core::int};
-      {
-        return a;
-      }
-    }
-    else
-      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::String && (let final dynamic #t6 = a#2 = #0#6{core::String} in true)) || #0#0 is{ForNonNullableByDefault} core::String && (let final dynamic #t7 = a#2 = #0#0{core::String} in true)) {
+    {
+      lowered final core::int a#case#0;
+      lowered final core::int a#case#1;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = a#case#0 = #0#6{core::int} in true)) && (let final dynamic #t3 = #t1 = a#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t4 = a#case#1 = #0#0{core::int} in true) && (let final dynamic #t5 = #t1 = a#case#1 in true)) {
+        final core::int a = #t1{core::int};
         {
-          return a#2;
+          return a;
         }
       }
-      else {
+    }
+    {
+      final core::String a;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::String && (let final dynamic #t6 = a = #0#6{core::String} in true)) || #0#0 is{ForNonNullableByDefault} core::String && (let final dynamic #t7 = a = #0#0{core::String} in true)) {
+        {
+          return a;
+        }
+      }
+    }
+    {
+      {
         {
           return null;
         }
       }
+    }
   }
 }
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/patterns/final_joint_variables.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/final_joint_variables.dart.strong.transformed.expect
index 83e39c08d2b..3df509a11b6 100644
--- a/pkg/front_end/testcases/patterns/final_joint_variables.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/final_joint_variables.dart.strong.transformed.expect
@@ -5,9 +5,6 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final core::int a;
-    final core::int a#1;
-    final core::String a#2;
     final synthesized dynamic #0#0 = x;
     function ##0#4#initializer() → core::bool
       return #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1;
@@ -16,23 +13,31 @@ static method test(dynamic x) → dynamic {
       return #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
     late final synthesized dynamic #0#6 = ##0#6#initializer(){() → dynamic};
     dynamic #t1;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final core::int #t2 = a = #0#6{core::int} in true)) && (let final core::int #t3 = #t1 = a in true) || #0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t4 = a#1 = #0#0{core::int} in true) && (let final core::int #t5 = #t1 = a#1 in true)) {
-      final core::int a = #t1{core::int};
-      {
-        return a;
-      }
-    }
-    else
-      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::String && (let final core::String #t6 = a#2 = #0#6{core::String} in true)) || #0#0 is{ForNonNullableByDefault} core::String && (let final core::String #t7 = a#2 = #0#0{core::String} in true)) {
+    {
+      lowered final core::int a#case#0;
+      lowered final core::int a#case#1;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final core::int #t2 = a#case#0 = #0#6{core::int} in true)) && (let final core::int #t3 = #t1 = a#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t4 = a#case#1 = #0#0{core::int} in true) && (let final core::int #t5 = #t1 = a#case#1 in true)) {
+        final core::int a = #t1{core::int};
         {
-          return a#2;
+          return a;
         }
       }
-      else {
+    }
+    {
+      final core::String a;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::String && (let final core::String #t6 = a = #0#6{core::String} in true)) || #0#0 is{ForNonNullableByDefault} core::String && (let final core::String #t7 = a = #0#0{core::String} in true)) {
+        {
+          return a;
+        }
+      }
+    }
+    {
+      {
         {
           return null;
         }
       }
+    }
   }
 }
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/patterns/final_joint_variables.dart.weak.expect b/pkg/front_end/testcases/patterns/final_joint_variables.dart.weak.expect
index fcbebfbeab0..d2ae9044e08 100644
--- a/pkg/front_end/testcases/patterns/final_joint_variables.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/final_joint_variables.dart.weak.expect
@@ -5,30 +5,35 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final core::int a;
-    final core::int a#1;
-    final core::String a#2;
     final synthesized dynamic #0#0 = x;
     late final synthesized core::bool #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1;
     late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
     dynamic #t1;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = a = #0#6{core::int} in true)) && (let final dynamic #t3 = #t1 = a in true) || #0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t4 = a#1 = #0#0{core::int} in true) && (let final dynamic #t5 = #t1 = a#1 in true)) {
-      final core::int a = #t1{core::int};
-      {
-        return a;
-      }
-    }
-    else
-      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::String && (let final dynamic #t6 = a#2 = #0#6{core::String} in true)) || #0#0 is{ForNonNullableByDefault} core::String && (let final dynamic #t7 = a#2 = #0#0{core::String} in true)) {
+    {
+      lowered final core::int a#case#0;
+      lowered final core::int a#case#1;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = a#case#0 = #0#6{core::int} in true)) && (let final dynamic #t3 = #t1 = a#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t4 = a#case#1 = #0#0{core::int} in true) && (let final dynamic #t5 = #t1 = a#case#1 in true)) {
+        final core::int a = #t1{core::int};
         {
-          return a#2;
+          return a;
         }
       }
-      else {
+    }
+    {
+      final core::String a;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::String && (let final dynamic #t6 = a = #0#6{core::String} in true)) || #0#0 is{ForNonNullableByDefault} core::String && (let final dynamic #t7 = a = #0#0{core::String} in true)) {
+        {
+          return a;
+        }
+      }
+    }
+    {
+      {
         {
           return null;
         }
       }
+    }
   }
 }
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/patterns/final_joint_variables.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/final_joint_variables.dart.weak.modular.expect
index fcbebfbeab0..d2ae9044e08 100644
--- a/pkg/front_end/testcases/patterns/final_joint_variables.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/final_joint_variables.dart.weak.modular.expect
@@ -5,30 +5,35 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final core::int a;
-    final core::int a#1;
-    final core::String a#2;
     final synthesized dynamic #0#0 = x;
     late final synthesized core::bool #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1;
     late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
     dynamic #t1;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = a = #0#6{core::int} in true)) && (let final dynamic #t3 = #t1 = a in true) || #0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t4 = a#1 = #0#0{core::int} in true) && (let final dynamic #t5 = #t1 = a#1 in true)) {
-      final core::int a = #t1{core::int};
-      {
-        return a;
-      }
-    }
-    else
-      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::String && (let final dynamic #t6 = a#2 = #0#6{core::String} in true)) || #0#0 is{ForNonNullableByDefault} core::String && (let final dynamic #t7 = a#2 = #0#0{core::String} in true)) {
+    {
+      lowered final core::int a#case#0;
+      lowered final core::int a#case#1;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = a#case#0 = #0#6{core::int} in true)) && (let final dynamic #t3 = #t1 = a#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t4 = a#case#1 = #0#0{core::int} in true) && (let final dynamic #t5 = #t1 = a#case#1 in true)) {
+        final core::int a = #t1{core::int};
         {
-          return a#2;
+          return a;
         }
       }
-      else {
+    }
+    {
+      final core::String a;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::String && (let final dynamic #t6 = a = #0#6{core::String} in true)) || #0#0 is{ForNonNullableByDefault} core::String && (let final dynamic #t7 = a = #0#0{core::String} in true)) {
+        {
+          return a;
+        }
+      }
+    }
+    {
+      {
         {
           return null;
         }
       }
+    }
   }
 }
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/patterns/final_joint_variables.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/final_joint_variables.dart.weak.transformed.expect
index 83e39c08d2b..3df509a11b6 100644
--- a/pkg/front_end/testcases/patterns/final_joint_variables.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/final_joint_variables.dart.weak.transformed.expect
@@ -5,9 +5,6 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final core::int a;
-    final core::int a#1;
-    final core::String a#2;
     final synthesized dynamic #0#0 = x;
     function ##0#4#initializer() → core::bool
       return #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1;
@@ -16,23 +13,31 @@ static method test(dynamic x) → dynamic {
       return #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
     late final synthesized dynamic #0#6 = ##0#6#initializer(){() → dynamic};
     dynamic #t1;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final core::int #t2 = a = #0#6{core::int} in true)) && (let final core::int #t3 = #t1 = a in true) || #0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t4 = a#1 = #0#0{core::int} in true) && (let final core::int #t5 = #t1 = a#1 in true)) {
-      final core::int a = #t1{core::int};
-      {
-        return a;
-      }
-    }
-    else
-      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::String && (let final core::String #t6 = a#2 = #0#6{core::String} in true)) || #0#0 is{ForNonNullableByDefault} core::String && (let final core::String #t7 = a#2 = #0#0{core::String} in true)) {
+    {
+      lowered final core::int a#case#0;
+      lowered final core::int a#case#1;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final core::int #t2 = a#case#0 = #0#6{core::int} in true)) && (let final core::int #t3 = #t1 = a#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t4 = a#case#1 = #0#0{core::int} in true) && (let final core::int #t5 = #t1 = a#case#1 in true)) {
+        final core::int a = #t1{core::int};
         {
-          return a#2;
+          return a;
         }
       }
-      else {
+    }
+    {
+      final core::String a;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::String && (let final core::String #t6 = a = #0#6{core::String} in true)) || #0#0 is{ForNonNullableByDefault} core::String && (let final core::String #t7 = a = #0#0{core::String} in true)) {
+        {
+          return a;
+        }
+      }
+    }
+    {
+      {
         {
           return null;
         }
       }
+    }
   }
 }
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/patterns/final_variable_inside_case.dart.strong.expect b/pkg/front_end/testcases/patterns/final_variable_inside_case.dart.strong.expect
index 04cf077de08..af4d74d8980 100644
--- a/pkg/front_end/testcases/patterns/final_variable_inside_case.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/final_variable_inside_case.dart.strong.expect
@@ -4,11 +4,13 @@ import self as self;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final dynamic y;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = y = #0#0 in true) {
-      {
-        break #L1;
+    {
+      final dynamic y;
+      if(let final dynamic #t1 = y = #0#0 in true) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/final_variable_inside_case.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/final_variable_inside_case.dart.strong.transformed.expect
index 04cf077de08..af4d74d8980 100644
--- a/pkg/front_end/testcases/patterns/final_variable_inside_case.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/final_variable_inside_case.dart.strong.transformed.expect
@@ -4,11 +4,13 @@ import self as self;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final dynamic y;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = y = #0#0 in true) {
-      {
-        break #L1;
+    {
+      final dynamic y;
+      if(let final dynamic #t1 = y = #0#0 in true) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/final_variable_inside_case.dart.weak.expect b/pkg/front_end/testcases/patterns/final_variable_inside_case.dart.weak.expect
index 04cf077de08..af4d74d8980 100644
--- a/pkg/front_end/testcases/patterns/final_variable_inside_case.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/final_variable_inside_case.dart.weak.expect
@@ -4,11 +4,13 @@ import self as self;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final dynamic y;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = y = #0#0 in true) {
-      {
-        break #L1;
+    {
+      final dynamic y;
+      if(let final dynamic #t1 = y = #0#0 in true) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/final_variable_inside_case.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/final_variable_inside_case.dart.weak.modular.expect
index 04cf077de08..af4d74d8980 100644
--- a/pkg/front_end/testcases/patterns/final_variable_inside_case.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/final_variable_inside_case.dart.weak.modular.expect
@@ -4,11 +4,13 @@ import self as self;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final dynamic y;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = y = #0#0 in true) {
-      {
-        break #L1;
+    {
+      final dynamic y;
+      if(let final dynamic #t1 = y = #0#0 in true) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/final_variable_inside_case.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/final_variable_inside_case.dart.weak.transformed.expect
index 04cf077de08..af4d74d8980 100644
--- a/pkg/front_end/testcases/patterns/final_variable_inside_case.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/final_variable_inside_case.dart.weak.transformed.expect
@@ -4,11 +4,13 @@ import self as self;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final dynamic y;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = y = #0#0 in true) {
-      {
-        break #L1;
+    {
+      final dynamic y;
+      if(let final dynamic #t1 = y = #0#0 in true) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/final_variable_inside_cast.dart.strong.expect b/pkg/front_end/testcases/patterns/final_variable_inside_cast.dart.strong.expect
index 4c8a539e6bb..370409c5f67 100644
--- a/pkg/front_end/testcases/patterns/final_variable_inside_cast.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/final_variable_inside_cast.dart.strong.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final core::Object y;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in let final dynamic #t2 = y = #0#0 as{ForNonNullableByDefault} core::Object in true) {
-      {
-        break #L1;
+    {
+      final core::Object y;
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in let final dynamic #t2 = y = #0#0 as{ForNonNullableByDefault} core::Object in true) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/final_variable_inside_cast.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/final_variable_inside_cast.dart.strong.transformed.expect
index dc0666b808e..91b26091d66 100644
--- a/pkg/front_end/testcases/patterns/final_variable_inside_cast.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/final_variable_inside_cast.dart.strong.transformed.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final core::Object y;
     final synthesized dynamic #0#0 = x;
-    if(let final core::Object #t1 = let dynamic #t2 = #0#0 in #t2 == null ?{core::Object} #t2 as{ForNonNullableByDefault} core::Object : #t2{core::Object} in let final core::Object #t3 = y = let dynamic #t4 = #0#0 in #t4 == null ?{core::Object} #t4 as{ForNonNullableByDefault} core::Object : #t4{core::Object} in true) {
-      {
-        break #L1;
+    {
+      final core::Object y;
+      if(let final core::Object #t1 = let dynamic #t2 = #0#0 in #t2 == null ?{core::Object} #t2 as{ForNonNullableByDefault} core::Object : #t2{core::Object} in let final core::Object #t3 = y = let dynamic #t4 = #0#0 in #t4 == null ?{core::Object} #t4 as{ForNonNullableByDefault} core::Object : #t4{core::Object} in true) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/final_variable_inside_cast.dart.weak.expect b/pkg/front_end/testcases/patterns/final_variable_inside_cast.dart.weak.expect
index 4c8a539e6bb..370409c5f67 100644
--- a/pkg/front_end/testcases/patterns/final_variable_inside_cast.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/final_variable_inside_cast.dart.weak.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final core::Object y;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in let final dynamic #t2 = y = #0#0 as{ForNonNullableByDefault} core::Object in true) {
-      {
-        break #L1;
+    {
+      final core::Object y;
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in let final dynamic #t2 = y = #0#0 as{ForNonNullableByDefault} core::Object in true) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/final_variable_inside_cast.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/final_variable_inside_cast.dart.weak.modular.expect
index 4c8a539e6bb..370409c5f67 100644
--- a/pkg/front_end/testcases/patterns/final_variable_inside_cast.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/final_variable_inside_cast.dart.weak.modular.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final core::Object y;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in let final dynamic #t2 = y = #0#0 as{ForNonNullableByDefault} core::Object in true) {
-      {
-        break #L1;
+    {
+      final core::Object y;
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in let final dynamic #t2 = y = #0#0 as{ForNonNullableByDefault} core::Object in true) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/final_variable_inside_cast.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/final_variable_inside_cast.dart.weak.transformed.expect
index 78708788433..81123e1f64c 100644
--- a/pkg/front_end/testcases/patterns/final_variable_inside_cast.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/final_variable_inside_cast.dart.weak.transformed.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final core::Object y;
     final synthesized dynamic #0#0 = x;
-    if(let final core::Object #t1 = #0#0 in let final core::Object #t2 = y = #0#0 in true) {
-      {
-        break #L1;
+    {
+      final core::Object y;
+      if(let final core::Object #t1 = #0#0 in let final core::Object #t2 = y = #0#0 in true) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/final_variable_inside_null_assert.dart.strong.expect b/pkg/front_end/testcases/patterns/final_variable_inside_null_assert.dart.strong.expect
index cab7a9a2a10..f89c2657f10 100644
--- a/pkg/front_end/testcases/patterns/final_variable_inside_null_assert.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/final_variable_inside_null_assert.dart.strong.expect
@@ -4,11 +4,13 @@ import self as self;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final dynamic y;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in let final dynamic #t2 = y = #0#0! in true) {
-      {
-        break #L1;
+    {
+      final dynamic y;
+      if(let final dynamic #t1 = #0#0! in let final dynamic #t2 = y = #0#0! in true) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/final_variable_inside_null_assert.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/final_variable_inside_null_assert.dart.strong.transformed.expect
index cab7a9a2a10..f89c2657f10 100644
--- a/pkg/front_end/testcases/patterns/final_variable_inside_null_assert.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/final_variable_inside_null_assert.dart.strong.transformed.expect
@@ -4,11 +4,13 @@ import self as self;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final dynamic y;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in let final dynamic #t2 = y = #0#0! in true) {
-      {
-        break #L1;
+    {
+      final dynamic y;
+      if(let final dynamic #t1 = #0#0! in let final dynamic #t2 = y = #0#0! in true) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/final_variable_inside_null_assert.dart.weak.expect b/pkg/front_end/testcases/patterns/final_variable_inside_null_assert.dart.weak.expect
index cab7a9a2a10..f89c2657f10 100644
--- a/pkg/front_end/testcases/patterns/final_variable_inside_null_assert.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/final_variable_inside_null_assert.dart.weak.expect
@@ -4,11 +4,13 @@ import self as self;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final dynamic y;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in let final dynamic #t2 = y = #0#0! in true) {
-      {
-        break #L1;
+    {
+      final dynamic y;
+      if(let final dynamic #t1 = #0#0! in let final dynamic #t2 = y = #0#0! in true) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/final_variable_inside_null_assert.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/final_variable_inside_null_assert.dart.weak.modular.expect
index cab7a9a2a10..f89c2657f10 100644
--- a/pkg/front_end/testcases/patterns/final_variable_inside_null_assert.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/final_variable_inside_null_assert.dart.weak.modular.expect
@@ -4,11 +4,13 @@ import self as self;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final dynamic y;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in let final dynamic #t2 = y = #0#0! in true) {
-      {
-        break #L1;
+    {
+      final dynamic y;
+      if(let final dynamic #t1 = #0#0! in let final dynamic #t2 = y = #0#0! in true) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/final_variable_inside_null_assert.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/final_variable_inside_null_assert.dart.weak.transformed.expect
index cab7a9a2a10..f89c2657f10 100644
--- a/pkg/front_end/testcases/patterns/final_variable_inside_null_assert.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/final_variable_inside_null_assert.dart.weak.transformed.expect
@@ -4,11 +4,13 @@ import self as self;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final dynamic y;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in let final dynamic #t2 = y = #0#0! in true) {
-      {
-        break #L1;
+    {
+      final dynamic y;
+      if(let final dynamic #t1 = #0#0! in let final dynamic #t2 = y = #0#0! in true) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/final_variable_inside_null_check.dart.strong.expect b/pkg/front_end/testcases/patterns/final_variable_inside_null_check.dart.strong.expect
index 9a30637e84c..27bd8536f20 100644
--- a/pkg/front_end/testcases/patterns/final_variable_inside_null_check.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/final_variable_inside_null_check.dart.strong.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final dynamic y;
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} let final dynamic #t1 = y = #0#0 in true : false) {
-      {
-        break #L1;
+    {
+      final dynamic y;
+      if(!(#0#0 == null) ?{core::bool} let final dynamic #t1 = y = #0#0 in true : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/final_variable_inside_null_check.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/final_variable_inside_null_check.dart.strong.transformed.expect
index 9a30637e84c..27bd8536f20 100644
--- a/pkg/front_end/testcases/patterns/final_variable_inside_null_check.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/final_variable_inside_null_check.dart.strong.transformed.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final dynamic y;
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} let final dynamic #t1 = y = #0#0 in true : false) {
-      {
-        break #L1;
+    {
+      final dynamic y;
+      if(!(#0#0 == null) ?{core::bool} let final dynamic #t1 = y = #0#0 in true : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/final_variable_inside_null_check.dart.weak.expect b/pkg/front_end/testcases/patterns/final_variable_inside_null_check.dart.weak.expect
index 9a30637e84c..27bd8536f20 100644
--- a/pkg/front_end/testcases/patterns/final_variable_inside_null_check.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/final_variable_inside_null_check.dart.weak.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final dynamic y;
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} let final dynamic #t1 = y = #0#0 in true : false) {
-      {
-        break #L1;
+    {
+      final dynamic y;
+      if(!(#0#0 == null) ?{core::bool} let final dynamic #t1 = y = #0#0 in true : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/final_variable_inside_null_check.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/final_variable_inside_null_check.dart.weak.modular.expect
index 9a30637e84c..27bd8536f20 100644
--- a/pkg/front_end/testcases/patterns/final_variable_inside_null_check.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/final_variable_inside_null_check.dart.weak.modular.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final dynamic y;
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} let final dynamic #t1 = y = #0#0 in true : false) {
-      {
-        break #L1;
+    {
+      final dynamic y;
+      if(!(#0#0 == null) ?{core::bool} let final dynamic #t1 = y = #0#0 in true : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/final_variable_inside_null_check.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/final_variable_inside_null_check.dart.weak.transformed.expect
index 9a30637e84c..27bd8536f20 100644
--- a/pkg/front_end/testcases/patterns/final_variable_inside_null_check.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/final_variable_inside_null_check.dart.weak.transformed.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final dynamic y;
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} let final dynamic #t1 = y = #0#0 in true : false) {
-      {
-        break #L1;
+    {
+      final dynamic y;
+      if(!(#0#0 == null) ?{core::bool} let final dynamic #t1 = y = #0#0 in true : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/identical_map_keys.dart.strong.expect b/pkg/front_end/testcases/patterns/identical_map_keys.dart.strong.expect
index d2050a09dbb..54feebe0fc2 100644
--- a/pkg/front_end/testcases/patterns/identical_map_keys.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/identical_map_keys.dart.strong.expect
@@ -176,12 +176,6 @@ static const field self::C c2 = #C1;
 static method test1(core::Map<dynamic, dynamic> map) → core::String {
   return block {
     core::String #t1;
-    dynamic a1;
-    final dynamic b1;
-    dynamic a2;
-    final dynamic b2;
-    dynamic a3;
-    final dynamic b3;
     final synthesized core::Map<dynamic, dynamic> #0#0 = map;
     late final synthesized core::bool #0#3 = #0#0.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2;
     late final synthesized core::bool #0#5 = #0#0.{core::Map::containsKey}(#C1){(core::Object?) → core::bool};
@@ -192,67 +186,100 @@ static method test1(core::Map<dynamic, dynamic> map) → core::String {
     late final synthesized dynamic #0#16 = #0#0.{core::Map::[]}(#C4){(core::Object?) → dynamic};
     late final synthesized core::bool #0#18 = #0#0.{core::Map::containsKey}(#C5){(core::Object?) → core::bool};
     late final synthesized dynamic #0#19 = #0#0.{core::Map::[]}(#C5){(core::Object?) → dynamic};
-    if(#0#3 && #0#5 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#6 && #0#5 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#6)
-      #t1 = "";
-    else
-      if(#0#3 && #0#10 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#11 && #0#10 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#11)
-        #t1 = "";
-      else
-        if(#0#3 && #0#5 && (let final dynamic #t2 = a1 = #0#6 in true) && #0#5 && (let final dynamic #t3 = b1 = #0#6 in true))
-          #t1 = "";
-        else
-          if(#0#3 && #0#15 && (let final dynamic #t4 = a2 = #0#16 in true) && #0#15 && (let final dynamic #t5 = b2 = #0#16 in true))
-            #t1 = "";
-          else
-            if(#0#3 && #0#18 && (let final dynamic #t6 = a3 = #0#19 in true) && #0#18 && (let final dynamic #t7 = b3 = #0#19 in true))
-              #t1 = "";
-            else
-              if(true)
-                #t1 = "default";
-  } =>#t1;
-}
-static method test2(core::Map<dynamic, dynamic> map) → void {
-  #L1:
-  {
-    dynamic a1;
-    final dynamic b1;
-    dynamic a2;
-    final dynamic b2;
-    dynamic a3;
-    final dynamic b3;
-    final synthesized core::Map<dynamic, dynamic> #0#0 = map;
-    late final synthesized core::bool #0#3 = #0#0.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2;
-    late final synthesized core::bool #0#5 = #0#0.{core::Map::containsKey}(#C1){(core::Object?) → core::bool};
-    late final synthesized dynamic #0#6 = #0#0.{core::Map::[]}(#C1){(core::Object?) → dynamic};
-    late final synthesized core::bool #0#10 = #0#0.{core::Map::containsKey}(#C3){(core::Object?) → core::bool};
-    late final synthesized dynamic #0#11 = #0#0.{core::Map::[]}(#C3){(core::Object?) → dynamic};
-    late final synthesized core::bool #0#15 = #0#0.{core::Map::containsKey}(#C4){(core::Object?) → core::bool};
-    late final synthesized dynamic #0#16 = #0#0.{core::Map::[]}(#C4){(core::Object?) → dynamic};
-    late final synthesized core::bool #0#18 = #0#0.{core::Map::containsKey}(#C5){(core::Object?) → core::bool};
-    late final synthesized dynamic #0#19 = #0#0.{core::Map::[]}(#C5){(core::Object?) → dynamic};
-    if(#0#3 && #0#5 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#6 && #0#5 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#6) {
+    #L1:
+    {
       {
-        break #L1;
-      }
-    }
-    else
-      if(#0#3 && #0#10 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#11 && #0#10 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#11) {
-        {
+        if(#0#3 && #0#5 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#6 && #0#5 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#6) {
+          #t1 = "";
           break #L1;
         }
       }
-      else
-        if(#0#3 && #0#5 && (let final dynamic #t8 = a1 = #0#6 in true) && #0#5 && (let final dynamic #t9 = b1 = #0#6 in true) || #0#3 && #0#15 && (let final dynamic #t10 = a2 = #0#16 in true) && #0#15 && (let final dynamic #t11 = b2 = #0#16 in true)) {
-          {
-            break #L1;
-          }
+      {
+        if(#0#3 && #0#10 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#11 && #0#10 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#11) {
+          #t1 = "";
+          break #L1;
         }
-        else
-          if(#0#3 && #0#18 && (let final dynamic #t12 = a3 = #0#19 in true) && #0#18 && (let final dynamic #t13 = b3 = #0#19 in true)) {
-            {
-              break #L1;
-            }
-          }
+      }
+      {
+        dynamic a1;
+        final dynamic b1;
+        if(#0#3 && #0#5 && (let final dynamic #t2 = a1 = #0#6 in true) && #0#5 && (let final dynamic #t3 = b1 = #0#6 in true)) {
+          #t1 = "";
+          break #L1;
+        }
+      }
+      {
+        dynamic a2;
+        final dynamic b2;
+        if(#0#3 && #0#15 && (let final dynamic #t4 = a2 = #0#16 in true) && #0#15 && (let final dynamic #t5 = b2 = #0#16 in true)) {
+          #t1 = "";
+          break #L1;
+        }
+      }
+      {
+        dynamic a3;
+        final dynamic b3;
+        if(#0#3 && #0#18 && (let final dynamic #t6 = a3 = #0#19 in true) && #0#18 && (let final dynamic #t7 = b3 = #0#19 in true)) {
+          #t1 = "";
+          break #L1;
+        }
+      }
+      {
+        if(true) {
+          #t1 = "default";
+          break #L1;
+        }
+      }
+    }
+  } =>#t1;
+}
+static method test2(core::Map<dynamic, dynamic> map) → void {
+  #L2:
+  {
+    final synthesized core::Map<dynamic, dynamic> #0#0 = map;
+    late final synthesized core::bool #0#3 = #0#0.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2;
+    late final synthesized core::bool #0#5 = #0#0.{core::Map::containsKey}(#C1){(core::Object?) → core::bool};
+    late final synthesized dynamic #0#6 = #0#0.{core::Map::[]}(#C1){(core::Object?) → dynamic};
+    late final synthesized core::bool #0#10 = #0#0.{core::Map::containsKey}(#C3){(core::Object?) → core::bool};
+    late final synthesized dynamic #0#11 = #0#0.{core::Map::[]}(#C3){(core::Object?) → dynamic};
+    late final synthesized core::bool #0#15 = #0#0.{core::Map::containsKey}(#C4){(core::Object?) → core::bool};
+    late final synthesized dynamic #0#16 = #0#0.{core::Map::[]}(#C4){(core::Object?) → dynamic};
+    late final synthesized core::bool #0#18 = #0#0.{core::Map::containsKey}(#C5){(core::Object?) → core::bool};
+    late final synthesized dynamic #0#19 = #0#0.{core::Map::[]}(#C5){(core::Object?) → dynamic};
+    {
+      if(#0#3 && #0#5 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#6 && #0#5 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#6) {
+        {
+          break #L2;
+        }
+      }
+    }
+    {
+      if(#0#3 && #0#10 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#11 && #0#10 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#11) {
+        {
+          break #L2;
+        }
+      }
+    }
+    {
+      dynamic a1;
+      final dynamic b1;
+      dynamic a2;
+      final dynamic b2;
+      if(#0#3 && #0#5 && (let final dynamic #t8 = a1 = #0#6 in true) && #0#5 && (let final dynamic #t9 = b1 = #0#6 in true) || #0#3 && #0#15 && (let final dynamic #t10 = a2 = #0#16 in true) && #0#15 && (let final dynamic #t11 = b2 = #0#16 in true)) {
+        {
+          break #L2;
+        }
+      }
+    }
+    {
+      dynamic a3;
+      final dynamic b3;
+      if(#0#3 && #0#18 && (let final dynamic #t12 = a3 = #0#19 in true) && #0#18 && (let final dynamic #t13 = b3 = #0#19 in true)) {
+        {
+          break #L2;
+        }
+      }
+    }
   }
 }
 static method test3(core::Map<dynamic, dynamic> map) → void {
diff --git a/pkg/front_end/testcases/patterns/identical_map_keys.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/identical_map_keys.dart.strong.transformed.expect
index df1dc051b99..612e8a726c2 100644
--- a/pkg/front_end/testcases/patterns/identical_map_keys.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/identical_map_keys.dart.strong.transformed.expect
@@ -176,12 +176,6 @@ static const field self::C c2 = #C1;
 static method test1(core::Map<dynamic, dynamic> map) → core::String {
   return block {
     core::String #t1;
-    dynamic a1;
-    final dynamic b1;
-    dynamic a2;
-    final dynamic b2;
-    dynamic a3;
-    final dynamic b3;
     final synthesized core::Map<dynamic, dynamic> #0#0 = map;
     function ##0#3#initializer() → core::bool
       return #0#0.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2;
@@ -210,85 +204,118 @@ static method test1(core::Map<dynamic, dynamic> map) → core::String {
     function ##0#19#initializer() → dynamic
       return #0#0.{core::Map::[]}(#C5){(core::Object?) → dynamic};
     late final synthesized dynamic #0#19 = ##0#19#initializer(){() → dynamic};
-    if(#0#3 && #0#5 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#6 && #0#5 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#6)
-      #t1 = "";
-    else
-      if(#0#3 && #0#10 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#11 && #0#10 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#11)
-        #t1 = "";
-      else
-        if(#0#3 && #0#5 && (let final dynamic #t2 = a1 = #0#6 in true) && #0#5 && (let final dynamic #t3 = b1 = #0#6 in true))
-          #t1 = "";
-        else
-          if(#0#3 && #0#15 && (let final dynamic #t4 = a2 = #0#16 in true) && #0#15 && (let final dynamic #t5 = b2 = #0#16 in true))
-            #t1 = "";
-          else
-            if(#0#3 && #0#18 && (let final dynamic #t6 = a3 = #0#19 in true) && #0#18 && (let final dynamic #t7 = b3 = #0#19 in true))
-              #t1 = "";
-            else
-              if(true)
-                #t1 = "default";
-  } =>#t1;
-}
-static method test2(core::Map<dynamic, dynamic> map) → void {
-  #L1:
-  {
-    dynamic a1;
-    final dynamic b1;
-    dynamic a2;
-    final dynamic b2;
-    dynamic a3;
-    final dynamic b3;
-    final synthesized core::Map<dynamic, dynamic> #0#0 = map;
-    function ##0#3#initializer() → core::bool
-      return #0#0.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2;
-    late final synthesized core::bool #0#3 = ##0#3#initializer(){() → core::bool};
-    function ##0#5#initializer() → core::bool
-      return #0#0.{core::Map::containsKey}(#C1){(core::Object?) → core::bool};
-    late final synthesized core::bool #0#5 = ##0#5#initializer(){() → core::bool};
-    function ##0#6#initializer() → dynamic
-      return #0#0.{core::Map::[]}(#C1){(core::Object?) → dynamic};
-    late final synthesized dynamic #0#6 = ##0#6#initializer(){() → dynamic};
-    function ##0#10#initializer() → core::bool
-      return #0#0.{core::Map::containsKey}(#C3){(core::Object?) → core::bool};
-    late final synthesized core::bool #0#10 = ##0#10#initializer(){() → core::bool};
-    function ##0#11#initializer() → dynamic
-      return #0#0.{core::Map::[]}(#C3){(core::Object?) → dynamic};
-    late final synthesized dynamic #0#11 = ##0#11#initializer(){() → dynamic};
-    function ##0#15#initializer() → core::bool
-      return #0#0.{core::Map::containsKey}(#C4){(core::Object?) → core::bool};
-    late final synthesized core::bool #0#15 = ##0#15#initializer(){() → core::bool};
-    function ##0#16#initializer() → dynamic
-      return #0#0.{core::Map::[]}(#C4){(core::Object?) → dynamic};
-    late final synthesized dynamic #0#16 = ##0#16#initializer(){() → dynamic};
-    function ##0#18#initializer() → core::bool
-      return #0#0.{core::Map::containsKey}(#C5){(core::Object?) → core::bool};
-    late final synthesized core::bool #0#18 = ##0#18#initializer(){() → core::bool};
-    function ##0#19#initializer() → dynamic
-      return #0#0.{core::Map::[]}(#C5){(core::Object?) → dynamic};
-    late final synthesized dynamic #0#19 = ##0#19#initializer(){() → dynamic};
-    if(#0#3 && #0#5 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#6 && #0#5 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#6) {
+    #L1:
+    {
       {
-        break #L1;
-      }
-    }
-    else
-      if(#0#3 && #0#10 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#11 && #0#10 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#11) {
-        {
+        if(#0#3 && #0#5 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#6 && #0#5 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#6) {
+          #t1 = "";
           break #L1;
         }
       }
-      else
-        if(#0#3 && #0#5 && (let final dynamic #t8 = a1 = #0#6 in true) && #0#5 && (let final dynamic #t9 = b1 = #0#6 in true) || #0#3 && #0#15 && (let final dynamic #t10 = a2 = #0#16 in true) && #0#15 && (let final dynamic #t11 = b2 = #0#16 in true)) {
-          {
-            break #L1;
-          }
+      {
+        if(#0#3 && #0#10 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#11 && #0#10 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#11) {
+          #t1 = "";
+          break #L1;
         }
-        else
-          if(#0#3 && #0#18 && (let final dynamic #t12 = a3 = #0#19 in true) && #0#18 && (let final dynamic #t13 = b3 = #0#19 in true)) {
-            {
-              break #L1;
-            }
-          }
+      }
+      {
+        dynamic a1;
+        final dynamic b1;
+        if(#0#3 && #0#5 && (let final dynamic #t2 = a1 = #0#6 in true) && #0#5 && (let final dynamic #t3 = b1 = #0#6 in true)) {
+          #t1 = "";
+          break #L1;
+        }
+      }
+      {
+        dynamic a2;
+        final dynamic b2;
+        if(#0#3 && #0#15 && (let final dynamic #t4 = a2 = #0#16 in true) && #0#15 && (let final dynamic #t5 = b2 = #0#16 in true)) {
+          #t1 = "";
+          break #L1;
+        }
+      }
+      {
+        dynamic a3;
+        final dynamic b3;
+        if(#0#3 && #0#18 && (let final dynamic #t6 = a3 = #0#19 in true) && #0#18 && (let final dynamic #t7 = b3 = #0#19 in true)) {
+          #t1 = "";
+          break #L1;
+        }
+      }
+      {
+        if(true) {
+          #t1 = "default";
+          break #L1;
+        }
+      }
+    }
+  } =>#t1;
+}
+static method test2(core::Map<dynamic, dynamic> map) → void {
+  #L2:
+  {
+    final synthesized core::Map<dynamic, dynamic> #0#0 = map;
+    function ##0#3#initializer() → core::bool
+      return #0#0.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2;
+    late final synthesized core::bool #0#3 = ##0#3#initializer(){() → core::bool};
+    function ##0#5#initializer() → core::bool
+      return #0#0.{core::Map::containsKey}(#C1){(core::Object?) → core::bool};
+    late final synthesized core::bool #0#5 = ##0#5#initializer(){() → core::bool};
+    function ##0#6#initializer() → dynamic
+      return #0#0.{core::Map::[]}(#C1){(core::Object?) → dynamic};
+    late final synthesized dynamic #0#6 = ##0#6#initializer(){() → dynamic};
+    function ##0#10#initializer() → core::bool
+      return #0#0.{core::Map::containsKey}(#C3){(core::Object?) → core::bool};
+    late final synthesized core::bool #0#10 = ##0#10#initializer(){() → core::bool};
+    function ##0#11#initializer() → dynamic
+      return #0#0.{core::Map::[]}(#C3){(core::Object?) → dynamic};
+    late final synthesized dynamic #0#11 = ##0#11#initializer(){() → dynamic};
+    function ##0#15#initializer() → core::bool
+      return #0#0.{core::Map::containsKey}(#C4){(core::Object?) → core::bool};
+    late final synthesized core::bool #0#15 = ##0#15#initializer(){() → core::bool};
+    function ##0#16#initializer() → dynamic
+      return #0#0.{core::Map::[]}(#C4){(core::Object?) → dynamic};
+    late final synthesized dynamic #0#16 = ##0#16#initializer(){() → dynamic};
+    function ##0#18#initializer() → core::bool
+      return #0#0.{core::Map::containsKey}(#C5){(core::Object?) → core::bool};
+    late final synthesized core::bool #0#18 = ##0#18#initializer(){() → core::bool};
+    function ##0#19#initializer() → dynamic
+      return #0#0.{core::Map::[]}(#C5){(core::Object?) → dynamic};
+    late final synthesized dynamic #0#19 = ##0#19#initializer(){() → dynamic};
+    {
+      if(#0#3 && #0#5 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#6 && #0#5 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#6) {
+        {
+          break #L2;
+        }
+      }
+    }
+    {
+      if(#0#3 && #0#10 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#11 && #0#10 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#11) {
+        {
+          break #L2;
+        }
+      }
+    }
+    {
+      dynamic a1;
+      final dynamic b1;
+      dynamic a2;
+      final dynamic b2;
+      if(#0#3 && #0#5 && (let final dynamic #t8 = a1 = #0#6 in true) && #0#5 && (let final dynamic #t9 = b1 = #0#6 in true) || #0#3 && #0#15 && (let final dynamic #t10 = a2 = #0#16 in true) && #0#15 && (let final dynamic #t11 = b2 = #0#16 in true)) {
+        {
+          break #L2;
+        }
+      }
+    }
+    {
+      dynamic a3;
+      final dynamic b3;
+      if(#0#3 && #0#18 && (let final dynamic #t12 = a3 = #0#19 in true) && #0#18 && (let final dynamic #t13 = b3 = #0#19 in true)) {
+        {
+          break #L2;
+        }
+      }
+    }
   }
 }
 static method test3(core::Map<dynamic, dynamic> map) → void {
diff --git a/pkg/front_end/testcases/patterns/identical_map_keys.dart.weak.expect b/pkg/front_end/testcases/patterns/identical_map_keys.dart.weak.expect
index d2050a09dbb..54feebe0fc2 100644
--- a/pkg/front_end/testcases/patterns/identical_map_keys.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/identical_map_keys.dart.weak.expect
@@ -176,12 +176,6 @@ static const field self::C c2 = #C1;
 static method test1(core::Map<dynamic, dynamic> map) → core::String {
   return block {
     core::String #t1;
-    dynamic a1;
-    final dynamic b1;
-    dynamic a2;
-    final dynamic b2;
-    dynamic a3;
-    final dynamic b3;
     final synthesized core::Map<dynamic, dynamic> #0#0 = map;
     late final synthesized core::bool #0#3 = #0#0.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2;
     late final synthesized core::bool #0#5 = #0#0.{core::Map::containsKey}(#C1){(core::Object?) → core::bool};
@@ -192,67 +186,100 @@ static method test1(core::Map<dynamic, dynamic> map) → core::String {
     late final synthesized dynamic #0#16 = #0#0.{core::Map::[]}(#C4){(core::Object?) → dynamic};
     late final synthesized core::bool #0#18 = #0#0.{core::Map::containsKey}(#C5){(core::Object?) → core::bool};
     late final synthesized dynamic #0#19 = #0#0.{core::Map::[]}(#C5){(core::Object?) → dynamic};
-    if(#0#3 && #0#5 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#6 && #0#5 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#6)
-      #t1 = "";
-    else
-      if(#0#3 && #0#10 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#11 && #0#10 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#11)
-        #t1 = "";
-      else
-        if(#0#3 && #0#5 && (let final dynamic #t2 = a1 = #0#6 in true) && #0#5 && (let final dynamic #t3 = b1 = #0#6 in true))
-          #t1 = "";
-        else
-          if(#0#3 && #0#15 && (let final dynamic #t4 = a2 = #0#16 in true) && #0#15 && (let final dynamic #t5 = b2 = #0#16 in true))
-            #t1 = "";
-          else
-            if(#0#3 && #0#18 && (let final dynamic #t6 = a3 = #0#19 in true) && #0#18 && (let final dynamic #t7 = b3 = #0#19 in true))
-              #t1 = "";
-            else
-              if(true)
-                #t1 = "default";
-  } =>#t1;
-}
-static method test2(core::Map<dynamic, dynamic> map) → void {
-  #L1:
-  {
-    dynamic a1;
-    final dynamic b1;
-    dynamic a2;
-    final dynamic b2;
-    dynamic a3;
-    final dynamic b3;
-    final synthesized core::Map<dynamic, dynamic> #0#0 = map;
-    late final synthesized core::bool #0#3 = #0#0.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2;
-    late final synthesized core::bool #0#5 = #0#0.{core::Map::containsKey}(#C1){(core::Object?) → core::bool};
-    late final synthesized dynamic #0#6 = #0#0.{core::Map::[]}(#C1){(core::Object?) → dynamic};
-    late final synthesized core::bool #0#10 = #0#0.{core::Map::containsKey}(#C3){(core::Object?) → core::bool};
-    late final synthesized dynamic #0#11 = #0#0.{core::Map::[]}(#C3){(core::Object?) → dynamic};
-    late final synthesized core::bool #0#15 = #0#0.{core::Map::containsKey}(#C4){(core::Object?) → core::bool};
-    late final synthesized dynamic #0#16 = #0#0.{core::Map::[]}(#C4){(core::Object?) → dynamic};
-    late final synthesized core::bool #0#18 = #0#0.{core::Map::containsKey}(#C5){(core::Object?) → core::bool};
-    late final synthesized dynamic #0#19 = #0#0.{core::Map::[]}(#C5){(core::Object?) → dynamic};
-    if(#0#3 && #0#5 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#6 && #0#5 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#6) {
+    #L1:
+    {
       {
-        break #L1;
-      }
-    }
-    else
-      if(#0#3 && #0#10 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#11 && #0#10 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#11) {
-        {
+        if(#0#3 && #0#5 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#6 && #0#5 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#6) {
+          #t1 = "";
           break #L1;
         }
       }
-      else
-        if(#0#3 && #0#5 && (let final dynamic #t8 = a1 = #0#6 in true) && #0#5 && (let final dynamic #t9 = b1 = #0#6 in true) || #0#3 && #0#15 && (let final dynamic #t10 = a2 = #0#16 in true) && #0#15 && (let final dynamic #t11 = b2 = #0#16 in true)) {
-          {
-            break #L1;
-          }
+      {
+        if(#0#3 && #0#10 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#11 && #0#10 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#11) {
+          #t1 = "";
+          break #L1;
         }
-        else
-          if(#0#3 && #0#18 && (let final dynamic #t12 = a3 = #0#19 in true) && #0#18 && (let final dynamic #t13 = b3 = #0#19 in true)) {
-            {
-              break #L1;
-            }
-          }
+      }
+      {
+        dynamic a1;
+        final dynamic b1;
+        if(#0#3 && #0#5 && (let final dynamic #t2 = a1 = #0#6 in true) && #0#5 && (let final dynamic #t3 = b1 = #0#6 in true)) {
+          #t1 = "";
+          break #L1;
+        }
+      }
+      {
+        dynamic a2;
+        final dynamic b2;
+        if(#0#3 && #0#15 && (let final dynamic #t4 = a2 = #0#16 in true) && #0#15 && (let final dynamic #t5 = b2 = #0#16 in true)) {
+          #t1 = "";
+          break #L1;
+        }
+      }
+      {
+        dynamic a3;
+        final dynamic b3;
+        if(#0#3 && #0#18 && (let final dynamic #t6 = a3 = #0#19 in true) && #0#18 && (let final dynamic #t7 = b3 = #0#19 in true)) {
+          #t1 = "";
+          break #L1;
+        }
+      }
+      {
+        if(true) {
+          #t1 = "default";
+          break #L1;
+        }
+      }
+    }
+  } =>#t1;
+}
+static method test2(core::Map<dynamic, dynamic> map) → void {
+  #L2:
+  {
+    final synthesized core::Map<dynamic, dynamic> #0#0 = map;
+    late final synthesized core::bool #0#3 = #0#0.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2;
+    late final synthesized core::bool #0#5 = #0#0.{core::Map::containsKey}(#C1){(core::Object?) → core::bool};
+    late final synthesized dynamic #0#6 = #0#0.{core::Map::[]}(#C1){(core::Object?) → dynamic};
+    late final synthesized core::bool #0#10 = #0#0.{core::Map::containsKey}(#C3){(core::Object?) → core::bool};
+    late final synthesized dynamic #0#11 = #0#0.{core::Map::[]}(#C3){(core::Object?) → dynamic};
+    late final synthesized core::bool #0#15 = #0#0.{core::Map::containsKey}(#C4){(core::Object?) → core::bool};
+    late final synthesized dynamic #0#16 = #0#0.{core::Map::[]}(#C4){(core::Object?) → dynamic};
+    late final synthesized core::bool #0#18 = #0#0.{core::Map::containsKey}(#C5){(core::Object?) → core::bool};
+    late final synthesized dynamic #0#19 = #0#0.{core::Map::[]}(#C5){(core::Object?) → dynamic};
+    {
+      if(#0#3 && #0#5 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#6 && #0#5 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#6) {
+        {
+          break #L2;
+        }
+      }
+    }
+    {
+      if(#0#3 && #0#10 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#11 && #0#10 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#11) {
+        {
+          break #L2;
+        }
+      }
+    }
+    {
+      dynamic a1;
+      final dynamic b1;
+      dynamic a2;
+      final dynamic b2;
+      if(#0#3 && #0#5 && (let final dynamic #t8 = a1 = #0#6 in true) && #0#5 && (let final dynamic #t9 = b1 = #0#6 in true) || #0#3 && #0#15 && (let final dynamic #t10 = a2 = #0#16 in true) && #0#15 && (let final dynamic #t11 = b2 = #0#16 in true)) {
+        {
+          break #L2;
+        }
+      }
+    }
+    {
+      dynamic a3;
+      final dynamic b3;
+      if(#0#3 && #0#18 && (let final dynamic #t12 = a3 = #0#19 in true) && #0#18 && (let final dynamic #t13 = b3 = #0#19 in true)) {
+        {
+          break #L2;
+        }
+      }
+    }
   }
 }
 static method test3(core::Map<dynamic, dynamic> map) → void {
diff --git a/pkg/front_end/testcases/patterns/identical_map_keys.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/identical_map_keys.dart.weak.modular.expect
index d2050a09dbb..54feebe0fc2 100644
--- a/pkg/front_end/testcases/patterns/identical_map_keys.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/identical_map_keys.dart.weak.modular.expect
@@ -176,12 +176,6 @@ static const field self::C c2 = #C1;
 static method test1(core::Map<dynamic, dynamic> map) → core::String {
   return block {
     core::String #t1;
-    dynamic a1;
-    final dynamic b1;
-    dynamic a2;
-    final dynamic b2;
-    dynamic a3;
-    final dynamic b3;
     final synthesized core::Map<dynamic, dynamic> #0#0 = map;
     late final synthesized core::bool #0#3 = #0#0.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2;
     late final synthesized core::bool #0#5 = #0#0.{core::Map::containsKey}(#C1){(core::Object?) → core::bool};
@@ -192,67 +186,100 @@ static method test1(core::Map<dynamic, dynamic> map) → core::String {
     late final synthesized dynamic #0#16 = #0#0.{core::Map::[]}(#C4){(core::Object?) → dynamic};
     late final synthesized core::bool #0#18 = #0#0.{core::Map::containsKey}(#C5){(core::Object?) → core::bool};
     late final synthesized dynamic #0#19 = #0#0.{core::Map::[]}(#C5){(core::Object?) → dynamic};
-    if(#0#3 && #0#5 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#6 && #0#5 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#6)
-      #t1 = "";
-    else
-      if(#0#3 && #0#10 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#11 && #0#10 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#11)
-        #t1 = "";
-      else
-        if(#0#3 && #0#5 && (let final dynamic #t2 = a1 = #0#6 in true) && #0#5 && (let final dynamic #t3 = b1 = #0#6 in true))
-          #t1 = "";
-        else
-          if(#0#3 && #0#15 && (let final dynamic #t4 = a2 = #0#16 in true) && #0#15 && (let final dynamic #t5 = b2 = #0#16 in true))
-            #t1 = "";
-          else
-            if(#0#3 && #0#18 && (let final dynamic #t6 = a3 = #0#19 in true) && #0#18 && (let final dynamic #t7 = b3 = #0#19 in true))
-              #t1 = "";
-            else
-              if(true)
-                #t1 = "default";
-  } =>#t1;
-}
-static method test2(core::Map<dynamic, dynamic> map) → void {
-  #L1:
-  {
-    dynamic a1;
-    final dynamic b1;
-    dynamic a2;
-    final dynamic b2;
-    dynamic a3;
-    final dynamic b3;
-    final synthesized core::Map<dynamic, dynamic> #0#0 = map;
-    late final synthesized core::bool #0#3 = #0#0.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2;
-    late final synthesized core::bool #0#5 = #0#0.{core::Map::containsKey}(#C1){(core::Object?) → core::bool};
-    late final synthesized dynamic #0#6 = #0#0.{core::Map::[]}(#C1){(core::Object?) → dynamic};
-    late final synthesized core::bool #0#10 = #0#0.{core::Map::containsKey}(#C3){(core::Object?) → core::bool};
-    late final synthesized dynamic #0#11 = #0#0.{core::Map::[]}(#C3){(core::Object?) → dynamic};
-    late final synthesized core::bool #0#15 = #0#0.{core::Map::containsKey}(#C4){(core::Object?) → core::bool};
-    late final synthesized dynamic #0#16 = #0#0.{core::Map::[]}(#C4){(core::Object?) → dynamic};
-    late final synthesized core::bool #0#18 = #0#0.{core::Map::containsKey}(#C5){(core::Object?) → core::bool};
-    late final synthesized dynamic #0#19 = #0#0.{core::Map::[]}(#C5){(core::Object?) → dynamic};
-    if(#0#3 && #0#5 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#6 && #0#5 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#6) {
+    #L1:
+    {
       {
-        break #L1;
-      }
-    }
-    else
-      if(#0#3 && #0#10 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#11 && #0#10 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#11) {
-        {
+        if(#0#3 && #0#5 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#6 && #0#5 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#6) {
+          #t1 = "";
           break #L1;
         }
       }
-      else
-        if(#0#3 && #0#5 && (let final dynamic #t8 = a1 = #0#6 in true) && #0#5 && (let final dynamic #t9 = b1 = #0#6 in true) || #0#3 && #0#15 && (let final dynamic #t10 = a2 = #0#16 in true) && #0#15 && (let final dynamic #t11 = b2 = #0#16 in true)) {
-          {
-            break #L1;
-          }
+      {
+        if(#0#3 && #0#10 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#11 && #0#10 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#11) {
+          #t1 = "";
+          break #L1;
         }
-        else
-          if(#0#3 && #0#18 && (let final dynamic #t12 = a3 = #0#19 in true) && #0#18 && (let final dynamic #t13 = b3 = #0#19 in true)) {
-            {
-              break #L1;
-            }
-          }
+      }
+      {
+        dynamic a1;
+        final dynamic b1;
+        if(#0#3 && #0#5 && (let final dynamic #t2 = a1 = #0#6 in true) && #0#5 && (let final dynamic #t3 = b1 = #0#6 in true)) {
+          #t1 = "";
+          break #L1;
+        }
+      }
+      {
+        dynamic a2;
+        final dynamic b2;
+        if(#0#3 && #0#15 && (let final dynamic #t4 = a2 = #0#16 in true) && #0#15 && (let final dynamic #t5 = b2 = #0#16 in true)) {
+          #t1 = "";
+          break #L1;
+        }
+      }
+      {
+        dynamic a3;
+        final dynamic b3;
+        if(#0#3 && #0#18 && (let final dynamic #t6 = a3 = #0#19 in true) && #0#18 && (let final dynamic #t7 = b3 = #0#19 in true)) {
+          #t1 = "";
+          break #L1;
+        }
+      }
+      {
+        if(true) {
+          #t1 = "default";
+          break #L1;
+        }
+      }
+    }
+  } =>#t1;
+}
+static method test2(core::Map<dynamic, dynamic> map) → void {
+  #L2:
+  {
+    final synthesized core::Map<dynamic, dynamic> #0#0 = map;
+    late final synthesized core::bool #0#3 = #0#0.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2;
+    late final synthesized core::bool #0#5 = #0#0.{core::Map::containsKey}(#C1){(core::Object?) → core::bool};
+    late final synthesized dynamic #0#6 = #0#0.{core::Map::[]}(#C1){(core::Object?) → dynamic};
+    late final synthesized core::bool #0#10 = #0#0.{core::Map::containsKey}(#C3){(core::Object?) → core::bool};
+    late final synthesized dynamic #0#11 = #0#0.{core::Map::[]}(#C3){(core::Object?) → dynamic};
+    late final synthesized core::bool #0#15 = #0#0.{core::Map::containsKey}(#C4){(core::Object?) → core::bool};
+    late final synthesized dynamic #0#16 = #0#0.{core::Map::[]}(#C4){(core::Object?) → dynamic};
+    late final synthesized core::bool #0#18 = #0#0.{core::Map::containsKey}(#C5){(core::Object?) → core::bool};
+    late final synthesized dynamic #0#19 = #0#0.{core::Map::[]}(#C5){(core::Object?) → dynamic};
+    {
+      if(#0#3 && #0#5 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#6 && #0#5 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#6) {
+        {
+          break #L2;
+        }
+      }
+    }
+    {
+      if(#0#3 && #0#10 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#11 && #0#10 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#11) {
+        {
+          break #L2;
+        }
+      }
+    }
+    {
+      dynamic a1;
+      final dynamic b1;
+      dynamic a2;
+      final dynamic b2;
+      if(#0#3 && #0#5 && (let final dynamic #t8 = a1 = #0#6 in true) && #0#5 && (let final dynamic #t9 = b1 = #0#6 in true) || #0#3 && #0#15 && (let final dynamic #t10 = a2 = #0#16 in true) && #0#15 && (let final dynamic #t11 = b2 = #0#16 in true)) {
+        {
+          break #L2;
+        }
+      }
+    }
+    {
+      dynamic a3;
+      final dynamic b3;
+      if(#0#3 && #0#18 && (let final dynamic #t12 = a3 = #0#19 in true) && #0#18 && (let final dynamic #t13 = b3 = #0#19 in true)) {
+        {
+          break #L2;
+        }
+      }
+    }
   }
 }
 static method test3(core::Map<dynamic, dynamic> map) → void {
diff --git a/pkg/front_end/testcases/patterns/identical_map_keys.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/identical_map_keys.dart.weak.transformed.expect
index df1dc051b99..612e8a726c2 100644
--- a/pkg/front_end/testcases/patterns/identical_map_keys.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/identical_map_keys.dart.weak.transformed.expect
@@ -176,12 +176,6 @@ static const field self::C c2 = #C1;
 static method test1(core::Map<dynamic, dynamic> map) → core::String {
   return block {
     core::String #t1;
-    dynamic a1;
-    final dynamic b1;
-    dynamic a2;
-    final dynamic b2;
-    dynamic a3;
-    final dynamic b3;
     final synthesized core::Map<dynamic, dynamic> #0#0 = map;
     function ##0#3#initializer() → core::bool
       return #0#0.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2;
@@ -210,85 +204,118 @@ static method test1(core::Map<dynamic, dynamic> map) → core::String {
     function ##0#19#initializer() → dynamic
       return #0#0.{core::Map::[]}(#C5){(core::Object?) → dynamic};
     late final synthesized dynamic #0#19 = ##0#19#initializer(){() → dynamic};
-    if(#0#3 && #0#5 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#6 && #0#5 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#6)
-      #t1 = "";
-    else
-      if(#0#3 && #0#10 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#11 && #0#10 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#11)
-        #t1 = "";
-      else
-        if(#0#3 && #0#5 && (let final dynamic #t2 = a1 = #0#6 in true) && #0#5 && (let final dynamic #t3 = b1 = #0#6 in true))
-          #t1 = "";
-        else
-          if(#0#3 && #0#15 && (let final dynamic #t4 = a2 = #0#16 in true) && #0#15 && (let final dynamic #t5 = b2 = #0#16 in true))
-            #t1 = "";
-          else
-            if(#0#3 && #0#18 && (let final dynamic #t6 = a3 = #0#19 in true) && #0#18 && (let final dynamic #t7 = b3 = #0#19 in true))
-              #t1 = "";
-            else
-              if(true)
-                #t1 = "default";
-  } =>#t1;
-}
-static method test2(core::Map<dynamic, dynamic> map) → void {
-  #L1:
-  {
-    dynamic a1;
-    final dynamic b1;
-    dynamic a2;
-    final dynamic b2;
-    dynamic a3;
-    final dynamic b3;
-    final synthesized core::Map<dynamic, dynamic> #0#0 = map;
-    function ##0#3#initializer() → core::bool
-      return #0#0.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2;
-    late final synthesized core::bool #0#3 = ##0#3#initializer(){() → core::bool};
-    function ##0#5#initializer() → core::bool
-      return #0#0.{core::Map::containsKey}(#C1){(core::Object?) → core::bool};
-    late final synthesized core::bool #0#5 = ##0#5#initializer(){() → core::bool};
-    function ##0#6#initializer() → dynamic
-      return #0#0.{core::Map::[]}(#C1){(core::Object?) → dynamic};
-    late final synthesized dynamic #0#6 = ##0#6#initializer(){() → dynamic};
-    function ##0#10#initializer() → core::bool
-      return #0#0.{core::Map::containsKey}(#C3){(core::Object?) → core::bool};
-    late final synthesized core::bool #0#10 = ##0#10#initializer(){() → core::bool};
-    function ##0#11#initializer() → dynamic
-      return #0#0.{core::Map::[]}(#C3){(core::Object?) → dynamic};
-    late final synthesized dynamic #0#11 = ##0#11#initializer(){() → dynamic};
-    function ##0#15#initializer() → core::bool
-      return #0#0.{core::Map::containsKey}(#C4){(core::Object?) → core::bool};
-    late final synthesized core::bool #0#15 = ##0#15#initializer(){() → core::bool};
-    function ##0#16#initializer() → dynamic
-      return #0#0.{core::Map::[]}(#C4){(core::Object?) → dynamic};
-    late final synthesized dynamic #0#16 = ##0#16#initializer(){() → dynamic};
-    function ##0#18#initializer() → core::bool
-      return #0#0.{core::Map::containsKey}(#C5){(core::Object?) → core::bool};
-    late final synthesized core::bool #0#18 = ##0#18#initializer(){() → core::bool};
-    function ##0#19#initializer() → dynamic
-      return #0#0.{core::Map::[]}(#C5){(core::Object?) → dynamic};
-    late final synthesized dynamic #0#19 = ##0#19#initializer(){() → dynamic};
-    if(#0#3 && #0#5 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#6 && #0#5 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#6) {
+    #L1:
+    {
       {
-        break #L1;
-      }
-    }
-    else
-      if(#0#3 && #0#10 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#11 && #0#10 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#11) {
-        {
+        if(#0#3 && #0#5 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#6 && #0#5 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#6) {
+          #t1 = "";
           break #L1;
         }
       }
-      else
-        if(#0#3 && #0#5 && (let final dynamic #t8 = a1 = #0#6 in true) && #0#5 && (let final dynamic #t9 = b1 = #0#6 in true) || #0#3 && #0#15 && (let final dynamic #t10 = a2 = #0#16 in true) && #0#15 && (let final dynamic #t11 = b2 = #0#16 in true)) {
-          {
-            break #L1;
-          }
+      {
+        if(#0#3 && #0#10 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#11 && #0#10 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#11) {
+          #t1 = "";
+          break #L1;
         }
-        else
-          if(#0#3 && #0#18 && (let final dynamic #t12 = a3 = #0#19 in true) && #0#18 && (let final dynamic #t13 = b3 = #0#19 in true)) {
-            {
-              break #L1;
-            }
-          }
+      }
+      {
+        dynamic a1;
+        final dynamic b1;
+        if(#0#3 && #0#5 && (let final dynamic #t2 = a1 = #0#6 in true) && #0#5 && (let final dynamic #t3 = b1 = #0#6 in true)) {
+          #t1 = "";
+          break #L1;
+        }
+      }
+      {
+        dynamic a2;
+        final dynamic b2;
+        if(#0#3 && #0#15 && (let final dynamic #t4 = a2 = #0#16 in true) && #0#15 && (let final dynamic #t5 = b2 = #0#16 in true)) {
+          #t1 = "";
+          break #L1;
+        }
+      }
+      {
+        dynamic a3;
+        final dynamic b3;
+        if(#0#3 && #0#18 && (let final dynamic #t6 = a3 = #0#19 in true) && #0#18 && (let final dynamic #t7 = b3 = #0#19 in true)) {
+          #t1 = "";
+          break #L1;
+        }
+      }
+      {
+        if(true) {
+          #t1 = "default";
+          break #L1;
+        }
+      }
+    }
+  } =>#t1;
+}
+static method test2(core::Map<dynamic, dynamic> map) → void {
+  #L2:
+  {
+    final synthesized core::Map<dynamic, dynamic> #0#0 = map;
+    function ##0#3#initializer() → core::bool
+      return #0#0.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2;
+    late final synthesized core::bool #0#3 = ##0#3#initializer(){() → core::bool};
+    function ##0#5#initializer() → core::bool
+      return #0#0.{core::Map::containsKey}(#C1){(core::Object?) → core::bool};
+    late final synthesized core::bool #0#5 = ##0#5#initializer(){() → core::bool};
+    function ##0#6#initializer() → dynamic
+      return #0#0.{core::Map::[]}(#C1){(core::Object?) → dynamic};
+    late final synthesized dynamic #0#6 = ##0#6#initializer(){() → dynamic};
+    function ##0#10#initializer() → core::bool
+      return #0#0.{core::Map::containsKey}(#C3){(core::Object?) → core::bool};
+    late final synthesized core::bool #0#10 = ##0#10#initializer(){() → core::bool};
+    function ##0#11#initializer() → dynamic
+      return #0#0.{core::Map::[]}(#C3){(core::Object?) → dynamic};
+    late final synthesized dynamic #0#11 = ##0#11#initializer(){() → dynamic};
+    function ##0#15#initializer() → core::bool
+      return #0#0.{core::Map::containsKey}(#C4){(core::Object?) → core::bool};
+    late final synthesized core::bool #0#15 = ##0#15#initializer(){() → core::bool};
+    function ##0#16#initializer() → dynamic
+      return #0#0.{core::Map::[]}(#C4){(core::Object?) → dynamic};
+    late final synthesized dynamic #0#16 = ##0#16#initializer(){() → dynamic};
+    function ##0#18#initializer() → core::bool
+      return #0#0.{core::Map::containsKey}(#C5){(core::Object?) → core::bool};
+    late final synthesized core::bool #0#18 = ##0#18#initializer(){() → core::bool};
+    function ##0#19#initializer() → dynamic
+      return #0#0.{core::Map::[]}(#C5){(core::Object?) → dynamic};
+    late final synthesized dynamic #0#19 = ##0#19#initializer(){() → dynamic};
+    {
+      if(#0#3 && #0#5 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#6 && #0#5 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#6) {
+        {
+          break #L2;
+        }
+      }
+    }
+    {
+      if(#0#3 && #0#10 && #C3 =={core::num::==}{(core::Object) → core::bool} #0#11 && #0#10 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#11) {
+        {
+          break #L2;
+        }
+      }
+    }
+    {
+      dynamic a1;
+      final dynamic b1;
+      dynamic a2;
+      final dynamic b2;
+      if(#0#3 && #0#5 && (let final dynamic #t8 = a1 = #0#6 in true) && #0#5 && (let final dynamic #t9 = b1 = #0#6 in true) || #0#3 && #0#15 && (let final dynamic #t10 = a2 = #0#16 in true) && #0#15 && (let final dynamic #t11 = b2 = #0#16 in true)) {
+        {
+          break #L2;
+        }
+      }
+    }
+    {
+      dynamic a3;
+      final dynamic b3;
+      if(#0#3 && #0#18 && (let final dynamic #t12 = a3 = #0#19 in true) && #0#18 && (let final dynamic #t13 = b3 = #0#19 in true)) {
+        {
+          break #L2;
+        }
+      }
+    }
   }
 }
 static method test3(core::Map<dynamic, dynamic> map) → void {
diff --git a/pkg/front_end/testcases/patterns/integer_literal_inside_case.dart.strong.expect b/pkg/front_end/testcases/patterns/integer_literal_inside_case.dart.strong.expect
index 345f852ec43..78d52d9158e 100644
--- a/pkg/front_end/testcases/patterns/integer_literal_inside_case.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/integer_literal_inside_case.dart.strong.expect
@@ -4,13 +4,12 @@ import "dart:core" as core;
 
 static method test(dynamic x) → dynamic {
   #L1:
-  {
-    final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+  switch(x) {
+    #L2:
+    case #C1:
       {
         break #L1;
       }
-    }
   }
 }
 
diff --git a/pkg/front_end/testcases/patterns/integer_literal_inside_case.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/integer_literal_inside_case.dart.strong.transformed.expect
index 345f852ec43..78d52d9158e 100644
--- a/pkg/front_end/testcases/patterns/integer_literal_inside_case.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/integer_literal_inside_case.dart.strong.transformed.expect
@@ -4,13 +4,12 @@ import "dart:core" as core;
 
 static method test(dynamic x) → dynamic {
   #L1:
-  {
-    final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+  switch(x) {
+    #L2:
+    case #C1:
       {
         break #L1;
       }
-    }
   }
 }
 
diff --git a/pkg/front_end/testcases/patterns/integer_literal_inside_case.dart.weak.expect b/pkg/front_end/testcases/patterns/integer_literal_inside_case.dart.weak.expect
index 345f852ec43..78d52d9158e 100644
--- a/pkg/front_end/testcases/patterns/integer_literal_inside_case.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/integer_literal_inside_case.dart.weak.expect
@@ -4,13 +4,12 @@ import "dart:core" as core;
 
 static method test(dynamic x) → dynamic {
   #L1:
-  {
-    final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+  switch(x) {
+    #L2:
+    case #C1:
       {
         break #L1;
       }
-    }
   }
 }
 
diff --git a/pkg/front_end/testcases/patterns/integer_literal_inside_case.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/integer_literal_inside_case.dart.weak.modular.expect
index 345f852ec43..78d52d9158e 100644
--- a/pkg/front_end/testcases/patterns/integer_literal_inside_case.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/integer_literal_inside_case.dart.weak.modular.expect
@@ -4,13 +4,12 @@ import "dart:core" as core;
 
 static method test(dynamic x) → dynamic {
   #L1:
-  {
-    final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+  switch(x) {
+    #L2:
+    case #C1:
       {
         break #L1;
       }
-    }
   }
 }
 
diff --git a/pkg/front_end/testcases/patterns/integer_literal_inside_case.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/integer_literal_inside_case.dart.weak.transformed.expect
index 345f852ec43..78d52d9158e 100644
--- a/pkg/front_end/testcases/patterns/integer_literal_inside_case.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/integer_literal_inside_case.dart.weak.transformed.expect
@@ -4,13 +4,12 @@ import "dart:core" as core;
 
 static method test(dynamic x) → dynamic {
   #L1:
-  {
-    final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+  switch(x) {
+    #L2:
+    case #C1:
       {
         break #L1;
       }
-    }
   }
 }
 
diff --git a/pkg/front_end/testcases/patterns/integer_literal_inside_cast.dart.strong.expect b/pkg/front_end/testcases/patterns/integer_literal_inside_cast.dart.strong.expect
index 663e02f4ddf..d77d21dfa9c 100644
--- a/pkg/front_end/testcases/patterns/integer_literal_inside_cast.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/integer_literal_inside_cast.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::Object) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::Object) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/integer_literal_inside_cast.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/integer_literal_inside_cast.dart.strong.transformed.expect
index b4a55240812..488b36eee35 100644
--- a/pkg/front_end/testcases/patterns/integer_literal_inside_cast.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/integer_literal_inside_cast.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final core::Object #t1 = let dynamic #t2 = #0#0 in #t2 == null ?{core::Object} #t2 as{ForNonNullableByDefault} core::Object : #t2{core::Object} in #C1 =={core::num::==}{(core::Object) → core::bool} (let dynamic #t3 = #0#0 in #t3 == null ?{core::Object} #t3 as{ForNonNullableByDefault} core::Object : #t3{core::Object})) {
-      {
-        break #L1;
+    {
+      if(let final core::Object #t1 = let dynamic #t2 = #0#0 in #t2 == null ?{core::Object} #t2 as{ForNonNullableByDefault} core::Object : #t2{core::Object} in #C1 =={core::num::==}{(core::Object) → core::bool} (let dynamic #t3 = #0#0 in #t3 == null ?{core::Object} #t3 as{ForNonNullableByDefault} core::Object : #t3{core::Object})) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/integer_literal_inside_cast.dart.weak.expect b/pkg/front_end/testcases/patterns/integer_literal_inside_cast.dart.weak.expect
index 663e02f4ddf..d77d21dfa9c 100644
--- a/pkg/front_end/testcases/patterns/integer_literal_inside_cast.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/integer_literal_inside_cast.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::Object) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::Object) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/integer_literal_inside_cast.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/integer_literal_inside_cast.dart.weak.modular.expect
index 663e02f4ddf..d77d21dfa9c 100644
--- a/pkg/front_end/testcases/patterns/integer_literal_inside_cast.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/integer_literal_inside_cast.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::Object) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::Object) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/integer_literal_inside_cast.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/integer_literal_inside_cast.dart.weak.transformed.expect
index 6f92fed796f..5053cc6fde4 100644
--- a/pkg/front_end/testcases/patterns/integer_literal_inside_cast.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/integer_literal_inside_cast.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final core::Object #t1 = #0#0 in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        break #L1;
+    {
+      if(let final core::Object #t1 = #0#0 in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/integer_literal_inside_null_assert.dart.strong.expect b/pkg/front_end/testcases/patterns/integer_literal_inside_null_assert.dart.strong.expect
index 7d8550841b3..b2bc2051445 100644
--- a/pkg/front_end/testcases/patterns/integer_literal_inside_null_assert.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/integer_literal_inside_null_assert.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/integer_literal_inside_null_assert.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/integer_literal_inside_null_assert.dart.strong.transformed.expect
index 7d8550841b3..b2bc2051445 100644
--- a/pkg/front_end/testcases/patterns/integer_literal_inside_null_assert.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/integer_literal_inside_null_assert.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/integer_literal_inside_null_assert.dart.weak.expect b/pkg/front_end/testcases/patterns/integer_literal_inside_null_assert.dart.weak.expect
index 7d8550841b3..b2bc2051445 100644
--- a/pkg/front_end/testcases/patterns/integer_literal_inside_null_assert.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/integer_literal_inside_null_assert.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/integer_literal_inside_null_assert.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/integer_literal_inside_null_assert.dart.weak.modular.expect
index 7d8550841b3..b2bc2051445 100644
--- a/pkg/front_end/testcases/patterns/integer_literal_inside_null_assert.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/integer_literal_inside_null_assert.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/integer_literal_inside_null_assert.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/integer_literal_inside_null_assert.dart.weak.transformed.expect
index 7d8550841b3..b2bc2051445 100644
--- a/pkg/front_end/testcases/patterns/integer_literal_inside_null_assert.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/integer_literal_inside_null_assert.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/integer_literal_inside_null_check.dart.strong.expect b/pkg/front_end/testcases/patterns/integer_literal_inside_null_check.dart.strong.expect
index bce0857c6fe..0217a608547 100644
--- a/pkg/front_end/testcases/patterns/integer_literal_inside_null_check.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/integer_literal_inside_null_check.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/integer_literal_inside_null_check.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/integer_literal_inside_null_check.dart.strong.transformed.expect
index bce0857c6fe..0217a608547 100644
--- a/pkg/front_end/testcases/patterns/integer_literal_inside_null_check.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/integer_literal_inside_null_check.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/integer_literal_inside_null_check.dart.weak.expect b/pkg/front_end/testcases/patterns/integer_literal_inside_null_check.dart.weak.expect
index bce0857c6fe..0217a608547 100644
--- a/pkg/front_end/testcases/patterns/integer_literal_inside_null_check.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/integer_literal_inside_null_check.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/integer_literal_inside_null_check.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/integer_literal_inside_null_check.dart.weak.modular.expect
index bce0857c6fe..0217a608547 100644
--- a/pkg/front_end/testcases/patterns/integer_literal_inside_null_check.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/integer_literal_inside_null_check.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/integer_literal_inside_null_check.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/integer_literal_inside_null_check.dart.weak.transformed.expect
index bce0857c6fe..0217a608547 100644
--- a/pkg/front_end/testcases/patterns/integer_literal_inside_null_check.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/integer_literal_inside_null_check.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/issue50871.dart.strong.expect b/pkg/front_end/testcases/patterns/issue50871.dart.strong.expect
index 1d85ed36f81..25a6658b3d0 100644
--- a/pkg/front_end/testcases/patterns/issue50871.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/issue50871.dart.strong.expect
@@ -7,14 +7,18 @@ static method test(core::Symbol value) → core::String {
   #L1:
   {
     final synthesized core::Symbol #0#0 = value;
-    if(#C1 =={core::Symbol::==}{(core::Object) → core::bool} #0#0) {
-      {
-        return "foo";
+    {
+      if(#C1 =={core::Symbol::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return "foo";
+        }
       }
     }
-    else {
+    {
       {
-        return "default";
+        {
+          return "default";
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/issue50871.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/issue50871.dart.strong.transformed.expect
index 1d85ed36f81..25a6658b3d0 100644
--- a/pkg/front_end/testcases/patterns/issue50871.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/issue50871.dart.strong.transformed.expect
@@ -7,14 +7,18 @@ static method test(core::Symbol value) → core::String {
   #L1:
   {
     final synthesized core::Symbol #0#0 = value;
-    if(#C1 =={core::Symbol::==}{(core::Object) → core::bool} #0#0) {
-      {
-        return "foo";
+    {
+      if(#C1 =={core::Symbol::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return "foo";
+        }
       }
     }
-    else {
+    {
       {
-        return "default";
+        {
+          return "default";
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/issue50871.dart.weak.expect b/pkg/front_end/testcases/patterns/issue50871.dart.weak.expect
index 1d85ed36f81..25a6658b3d0 100644
--- a/pkg/front_end/testcases/patterns/issue50871.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/issue50871.dart.weak.expect
@@ -7,14 +7,18 @@ static method test(core::Symbol value) → core::String {
   #L1:
   {
     final synthesized core::Symbol #0#0 = value;
-    if(#C1 =={core::Symbol::==}{(core::Object) → core::bool} #0#0) {
-      {
-        return "foo";
+    {
+      if(#C1 =={core::Symbol::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return "foo";
+        }
       }
     }
-    else {
+    {
       {
-        return "default";
+        {
+          return "default";
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/issue50871.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/issue50871.dart.weak.modular.expect
index 1d85ed36f81..25a6658b3d0 100644
--- a/pkg/front_end/testcases/patterns/issue50871.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/issue50871.dart.weak.modular.expect
@@ -7,14 +7,18 @@ static method test(core::Symbol value) → core::String {
   #L1:
   {
     final synthesized core::Symbol #0#0 = value;
-    if(#C1 =={core::Symbol::==}{(core::Object) → core::bool} #0#0) {
-      {
-        return "foo";
+    {
+      if(#C1 =={core::Symbol::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return "foo";
+        }
       }
     }
-    else {
+    {
       {
-        return "default";
+        {
+          return "default";
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/issue50871.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/issue50871.dart.weak.transformed.expect
index 1d85ed36f81..25a6658b3d0 100644
--- a/pkg/front_end/testcases/patterns/issue50871.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/issue50871.dart.weak.transformed.expect
@@ -7,14 +7,18 @@ static method test(core::Symbol value) → core::String {
   #L1:
   {
     final synthesized core::Symbol #0#0 = value;
-    if(#C1 =={core::Symbol::==}{(core::Object) → core::bool} #0#0) {
-      {
-        return "foo";
+    {
+      if(#C1 =={core::Symbol::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return "foo";
+        }
       }
     }
-    else {
+    {
       {
-        return "default";
+        {
+          return "default";
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/issue50931.dart.strong.expect b/pkg/front_end/testcases/patterns/issue50931.dart.strong.expect
index 371fe4ccd96..d75a287406e 100644
--- a/pkg/front_end/testcases/patterns/issue50931.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/issue50931.dart.strong.expect
@@ -6,118 +6,119 @@ static method test1(dynamic x) → dynamic {
   #L1:
   {
     core::int #t1 = -1;
-    core::int y;
-    core::double y#1;
-    core::String y#2;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = y = #0#0{core::int} in true))
-      #t1 = 0;
-    else
-      if(#C1 =={core::String::==}{(core::Object) → core::bool} #0#0 || #C2 =={core::String::==}{(core::Object) → core::bool} #0#0)
-        #t1 = 1;
-      else
-        if(#0#0 is{ForNonNullableByDefault} core::double && (let final dynamic #t3 = y#1 = #0#0{core::double} in true))
-          #t1 = 2;
-        else
-          if(#0#0 is{ForNonNullableByDefault} core::String && (let final dynamic #t4 = y#2 = #0#0{core::String} in true))
-            #t1 = 3;
-          else
-            #t1 = 4;
-    switch(#t1) {
-      #L2:
-      case #C3:
-        {
+    #L2:
+    {
+      {
+        core::int y;
+        if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = y = #0#0{core::int} in true)) {
           {
-            continue #L3;
+            #t1 = 0;
+            break #L2;
           }
         }
-      #L3:
-      case #C4:
-        {
+      }
+      {
+        if(#C1 =={core::String::==}{(core::Object) → core::bool} #0#0 || #C2 =={core::String::==}{(core::Object) → core::bool} #0#0) {
+          #t1 = 0;
+          break #L2;
+        }
+      }
+      {
+        core::double y;
+        if(#0#0 is{ForNonNullableByDefault} core::double && (let final dynamic #t3 = y = #0#0{core::double} in true)) {
           {
-            return 0;
+            #t1 = 0;
+            break #L2;
           }
         }
-      #L4:
-      case #C5:
-        {
+      }
+      {
+        core::String y;
+        if(#0#0 is{ForNonNullableByDefault} core::String && (let final dynamic #t4 = y = #0#0{core::String} in true)) {
           {
-            continue #L3;
+            #t1 = 0;
+            break #L2;
           }
         }
-      #L5:
-      case #C6:
-        {
-          {
-            continue #L3;
-          }
-        }
-      #L6:
-      case #C7:
-      default:
+      }
+      {
         {
           {
             return 1;
           }
         }
+      }
+    }
+    switch(#t1) {
+      #L3:
+      case #C3:
+        {
+          {
+            return 0;
+          }
+        }
     }
   }
 }
 static method test2(dynamic x) → dynamic {
-  #L7:
+  #L4:
   {
     core::int #t5 = -1;
-    core::String y;
-    core::int y#1;
-    core::double y#2;
-    core::bool y1;
+    core::double y;
     core::List<dynamic> y2;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::String && (let final dynamic #t6 = y = #0#0{core::String} in true))
-      #t5 = 0;
-    else
-      if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t7 = y#1 = #0#0{core::int} in true))
-        #t5 = 1;
-      else
-        if(#0#0 is{ForNonNullableByDefault} core::double && (let final dynamic #t8 = y#2 = #0#0{core::double} in true))
-          #t5 = 2;
-        else
-          if(#0#0 is{ForNonNullableByDefault} core::bool && (let final dynamic #t9 = y1 = #0#0{core::bool} in true))
-            #t5 = 3;
-          else
-            if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (let final dynamic #t10 = y2 = #0#0{core::List<dynamic>} in true) || true)
-              #t5 = 4;
-    switch(#t5) {
-      #L8:
-      case #C3:
-        {
+    #L5:
+    {
+      {
+        core::String y;
+        if(#0#0 is{ForNonNullableByDefault} core::String && (let final dynamic #t6 = y = #0#0{core::String} in true)) {
           {
             return "String";
           }
         }
-      #L9:
-      case #C4:
-        {
+      }
+      {
+        core::int y;
+        if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t7 = y = #0#0{core::int} in true)) {
           {
-            continue #L10;
+            #t5 = 0;
+            break #L5;
           }
         }
-      #L10:
-      case #C5:
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::double && (let final dynamic #t8 = y = #0#0{core::double} in true)) {
+          #t5 = 0;
+          break #L5;
+        }
+      }
+      {
+        core::bool y1;
+        if(#0#0 is{ForNonNullableByDefault} core::bool && (let final dynamic #t9 = y1 = #0#0{core::bool} in true)) {
+          {
+            #t5 = 1;
+            break #L5;
+          }
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (let final dynamic #t10 = y2 = #0#0{core::List<dynamic>} in true) || true) {
+          #t5 = 1;
+          break #L5;
+        }
+      }
+    }
+    switch(#t5) {
+      #L6:
+      case #C3:
         {
           {
             return "num";
           }
         }
-      #L11:
-      case #C6:
-        {
-          {
-            continue #L12;
-          }
-        }
-      #L12:
-      case #C7:
+      #L7:
+      case #C4:
       default:
         {
           {
@@ -155,7 +156,4 @@ constants  {
   #C2 = "foobar"
   #C3 = 0
   #C4 = 1
-  #C5 = 2
-  #C6 = 3
-  #C7 = 4
 }
diff --git a/pkg/front_end/testcases/patterns/issue50931.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/issue50931.dart.strong.transformed.expect
index 882a26b8cd6..43002bb3934 100644
--- a/pkg/front_end/testcases/patterns/issue50931.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/issue50931.dart.strong.transformed.expect
@@ -6,118 +6,119 @@ static method test1(dynamic x) → dynamic {
   #L1:
   {
     core::int #t1 = -1;
-    core::int y;
-    core::double y#1;
-    core::String y#2;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t2 = y = #0#0{core::int} in true))
-      #t1 = 0;
-    else
-      if(#C1 =={core::String::==}{(core::Object) → core::bool} #0#0 || #C2 =={core::String::==}{(core::Object) → core::bool} #0#0)
-        #t1 = 1;
-      else
-        if(#0#0 is{ForNonNullableByDefault} core::double && (let final core::double #t3 = y#1 = #0#0{core::double} in true))
-          #t1 = 2;
-        else
-          if(#0#0 is{ForNonNullableByDefault} core::String && (let final core::String #t4 = y#2 = #0#0{core::String} in true))
-            #t1 = 3;
-          else
-            #t1 = 4;
-    switch(#t1) {
-      #L2:
-      case #C3:
-        {
+    #L2:
+    {
+      {
+        core::int y;
+        if(#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t2 = y = #0#0{core::int} in true)) {
           {
-            continue #L3;
+            #t1 = 0;
+            break #L2;
           }
         }
-      #L3:
-      case #C4:
-        {
+      }
+      {
+        if(#C1 =={core::String::==}{(core::Object) → core::bool} #0#0 || #C2 =={core::String::==}{(core::Object) → core::bool} #0#0) {
+          #t1 = 0;
+          break #L2;
+        }
+      }
+      {
+        core::double y;
+        if(#0#0 is{ForNonNullableByDefault} core::double && (let final core::double #t3 = y = #0#0{core::double} in true)) {
           {
-            return 0;
+            #t1 = 0;
+            break #L2;
           }
         }
-      #L4:
-      case #C5:
-        {
+      }
+      {
+        core::String y;
+        if(#0#0 is{ForNonNullableByDefault} core::String && (let final core::String #t4 = y = #0#0{core::String} in true)) {
           {
-            continue #L3;
+            #t1 = 0;
+            break #L2;
           }
         }
-      #L5:
-      case #C6:
-        {
-          {
-            continue #L3;
-          }
-        }
-      #L6:
-      case #C7:
-      default:
+      }
+      {
         {
           {
             return 1;
           }
         }
+      }
+    }
+    switch(#t1) {
+      #L3:
+      case #C3:
+        {
+          {
+            return 0;
+          }
+        }
     }
   }
 }
 static method test2(dynamic x) → dynamic {
-  #L7:
+  #L4:
   {
     core::int #t5 = -1;
-    core::String y;
-    core::int y#1;
-    core::double y#2;
-    core::bool y1;
+    core::double y;
     core::List<dynamic> y2;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::String && (let final core::String #t6 = y = #0#0{core::String} in true))
-      #t5 = 0;
-    else
-      if(#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t7 = y#1 = #0#0{core::int} in true))
-        #t5 = 1;
-      else
-        if(#0#0 is{ForNonNullableByDefault} core::double && (let final core::double #t8 = y#2 = #0#0{core::double} in true))
-          #t5 = 2;
-        else
-          if(#0#0 is{ForNonNullableByDefault} core::bool && (let final core::bool #t9 = y1 = #0#0{core::bool} in true))
-            #t5 = 3;
-          else
-            if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (let final core::List<dynamic> #t10 = y2 = #0#0{core::List<dynamic>} in true) || true)
-              #t5 = 4;
-    switch(#t5) {
-      #L8:
-      case #C3:
-        {
+    #L5:
+    {
+      {
+        core::String y;
+        if(#0#0 is{ForNonNullableByDefault} core::String && (let final core::String #t6 = y = #0#0{core::String} in true)) {
           {
             return "String";
           }
         }
-      #L9:
-      case #C4:
-        {
+      }
+      {
+        core::int y;
+        if(#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t7 = y = #0#0{core::int} in true)) {
           {
-            continue #L10;
+            #t5 = 0;
+            break #L5;
           }
         }
-      #L10:
-      case #C5:
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::double && (let final core::double #t8 = y = #0#0{core::double} in true)) {
+          #t5 = 0;
+          break #L5;
+        }
+      }
+      {
+        core::bool y1;
+        if(#0#0 is{ForNonNullableByDefault} core::bool && (let final core::bool #t9 = y1 = #0#0{core::bool} in true)) {
+          {
+            #t5 = 1;
+            break #L5;
+          }
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (let final core::List<dynamic> #t10 = y2 = #0#0{core::List<dynamic>} in true) || true) {
+          #t5 = 1;
+          break #L5;
+        }
+      }
+    }
+    switch(#t5) {
+      #L6:
+      case #C3:
         {
           {
             return "num";
           }
         }
-      #L11:
-      case #C6:
-        {
-          {
-            continue #L12;
-          }
-        }
-      #L12:
-      case #C7:
+      #L7:
+      case #C4:
       default:
         {
           {
@@ -155,7 +156,4 @@ constants  {
   #C2 = "foobar"
   #C3 = 0
   #C4 = 1
-  #C5 = 2
-  #C6 = 3
-  #C7 = 4
 }
diff --git a/pkg/front_end/testcases/patterns/issue50931.dart.weak.expect b/pkg/front_end/testcases/patterns/issue50931.dart.weak.expect
index 371fe4ccd96..d75a287406e 100644
--- a/pkg/front_end/testcases/patterns/issue50931.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/issue50931.dart.weak.expect
@@ -6,118 +6,119 @@ static method test1(dynamic x) → dynamic {
   #L1:
   {
     core::int #t1 = -1;
-    core::int y;
-    core::double y#1;
-    core::String y#2;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = y = #0#0{core::int} in true))
-      #t1 = 0;
-    else
-      if(#C1 =={core::String::==}{(core::Object) → core::bool} #0#0 || #C2 =={core::String::==}{(core::Object) → core::bool} #0#0)
-        #t1 = 1;
-      else
-        if(#0#0 is{ForNonNullableByDefault} core::double && (let final dynamic #t3 = y#1 = #0#0{core::double} in true))
-          #t1 = 2;
-        else
-          if(#0#0 is{ForNonNullableByDefault} core::String && (let final dynamic #t4 = y#2 = #0#0{core::String} in true))
-            #t1 = 3;
-          else
-            #t1 = 4;
-    switch(#t1) {
-      #L2:
-      case #C3:
-        {
+    #L2:
+    {
+      {
+        core::int y;
+        if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = y = #0#0{core::int} in true)) {
           {
-            continue #L3;
+            #t1 = 0;
+            break #L2;
           }
         }
-      #L3:
-      case #C4:
-        {
+      }
+      {
+        if(#C1 =={core::String::==}{(core::Object) → core::bool} #0#0 || #C2 =={core::String::==}{(core::Object) → core::bool} #0#0) {
+          #t1 = 0;
+          break #L2;
+        }
+      }
+      {
+        core::double y;
+        if(#0#0 is{ForNonNullableByDefault} core::double && (let final dynamic #t3 = y = #0#0{core::double} in true)) {
           {
-            return 0;
+            #t1 = 0;
+            break #L2;
           }
         }
-      #L4:
-      case #C5:
-        {
+      }
+      {
+        core::String y;
+        if(#0#0 is{ForNonNullableByDefault} core::String && (let final dynamic #t4 = y = #0#0{core::String} in true)) {
           {
-            continue #L3;
+            #t1 = 0;
+            break #L2;
           }
         }
-      #L5:
-      case #C6:
-        {
-          {
-            continue #L3;
-          }
-        }
-      #L6:
-      case #C7:
-      default:
+      }
+      {
         {
           {
             return 1;
           }
         }
+      }
+    }
+    switch(#t1) {
+      #L3:
+      case #C3:
+        {
+          {
+            return 0;
+          }
+        }
     }
   }
 }
 static method test2(dynamic x) → dynamic {
-  #L7:
+  #L4:
   {
     core::int #t5 = -1;
-    core::String y;
-    core::int y#1;
-    core::double y#2;
-    core::bool y1;
+    core::double y;
     core::List<dynamic> y2;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::String && (let final dynamic #t6 = y = #0#0{core::String} in true))
-      #t5 = 0;
-    else
-      if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t7 = y#1 = #0#0{core::int} in true))
-        #t5 = 1;
-      else
-        if(#0#0 is{ForNonNullableByDefault} core::double && (let final dynamic #t8 = y#2 = #0#0{core::double} in true))
-          #t5 = 2;
-        else
-          if(#0#0 is{ForNonNullableByDefault} core::bool && (let final dynamic #t9 = y1 = #0#0{core::bool} in true))
-            #t5 = 3;
-          else
-            if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (let final dynamic #t10 = y2 = #0#0{core::List<dynamic>} in true) || true)
-              #t5 = 4;
-    switch(#t5) {
-      #L8:
-      case #C3:
-        {
+    #L5:
+    {
+      {
+        core::String y;
+        if(#0#0 is{ForNonNullableByDefault} core::String && (let final dynamic #t6 = y = #0#0{core::String} in true)) {
           {
             return "String";
           }
         }
-      #L9:
-      case #C4:
-        {
+      }
+      {
+        core::int y;
+        if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t7 = y = #0#0{core::int} in true)) {
           {
-            continue #L10;
+            #t5 = 0;
+            break #L5;
           }
         }
-      #L10:
-      case #C5:
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::double && (let final dynamic #t8 = y = #0#0{core::double} in true)) {
+          #t5 = 0;
+          break #L5;
+        }
+      }
+      {
+        core::bool y1;
+        if(#0#0 is{ForNonNullableByDefault} core::bool && (let final dynamic #t9 = y1 = #0#0{core::bool} in true)) {
+          {
+            #t5 = 1;
+            break #L5;
+          }
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (let final dynamic #t10 = y2 = #0#0{core::List<dynamic>} in true) || true) {
+          #t5 = 1;
+          break #L5;
+        }
+      }
+    }
+    switch(#t5) {
+      #L6:
+      case #C3:
         {
           {
             return "num";
           }
         }
-      #L11:
-      case #C6:
-        {
-          {
-            continue #L12;
-          }
-        }
-      #L12:
-      case #C7:
+      #L7:
+      case #C4:
       default:
         {
           {
@@ -155,7 +156,4 @@ constants  {
   #C2 = "foobar"
   #C3 = 0
   #C4 = 1
-  #C5 = 2
-  #C6 = 3
-  #C7 = 4
 }
diff --git a/pkg/front_end/testcases/patterns/issue50931.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/issue50931.dart.weak.modular.expect
index 371fe4ccd96..d75a287406e 100644
--- a/pkg/front_end/testcases/patterns/issue50931.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/issue50931.dart.weak.modular.expect
@@ -6,118 +6,119 @@ static method test1(dynamic x) → dynamic {
   #L1:
   {
     core::int #t1 = -1;
-    core::int y;
-    core::double y#1;
-    core::String y#2;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = y = #0#0{core::int} in true))
-      #t1 = 0;
-    else
-      if(#C1 =={core::String::==}{(core::Object) → core::bool} #0#0 || #C2 =={core::String::==}{(core::Object) → core::bool} #0#0)
-        #t1 = 1;
-      else
-        if(#0#0 is{ForNonNullableByDefault} core::double && (let final dynamic #t3 = y#1 = #0#0{core::double} in true))
-          #t1 = 2;
-        else
-          if(#0#0 is{ForNonNullableByDefault} core::String && (let final dynamic #t4 = y#2 = #0#0{core::String} in true))
-            #t1 = 3;
-          else
-            #t1 = 4;
-    switch(#t1) {
-      #L2:
-      case #C3:
-        {
+    #L2:
+    {
+      {
+        core::int y;
+        if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = y = #0#0{core::int} in true)) {
           {
-            continue #L3;
+            #t1 = 0;
+            break #L2;
           }
         }
-      #L3:
-      case #C4:
-        {
+      }
+      {
+        if(#C1 =={core::String::==}{(core::Object) → core::bool} #0#0 || #C2 =={core::String::==}{(core::Object) → core::bool} #0#0) {
+          #t1 = 0;
+          break #L2;
+        }
+      }
+      {
+        core::double y;
+        if(#0#0 is{ForNonNullableByDefault} core::double && (let final dynamic #t3 = y = #0#0{core::double} in true)) {
           {
-            return 0;
+            #t1 = 0;
+            break #L2;
           }
         }
-      #L4:
-      case #C5:
-        {
+      }
+      {
+        core::String y;
+        if(#0#0 is{ForNonNullableByDefault} core::String && (let final dynamic #t4 = y = #0#0{core::String} in true)) {
           {
-            continue #L3;
+            #t1 = 0;
+            break #L2;
           }
         }
-      #L5:
-      case #C6:
-        {
-          {
-            continue #L3;
-          }
-        }
-      #L6:
-      case #C7:
-      default:
+      }
+      {
         {
           {
             return 1;
           }
         }
+      }
+    }
+    switch(#t1) {
+      #L3:
+      case #C3:
+        {
+          {
+            return 0;
+          }
+        }
     }
   }
 }
 static method test2(dynamic x) → dynamic {
-  #L7:
+  #L4:
   {
     core::int #t5 = -1;
-    core::String y;
-    core::int y#1;
-    core::double y#2;
-    core::bool y1;
+    core::double y;
     core::List<dynamic> y2;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::String && (let final dynamic #t6 = y = #0#0{core::String} in true))
-      #t5 = 0;
-    else
-      if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t7 = y#1 = #0#0{core::int} in true))
-        #t5 = 1;
-      else
-        if(#0#0 is{ForNonNullableByDefault} core::double && (let final dynamic #t8 = y#2 = #0#0{core::double} in true))
-          #t5 = 2;
-        else
-          if(#0#0 is{ForNonNullableByDefault} core::bool && (let final dynamic #t9 = y1 = #0#0{core::bool} in true))
-            #t5 = 3;
-          else
-            if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (let final dynamic #t10 = y2 = #0#0{core::List<dynamic>} in true) || true)
-              #t5 = 4;
-    switch(#t5) {
-      #L8:
-      case #C3:
-        {
+    #L5:
+    {
+      {
+        core::String y;
+        if(#0#0 is{ForNonNullableByDefault} core::String && (let final dynamic #t6 = y = #0#0{core::String} in true)) {
           {
             return "String";
           }
         }
-      #L9:
-      case #C4:
-        {
+      }
+      {
+        core::int y;
+        if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t7 = y = #0#0{core::int} in true)) {
           {
-            continue #L10;
+            #t5 = 0;
+            break #L5;
           }
         }
-      #L10:
-      case #C5:
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::double && (let final dynamic #t8 = y = #0#0{core::double} in true)) {
+          #t5 = 0;
+          break #L5;
+        }
+      }
+      {
+        core::bool y1;
+        if(#0#0 is{ForNonNullableByDefault} core::bool && (let final dynamic #t9 = y1 = #0#0{core::bool} in true)) {
+          {
+            #t5 = 1;
+            break #L5;
+          }
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (let final dynamic #t10 = y2 = #0#0{core::List<dynamic>} in true) || true) {
+          #t5 = 1;
+          break #L5;
+        }
+      }
+    }
+    switch(#t5) {
+      #L6:
+      case #C3:
         {
           {
             return "num";
           }
         }
-      #L11:
-      case #C6:
-        {
-          {
-            continue #L12;
-          }
-        }
-      #L12:
-      case #C7:
+      #L7:
+      case #C4:
       default:
         {
           {
@@ -155,7 +156,4 @@ constants  {
   #C2 = "foobar"
   #C3 = 0
   #C4 = 1
-  #C5 = 2
-  #C6 = 3
-  #C7 = 4
 }
diff --git a/pkg/front_end/testcases/patterns/issue50931.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/issue50931.dart.weak.transformed.expect
index 882a26b8cd6..43002bb3934 100644
--- a/pkg/front_end/testcases/patterns/issue50931.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/issue50931.dart.weak.transformed.expect
@@ -6,118 +6,119 @@ static method test1(dynamic x) → dynamic {
   #L1:
   {
     core::int #t1 = -1;
-    core::int y;
-    core::double y#1;
-    core::String y#2;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t2 = y = #0#0{core::int} in true))
-      #t1 = 0;
-    else
-      if(#C1 =={core::String::==}{(core::Object) → core::bool} #0#0 || #C2 =={core::String::==}{(core::Object) → core::bool} #0#0)
-        #t1 = 1;
-      else
-        if(#0#0 is{ForNonNullableByDefault} core::double && (let final core::double #t3 = y#1 = #0#0{core::double} in true))
-          #t1 = 2;
-        else
-          if(#0#0 is{ForNonNullableByDefault} core::String && (let final core::String #t4 = y#2 = #0#0{core::String} in true))
-            #t1 = 3;
-          else
-            #t1 = 4;
-    switch(#t1) {
-      #L2:
-      case #C3:
-        {
+    #L2:
+    {
+      {
+        core::int y;
+        if(#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t2 = y = #0#0{core::int} in true)) {
           {
-            continue #L3;
+            #t1 = 0;
+            break #L2;
           }
         }
-      #L3:
-      case #C4:
-        {
+      }
+      {
+        if(#C1 =={core::String::==}{(core::Object) → core::bool} #0#0 || #C2 =={core::String::==}{(core::Object) → core::bool} #0#0) {
+          #t1 = 0;
+          break #L2;
+        }
+      }
+      {
+        core::double y;
+        if(#0#0 is{ForNonNullableByDefault} core::double && (let final core::double #t3 = y = #0#0{core::double} in true)) {
           {
-            return 0;
+            #t1 = 0;
+            break #L2;
           }
         }
-      #L4:
-      case #C5:
-        {
+      }
+      {
+        core::String y;
+        if(#0#0 is{ForNonNullableByDefault} core::String && (let final core::String #t4 = y = #0#0{core::String} in true)) {
           {
-            continue #L3;
+            #t1 = 0;
+            break #L2;
           }
         }
-      #L5:
-      case #C6:
-        {
-          {
-            continue #L3;
-          }
-        }
-      #L6:
-      case #C7:
-      default:
+      }
+      {
         {
           {
             return 1;
           }
         }
+      }
+    }
+    switch(#t1) {
+      #L3:
+      case #C3:
+        {
+          {
+            return 0;
+          }
+        }
     }
   }
 }
 static method test2(dynamic x) → dynamic {
-  #L7:
+  #L4:
   {
     core::int #t5 = -1;
-    core::String y;
-    core::int y#1;
-    core::double y#2;
-    core::bool y1;
+    core::double y;
     core::List<dynamic> y2;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::String && (let final core::String #t6 = y = #0#0{core::String} in true))
-      #t5 = 0;
-    else
-      if(#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t7 = y#1 = #0#0{core::int} in true))
-        #t5 = 1;
-      else
-        if(#0#0 is{ForNonNullableByDefault} core::double && (let final core::double #t8 = y#2 = #0#0{core::double} in true))
-          #t5 = 2;
-        else
-          if(#0#0 is{ForNonNullableByDefault} core::bool && (let final core::bool #t9 = y1 = #0#0{core::bool} in true))
-            #t5 = 3;
-          else
-            if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (let final core::List<dynamic> #t10 = y2 = #0#0{core::List<dynamic>} in true) || true)
-              #t5 = 4;
-    switch(#t5) {
-      #L8:
-      case #C3:
-        {
+    #L5:
+    {
+      {
+        core::String y;
+        if(#0#0 is{ForNonNullableByDefault} core::String && (let final core::String #t6 = y = #0#0{core::String} in true)) {
           {
             return "String";
           }
         }
-      #L9:
-      case #C4:
-        {
+      }
+      {
+        core::int y;
+        if(#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t7 = y = #0#0{core::int} in true)) {
           {
-            continue #L10;
+            #t5 = 0;
+            break #L5;
           }
         }
-      #L10:
-      case #C5:
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::double && (let final core::double #t8 = y = #0#0{core::double} in true)) {
+          #t5 = 0;
+          break #L5;
+        }
+      }
+      {
+        core::bool y1;
+        if(#0#0 is{ForNonNullableByDefault} core::bool && (let final core::bool #t9 = y1 = #0#0{core::bool} in true)) {
+          {
+            #t5 = 1;
+            break #L5;
+          }
+        }
+      }
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (let final core::List<dynamic> #t10 = y2 = #0#0{core::List<dynamic>} in true) || true) {
+          #t5 = 1;
+          break #L5;
+        }
+      }
+    }
+    switch(#t5) {
+      #L6:
+      case #C3:
         {
           {
             return "num";
           }
         }
-      #L11:
-      case #C6:
-        {
-          {
-            continue #L12;
-          }
-        }
-      #L12:
-      case #C7:
+      #L7:
+      case #C4:
       default:
         {
           {
@@ -155,7 +156,4 @@ constants  {
   #C2 = "foobar"
   #C3 = 0
   #C4 = 1
-  #C5 = 2
-  #C6 = 3
-  #C7 = 4
 }
diff --git a/pkg/front_end/testcases/patterns/issue50985.dart.strong.expect b/pkg/front_end/testcases/patterns/issue50985.dart.strong.expect
index 1f4fd46b23e..e2a5a4b8888 100644
--- a/pkg/front_end/testcases/patterns/issue50985.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/issue50985.dart.strong.expect
@@ -5,13 +5,23 @@ import "dart:core" as core;
 static method test1(core::List<dynamic> list) → core::String {
   return block {
     core::String #t1;
-    core::List<core::int> r1;
     final synthesized core::List<dynamic> #0#0 = list;
-    if(#0#0 is{ForNonNullableByDefault} core::List<core::int> && #0#0{core::List<core::int>}.{core::List::length}{core::int}.{core::num::>=}(#C1){(core::num) → core::bool} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(0){(core::int) → core::int} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(1){(core::int) → core::int} && #C4 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(2){(core::int) → core::int} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(3){(core::int) → core::int} && (let final dynamic #t2 = r1 = #0#0{core::List<core::int>}.{core::List::sublist}(4){(core::int, [core::int?]) → core::List<core::int>} in true))
-      #t1 = r1.{core::Object::toString}(){() → core::String};
-    else
-      if(true)
-        #t1 = "default";
+    #L1:
+    {
+      {
+        core::List<core::int> r1;
+        if(#0#0 is{ForNonNullableByDefault} core::List<core::int> && #0#0{core::List<core::int>}.{core::List::length}{core::int}.{core::num::>=}(#C1){(core::num) → core::bool} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(0){(core::int) → core::int} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(1){(core::int) → core::int} && #C4 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(2){(core::int) → core::int} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(3){(core::int) → core::int} && (let final dynamic #t2 = r1 = #0#0{core::List<core::int>}.{core::List::sublist}(4){(core::int, [core::int?]) → core::List<core::int>} in true)) {
+          #t1 = r1.{core::Object::toString}(){() → core::String};
+          break #L1;
+        }
+      }
+      {
+        if(true) {
+          #t1 = "default";
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
 }
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/patterns/issue50985.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/issue50985.dart.strong.transformed.expect
index 19bddc7d06a..c3f27b0340b 100644
--- a/pkg/front_end/testcases/patterns/issue50985.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/issue50985.dart.strong.transformed.expect
@@ -5,13 +5,23 @@ import "dart:core" as core;
 static method test1(core::List<dynamic> list) → core::String {
   return block {
     core::String #t1;
-    core::List<core::int> r1;
     final synthesized core::List<dynamic> #0#0 = list;
-    if(#0#0 is{ForNonNullableByDefault} core::List<core::int> && #0#0{core::List<core::int>}.{core::List::length}{core::int}.{core::num::>=}(#C1){(core::num) → core::bool} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(0){(core::int) → core::int} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(1){(core::int) → core::int} && #C4 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(2){(core::int) → core::int} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(3){(core::int) → core::int} && (let final core::List<core::int> #t2 = r1 = #0#0{core::List<core::int>}.{core::List::sublist}(4){(core::int, [core::int?]) → core::List<core::int>} in true))
-      #t1 = r1.{core::Object::toString}(){() → core::String};
-    else
-      if(true)
-        #t1 = "default";
+    #L1:
+    {
+      {
+        core::List<core::int> r1;
+        if(#0#0 is{ForNonNullableByDefault} core::List<core::int> && #0#0{core::List<core::int>}.{core::List::length}{core::int}.{core::num::>=}(#C1){(core::num) → core::bool} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(0){(core::int) → core::int} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(1){(core::int) → core::int} && #C4 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(2){(core::int) → core::int} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(3){(core::int) → core::int} && (let final core::List<core::int> #t2 = r1 = #0#0{core::List<core::int>}.{core::List::sublist}(4){(core::int, [core::int?]) → core::List<core::int>} in true)) {
+          #t1 = r1.{core::Object::toString}(){() → core::String};
+          break #L1;
+        }
+      }
+      {
+        if(true) {
+          #t1 = "default";
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
 }
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/patterns/issue50985.dart.weak.expect b/pkg/front_end/testcases/patterns/issue50985.dart.weak.expect
index 1f4fd46b23e..e2a5a4b8888 100644
--- a/pkg/front_end/testcases/patterns/issue50985.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/issue50985.dart.weak.expect
@@ -5,13 +5,23 @@ import "dart:core" as core;
 static method test1(core::List<dynamic> list) → core::String {
   return block {
     core::String #t1;
-    core::List<core::int> r1;
     final synthesized core::List<dynamic> #0#0 = list;
-    if(#0#0 is{ForNonNullableByDefault} core::List<core::int> && #0#0{core::List<core::int>}.{core::List::length}{core::int}.{core::num::>=}(#C1){(core::num) → core::bool} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(0){(core::int) → core::int} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(1){(core::int) → core::int} && #C4 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(2){(core::int) → core::int} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(3){(core::int) → core::int} && (let final dynamic #t2 = r1 = #0#0{core::List<core::int>}.{core::List::sublist}(4){(core::int, [core::int?]) → core::List<core::int>} in true))
-      #t1 = r1.{core::Object::toString}(){() → core::String};
-    else
-      if(true)
-        #t1 = "default";
+    #L1:
+    {
+      {
+        core::List<core::int> r1;
+        if(#0#0 is{ForNonNullableByDefault} core::List<core::int> && #0#0{core::List<core::int>}.{core::List::length}{core::int}.{core::num::>=}(#C1){(core::num) → core::bool} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(0){(core::int) → core::int} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(1){(core::int) → core::int} && #C4 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(2){(core::int) → core::int} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(3){(core::int) → core::int} && (let final dynamic #t2 = r1 = #0#0{core::List<core::int>}.{core::List::sublist}(4){(core::int, [core::int?]) → core::List<core::int>} in true)) {
+          #t1 = r1.{core::Object::toString}(){() → core::String};
+          break #L1;
+        }
+      }
+      {
+        if(true) {
+          #t1 = "default";
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
 }
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/patterns/issue50985.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/issue50985.dart.weak.modular.expect
index 1f4fd46b23e..e2a5a4b8888 100644
--- a/pkg/front_end/testcases/patterns/issue50985.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/issue50985.dart.weak.modular.expect
@@ -5,13 +5,23 @@ import "dart:core" as core;
 static method test1(core::List<dynamic> list) → core::String {
   return block {
     core::String #t1;
-    core::List<core::int> r1;
     final synthesized core::List<dynamic> #0#0 = list;
-    if(#0#0 is{ForNonNullableByDefault} core::List<core::int> && #0#0{core::List<core::int>}.{core::List::length}{core::int}.{core::num::>=}(#C1){(core::num) → core::bool} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(0){(core::int) → core::int} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(1){(core::int) → core::int} && #C4 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(2){(core::int) → core::int} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(3){(core::int) → core::int} && (let final dynamic #t2 = r1 = #0#0{core::List<core::int>}.{core::List::sublist}(4){(core::int, [core::int?]) → core::List<core::int>} in true))
-      #t1 = r1.{core::Object::toString}(){() → core::String};
-    else
-      if(true)
-        #t1 = "default";
+    #L1:
+    {
+      {
+        core::List<core::int> r1;
+        if(#0#0 is{ForNonNullableByDefault} core::List<core::int> && #0#0{core::List<core::int>}.{core::List::length}{core::int}.{core::num::>=}(#C1){(core::num) → core::bool} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(0){(core::int) → core::int} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(1){(core::int) → core::int} && #C4 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(2){(core::int) → core::int} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(3){(core::int) → core::int} && (let final dynamic #t2 = r1 = #0#0{core::List<core::int>}.{core::List::sublist}(4){(core::int, [core::int?]) → core::List<core::int>} in true)) {
+          #t1 = r1.{core::Object::toString}(){() → core::String};
+          break #L1;
+        }
+      }
+      {
+        if(true) {
+          #t1 = "default";
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
 }
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/patterns/issue50985.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/issue50985.dart.weak.transformed.expect
index 19bddc7d06a..c3f27b0340b 100644
--- a/pkg/front_end/testcases/patterns/issue50985.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/issue50985.dart.weak.transformed.expect
@@ -5,13 +5,23 @@ import "dart:core" as core;
 static method test1(core::List<dynamic> list) → core::String {
   return block {
     core::String #t1;
-    core::List<core::int> r1;
     final synthesized core::List<dynamic> #0#0 = list;
-    if(#0#0 is{ForNonNullableByDefault} core::List<core::int> && #0#0{core::List<core::int>}.{core::List::length}{core::int}.{core::num::>=}(#C1){(core::num) → core::bool} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(0){(core::int) → core::int} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(1){(core::int) → core::int} && #C4 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(2){(core::int) → core::int} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(3){(core::int) → core::int} && (let final core::List<core::int> #t2 = r1 = #0#0{core::List<core::int>}.{core::List::sublist}(4){(core::int, [core::int?]) → core::List<core::int>} in true))
-      #t1 = r1.{core::Object::toString}(){() → core::String};
-    else
-      if(true)
-        #t1 = "default";
+    #L1:
+    {
+      {
+        core::List<core::int> r1;
+        if(#0#0 is{ForNonNullableByDefault} core::List<core::int> && #0#0{core::List<core::int>}.{core::List::length}{core::int}.{core::num::>=}(#C1){(core::num) → core::bool} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(0){(core::int) → core::int} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(1){(core::int) → core::int} && #C4 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(2){(core::int) → core::int} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(3){(core::int) → core::int} && (let final core::List<core::int> #t2 = r1 = #0#0{core::List<core::int>}.{core::List::sublist}(4){(core::int, [core::int?]) → core::List<core::int>} in true)) {
+          #t1 = r1.{core::Object::toString}(){() → core::String};
+          break #L1;
+        }
+      }
+      {
+        if(true) {
+          #t1 = "default";
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
 }
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/patterns/issue50993.dart.strong.expect b/pkg/front_end/testcases/patterns/issue50993.dart.strong.expect
index 46118e4a52a..dc92b93b7c0 100644
--- a/pkg/front_end/testcases/patterns/issue50993.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/issue50993.dart.strong.expect
@@ -6,17 +6,20 @@ static method test1(core::int value) → core::String {
   #L1:
   {
     final synthesized core::int #0#0 = value;
-    if(#0#0.{core::num::<}(#C1){(core::num) → core::bool}) {
-      {
-        return "case <2";
+    {
+      if(#0#0.{core::num::<}(#C1){(core::num) → core::bool}) {
+        {
+          return "case <2";
+        }
       }
     }
-    else
+    {
       if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
         {
           return "case 2";
         }
       }
+    }
   }
   return "not matched";
 }
@@ -24,17 +27,20 @@ static method test2(core::int value) → core::String {
   #L2:
   {
     final synthesized core::int #0#0 = value;
-    if(#0#0.{core::num::<}(#C1){(core::num) → core::bool}) {
-      {
-        return "case <2";
+    {
+      if(#0#0.{core::num::<}(#C1){(core::num) → core::bool}) {
+        {
+          return "case <2";
+        }
       }
     }
-    else
+    {
       if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || true) {
         {
           return "case 2";
         }
       }
+    }
   }
   return "not matched";
 }
@@ -42,17 +48,20 @@ static method test3(core::int value) → core::String {
   #L3:
   {
     final synthesized core::int #0#0 = value;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        return "case 2";
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return "case 2";
+        }
       }
     }
-    else
+    {
       if(#0#0.{core::num::<}(#C1){(core::num) → core::bool} || true) {
         {
           return "case <2";
         }
       }
+    }
   }
   return "not matched";
 }
@@ -60,65 +69,74 @@ static method test4(core::int value) → core::String {
   #L4:
   {
     final synthesized core::int #0#0 = value;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        return "case 2";
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return "case 2";
+        }
       }
     }
-    else
+    {
       if(#0#0.{core::num::<}(#C1){(core::num) → core::bool}) {
         {
           return "case <2";
         }
       }
-      else {
+    }
+    {
+      {
         {
           return "default";
         }
       }
+    }
   }
 }
 static method test5(core::int value) → core::String {
   #L5:
   {
     final synthesized core::int #0#0 = value;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        return "case 2";
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return "case 2";
+        }
       }
     }
-    else
+    {
       if(#0#0.{core::num::<}(#C1){(core::num) → core::bool} || #0#0.{core::num::>}(#C2){(core::num) → core::bool}) {
         {
           return "case <2 >3";
         }
       }
-      else {
+    }
+    {
+      {
         {
           return "default";
         }
       }
+    }
   }
 }
 static method test6(core::int value) → core::String {
   #L6:
-  {
-    final synthesized core::int #0#0 = value;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+  switch(value) {
+    #L7:
+    case #C1:
       {
         return "case 2";
       }
-    }
-    else
-      if(#C3 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C4 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-        {
-          return "case 1/4";
-        }
+    #L8:
+    case #C3:
+    case #C4:
+      {
+        return "case 1/4";
       }
-      else {
-        {
-          return "default";
-        }
+    #L9:
+    default:
+      {
+        return "default";
       }
   }
 }
diff --git a/pkg/front_end/testcases/patterns/issue50993.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/issue50993.dart.strong.transformed.expect
index 46118e4a52a..dc92b93b7c0 100644
--- a/pkg/front_end/testcases/patterns/issue50993.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/issue50993.dart.strong.transformed.expect
@@ -6,17 +6,20 @@ static method test1(core::int value) → core::String {
   #L1:
   {
     final synthesized core::int #0#0 = value;
-    if(#0#0.{core::num::<}(#C1){(core::num) → core::bool}) {
-      {
-        return "case <2";
+    {
+      if(#0#0.{core::num::<}(#C1){(core::num) → core::bool}) {
+        {
+          return "case <2";
+        }
       }
     }
-    else
+    {
       if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
         {
           return "case 2";
         }
       }
+    }
   }
   return "not matched";
 }
@@ -24,17 +27,20 @@ static method test2(core::int value) → core::String {
   #L2:
   {
     final synthesized core::int #0#0 = value;
-    if(#0#0.{core::num::<}(#C1){(core::num) → core::bool}) {
-      {
-        return "case <2";
+    {
+      if(#0#0.{core::num::<}(#C1){(core::num) → core::bool}) {
+        {
+          return "case <2";
+        }
       }
     }
-    else
+    {
       if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || true) {
         {
           return "case 2";
         }
       }
+    }
   }
   return "not matched";
 }
@@ -42,17 +48,20 @@ static method test3(core::int value) → core::String {
   #L3:
   {
     final synthesized core::int #0#0 = value;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        return "case 2";
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return "case 2";
+        }
       }
     }
-    else
+    {
       if(#0#0.{core::num::<}(#C1){(core::num) → core::bool} || true) {
         {
           return "case <2";
         }
       }
+    }
   }
   return "not matched";
 }
@@ -60,65 +69,74 @@ static method test4(core::int value) → core::String {
   #L4:
   {
     final synthesized core::int #0#0 = value;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        return "case 2";
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return "case 2";
+        }
       }
     }
-    else
+    {
       if(#0#0.{core::num::<}(#C1){(core::num) → core::bool}) {
         {
           return "case <2";
         }
       }
-      else {
+    }
+    {
+      {
         {
           return "default";
         }
       }
+    }
   }
 }
 static method test5(core::int value) → core::String {
   #L5:
   {
     final synthesized core::int #0#0 = value;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        return "case 2";
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return "case 2";
+        }
       }
     }
-    else
+    {
       if(#0#0.{core::num::<}(#C1){(core::num) → core::bool} || #0#0.{core::num::>}(#C2){(core::num) → core::bool}) {
         {
           return "case <2 >3";
         }
       }
-      else {
+    }
+    {
+      {
         {
           return "default";
         }
       }
+    }
   }
 }
 static method test6(core::int value) → core::String {
   #L6:
-  {
-    final synthesized core::int #0#0 = value;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+  switch(value) {
+    #L7:
+    case #C1:
       {
         return "case 2";
       }
-    }
-    else
-      if(#C3 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C4 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-        {
-          return "case 1/4";
-        }
+    #L8:
+    case #C3:
+    case #C4:
+      {
+        return "case 1/4";
       }
-      else {
-        {
-          return "default";
-        }
+    #L9:
+    default:
+      {
+        return "default";
       }
   }
 }
diff --git a/pkg/front_end/testcases/patterns/issue50993.dart.weak.expect b/pkg/front_end/testcases/patterns/issue50993.dart.weak.expect
index 46118e4a52a..dc92b93b7c0 100644
--- a/pkg/front_end/testcases/patterns/issue50993.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/issue50993.dart.weak.expect
@@ -6,17 +6,20 @@ static method test1(core::int value) → core::String {
   #L1:
   {
     final synthesized core::int #0#0 = value;
-    if(#0#0.{core::num::<}(#C1){(core::num) → core::bool}) {
-      {
-        return "case <2";
+    {
+      if(#0#0.{core::num::<}(#C1){(core::num) → core::bool}) {
+        {
+          return "case <2";
+        }
       }
     }
-    else
+    {
       if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
         {
           return "case 2";
         }
       }
+    }
   }
   return "not matched";
 }
@@ -24,17 +27,20 @@ static method test2(core::int value) → core::String {
   #L2:
   {
     final synthesized core::int #0#0 = value;
-    if(#0#0.{core::num::<}(#C1){(core::num) → core::bool}) {
-      {
-        return "case <2";
+    {
+      if(#0#0.{core::num::<}(#C1){(core::num) → core::bool}) {
+        {
+          return "case <2";
+        }
       }
     }
-    else
+    {
       if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || true) {
         {
           return "case 2";
         }
       }
+    }
   }
   return "not matched";
 }
@@ -42,17 +48,20 @@ static method test3(core::int value) → core::String {
   #L3:
   {
     final synthesized core::int #0#0 = value;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        return "case 2";
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return "case 2";
+        }
       }
     }
-    else
+    {
       if(#0#0.{core::num::<}(#C1){(core::num) → core::bool} || true) {
         {
           return "case <2";
         }
       }
+    }
   }
   return "not matched";
 }
@@ -60,65 +69,74 @@ static method test4(core::int value) → core::String {
   #L4:
   {
     final synthesized core::int #0#0 = value;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        return "case 2";
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return "case 2";
+        }
       }
     }
-    else
+    {
       if(#0#0.{core::num::<}(#C1){(core::num) → core::bool}) {
         {
           return "case <2";
         }
       }
-      else {
+    }
+    {
+      {
         {
           return "default";
         }
       }
+    }
   }
 }
 static method test5(core::int value) → core::String {
   #L5:
   {
     final synthesized core::int #0#0 = value;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        return "case 2";
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return "case 2";
+        }
       }
     }
-    else
+    {
       if(#0#0.{core::num::<}(#C1){(core::num) → core::bool} || #0#0.{core::num::>}(#C2){(core::num) → core::bool}) {
         {
           return "case <2 >3";
         }
       }
-      else {
+    }
+    {
+      {
         {
           return "default";
         }
       }
+    }
   }
 }
 static method test6(core::int value) → core::String {
   #L6:
-  {
-    final synthesized core::int #0#0 = value;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+  switch(value) {
+    #L7:
+    case #C1:
       {
         return "case 2";
       }
-    }
-    else
-      if(#C3 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C4 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-        {
-          return "case 1/4";
-        }
+    #L8:
+    case #C3:
+    case #C4:
+      {
+        return "case 1/4";
       }
-      else {
-        {
-          return "default";
-        }
+    #L9:
+    default:
+      {
+        return "default";
       }
   }
 }
diff --git a/pkg/front_end/testcases/patterns/issue50993.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/issue50993.dart.weak.modular.expect
index 46118e4a52a..dc92b93b7c0 100644
--- a/pkg/front_end/testcases/patterns/issue50993.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/issue50993.dart.weak.modular.expect
@@ -6,17 +6,20 @@ static method test1(core::int value) → core::String {
   #L1:
   {
     final synthesized core::int #0#0 = value;
-    if(#0#0.{core::num::<}(#C1){(core::num) → core::bool}) {
-      {
-        return "case <2";
+    {
+      if(#0#0.{core::num::<}(#C1){(core::num) → core::bool}) {
+        {
+          return "case <2";
+        }
       }
     }
-    else
+    {
       if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
         {
           return "case 2";
         }
       }
+    }
   }
   return "not matched";
 }
@@ -24,17 +27,20 @@ static method test2(core::int value) → core::String {
   #L2:
   {
     final synthesized core::int #0#0 = value;
-    if(#0#0.{core::num::<}(#C1){(core::num) → core::bool}) {
-      {
-        return "case <2";
+    {
+      if(#0#0.{core::num::<}(#C1){(core::num) → core::bool}) {
+        {
+          return "case <2";
+        }
       }
     }
-    else
+    {
       if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || true) {
         {
           return "case 2";
         }
       }
+    }
   }
   return "not matched";
 }
@@ -42,17 +48,20 @@ static method test3(core::int value) → core::String {
   #L3:
   {
     final synthesized core::int #0#0 = value;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        return "case 2";
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return "case 2";
+        }
       }
     }
-    else
+    {
       if(#0#0.{core::num::<}(#C1){(core::num) → core::bool} || true) {
         {
           return "case <2";
         }
       }
+    }
   }
   return "not matched";
 }
@@ -60,65 +69,74 @@ static method test4(core::int value) → core::String {
   #L4:
   {
     final synthesized core::int #0#0 = value;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        return "case 2";
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return "case 2";
+        }
       }
     }
-    else
+    {
       if(#0#0.{core::num::<}(#C1){(core::num) → core::bool}) {
         {
           return "case <2";
         }
       }
-      else {
+    }
+    {
+      {
         {
           return "default";
         }
       }
+    }
   }
 }
 static method test5(core::int value) → core::String {
   #L5:
   {
     final synthesized core::int #0#0 = value;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        return "case 2";
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return "case 2";
+        }
       }
     }
-    else
+    {
       if(#0#0.{core::num::<}(#C1){(core::num) → core::bool} || #0#0.{core::num::>}(#C2){(core::num) → core::bool}) {
         {
           return "case <2 >3";
         }
       }
-      else {
+    }
+    {
+      {
         {
           return "default";
         }
       }
+    }
   }
 }
 static method test6(core::int value) → core::String {
   #L6:
-  {
-    final synthesized core::int #0#0 = value;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+  switch(value) {
+    #L7:
+    case #C1:
       {
         return "case 2";
       }
-    }
-    else
-      if(#C3 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C4 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-        {
-          return "case 1/4";
-        }
+    #L8:
+    case #C3:
+    case #C4:
+      {
+        return "case 1/4";
       }
-      else {
-        {
-          return "default";
-        }
+    #L9:
+    default:
+      {
+        return "default";
       }
   }
 }
diff --git a/pkg/front_end/testcases/patterns/issue50993.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/issue50993.dart.weak.transformed.expect
index 46118e4a52a..dc92b93b7c0 100644
--- a/pkg/front_end/testcases/patterns/issue50993.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/issue50993.dart.weak.transformed.expect
@@ -6,17 +6,20 @@ static method test1(core::int value) → core::String {
   #L1:
   {
     final synthesized core::int #0#0 = value;
-    if(#0#0.{core::num::<}(#C1){(core::num) → core::bool}) {
-      {
-        return "case <2";
+    {
+      if(#0#0.{core::num::<}(#C1){(core::num) → core::bool}) {
+        {
+          return "case <2";
+        }
       }
     }
-    else
+    {
       if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
         {
           return "case 2";
         }
       }
+    }
   }
   return "not matched";
 }
@@ -24,17 +27,20 @@ static method test2(core::int value) → core::String {
   #L2:
   {
     final synthesized core::int #0#0 = value;
-    if(#0#0.{core::num::<}(#C1){(core::num) → core::bool}) {
-      {
-        return "case <2";
+    {
+      if(#0#0.{core::num::<}(#C1){(core::num) → core::bool}) {
+        {
+          return "case <2";
+        }
       }
     }
-    else
+    {
       if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || true) {
         {
           return "case 2";
         }
       }
+    }
   }
   return "not matched";
 }
@@ -42,17 +48,20 @@ static method test3(core::int value) → core::String {
   #L3:
   {
     final synthesized core::int #0#0 = value;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        return "case 2";
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return "case 2";
+        }
       }
     }
-    else
+    {
       if(#0#0.{core::num::<}(#C1){(core::num) → core::bool} || true) {
         {
           return "case <2";
         }
       }
+    }
   }
   return "not matched";
 }
@@ -60,65 +69,74 @@ static method test4(core::int value) → core::String {
   #L4:
   {
     final synthesized core::int #0#0 = value;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        return "case 2";
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return "case 2";
+        }
       }
     }
-    else
+    {
       if(#0#0.{core::num::<}(#C1){(core::num) → core::bool}) {
         {
           return "case <2";
         }
       }
-      else {
+    }
+    {
+      {
         {
           return "default";
         }
       }
+    }
   }
 }
 static method test5(core::int value) → core::String {
   #L5:
   {
     final synthesized core::int #0#0 = value;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        return "case 2";
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return "case 2";
+        }
       }
     }
-    else
+    {
       if(#0#0.{core::num::<}(#C1){(core::num) → core::bool} || #0#0.{core::num::>}(#C2){(core::num) → core::bool}) {
         {
           return "case <2 >3";
         }
       }
-      else {
+    }
+    {
+      {
         {
           return "default";
         }
       }
+    }
   }
 }
 static method test6(core::int value) → core::String {
   #L6:
-  {
-    final synthesized core::int #0#0 = value;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+  switch(value) {
+    #L7:
+    case #C1:
       {
         return "case 2";
       }
-    }
-    else
-      if(#C3 =={core::num::==}{(core::Object) → core::bool} #0#0 || #C4 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-        {
-          return "case 1/4";
-        }
+    #L8:
+    case #C3:
+    case #C4:
+      {
+        return "case 1/4";
       }
-      else {
-        {
-          return "default";
-        }
+    #L9:
+    default:
+      {
+        return "default";
       }
   }
 }
diff --git a/pkg/front_end/testcases/patterns/issue51009.dart.strong.expect b/pkg/front_end/testcases/patterns/issue51009.dart.strong.expect
index 9898e5a6bcb..9820a1ecd77 100644
--- a/pkg/front_end/testcases/patterns/issue51009.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/issue51009.dart.strong.expect
@@ -10,11 +10,13 @@ static method _extension#0|get#q(lowered final core::Object #this) → core::int
 static method main() → void {
   #L1:
   {
-    dynamic x;
     final synthesized dynamic #0#0 = new core::Object::•() as{ForNonNullableByDefault} dynamic;
-    if(#0#0 is{ForNonNullableByDefault} core::Object && (let final dynamic #t1 = x = self::_extension#0|get#q(#0#0{core::Object}) in true)) {
-      {
-        core::print(x);
+    {
+      dynamic x;
+      if(#0#0 is{ForNonNullableByDefault} core::Object && (let final dynamic #t1 = x = self::_extension#0|get#q(#0#0{core::Object}) in true)) {
+        {
+          core::print(x);
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/issue51009.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/issue51009.dart.strong.transformed.expect
index e1618c0c66d..22e7075fb38 100644
--- a/pkg/front_end/testcases/patterns/issue51009.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/issue51009.dart.strong.transformed.expect
@@ -10,11 +10,13 @@ static method _extension#0|get#q(lowered final core::Object #this) → core::int
 static method main() → void {
   #L1:
   {
-    dynamic x;
     final synthesized dynamic #0#0 = new core::Object::•() as{ForNonNullableByDefault} dynamic;
-    if(#0#0 is{ForNonNullableByDefault} core::Object && (let final core::int #t1 = x = self::_extension#0|get#q(#0#0{core::Object}) in true)) {
-      {
-        core::print(x);
+    {
+      dynamic x;
+      if(#0#0 is{ForNonNullableByDefault} core::Object && (let final core::int #t1 = x = self::_extension#0|get#q(#0#0{core::Object}) in true)) {
+        {
+          core::print(x);
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/issue51009.dart.weak.expect b/pkg/front_end/testcases/patterns/issue51009.dart.weak.expect
index 9898e5a6bcb..9820a1ecd77 100644
--- a/pkg/front_end/testcases/patterns/issue51009.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/issue51009.dart.weak.expect
@@ -10,11 +10,13 @@ static method _extension#0|get#q(lowered final core::Object #this) → core::int
 static method main() → void {
   #L1:
   {
-    dynamic x;
     final synthesized dynamic #0#0 = new core::Object::•() as{ForNonNullableByDefault} dynamic;
-    if(#0#0 is{ForNonNullableByDefault} core::Object && (let final dynamic #t1 = x = self::_extension#0|get#q(#0#0{core::Object}) in true)) {
-      {
-        core::print(x);
+    {
+      dynamic x;
+      if(#0#0 is{ForNonNullableByDefault} core::Object && (let final dynamic #t1 = x = self::_extension#0|get#q(#0#0{core::Object}) in true)) {
+        {
+          core::print(x);
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/issue51009.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/issue51009.dart.weak.modular.expect
index 9898e5a6bcb..9820a1ecd77 100644
--- a/pkg/front_end/testcases/patterns/issue51009.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/issue51009.dart.weak.modular.expect
@@ -10,11 +10,13 @@ static method _extension#0|get#q(lowered final core::Object #this) → core::int
 static method main() → void {
   #L1:
   {
-    dynamic x;
     final synthesized dynamic #0#0 = new core::Object::•() as{ForNonNullableByDefault} dynamic;
-    if(#0#0 is{ForNonNullableByDefault} core::Object && (let final dynamic #t1 = x = self::_extension#0|get#q(#0#0{core::Object}) in true)) {
-      {
-        core::print(x);
+    {
+      dynamic x;
+      if(#0#0 is{ForNonNullableByDefault} core::Object && (let final dynamic #t1 = x = self::_extension#0|get#q(#0#0{core::Object}) in true)) {
+        {
+          core::print(x);
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/issue51009.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/issue51009.dart.weak.transformed.expect
index e1618c0c66d..22e7075fb38 100644
--- a/pkg/front_end/testcases/patterns/issue51009.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/issue51009.dart.weak.transformed.expect
@@ -10,11 +10,13 @@ static method _extension#0|get#q(lowered final core::Object #this) → core::int
 static method main() → void {
   #L1:
   {
-    dynamic x;
     final synthesized dynamic #0#0 = new core::Object::•() as{ForNonNullableByDefault} dynamic;
-    if(#0#0 is{ForNonNullableByDefault} core::Object && (let final core::int #t1 = x = self::_extension#0|get#q(#0#0{core::Object}) in true)) {
-      {
-        core::print(x);
+    {
+      dynamic x;
+      if(#0#0 is{ForNonNullableByDefault} core::Object && (let final core::int #t1 = x = self::_extension#0|get#q(#0#0{core::Object}) in true)) {
+        {
+          core::print(x);
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/issue51112.dart.strong.expect b/pkg/front_end/testcases/patterns/issue51112.dart.strong.expect
index 3188638d149..d9e477d98d9 100644
--- a/pkg/front_end/testcases/patterns/issue51112.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/issue51112.dart.strong.expect
@@ -6,49 +6,54 @@ static method test(dynamic x) → dynamic {
   () → void setToOne = () → void {};
   #L1:
   {
-    core::int y;
-    core::int y#1;
-    core::double y#2;
     final synthesized dynamic #0#0 = x;
     late final synthesized core::int #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int};
     late final synthesized core::bool #0#4 = #0#2 =={core::num::==}{(core::Object) → core::bool} #C1;
     late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
     late final synthesized dynamic #0#7 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic};
     dynamic #t1;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = y = #0#6{core::int} in true)) && (let final dynamic #t3 = #0#7 in true) && (() → core::bool {
-      setToOne = () → void {
-        y = 1;
-      };
-      return true;
-    })(){() → core::bool} && (let final dynamic #t4 = #t1 = y in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (let final dynamic #t5 = #0#6 in true) && (#0#7 is{ForNonNullableByDefault} core::int && (let final dynamic #t6 = y#1 = #0#7{core::int} in true)) && (() → core::bool {
-      setToOne = () → void {
-        y#1 = 1;
-      };
-      return true;
-    })(){() → core::bool} && (let final dynamic #t7 = #t1 = y#1 in true)) {
-      core::int y = #t1{core::int};
-      {
-        setToOne(){() → void};
-        return y;
+    {
+      lowered core::int y#case#0;
+      lowered core::int y#case#1;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = y#case#0 = #0#6{core::int} in true)) && (let final dynamic #t3 = #0#7 in true) && (() → core::bool {
+        setToOne = () → void {
+          y#case#0 = 1;
+        };
+        return true;
+      })(){() → core::bool} && (let final dynamic #t4 = #t1 = y#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (let final dynamic #t5 = #0#6 in true) && (#0#7 is{ForNonNullableByDefault} core::int && (let final dynamic #t6 = y#case#1 = #0#7{core::int} in true)) && (() → core::bool {
+        setToOne = () → void {
+          y#case#1 = 1;
+        };
+        return true;
+      })(){() → core::bool} && (let final dynamic #t7 = #t1 = y#case#1 in true)) {
+        core::int y = #t1{core::int};
+        {
+          setToOne(){() → void};
+          return y;
+        }
       }
     }
-    else
-      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#2 =={core::num::==}{(core::Object) → core::bool} #C2 && (#0#6 is{ForNonNullableByDefault} core::double && (let final dynamic #t8 = y#2 = #0#6{core::double} in true)) && (() → core::bool {
+    {
+      core::double y;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#2 =={core::num::==}{(core::Object) → core::bool} #C2 && (#0#6 is{ForNonNullableByDefault} core::double && (let final dynamic #t8 = y = #0#6{core::double} in true)) && (() → core::bool {
         setToOne = () → void {
-          y#2 = 1.0;
+          y = 1.0;
         };
         return true;
       })(){() → core::bool}) {
         {
           setToOne(){() → void};
-          return y#2;
+          return y;
         }
       }
-      else {
+    }
+    {
+      {
         {
           return null;
         }
       }
+    }
   }
 }
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/patterns/issue51112.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/issue51112.dart.strong.transformed.expect
index 97a6f10d347..6c7706e3865 100644
--- a/pkg/front_end/testcases/patterns/issue51112.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/issue51112.dart.strong.transformed.expect
@@ -6,9 +6,6 @@ static method test(dynamic x) → dynamic {
   () → void setToOne = () → void {};
   #L1:
   {
-    core::int y;
-    core::int y#1;
-    core::double y#2;
     final synthesized dynamic #0#0 = x;
     function ##0#2#initializer() → core::int
       return #0#0{core::List<dynamic>}.{core::List::length}{core::int};
@@ -23,40 +20,48 @@ static method test(dynamic x) → dynamic {
       return #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic};
     late final synthesized dynamic #0#7 = ##0#7#initializer(){() → dynamic};
     dynamic #t1;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final core::int #t2 = y = #0#6{core::int} in true)) && (let final dynamic #t3 = #0#7 in true) && (() → core::bool {
-      setToOne = () → void {
-        y = 1;
-      };
-      return true;
-    })(){() → core::bool} && (let final core::int #t4 = #t1 = y in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (let final dynamic #t5 = #0#6 in true) && (#0#7 is{ForNonNullableByDefault} core::int && (let final core::int #t6 = y#1 = #0#7{core::int} in true)) && (() → core::bool {
-      setToOne = () → void {
-        y#1 = 1;
-      };
-      return true;
-    })(){() → core::bool} && (let final core::int #t7 = #t1 = y#1 in true)) {
-      core::int y = #t1{core::int};
-      {
-        setToOne(){() → void};
-        return y;
+    {
+      lowered core::int y#case#0;
+      lowered core::int y#case#1;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final core::int #t2 = y#case#0 = #0#6{core::int} in true)) && (let final dynamic #t3 = #0#7 in true) && (() → core::bool {
+        setToOne = () → void {
+          y#case#0 = 1;
+        };
+        return true;
+      })(){() → core::bool} && (let final core::int #t4 = #t1 = y#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (let final dynamic #t5 = #0#6 in true) && (#0#7 is{ForNonNullableByDefault} core::int && (let final core::int #t6 = y#case#1 = #0#7{core::int} in true)) && (() → core::bool {
+        setToOne = () → void {
+          y#case#1 = 1;
+        };
+        return true;
+      })(){() → core::bool} && (let final core::int #t7 = #t1 = y#case#1 in true)) {
+        core::int y = #t1{core::int};
+        {
+          setToOne(){() → void};
+          return y;
+        }
       }
     }
-    else
-      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#2 =={core::num::==}{(core::Object) → core::bool} #C2 && (#0#6 is{ForNonNullableByDefault} core::double && (let final core::double #t8 = y#2 = #0#6{core::double} in true)) && (() → core::bool {
+    {
+      core::double y;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#2 =={core::num::==}{(core::Object) → core::bool} #C2 && (#0#6 is{ForNonNullableByDefault} core::double && (let final core::double #t8 = y = #0#6{core::double} in true)) && (() → core::bool {
         setToOne = () → void {
-          y#2 = 1.0;
+          y = 1.0;
         };
         return true;
       })(){() → core::bool}) {
         {
           setToOne(){() → void};
-          return y#2;
+          return y;
         }
       }
-      else {
+    }
+    {
+      {
         {
           return null;
         }
       }
+    }
   }
 }
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/patterns/issue51112.dart.weak.expect b/pkg/front_end/testcases/patterns/issue51112.dart.weak.expect
index 3188638d149..d9e477d98d9 100644
--- a/pkg/front_end/testcases/patterns/issue51112.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/issue51112.dart.weak.expect
@@ -6,49 +6,54 @@ static method test(dynamic x) → dynamic {
   () → void setToOne = () → void {};
   #L1:
   {
-    core::int y;
-    core::int y#1;
-    core::double y#2;
     final synthesized dynamic #0#0 = x;
     late final synthesized core::int #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int};
     late final synthesized core::bool #0#4 = #0#2 =={core::num::==}{(core::Object) → core::bool} #C1;
     late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
     late final synthesized dynamic #0#7 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic};
     dynamic #t1;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = y = #0#6{core::int} in true)) && (let final dynamic #t3 = #0#7 in true) && (() → core::bool {
-      setToOne = () → void {
-        y = 1;
-      };
-      return true;
-    })(){() → core::bool} && (let final dynamic #t4 = #t1 = y in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (let final dynamic #t5 = #0#6 in true) && (#0#7 is{ForNonNullableByDefault} core::int && (let final dynamic #t6 = y#1 = #0#7{core::int} in true)) && (() → core::bool {
-      setToOne = () → void {
-        y#1 = 1;
-      };
-      return true;
-    })(){() → core::bool} && (let final dynamic #t7 = #t1 = y#1 in true)) {
-      core::int y = #t1{core::int};
-      {
-        setToOne(){() → void};
-        return y;
+    {
+      lowered core::int y#case#0;
+      lowered core::int y#case#1;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = y#case#0 = #0#6{core::int} in true)) && (let final dynamic #t3 = #0#7 in true) && (() → core::bool {
+        setToOne = () → void {
+          y#case#0 = 1;
+        };
+        return true;
+      })(){() → core::bool} && (let final dynamic #t4 = #t1 = y#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (let final dynamic #t5 = #0#6 in true) && (#0#7 is{ForNonNullableByDefault} core::int && (let final dynamic #t6 = y#case#1 = #0#7{core::int} in true)) && (() → core::bool {
+        setToOne = () → void {
+          y#case#1 = 1;
+        };
+        return true;
+      })(){() → core::bool} && (let final dynamic #t7 = #t1 = y#case#1 in true)) {
+        core::int y = #t1{core::int};
+        {
+          setToOne(){() → void};
+          return y;
+        }
       }
     }
-    else
-      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#2 =={core::num::==}{(core::Object) → core::bool} #C2 && (#0#6 is{ForNonNullableByDefault} core::double && (let final dynamic #t8 = y#2 = #0#6{core::double} in true)) && (() → core::bool {
+    {
+      core::double y;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#2 =={core::num::==}{(core::Object) → core::bool} #C2 && (#0#6 is{ForNonNullableByDefault} core::double && (let final dynamic #t8 = y = #0#6{core::double} in true)) && (() → core::bool {
         setToOne = () → void {
-          y#2 = 1.0;
+          y = 1.0;
         };
         return true;
       })(){() → core::bool}) {
         {
           setToOne(){() → void};
-          return y#2;
+          return y;
         }
       }
-      else {
+    }
+    {
+      {
         {
           return null;
         }
       }
+    }
   }
 }
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/patterns/issue51112.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/issue51112.dart.weak.modular.expect
index 3188638d149..d9e477d98d9 100644
--- a/pkg/front_end/testcases/patterns/issue51112.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/issue51112.dart.weak.modular.expect
@@ -6,49 +6,54 @@ static method test(dynamic x) → dynamic {
   () → void setToOne = () → void {};
   #L1:
   {
-    core::int y;
-    core::int y#1;
-    core::double y#2;
     final synthesized dynamic #0#0 = x;
     late final synthesized core::int #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int};
     late final synthesized core::bool #0#4 = #0#2 =={core::num::==}{(core::Object) → core::bool} #C1;
     late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
     late final synthesized dynamic #0#7 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic};
     dynamic #t1;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = y = #0#6{core::int} in true)) && (let final dynamic #t3 = #0#7 in true) && (() → core::bool {
-      setToOne = () → void {
-        y = 1;
-      };
-      return true;
-    })(){() → core::bool} && (let final dynamic #t4 = #t1 = y in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (let final dynamic #t5 = #0#6 in true) && (#0#7 is{ForNonNullableByDefault} core::int && (let final dynamic #t6 = y#1 = #0#7{core::int} in true)) && (() → core::bool {
-      setToOne = () → void {
-        y#1 = 1;
-      };
-      return true;
-    })(){() → core::bool} && (let final dynamic #t7 = #t1 = y#1 in true)) {
-      core::int y = #t1{core::int};
-      {
-        setToOne(){() → void};
-        return y;
+    {
+      lowered core::int y#case#0;
+      lowered core::int y#case#1;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = y#case#0 = #0#6{core::int} in true)) && (let final dynamic #t3 = #0#7 in true) && (() → core::bool {
+        setToOne = () → void {
+          y#case#0 = 1;
+        };
+        return true;
+      })(){() → core::bool} && (let final dynamic #t4 = #t1 = y#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (let final dynamic #t5 = #0#6 in true) && (#0#7 is{ForNonNullableByDefault} core::int && (let final dynamic #t6 = y#case#1 = #0#7{core::int} in true)) && (() → core::bool {
+        setToOne = () → void {
+          y#case#1 = 1;
+        };
+        return true;
+      })(){() → core::bool} && (let final dynamic #t7 = #t1 = y#case#1 in true)) {
+        core::int y = #t1{core::int};
+        {
+          setToOne(){() → void};
+          return y;
+        }
       }
     }
-    else
-      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#2 =={core::num::==}{(core::Object) → core::bool} #C2 && (#0#6 is{ForNonNullableByDefault} core::double && (let final dynamic #t8 = y#2 = #0#6{core::double} in true)) && (() → core::bool {
+    {
+      core::double y;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#2 =={core::num::==}{(core::Object) → core::bool} #C2 && (#0#6 is{ForNonNullableByDefault} core::double && (let final dynamic #t8 = y = #0#6{core::double} in true)) && (() → core::bool {
         setToOne = () → void {
-          y#2 = 1.0;
+          y = 1.0;
         };
         return true;
       })(){() → core::bool}) {
         {
           setToOne(){() → void};
-          return y#2;
+          return y;
         }
       }
-      else {
+    }
+    {
+      {
         {
           return null;
         }
       }
+    }
   }
 }
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/patterns/issue51112.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/issue51112.dart.weak.transformed.expect
index 97a6f10d347..6c7706e3865 100644
--- a/pkg/front_end/testcases/patterns/issue51112.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/issue51112.dart.weak.transformed.expect
@@ -6,9 +6,6 @@ static method test(dynamic x) → dynamic {
   () → void setToOne = () → void {};
   #L1:
   {
-    core::int y;
-    core::int y#1;
-    core::double y#2;
     final synthesized dynamic #0#0 = x;
     function ##0#2#initializer() → core::int
       return #0#0{core::List<dynamic>}.{core::List::length}{core::int};
@@ -23,40 +20,48 @@ static method test(dynamic x) → dynamic {
       return #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic};
     late final synthesized dynamic #0#7 = ##0#7#initializer(){() → dynamic};
     dynamic #t1;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final core::int #t2 = y = #0#6{core::int} in true)) && (let final dynamic #t3 = #0#7 in true) && (() → core::bool {
-      setToOne = () → void {
-        y = 1;
-      };
-      return true;
-    })(){() → core::bool} && (let final core::int #t4 = #t1 = y in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (let final dynamic #t5 = #0#6 in true) && (#0#7 is{ForNonNullableByDefault} core::int && (let final core::int #t6 = y#1 = #0#7{core::int} in true)) && (() → core::bool {
-      setToOne = () → void {
-        y#1 = 1;
-      };
-      return true;
-    })(){() → core::bool} && (let final core::int #t7 = #t1 = y#1 in true)) {
-      core::int y = #t1{core::int};
-      {
-        setToOne(){() → void};
-        return y;
+    {
+      lowered core::int y#case#0;
+      lowered core::int y#case#1;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final core::int #t2 = y#case#0 = #0#6{core::int} in true)) && (let final dynamic #t3 = #0#7 in true) && (() → core::bool {
+        setToOne = () → void {
+          y#case#0 = 1;
+        };
+        return true;
+      })(){() → core::bool} && (let final core::int #t4 = #t1 = y#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (let final dynamic #t5 = #0#6 in true) && (#0#7 is{ForNonNullableByDefault} core::int && (let final core::int #t6 = y#case#1 = #0#7{core::int} in true)) && (() → core::bool {
+        setToOne = () → void {
+          y#case#1 = 1;
+        };
+        return true;
+      })(){() → core::bool} && (let final core::int #t7 = #t1 = y#case#1 in true)) {
+        core::int y = #t1{core::int};
+        {
+          setToOne(){() → void};
+          return y;
+        }
       }
     }
-    else
-      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#2 =={core::num::==}{(core::Object) → core::bool} #C2 && (#0#6 is{ForNonNullableByDefault} core::double && (let final core::double #t8 = y#2 = #0#6{core::double} in true)) && (() → core::bool {
+    {
+      core::double y;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#2 =={core::num::==}{(core::Object) → core::bool} #C2 && (#0#6 is{ForNonNullableByDefault} core::double && (let final core::double #t8 = y = #0#6{core::double} in true)) && (() → core::bool {
         setToOne = () → void {
-          y#2 = 1.0;
+          y = 1.0;
         };
         return true;
       })(){() → core::bool}) {
         {
           setToOne(){() → void};
-          return y#2;
+          return y;
         }
       }
-      else {
+    }
+    {
+      {
         {
           return null;
         }
       }
+    }
   }
 }
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/patterns/issue51138.dart.strong.expect b/pkg/front_end/testcases/patterns/issue51138.dart.strong.expect
index de0b800d187..fc9f1368455 100644
--- a/pkg/front_end/testcases/patterns/issue51138.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/issue51138.dart.strong.expect
@@ -5,7 +5,6 @@ import "dart:core" as core;
 static method test(core::List<dynamic> list) → core::String {
   return block {
     core::String #t1;
-    core::num c;
     final synthesized core::List<dynamic> #0#0 = list;
     synthesized core::bool #0#4;
     synthesized core::bool #0#4#isSet = false;
@@ -13,14 +12,28 @@ static method test(core::List<dynamic> list) → core::String {
     synthesized core::bool #0#6#isSet = false;
     synthesized dynamic #0#9;
     synthesized core::bool #0#9#isSet = false;
-    if(#0#0 is{ForNonNullableByDefault} core::List<core::num> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t2 = #0#4#isSet = true in #0#4 = #0#0{core::List<core::num>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) && #C2 =={core::num::==}{(core::Object) → core::bool} (#0#6#isSet ?{core::num} #0#6{core::num} : let final dynamic #t3 = #0#6#isSet = true in #0#6 = #0#0{core::List<core::num>}.{core::List::[]}(0){(core::int) → core::num}) && (#0#9#isSet ?{core::num} #0#9{core::num} : let final dynamic #t4 = #0#9#isSet = true in #0#9 = #0#0{core::List<core::num>}.{core::List::[]}(1){(core::int) → core::num}).{core::num::>}(#C3){(core::num) → core::bool})
-      #t1 = "relational";
-    else
-      if((#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t5 = #0#4#isSet = true in #0#4 = #0#0.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) && #C4 =={core::num::==}{(core::Object) → core::bool} (#0#6#isSet ?{dynamic} #0#6{dynamic} : let final dynamic #t6 = #0#6#isSet = true in #0#6 = #0#0.{core::List::[]}(0){(core::int) → dynamic}) && (let final dynamic #t7 = (#0#9#isSet ?{dynamic} #0#9{dynamic} : let final dynamic #t8 = #0#9#isSet = true in #0#9 = #0#0.{core::List::[]}(1){(core::int) → dynamic}) as{ForNonNullableByDefault} core::num in let final dynamic #t9 = c = (#0#9#isSet ?{dynamic} #0#9{dynamic} : let final dynamic #t10 = #0#9#isSet = true in #0#9 = #0#0.{core::List::[]}(1){(core::int) → dynamic}) as{ForNonNullableByDefault} core::num in true))
-        #t1 = "cast";
-      else
-        if(true)
+    #L1:
+    {
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<core::num> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t2 = #0#4#isSet = true in #0#4 = #0#0{core::List<core::num>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) && #C2 =={core::num::==}{(core::Object) → core::bool} (#0#6#isSet ?{core::num} #0#6{core::num} : let final dynamic #t3 = #0#6#isSet = true in #0#6 = #0#0{core::List<core::num>}.{core::List::[]}(0){(core::int) → core::num}) && (#0#9#isSet ?{core::num} #0#9{core::num} : let final dynamic #t4 = #0#9#isSet = true in #0#9 = #0#0{core::List<core::num>}.{core::List::[]}(1){(core::int) → core::num}).{core::num::>}(#C3){(core::num) → core::bool}) {
+          #t1 = "relational";
+          break #L1;
+        }
+      }
+      {
+        core::num c;
+        if((#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t5 = #0#4#isSet = true in #0#4 = #0#0.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) && #C4 =={core::num::==}{(core::Object) → core::bool} (#0#6#isSet ?{dynamic} #0#6{dynamic} : let final dynamic #t6 = #0#6#isSet = true in #0#6 = #0#0.{core::List::[]}(0){(core::int) → dynamic}) && (let final dynamic #t7 = (#0#9#isSet ?{dynamic} #0#9{dynamic} : let final dynamic #t8 = #0#9#isSet = true in #0#9 = #0#0.{core::List::[]}(1){(core::int) → dynamic}) as{ForNonNullableByDefault} core::num in let final dynamic #t9 = c = (#0#9#isSet ?{dynamic} #0#9{dynamic} : let final dynamic #t10 = #0#9#isSet = true in #0#9 = #0#0.{core::List::[]}(1){(core::int) → dynamic}) as{ForNonNullableByDefault} core::num in true)) {
+          #t1 = "cast";
+          break #L1;
+        }
+      }
+      {
+        if(true) {
           #t1 = "default";
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
 }
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/patterns/issue51138.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/issue51138.dart.strong.transformed.expect
index 37bb866c784..11b38282494 100644
--- a/pkg/front_end/testcases/patterns/issue51138.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/issue51138.dart.strong.transformed.expect
@@ -5,7 +5,6 @@ import "dart:core" as core;
 static method test(core::List<dynamic> list) → core::String {
   return block {
     core::String #t1;
-    core::num c;
     final synthesized core::List<dynamic> #0#0 = list;
     synthesized core::bool #0#4;
     synthesized core::bool #0#4#isSet = false;
@@ -13,14 +12,28 @@ static method test(core::List<dynamic> list) → core::String {
     synthesized core::bool #0#6#isSet = false;
     synthesized dynamic #0#9;
     synthesized core::bool #0#9#isSet = false;
-    if(#0#0 is{ForNonNullableByDefault} core::List<core::num> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t2 = #0#4#isSet = true in #0#4 = #0#0{core::List<core::num>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) && #C2 =={core::num::==}{(core::Object) → core::bool} (#0#6#isSet ?{core::num} #0#6{core::num} : let final core::bool* #t3 = #0#6#isSet = true in #0#6 = #0#0{core::List<core::num>}.{core::List::[]}(0){(core::int) → core::num}) && (#0#9#isSet ?{core::num} #0#9{core::num} : let final core::bool* #t4 = #0#9#isSet = true in #0#9 = #0#0{core::List<core::num>}.{core::List::[]}(1){(core::int) → core::num}).{core::num::>}(#C3){(core::num) → core::bool})
-      #t1 = "relational";
-    else
-      if((#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t5 = #0#4#isSet = true in #0#4 = #0#0.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) && #C4 =={core::num::==}{(core::Object) → core::bool} (#0#6#isSet ?{dynamic} #0#6{dynamic} : let final core::bool* #t6 = #0#6#isSet = true in #0#6 = #0#0.{core::List::[]}(0){(core::int) → dynamic}) && (let final core::num #t7 = (#0#9#isSet ?{dynamic} #0#9{dynamic} : let final core::bool* #t8 = #0#9#isSet = true in #0#9 = #0#0.{core::List::[]}(1){(core::int) → dynamic}) as{ForNonNullableByDefault} core::num in let final core::num #t9 = c = (#0#9#isSet ?{dynamic} #0#9{dynamic} : let final core::bool* #t10 = #0#9#isSet = true in #0#9 = #0#0.{core::List::[]}(1){(core::int) → dynamic}) as{ForNonNullableByDefault} core::num in true))
-        #t1 = "cast";
-      else
-        if(true)
+    #L1:
+    {
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<core::num> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t2 = #0#4#isSet = true in #0#4 = #0#0{core::List<core::num>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) && #C2 =={core::num::==}{(core::Object) → core::bool} (#0#6#isSet ?{core::num} #0#6{core::num} : let final core::bool* #t3 = #0#6#isSet = true in #0#6 = #0#0{core::List<core::num>}.{core::List::[]}(0){(core::int) → core::num}) && (#0#9#isSet ?{core::num} #0#9{core::num} : let final core::bool* #t4 = #0#9#isSet = true in #0#9 = #0#0{core::List<core::num>}.{core::List::[]}(1){(core::int) → core::num}).{core::num::>}(#C3){(core::num) → core::bool}) {
+          #t1 = "relational";
+          break #L1;
+        }
+      }
+      {
+        core::num c;
+        if((#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t5 = #0#4#isSet = true in #0#4 = #0#0.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) && #C4 =={core::num::==}{(core::Object) → core::bool} (#0#6#isSet ?{dynamic} #0#6{dynamic} : let final core::bool* #t6 = #0#6#isSet = true in #0#6 = #0#0.{core::List::[]}(0){(core::int) → dynamic}) && (let final core::num #t7 = (#0#9#isSet ?{dynamic} #0#9{dynamic} : let final core::bool* #t8 = #0#9#isSet = true in #0#9 = #0#0.{core::List::[]}(1){(core::int) → dynamic}) as{ForNonNullableByDefault} core::num in let final core::num #t9 = c = (#0#9#isSet ?{dynamic} #0#9{dynamic} : let final core::bool* #t10 = #0#9#isSet = true in #0#9 = #0#0.{core::List::[]}(1){(core::int) → dynamic}) as{ForNonNullableByDefault} core::num in true)) {
+          #t1 = "cast";
+          break #L1;
+        }
+      }
+      {
+        if(true) {
           #t1 = "default";
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
 }
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/patterns/issue51138.dart.weak.expect b/pkg/front_end/testcases/patterns/issue51138.dart.weak.expect
index de0b800d187..fc9f1368455 100644
--- a/pkg/front_end/testcases/patterns/issue51138.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/issue51138.dart.weak.expect
@@ -5,7 +5,6 @@ import "dart:core" as core;
 static method test(core::List<dynamic> list) → core::String {
   return block {
     core::String #t1;
-    core::num c;
     final synthesized core::List<dynamic> #0#0 = list;
     synthesized core::bool #0#4;
     synthesized core::bool #0#4#isSet = false;
@@ -13,14 +12,28 @@ static method test(core::List<dynamic> list) → core::String {
     synthesized core::bool #0#6#isSet = false;
     synthesized dynamic #0#9;
     synthesized core::bool #0#9#isSet = false;
-    if(#0#0 is{ForNonNullableByDefault} core::List<core::num> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t2 = #0#4#isSet = true in #0#4 = #0#0{core::List<core::num>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) && #C2 =={core::num::==}{(core::Object) → core::bool} (#0#6#isSet ?{core::num} #0#6{core::num} : let final dynamic #t3 = #0#6#isSet = true in #0#6 = #0#0{core::List<core::num>}.{core::List::[]}(0){(core::int) → core::num}) && (#0#9#isSet ?{core::num} #0#9{core::num} : let final dynamic #t4 = #0#9#isSet = true in #0#9 = #0#0{core::List<core::num>}.{core::List::[]}(1){(core::int) → core::num}).{core::num::>}(#C3){(core::num) → core::bool})
-      #t1 = "relational";
-    else
-      if((#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t5 = #0#4#isSet = true in #0#4 = #0#0.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) && #C4 =={core::num::==}{(core::Object) → core::bool} (#0#6#isSet ?{dynamic} #0#6{dynamic} : let final dynamic #t6 = #0#6#isSet = true in #0#6 = #0#0.{core::List::[]}(0){(core::int) → dynamic}) && (let final dynamic #t7 = (#0#9#isSet ?{dynamic} #0#9{dynamic} : let final dynamic #t8 = #0#9#isSet = true in #0#9 = #0#0.{core::List::[]}(1){(core::int) → dynamic}) as{ForNonNullableByDefault} core::num in let final dynamic #t9 = c = (#0#9#isSet ?{dynamic} #0#9{dynamic} : let final dynamic #t10 = #0#9#isSet = true in #0#9 = #0#0.{core::List::[]}(1){(core::int) → dynamic}) as{ForNonNullableByDefault} core::num in true))
-        #t1 = "cast";
-      else
-        if(true)
+    #L1:
+    {
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<core::num> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t2 = #0#4#isSet = true in #0#4 = #0#0{core::List<core::num>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) && #C2 =={core::num::==}{(core::Object) → core::bool} (#0#6#isSet ?{core::num} #0#6{core::num} : let final dynamic #t3 = #0#6#isSet = true in #0#6 = #0#0{core::List<core::num>}.{core::List::[]}(0){(core::int) → core::num}) && (#0#9#isSet ?{core::num} #0#9{core::num} : let final dynamic #t4 = #0#9#isSet = true in #0#9 = #0#0{core::List<core::num>}.{core::List::[]}(1){(core::int) → core::num}).{core::num::>}(#C3){(core::num) → core::bool}) {
+          #t1 = "relational";
+          break #L1;
+        }
+      }
+      {
+        core::num c;
+        if((#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t5 = #0#4#isSet = true in #0#4 = #0#0.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) && #C4 =={core::num::==}{(core::Object) → core::bool} (#0#6#isSet ?{dynamic} #0#6{dynamic} : let final dynamic #t6 = #0#6#isSet = true in #0#6 = #0#0.{core::List::[]}(0){(core::int) → dynamic}) && (let final dynamic #t7 = (#0#9#isSet ?{dynamic} #0#9{dynamic} : let final dynamic #t8 = #0#9#isSet = true in #0#9 = #0#0.{core::List::[]}(1){(core::int) → dynamic}) as{ForNonNullableByDefault} core::num in let final dynamic #t9 = c = (#0#9#isSet ?{dynamic} #0#9{dynamic} : let final dynamic #t10 = #0#9#isSet = true in #0#9 = #0#0.{core::List::[]}(1){(core::int) → dynamic}) as{ForNonNullableByDefault} core::num in true)) {
+          #t1 = "cast";
+          break #L1;
+        }
+      }
+      {
+        if(true) {
           #t1 = "default";
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
 }
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/patterns/issue51138.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/issue51138.dart.weak.modular.expect
index de0b800d187..fc9f1368455 100644
--- a/pkg/front_end/testcases/patterns/issue51138.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/issue51138.dart.weak.modular.expect
@@ -5,7 +5,6 @@ import "dart:core" as core;
 static method test(core::List<dynamic> list) → core::String {
   return block {
     core::String #t1;
-    core::num c;
     final synthesized core::List<dynamic> #0#0 = list;
     synthesized core::bool #0#4;
     synthesized core::bool #0#4#isSet = false;
@@ -13,14 +12,28 @@ static method test(core::List<dynamic> list) → core::String {
     synthesized core::bool #0#6#isSet = false;
     synthesized dynamic #0#9;
     synthesized core::bool #0#9#isSet = false;
-    if(#0#0 is{ForNonNullableByDefault} core::List<core::num> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t2 = #0#4#isSet = true in #0#4 = #0#0{core::List<core::num>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) && #C2 =={core::num::==}{(core::Object) → core::bool} (#0#6#isSet ?{core::num} #0#6{core::num} : let final dynamic #t3 = #0#6#isSet = true in #0#6 = #0#0{core::List<core::num>}.{core::List::[]}(0){(core::int) → core::num}) && (#0#9#isSet ?{core::num} #0#9{core::num} : let final dynamic #t4 = #0#9#isSet = true in #0#9 = #0#0{core::List<core::num>}.{core::List::[]}(1){(core::int) → core::num}).{core::num::>}(#C3){(core::num) → core::bool})
-      #t1 = "relational";
-    else
-      if((#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t5 = #0#4#isSet = true in #0#4 = #0#0.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) && #C4 =={core::num::==}{(core::Object) → core::bool} (#0#6#isSet ?{dynamic} #0#6{dynamic} : let final dynamic #t6 = #0#6#isSet = true in #0#6 = #0#0.{core::List::[]}(0){(core::int) → dynamic}) && (let final dynamic #t7 = (#0#9#isSet ?{dynamic} #0#9{dynamic} : let final dynamic #t8 = #0#9#isSet = true in #0#9 = #0#0.{core::List::[]}(1){(core::int) → dynamic}) as{ForNonNullableByDefault} core::num in let final dynamic #t9 = c = (#0#9#isSet ?{dynamic} #0#9{dynamic} : let final dynamic #t10 = #0#9#isSet = true in #0#9 = #0#0.{core::List::[]}(1){(core::int) → dynamic}) as{ForNonNullableByDefault} core::num in true))
-        #t1 = "cast";
-      else
-        if(true)
+    #L1:
+    {
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<core::num> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t2 = #0#4#isSet = true in #0#4 = #0#0{core::List<core::num>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) && #C2 =={core::num::==}{(core::Object) → core::bool} (#0#6#isSet ?{core::num} #0#6{core::num} : let final dynamic #t3 = #0#6#isSet = true in #0#6 = #0#0{core::List<core::num>}.{core::List::[]}(0){(core::int) → core::num}) && (#0#9#isSet ?{core::num} #0#9{core::num} : let final dynamic #t4 = #0#9#isSet = true in #0#9 = #0#0{core::List<core::num>}.{core::List::[]}(1){(core::int) → core::num}).{core::num::>}(#C3){(core::num) → core::bool}) {
+          #t1 = "relational";
+          break #L1;
+        }
+      }
+      {
+        core::num c;
+        if((#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t5 = #0#4#isSet = true in #0#4 = #0#0.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) && #C4 =={core::num::==}{(core::Object) → core::bool} (#0#6#isSet ?{dynamic} #0#6{dynamic} : let final dynamic #t6 = #0#6#isSet = true in #0#6 = #0#0.{core::List::[]}(0){(core::int) → dynamic}) && (let final dynamic #t7 = (#0#9#isSet ?{dynamic} #0#9{dynamic} : let final dynamic #t8 = #0#9#isSet = true in #0#9 = #0#0.{core::List::[]}(1){(core::int) → dynamic}) as{ForNonNullableByDefault} core::num in let final dynamic #t9 = c = (#0#9#isSet ?{dynamic} #0#9{dynamic} : let final dynamic #t10 = #0#9#isSet = true in #0#9 = #0#0.{core::List::[]}(1){(core::int) → dynamic}) as{ForNonNullableByDefault} core::num in true)) {
+          #t1 = "cast";
+          break #L1;
+        }
+      }
+      {
+        if(true) {
           #t1 = "default";
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
 }
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/patterns/issue51138.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/issue51138.dart.weak.transformed.expect
index 37bb866c784..11b38282494 100644
--- a/pkg/front_end/testcases/patterns/issue51138.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/issue51138.dart.weak.transformed.expect
@@ -5,7 +5,6 @@ import "dart:core" as core;
 static method test(core::List<dynamic> list) → core::String {
   return block {
     core::String #t1;
-    core::num c;
     final synthesized core::List<dynamic> #0#0 = list;
     synthesized core::bool #0#4;
     synthesized core::bool #0#4#isSet = false;
@@ -13,14 +12,28 @@ static method test(core::List<dynamic> list) → core::String {
     synthesized core::bool #0#6#isSet = false;
     synthesized dynamic #0#9;
     synthesized core::bool #0#9#isSet = false;
-    if(#0#0 is{ForNonNullableByDefault} core::List<core::num> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t2 = #0#4#isSet = true in #0#4 = #0#0{core::List<core::num>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) && #C2 =={core::num::==}{(core::Object) → core::bool} (#0#6#isSet ?{core::num} #0#6{core::num} : let final core::bool* #t3 = #0#6#isSet = true in #0#6 = #0#0{core::List<core::num>}.{core::List::[]}(0){(core::int) → core::num}) && (#0#9#isSet ?{core::num} #0#9{core::num} : let final core::bool* #t4 = #0#9#isSet = true in #0#9 = #0#0{core::List<core::num>}.{core::List::[]}(1){(core::int) → core::num}).{core::num::>}(#C3){(core::num) → core::bool})
-      #t1 = "relational";
-    else
-      if((#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t5 = #0#4#isSet = true in #0#4 = #0#0.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) && #C4 =={core::num::==}{(core::Object) → core::bool} (#0#6#isSet ?{dynamic} #0#6{dynamic} : let final core::bool* #t6 = #0#6#isSet = true in #0#6 = #0#0.{core::List::[]}(0){(core::int) → dynamic}) && (let final core::num #t7 = (#0#9#isSet ?{dynamic} #0#9{dynamic} : let final core::bool* #t8 = #0#9#isSet = true in #0#9 = #0#0.{core::List::[]}(1){(core::int) → dynamic}) as{ForNonNullableByDefault} core::num in let final core::num #t9 = c = (#0#9#isSet ?{dynamic} #0#9{dynamic} : let final core::bool* #t10 = #0#9#isSet = true in #0#9 = #0#0.{core::List::[]}(1){(core::int) → dynamic}) as{ForNonNullableByDefault} core::num in true))
-        #t1 = "cast";
-      else
-        if(true)
+    #L1:
+    {
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::List<core::num> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t2 = #0#4#isSet = true in #0#4 = #0#0{core::List<core::num>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) && #C2 =={core::num::==}{(core::Object) → core::bool} (#0#6#isSet ?{core::num} #0#6{core::num} : let final core::bool* #t3 = #0#6#isSet = true in #0#6 = #0#0{core::List<core::num>}.{core::List::[]}(0){(core::int) → core::num}) && (#0#9#isSet ?{core::num} #0#9{core::num} : let final core::bool* #t4 = #0#9#isSet = true in #0#9 = #0#0{core::List<core::num>}.{core::List::[]}(1){(core::int) → core::num}).{core::num::>}(#C3){(core::num) → core::bool}) {
+          #t1 = "relational";
+          break #L1;
+        }
+      }
+      {
+        core::num c;
+        if((#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t5 = #0#4#isSet = true in #0#4 = #0#0.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) && #C4 =={core::num::==}{(core::Object) → core::bool} (#0#6#isSet ?{dynamic} #0#6{dynamic} : let final core::bool* #t6 = #0#6#isSet = true in #0#6 = #0#0.{core::List::[]}(0){(core::int) → dynamic}) && (let final core::num #t7 = (#0#9#isSet ?{dynamic} #0#9{dynamic} : let final core::bool* #t8 = #0#9#isSet = true in #0#9 = #0#0.{core::List::[]}(1){(core::int) → dynamic}) as{ForNonNullableByDefault} core::num in let final core::num #t9 = c = (#0#9#isSet ?{dynamic} #0#9{dynamic} : let final core::bool* #t10 = #0#9#isSet = true in #0#9 = #0#0.{core::List::[]}(1){(core::int) → dynamic}) as{ForNonNullableByDefault} core::num in true)) {
+          #t1 = "cast";
+          break #L1;
+        }
+      }
+      {
+        if(true) {
           #t1 = "default";
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
 }
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/patterns/issue51140.dart.strong.expect b/pkg/front_end/testcases/patterns/issue51140.dart.strong.expect
index 81f1920e5c8..1fe5de2d412 100644
--- a/pkg/front_end/testcases/patterns/issue51140.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/issue51140.dart.strong.expect
@@ -9,24 +9,29 @@ static method test(core::Object? o) → core::String {
     final synthesized core::Object? #0#0 = o;
     synthesized core::int #0#2;
     synthesized core::bool #0#2#isSet = false;
-    if(#0#0 is{ForNonNullableByDefault} core::List<core::Object?> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t1 = #0#2#isSet = true in #0#2 = #0#0{core::List<core::Object?>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::Object?>}.{core::List::[]}(0){(core::int) → core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::Object?>}.{core::List::[]}(1){(core::int) → core::Object?}) {
-      {
-        toReturn = "list";
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<core::Object?> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t1 = #0#2#isSet = true in #0#2 = #0#0{core::List<core::Object?>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::Object?>}.{core::List::[]}(0){(core::int) → core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::Object?>}.{core::List::[]}(1){(core::int) → core::Object?}) {
+        {
+          toReturn = "list";
+          break #L1;
+        }
       }
     }
-    else
+    {
       if(#0#0 is{ForNonNullableByDefault} core::Map<core::Object?, core::Object?> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t2 = #0#2#isSet = true in #0#2 = #0#0{core::Map<core::Object?, core::Object?>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C2 && #0#0{core::Map<core::Object?, core::Object?>}.{core::Map::containsKey}(#C3){(core::Object?) → core::bool} && (let final dynamic #t3 = #0#0{core::Map<core::Object?, core::Object?>}.{core::Map::[]}(#C3){(core::Object?) → core::Object?} in true)) {
         {
           toReturn = "map";
           break #L1;
         }
       }
-      else {
+    }
+    {
+      {
         {
           toReturn = "default";
         }
       }
+    }
   }
   return toReturn;
 }
diff --git a/pkg/front_end/testcases/patterns/issue51140.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/issue51140.dart.strong.transformed.expect
index f16134135b5..46394ac7015 100644
--- a/pkg/front_end/testcases/patterns/issue51140.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/issue51140.dart.strong.transformed.expect
@@ -9,24 +9,29 @@ static method test(core::Object? o) → core::String {
     final synthesized core::Object? #0#0 = o;
     synthesized core::int #0#2;
     synthesized core::bool #0#2#isSet = false;
-    if(#0#0 is{ForNonNullableByDefault} core::List<core::Object?> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t1 = #0#2#isSet = true in #0#2 = #0#0{core::List<core::Object?>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::Object?>}.{core::List::[]}(0){(core::int) → core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::Object?>}.{core::List::[]}(1){(core::int) → core::Object?}) {
-      {
-        toReturn = "list";
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<core::Object?> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t1 = #0#2#isSet = true in #0#2 = #0#0{core::List<core::Object?>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::Object?>}.{core::List::[]}(0){(core::int) → core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::Object?>}.{core::List::[]}(1){(core::int) → core::Object?}) {
+        {
+          toReturn = "list";
+          break #L1;
+        }
       }
     }
-    else
+    {
       if(#0#0 is{ForNonNullableByDefault} core::Map<core::Object?, core::Object?> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t2 = #0#2#isSet = true in #0#2 = #0#0{core::Map<core::Object?, core::Object?>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C2 && #0#0{core::Map<core::Object?, core::Object?>}.{core::Map::containsKey}(#C3){(core::Object?) → core::bool} && (let final core::Object? #t3 = #0#0{core::Map<core::Object?, core::Object?>}.{core::Map::[]}(#C3){(core::Object?) → core::Object?} in true)) {
         {
           toReturn = "map";
           break #L1;
         }
       }
-      else {
+    }
+    {
+      {
         {
           toReturn = "default";
         }
       }
+    }
   }
   return toReturn;
 }
diff --git a/pkg/front_end/testcases/patterns/issue51140.dart.weak.expect b/pkg/front_end/testcases/patterns/issue51140.dart.weak.expect
index 81f1920e5c8..1fe5de2d412 100644
--- a/pkg/front_end/testcases/patterns/issue51140.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/issue51140.dart.weak.expect
@@ -9,24 +9,29 @@ static method test(core::Object? o) → core::String {
     final synthesized core::Object? #0#0 = o;
     synthesized core::int #0#2;
     synthesized core::bool #0#2#isSet = false;
-    if(#0#0 is{ForNonNullableByDefault} core::List<core::Object?> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t1 = #0#2#isSet = true in #0#2 = #0#0{core::List<core::Object?>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::Object?>}.{core::List::[]}(0){(core::int) → core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::Object?>}.{core::List::[]}(1){(core::int) → core::Object?}) {
-      {
-        toReturn = "list";
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<core::Object?> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t1 = #0#2#isSet = true in #0#2 = #0#0{core::List<core::Object?>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::Object?>}.{core::List::[]}(0){(core::int) → core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::Object?>}.{core::List::[]}(1){(core::int) → core::Object?}) {
+        {
+          toReturn = "list";
+          break #L1;
+        }
       }
     }
-    else
+    {
       if(#0#0 is{ForNonNullableByDefault} core::Map<core::Object?, core::Object?> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t2 = #0#2#isSet = true in #0#2 = #0#0{core::Map<core::Object?, core::Object?>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C2 && #0#0{core::Map<core::Object?, core::Object?>}.{core::Map::containsKey}(#C3){(core::Object?) → core::bool} && (let final dynamic #t3 = #0#0{core::Map<core::Object?, core::Object?>}.{core::Map::[]}(#C3){(core::Object?) → core::Object?} in true)) {
         {
           toReturn = "map";
           break #L1;
         }
       }
-      else {
+    }
+    {
+      {
         {
           toReturn = "default";
         }
       }
+    }
   }
   return toReturn;
 }
diff --git a/pkg/front_end/testcases/patterns/issue51140.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/issue51140.dart.weak.modular.expect
index 81f1920e5c8..1fe5de2d412 100644
--- a/pkg/front_end/testcases/patterns/issue51140.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/issue51140.dart.weak.modular.expect
@@ -9,24 +9,29 @@ static method test(core::Object? o) → core::String {
     final synthesized core::Object? #0#0 = o;
     synthesized core::int #0#2;
     synthesized core::bool #0#2#isSet = false;
-    if(#0#0 is{ForNonNullableByDefault} core::List<core::Object?> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t1 = #0#2#isSet = true in #0#2 = #0#0{core::List<core::Object?>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::Object?>}.{core::List::[]}(0){(core::int) → core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::Object?>}.{core::List::[]}(1){(core::int) → core::Object?}) {
-      {
-        toReturn = "list";
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<core::Object?> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t1 = #0#2#isSet = true in #0#2 = #0#0{core::List<core::Object?>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::Object?>}.{core::List::[]}(0){(core::int) → core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::Object?>}.{core::List::[]}(1){(core::int) → core::Object?}) {
+        {
+          toReturn = "list";
+          break #L1;
+        }
       }
     }
-    else
+    {
       if(#0#0 is{ForNonNullableByDefault} core::Map<core::Object?, core::Object?> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t2 = #0#2#isSet = true in #0#2 = #0#0{core::Map<core::Object?, core::Object?>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C2 && #0#0{core::Map<core::Object?, core::Object?>}.{core::Map::containsKey}(#C3){(core::Object?) → core::bool} && (let final dynamic #t3 = #0#0{core::Map<core::Object?, core::Object?>}.{core::Map::[]}(#C3){(core::Object?) → core::Object?} in true)) {
         {
           toReturn = "map";
           break #L1;
         }
       }
-      else {
+    }
+    {
+      {
         {
           toReturn = "default";
         }
       }
+    }
   }
   return toReturn;
 }
diff --git a/pkg/front_end/testcases/patterns/issue51140.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/issue51140.dart.weak.transformed.expect
index f16134135b5..46394ac7015 100644
--- a/pkg/front_end/testcases/patterns/issue51140.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/issue51140.dart.weak.transformed.expect
@@ -9,24 +9,29 @@ static method test(core::Object? o) → core::String {
     final synthesized core::Object? #0#0 = o;
     synthesized core::int #0#2;
     synthesized core::bool #0#2#isSet = false;
-    if(#0#0 is{ForNonNullableByDefault} core::List<core::Object?> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t1 = #0#2#isSet = true in #0#2 = #0#0{core::List<core::Object?>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::Object?>}.{core::List::[]}(0){(core::int) → core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::Object?>}.{core::List::[]}(1){(core::int) → core::Object?}) {
-      {
-        toReturn = "list";
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<core::Object?> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t1 = #0#2#isSet = true in #0#2 = #0#0{core::List<core::Object?>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::Object?>}.{core::List::[]}(0){(core::int) → core::Object?} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::Object?>}.{core::List::[]}(1){(core::int) → core::Object?}) {
+        {
+          toReturn = "list";
+          break #L1;
+        }
       }
     }
-    else
+    {
       if(#0#0 is{ForNonNullableByDefault} core::Map<core::Object?, core::Object?> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t2 = #0#2#isSet = true in #0#2 = #0#0{core::Map<core::Object?, core::Object?>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C2 && #0#0{core::Map<core::Object?, core::Object?>}.{core::Map::containsKey}(#C3){(core::Object?) → core::bool} && (let final core::Object? #t3 = #0#0{core::Map<core::Object?, core::Object?>}.{core::Map::[]}(#C3){(core::Object?) → core::Object?} in true)) {
         {
           toReturn = "map";
           break #L1;
         }
       }
-      else {
+    }
+    {
+      {
         {
           toReturn = "default";
         }
       }
+    }
   }
   return toReturn;
 }
diff --git a/pkg/front_end/testcases/patterns/issue51260.dart.strong.expect b/pkg/front_end/testcases/patterns/issue51260.dart.strong.expect
index ce26fe4d2c6..d4eb4bceaeb 100644
--- a/pkg/front_end/testcases/patterns/issue51260.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/issue51260.dart.strong.expect
@@ -5,23 +5,27 @@ import "dart:core" as core;
 static method foo(dynamic x) → dynamic {
   #L1:
   {
-    core::int a;
-    core::int a#1;
     final synthesized dynamic #0#0 = x;
     synthesized core::bool #0#4;
     synthesized core::bool #0#4#isSet = false;
     late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
     late final synthesized dynamic #0#11 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic};
     dynamic #t1;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t2 = #0#4#isSet = true in #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2) && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t3 = a = #0#6{core::int} in true)) && (let final dynamic #t4 = #t1 = a in true) || #0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t5 = #0#4#isSet = true in #0#4 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (#0#11 is{ForNonNullableByDefault} core::int && (let final dynamic #t6 = a#1 = #0#11{core::int} in true)) && (let final dynamic #t7 = #t1 = a#1 in true)) {
-      core::int a = #t1{core::int};
-      {
-        return a;
+    {
+      lowered core::int a#case#0;
+      lowered core::int a#case#1;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t2 = #0#4#isSet = true in #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2) && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t3 = a#case#0 = #0#6{core::int} in true)) && (let final dynamic #t4 = #t1 = a#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t5 = #0#4#isSet = true in #0#4 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (#0#11 is{ForNonNullableByDefault} core::int && (let final dynamic #t6 = a#case#1 = #0#11{core::int} in true)) && (let final dynamic #t7 = #t1 = a#case#1 in true)) {
+        core::int a = #t1{core::int};
+        {
+          return a;
+        }
       }
     }
-    else {
+    {
       {
-        return 0;
+        {
+          return 0;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/issue51260.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/issue51260.dart.strong.transformed.expect
index 30d5dd63482..4a707c0f118 100644
--- a/pkg/front_end/testcases/patterns/issue51260.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/issue51260.dart.strong.transformed.expect
@@ -5,8 +5,6 @@ import "dart:core" as core;
 static method foo(dynamic x) → dynamic {
   #L1:
   {
-    core::int a;
-    core::int a#1;
     final synthesized dynamic #0#0 = x;
     synthesized core::bool #0#4;
     synthesized core::bool #0#4#isSet = false;
@@ -17,15 +15,21 @@ static method foo(dynamic x) → dynamic {
       return #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic};
     late final synthesized dynamic #0#11 = ##0#11#initializer(){() → dynamic};
     dynamic #t1;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t2 = #0#4#isSet = true in #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2) && (#0#6 is{ForNonNullableByDefault} core::int && (let final core::int #t3 = a = #0#6{core::int} in true)) && (let final core::int #t4 = #t1 = a in true) || #0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t5 = #0#4#isSet = true in #0#4 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (#0#11 is{ForNonNullableByDefault} core::int && (let final core::int #t6 = a#1 = #0#11{core::int} in true)) && (let final core::int #t7 = #t1 = a#1 in true)) {
-      core::int a = #t1{core::int};
-      {
-        return a;
+    {
+      lowered core::int a#case#0;
+      lowered core::int a#case#1;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t2 = #0#4#isSet = true in #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2) && (#0#6 is{ForNonNullableByDefault} core::int && (let final core::int #t3 = a#case#0 = #0#6{core::int} in true)) && (let final core::int #t4 = #t1 = a#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t5 = #0#4#isSet = true in #0#4 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (#0#11 is{ForNonNullableByDefault} core::int && (let final core::int #t6 = a#case#1 = #0#11{core::int} in true)) && (let final core::int #t7 = #t1 = a#case#1 in true)) {
+        core::int a = #t1{core::int};
+        {
+          return a;
+        }
       }
     }
-    else {
+    {
       {
-        return 0;
+        {
+          return 0;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/issue51260.dart.weak.expect b/pkg/front_end/testcases/patterns/issue51260.dart.weak.expect
index ce26fe4d2c6..d4eb4bceaeb 100644
--- a/pkg/front_end/testcases/patterns/issue51260.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/issue51260.dart.weak.expect
@@ -5,23 +5,27 @@ import "dart:core" as core;
 static method foo(dynamic x) → dynamic {
   #L1:
   {
-    core::int a;
-    core::int a#1;
     final synthesized dynamic #0#0 = x;
     synthesized core::bool #0#4;
     synthesized core::bool #0#4#isSet = false;
     late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
     late final synthesized dynamic #0#11 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic};
     dynamic #t1;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t2 = #0#4#isSet = true in #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2) && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t3 = a = #0#6{core::int} in true)) && (let final dynamic #t4 = #t1 = a in true) || #0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t5 = #0#4#isSet = true in #0#4 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (#0#11 is{ForNonNullableByDefault} core::int && (let final dynamic #t6 = a#1 = #0#11{core::int} in true)) && (let final dynamic #t7 = #t1 = a#1 in true)) {
-      core::int a = #t1{core::int};
-      {
-        return a;
+    {
+      lowered core::int a#case#0;
+      lowered core::int a#case#1;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t2 = #0#4#isSet = true in #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2) && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t3 = a#case#0 = #0#6{core::int} in true)) && (let final dynamic #t4 = #t1 = a#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t5 = #0#4#isSet = true in #0#4 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (#0#11 is{ForNonNullableByDefault} core::int && (let final dynamic #t6 = a#case#1 = #0#11{core::int} in true)) && (let final dynamic #t7 = #t1 = a#case#1 in true)) {
+        core::int a = #t1{core::int};
+        {
+          return a;
+        }
       }
     }
-    else {
+    {
       {
-        return 0;
+        {
+          return 0;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/issue51260.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/issue51260.dart.weak.modular.expect
index ce26fe4d2c6..d4eb4bceaeb 100644
--- a/pkg/front_end/testcases/patterns/issue51260.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/issue51260.dart.weak.modular.expect
@@ -5,23 +5,27 @@ import "dart:core" as core;
 static method foo(dynamic x) → dynamic {
   #L1:
   {
-    core::int a;
-    core::int a#1;
     final synthesized dynamic #0#0 = x;
     synthesized core::bool #0#4;
     synthesized core::bool #0#4#isSet = false;
     late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
     late final synthesized dynamic #0#11 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic};
     dynamic #t1;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t2 = #0#4#isSet = true in #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2) && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t3 = a = #0#6{core::int} in true)) && (let final dynamic #t4 = #t1 = a in true) || #0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t5 = #0#4#isSet = true in #0#4 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (#0#11 is{ForNonNullableByDefault} core::int && (let final dynamic #t6 = a#1 = #0#11{core::int} in true)) && (let final dynamic #t7 = #t1 = a#1 in true)) {
-      core::int a = #t1{core::int};
-      {
-        return a;
+    {
+      lowered core::int a#case#0;
+      lowered core::int a#case#1;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t2 = #0#4#isSet = true in #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2) && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t3 = a#case#0 = #0#6{core::int} in true)) && (let final dynamic #t4 = #t1 = a#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t5 = #0#4#isSet = true in #0#4 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (#0#11 is{ForNonNullableByDefault} core::int && (let final dynamic #t6 = a#case#1 = #0#11{core::int} in true)) && (let final dynamic #t7 = #t1 = a#case#1 in true)) {
+        core::int a = #t1{core::int};
+        {
+          return a;
+        }
       }
     }
-    else {
+    {
       {
-        return 0;
+        {
+          return 0;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/issue51260.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/issue51260.dart.weak.transformed.expect
index 30d5dd63482..4a707c0f118 100644
--- a/pkg/front_end/testcases/patterns/issue51260.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/issue51260.dart.weak.transformed.expect
@@ -5,8 +5,6 @@ import "dart:core" as core;
 static method foo(dynamic x) → dynamic {
   #L1:
   {
-    core::int a;
-    core::int a#1;
     final synthesized dynamic #0#0 = x;
     synthesized core::bool #0#4;
     synthesized core::bool #0#4#isSet = false;
@@ -17,15 +15,21 @@ static method foo(dynamic x) → dynamic {
       return #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic};
     late final synthesized dynamic #0#11 = ##0#11#initializer(){() → dynamic};
     dynamic #t1;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t2 = #0#4#isSet = true in #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2) && (#0#6 is{ForNonNullableByDefault} core::int && (let final core::int #t3 = a = #0#6{core::int} in true)) && (let final core::int #t4 = #t1 = a in true) || #0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t5 = #0#4#isSet = true in #0#4 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (#0#11 is{ForNonNullableByDefault} core::int && (let final core::int #t6 = a#1 = #0#11{core::int} in true)) && (let final core::int #t7 = #t1 = a#1 in true)) {
-      core::int a = #t1{core::int};
-      {
-        return a;
+    {
+      lowered core::int a#case#0;
+      lowered core::int a#case#1;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t2 = #0#4#isSet = true in #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2) && (#0#6 is{ForNonNullableByDefault} core::int && (let final core::int #t3 = a#case#0 = #0#6{core::int} in true)) && (let final core::int #t4 = #t1 = a#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t5 = #0#4#isSet = true in #0#4 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (#0#11 is{ForNonNullableByDefault} core::int && (let final core::int #t6 = a#case#1 = #0#11{core::int} in true)) && (let final core::int #t7 = #t1 = a#case#1 in true)) {
+        core::int a = #t1{core::int};
+        {
+          return a;
+        }
       }
     }
-    else {
+    {
       {
-        return 0;
+        {
+          return 0;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/issue51553.dart.strong.expect b/pkg/front_end/testcases/patterns/issue51553.dart.strong.expect
index 75226d61187..2276c74082e 100644
--- a/pkg/front_end/testcases/patterns/issue51553.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/issue51553.dart.strong.expect
@@ -4,30 +4,18 @@ import "dart:core" as core;
 
 static method main() → dynamic {
   #L1:
-  {
-    core::int #t1 = -1;
-    final synthesized core::int #0#0 = 0;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0)
-      #t1 = 0;
-    else
-      #t1 = 1;
-    switch(#t1) {
-      #L2:
-      case #C2:
-        {
-          {
-            continue #L3;
-          }
-        }
-      #L3:
-      case #C1:
-      default:
-        {}
-    }
+  switch(0) {
+    #L2:
+    case #C1:
+      {
+        continue #L3;
+      }
+    #L3:
+    default:
+      {}
   }
 }
 
 constants  {
   #C1 = 1
-  #C2 = 0
 }
diff --git a/pkg/front_end/testcases/patterns/issue51553.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/issue51553.dart.strong.transformed.expect
index 75226d61187..2276c74082e 100644
--- a/pkg/front_end/testcases/patterns/issue51553.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/issue51553.dart.strong.transformed.expect
@@ -4,30 +4,18 @@ import "dart:core" as core;
 
 static method main() → dynamic {
   #L1:
-  {
-    core::int #t1 = -1;
-    final synthesized core::int #0#0 = 0;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0)
-      #t1 = 0;
-    else
-      #t1 = 1;
-    switch(#t1) {
-      #L2:
-      case #C2:
-        {
-          {
-            continue #L3;
-          }
-        }
-      #L3:
-      case #C1:
-      default:
-        {}
-    }
+  switch(0) {
+    #L2:
+    case #C1:
+      {
+        continue #L3;
+      }
+    #L3:
+    default:
+      {}
   }
 }
 
 constants  {
   #C1 = 1
-  #C2 = 0
 }
diff --git a/pkg/front_end/testcases/patterns/issue51553.dart.weak.expect b/pkg/front_end/testcases/patterns/issue51553.dart.weak.expect
index 75226d61187..2276c74082e 100644
--- a/pkg/front_end/testcases/patterns/issue51553.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/issue51553.dart.weak.expect
@@ -4,30 +4,18 @@ import "dart:core" as core;
 
 static method main() → dynamic {
   #L1:
-  {
-    core::int #t1 = -1;
-    final synthesized core::int #0#0 = 0;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0)
-      #t1 = 0;
-    else
-      #t1 = 1;
-    switch(#t1) {
-      #L2:
-      case #C2:
-        {
-          {
-            continue #L3;
-          }
-        }
-      #L3:
-      case #C1:
-      default:
-        {}
-    }
+  switch(0) {
+    #L2:
+    case #C1:
+      {
+        continue #L3;
+      }
+    #L3:
+    default:
+      {}
   }
 }
 
 constants  {
   #C1 = 1
-  #C2 = 0
 }
diff --git a/pkg/front_end/testcases/patterns/issue51553.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/issue51553.dart.weak.modular.expect
index 75226d61187..2276c74082e 100644
--- a/pkg/front_end/testcases/patterns/issue51553.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/issue51553.dart.weak.modular.expect
@@ -4,30 +4,18 @@ import "dart:core" as core;
 
 static method main() → dynamic {
   #L1:
-  {
-    core::int #t1 = -1;
-    final synthesized core::int #0#0 = 0;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0)
-      #t1 = 0;
-    else
-      #t1 = 1;
-    switch(#t1) {
-      #L2:
-      case #C2:
-        {
-          {
-            continue #L3;
-          }
-        }
-      #L3:
-      case #C1:
-      default:
-        {}
-    }
+  switch(0) {
+    #L2:
+    case #C1:
+      {
+        continue #L3;
+      }
+    #L3:
+    default:
+      {}
   }
 }
 
 constants  {
   #C1 = 1
-  #C2 = 0
 }
diff --git a/pkg/front_end/testcases/patterns/issue51553.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/issue51553.dart.weak.transformed.expect
index 75226d61187..2276c74082e 100644
--- a/pkg/front_end/testcases/patterns/issue51553.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/issue51553.dart.weak.transformed.expect
@@ -4,30 +4,18 @@ import "dart:core" as core;
 
 static method main() → dynamic {
   #L1:
-  {
-    core::int #t1 = -1;
-    final synthesized core::int #0#0 = 0;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0)
-      #t1 = 0;
-    else
-      #t1 = 1;
-    switch(#t1) {
-      #L2:
-      case #C2:
-        {
-          {
-            continue #L3;
-          }
-        }
-      #L3:
-      case #C1:
-      default:
-        {}
-    }
+  switch(0) {
+    #L2:
+    case #C1:
+      {
+        continue #L3;
+      }
+    #L3:
+    default:
+      {}
   }
 }
 
 constants  {
   #C1 = 1
-  #C2 = 0
 }
diff --git a/pkg/front_end/testcases/patterns/list_pattern_errors.dart.strong.expect b/pkg/front_end/testcases/patterns/list_pattern_errors.dart.strong.expect
index 4fa4a092221..e065749c4c3 100644
--- a/pkg/front_end/testcases/patterns/list_pattern_errors.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/list_pattern_errors.dart.strong.expect
@@ -13,7 +13,9 @@ static method test(dynamic o) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = o;
-    if(#0#0 is{ForNonNullableByDefault} core::List<invalid-type> && #0#0{core::List<invalid-type>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) {
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<invalid-type> && #0#0{core::List<invalid-type>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) {
+      }
     }
   }
 }
diff --git a/pkg/front_end/testcases/patterns/list_pattern_errors.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/list_pattern_errors.dart.strong.transformed.expect
index 4fa4a092221..e065749c4c3 100644
--- a/pkg/front_end/testcases/patterns/list_pattern_errors.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/list_pattern_errors.dart.strong.transformed.expect
@@ -13,7 +13,9 @@ static method test(dynamic o) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = o;
-    if(#0#0 is{ForNonNullableByDefault} core::List<invalid-type> && #0#0{core::List<invalid-type>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) {
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<invalid-type> && #0#0{core::List<invalid-type>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) {
+      }
     }
   }
 }
diff --git a/pkg/front_end/testcases/patterns/list_pattern_errors.dart.weak.expect b/pkg/front_end/testcases/patterns/list_pattern_errors.dart.weak.expect
index 4fa4a092221..e065749c4c3 100644
--- a/pkg/front_end/testcases/patterns/list_pattern_errors.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/list_pattern_errors.dart.weak.expect
@@ -13,7 +13,9 @@ static method test(dynamic o) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = o;
-    if(#0#0 is{ForNonNullableByDefault} core::List<invalid-type> && #0#0{core::List<invalid-type>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) {
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<invalid-type> && #0#0{core::List<invalid-type>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) {
+      }
     }
   }
 }
diff --git a/pkg/front_end/testcases/patterns/list_pattern_errors.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/list_pattern_errors.dart.weak.modular.expect
index 4fa4a092221..e065749c4c3 100644
--- a/pkg/front_end/testcases/patterns/list_pattern_errors.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/list_pattern_errors.dart.weak.modular.expect
@@ -13,7 +13,9 @@ static method test(dynamic o) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = o;
-    if(#0#0 is{ForNonNullableByDefault} core::List<invalid-type> && #0#0{core::List<invalid-type>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) {
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<invalid-type> && #0#0{core::List<invalid-type>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) {
+      }
     }
   }
 }
diff --git a/pkg/front_end/testcases/patterns/list_pattern_errors.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/list_pattern_errors.dart.weak.transformed.expect
index 4fa4a092221..e065749c4c3 100644
--- a/pkg/front_end/testcases/patterns/list_pattern_errors.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/list_pattern_errors.dart.weak.transformed.expect
@@ -13,7 +13,9 @@ static method test(dynamic o) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = o;
-    if(#0#0 is{ForNonNullableByDefault} core::List<invalid-type> && #0#0{core::List<invalid-type>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) {
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<invalid-type> && #0#0{core::List<invalid-type>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) {
+      }
     }
   }
 }
diff --git a/pkg/front_end/testcases/patterns/list_pattern_inside_case.dart.strong.expect b/pkg/front_end/testcases/patterns/list_pattern_inside_case.dart.strong.expect
index fd1073a5ccb..df703141def 100644
--- a/pkg/front_end/testcases/patterns/list_pattern_inside_case.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/list_pattern_inside_case.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/list_pattern_inside_case.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/list_pattern_inside_case.dart.strong.transformed.expect
index fd1073a5ccb..df703141def 100644
--- a/pkg/front_end/testcases/patterns/list_pattern_inside_case.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/list_pattern_inside_case.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/list_pattern_inside_case.dart.weak.expect b/pkg/front_end/testcases/patterns/list_pattern_inside_case.dart.weak.expect
index fd1073a5ccb..df703141def 100644
--- a/pkg/front_end/testcases/patterns/list_pattern_inside_case.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/list_pattern_inside_case.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/list_pattern_inside_case.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/list_pattern_inside_case.dart.weak.modular.expect
index fd1073a5ccb..df703141def 100644
--- a/pkg/front_end/testcases/patterns/list_pattern_inside_case.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/list_pattern_inside_case.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/list_pattern_inside_case.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/list_pattern_inside_case.dart.weak.transformed.expect
index fd1073a5ccb..df703141def 100644
--- a/pkg/front_end/testcases/patterns/list_pattern_inside_case.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/list_pattern_inside_case.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/list_pattern_inside_case_empty.dart.strong.expect b/pkg/front_end/testcases/patterns/list_pattern_inside_case_empty.dart.strong.expect
index 1d4ecc5b952..30b4b650d56 100644
--- a/pkg/front_end/testcases/patterns/list_pattern_inside_case_empty.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/list_pattern_inside_case_empty.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/list_pattern_inside_case_empty.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/list_pattern_inside_case_empty.dart.strong.transformed.expect
index 1d4ecc5b952..30b4b650d56 100644
--- a/pkg/front_end/testcases/patterns/list_pattern_inside_case_empty.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/list_pattern_inside_case_empty.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/list_pattern_inside_case_empty.dart.weak.expect b/pkg/front_end/testcases/patterns/list_pattern_inside_case_empty.dart.weak.expect
index 1d4ecc5b952..30b4b650d56 100644
--- a/pkg/front_end/testcases/patterns/list_pattern_inside_case_empty.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/list_pattern_inside_case_empty.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/list_pattern_inside_case_empty.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/list_pattern_inside_case_empty.dart.weak.modular.expect
index 1d4ecc5b952..30b4b650d56 100644
--- a/pkg/front_end/testcases/patterns/list_pattern_inside_case_empty.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/list_pattern_inside_case_empty.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/list_pattern_inside_case_empty.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/list_pattern_inside_case_empty.dart.weak.transformed.expect
index 1d4ecc5b952..30b4b650d56 100644
--- a/pkg/front_end/testcases/patterns/list_pattern_inside_case_empty.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/list_pattern_inside_case_empty.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/list_pattern_inside_case_empty_whitespace.dart.strong.expect b/pkg/front_end/testcases/patterns/list_pattern_inside_case_empty_whitespace.dart.strong.expect
index 1d4ecc5b952..30b4b650d56 100644
--- a/pkg/front_end/testcases/patterns/list_pattern_inside_case_empty_whitespace.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/list_pattern_inside_case_empty_whitespace.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/list_pattern_inside_case_empty_whitespace.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/list_pattern_inside_case_empty_whitespace.dart.strong.transformed.expect
index 1d4ecc5b952..30b4b650d56 100644
--- a/pkg/front_end/testcases/patterns/list_pattern_inside_case_empty_whitespace.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/list_pattern_inside_case_empty_whitespace.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/list_pattern_inside_case_empty_whitespace.dart.weak.expect b/pkg/front_end/testcases/patterns/list_pattern_inside_case_empty_whitespace.dart.weak.expect
index 1d4ecc5b952..30b4b650d56 100644
--- a/pkg/front_end/testcases/patterns/list_pattern_inside_case_empty_whitespace.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/list_pattern_inside_case_empty_whitespace.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/list_pattern_inside_case_empty_whitespace.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/list_pattern_inside_case_empty_whitespace.dart.weak.modular.expect
index 1d4ecc5b952..30b4b650d56 100644
--- a/pkg/front_end/testcases/patterns/list_pattern_inside_case_empty_whitespace.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/list_pattern_inside_case_empty_whitespace.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/list_pattern_inside_case_empty_whitespace.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/list_pattern_inside_case_empty_whitespace.dart.weak.transformed.expect
index 1d4ecc5b952..30b4b650d56 100644
--- a/pkg/front_end/testcases/patterns/list_pattern_inside_case_empty_whitespace.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/list_pattern_inside_case_empty_whitespace.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/list_pattern_inside_case_with_type_arguments.dart.strong.expect b/pkg/front_end/testcases/patterns/list_pattern_inside_case_with_type_arguments.dart.strong.expect
index c8f15c2b576..e40c296ffa5 100644
--- a/pkg/front_end/testcases/patterns/list_pattern_inside_case_with_type_arguments.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/list_pattern_inside_case_with_type_arguments.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::List<core::int> && #0#0{core::List<core::int>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(0){(core::int) → core::int} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(1){(core::int) → core::int}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<core::int> && #0#0{core::List<core::int>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(0){(core::int) → core::int} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(1){(core::int) → core::int}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/list_pattern_inside_case_with_type_arguments.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/list_pattern_inside_case_with_type_arguments.dart.strong.transformed.expect
index c8f15c2b576..e40c296ffa5 100644
--- a/pkg/front_end/testcases/patterns/list_pattern_inside_case_with_type_arguments.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/list_pattern_inside_case_with_type_arguments.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::List<core::int> && #0#0{core::List<core::int>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(0){(core::int) → core::int} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(1){(core::int) → core::int}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<core::int> && #0#0{core::List<core::int>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(0){(core::int) → core::int} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(1){(core::int) → core::int}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/list_pattern_inside_case_with_type_arguments.dart.weak.expect b/pkg/front_end/testcases/patterns/list_pattern_inside_case_with_type_arguments.dart.weak.expect
index c8f15c2b576..e40c296ffa5 100644
--- a/pkg/front_end/testcases/patterns/list_pattern_inside_case_with_type_arguments.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/list_pattern_inside_case_with_type_arguments.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::List<core::int> && #0#0{core::List<core::int>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(0){(core::int) → core::int} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(1){(core::int) → core::int}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<core::int> && #0#0{core::List<core::int>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(0){(core::int) → core::int} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(1){(core::int) → core::int}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/list_pattern_inside_case_with_type_arguments.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/list_pattern_inside_case_with_type_arguments.dart.weak.modular.expect
index c8f15c2b576..e40c296ffa5 100644
--- a/pkg/front_end/testcases/patterns/list_pattern_inside_case_with_type_arguments.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/list_pattern_inside_case_with_type_arguments.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::List<core::int> && #0#0{core::List<core::int>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(0){(core::int) → core::int} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(1){(core::int) → core::int}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<core::int> && #0#0{core::List<core::int>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(0){(core::int) → core::int} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(1){(core::int) → core::int}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/list_pattern_inside_case_with_type_arguments.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/list_pattern_inside_case_with_type_arguments.dart.weak.transformed.expect
index c8f15c2b576..e40c296ffa5 100644
--- a/pkg/front_end/testcases/patterns/list_pattern_inside_case_with_type_arguments.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/list_pattern_inside_case_with_type_arguments.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::List<core::int> && #0#0{core::List<core::int>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(0){(core::int) → core::int} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(1){(core::int) → core::int}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<core::int> && #0#0{core::List<core::int>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(0){(core::int) → core::int} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::int>}.{core::List::[]}(1){(core::int) → core::int}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/list_pattern_inside_cast.dart.strong.expect b/pkg/front_end/testcases/patterns/list_pattern_inside_cast.dart.strong.expect
index 900afa4d9a1..1056b7dd9ca 100644
--- a/pkg/front_end/testcases/patterns/list_pattern_inside_cast.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/list_pattern_inside_cast.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in (#0#0 as{ForNonNullableByDefault} core::Object) is{ForNonNullableByDefault} core::List<core::Object?> && ((#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} core::List<core::Object?>).{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C1 =={core::num::==}{(core::Object) → core::bool} ((#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} core::List<core::Object?>).{core::List::[]}(0){(core::int) → core::Object?}) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in (#0#0 as{ForNonNullableByDefault} core::Object) is{ForNonNullableByDefault} core::List<core::Object?> && ((#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} core::List<core::Object?>).{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C1 =={core::num::==}{(core::Object) → core::bool} ((#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} core::List<core::Object?>).{core::List::[]}(0){(core::int) → core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/list_pattern_inside_cast.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/list_pattern_inside_cast.dart.strong.transformed.expect
index e041242d399..790352b4801 100644
--- a/pkg/front_end/testcases/patterns/list_pattern_inside_cast.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/list_pattern_inside_cast.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final core::Object #t1 = let dynamic #t2 = #0#0 in #t2 == null ?{core::Object} #t2 as{ForNonNullableByDefault} core::Object : #t2{core::Object} in (let dynamic #t3 = #0#0 in #t3 == null ?{core::Object} #t3 as{ForNonNullableByDefault} core::Object : #t3{core::Object}) is{ForNonNullableByDefault} core::List<core::Object?> && ((let dynamic #t4 = #0#0 in #t4 == null ?{core::Object} #t4 as{ForNonNullableByDefault} core::Object : #t4{core::Object}) as{ForNonNullableByDefault} core::List<core::Object?>).{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C1 =={core::num::==}{(core::Object) → core::bool} ((let dynamic #t5 = #0#0 in #t5 == null ?{core::Object} #t5 as{ForNonNullableByDefault} core::Object : #t5{core::Object}) as{ForNonNullableByDefault} core::List<core::Object?>).{core::List::[]}(0){(core::int) → core::Object?}) {
-      {
-        break #L1;
+    {
+      if(let final core::Object #t1 = let dynamic #t2 = #0#0 in #t2 == null ?{core::Object} #t2 as{ForNonNullableByDefault} core::Object : #t2{core::Object} in (let dynamic #t3 = #0#0 in #t3 == null ?{core::Object} #t3 as{ForNonNullableByDefault} core::Object : #t3{core::Object}) is{ForNonNullableByDefault} core::List<core::Object?> && ((let dynamic #t4 = #0#0 in #t4 == null ?{core::Object} #t4 as{ForNonNullableByDefault} core::Object : #t4{core::Object}) as{ForNonNullableByDefault} core::List<core::Object?>).{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C1 =={core::num::==}{(core::Object) → core::bool} ((let dynamic #t5 = #0#0 in #t5 == null ?{core::Object} #t5 as{ForNonNullableByDefault} core::Object : #t5{core::Object}) as{ForNonNullableByDefault} core::List<core::Object?>).{core::List::[]}(0){(core::int) → core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/list_pattern_inside_cast.dart.weak.expect b/pkg/front_end/testcases/patterns/list_pattern_inside_cast.dart.weak.expect
index 900afa4d9a1..1056b7dd9ca 100644
--- a/pkg/front_end/testcases/patterns/list_pattern_inside_cast.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/list_pattern_inside_cast.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in (#0#0 as{ForNonNullableByDefault} core::Object) is{ForNonNullableByDefault} core::List<core::Object?> && ((#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} core::List<core::Object?>).{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C1 =={core::num::==}{(core::Object) → core::bool} ((#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} core::List<core::Object?>).{core::List::[]}(0){(core::int) → core::Object?}) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in (#0#0 as{ForNonNullableByDefault} core::Object) is{ForNonNullableByDefault} core::List<core::Object?> && ((#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} core::List<core::Object?>).{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C1 =={core::num::==}{(core::Object) → core::bool} ((#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} core::List<core::Object?>).{core::List::[]}(0){(core::int) → core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/list_pattern_inside_cast.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/list_pattern_inside_cast.dart.weak.modular.expect
index 900afa4d9a1..1056b7dd9ca 100644
--- a/pkg/front_end/testcases/patterns/list_pattern_inside_cast.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/list_pattern_inside_cast.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in (#0#0 as{ForNonNullableByDefault} core::Object) is{ForNonNullableByDefault} core::List<core::Object?> && ((#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} core::List<core::Object?>).{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C1 =={core::num::==}{(core::Object) → core::bool} ((#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} core::List<core::Object?>).{core::List::[]}(0){(core::int) → core::Object?}) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in (#0#0 as{ForNonNullableByDefault} core::Object) is{ForNonNullableByDefault} core::List<core::Object?> && ((#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} core::List<core::Object?>).{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C1 =={core::num::==}{(core::Object) → core::bool} ((#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} core::List<core::Object?>).{core::List::[]}(0){(core::int) → core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/list_pattern_inside_cast.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/list_pattern_inside_cast.dart.weak.transformed.expect
index 1d20a653d19..8f4366f35d2 100644
--- a/pkg/front_end/testcases/patterns/list_pattern_inside_cast.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/list_pattern_inside_cast.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final core::Object #t1 = #0#0 in #0#0 is{ForNonNullableByDefault} core::List<core::Object?> && (#0#0 as{ForNonNullableByDefault} core::List<core::Object?>).{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0 as{ForNonNullableByDefault} core::List<core::Object?>).{core::List::[]}(0){(core::int) → core::Object?}) {
-      {
-        break #L1;
+    {
+      if(let final core::Object #t1 = #0#0 in #0#0 is{ForNonNullableByDefault} core::List<core::Object?> && (#0#0 as{ForNonNullableByDefault} core::List<core::Object?>).{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0 as{ForNonNullableByDefault} core::List<core::Object?>).{core::List::[]}(0){(core::int) → core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/list_pattern_inside_null_assert.dart.strong.expect b/pkg/front_end/testcases/patterns/list_pattern_inside_null_assert.dart.strong.expect
index 75e6558d99b..123718ac65d 100644
--- a/pkg/front_end/testcases/patterns/list_pattern_inside_null_assert.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/list_pattern_inside_null_assert.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::List<dynamic> && (#0#0! as{ForNonNullableByDefault} core::List<dynamic>).{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} core::List<dynamic>).{core::List::[]}(0){(core::int) → dynamic}) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::List<dynamic> && (#0#0! as{ForNonNullableByDefault} core::List<dynamic>).{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} core::List<dynamic>).{core::List::[]}(0){(core::int) → dynamic}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/list_pattern_inside_null_assert.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/list_pattern_inside_null_assert.dart.strong.transformed.expect
index 75e6558d99b..123718ac65d 100644
--- a/pkg/front_end/testcases/patterns/list_pattern_inside_null_assert.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/list_pattern_inside_null_assert.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::List<dynamic> && (#0#0! as{ForNonNullableByDefault} core::List<dynamic>).{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} core::List<dynamic>).{core::List::[]}(0){(core::int) → dynamic}) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::List<dynamic> && (#0#0! as{ForNonNullableByDefault} core::List<dynamic>).{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} core::List<dynamic>).{core::List::[]}(0){(core::int) → dynamic}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/list_pattern_inside_null_assert.dart.weak.expect b/pkg/front_end/testcases/patterns/list_pattern_inside_null_assert.dart.weak.expect
index 75e6558d99b..123718ac65d 100644
--- a/pkg/front_end/testcases/patterns/list_pattern_inside_null_assert.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/list_pattern_inside_null_assert.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::List<dynamic> && (#0#0! as{ForNonNullableByDefault} core::List<dynamic>).{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} core::List<dynamic>).{core::List::[]}(0){(core::int) → dynamic}) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::List<dynamic> && (#0#0! as{ForNonNullableByDefault} core::List<dynamic>).{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} core::List<dynamic>).{core::List::[]}(0){(core::int) → dynamic}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/list_pattern_inside_null_assert.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/list_pattern_inside_null_assert.dart.weak.modular.expect
index 75e6558d99b..123718ac65d 100644
--- a/pkg/front_end/testcases/patterns/list_pattern_inside_null_assert.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/list_pattern_inside_null_assert.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::List<dynamic> && (#0#0! as{ForNonNullableByDefault} core::List<dynamic>).{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} core::List<dynamic>).{core::List::[]}(0){(core::int) → dynamic}) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::List<dynamic> && (#0#0! as{ForNonNullableByDefault} core::List<dynamic>).{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} core::List<dynamic>).{core::List::[]}(0){(core::int) → dynamic}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/list_pattern_inside_null_assert.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/list_pattern_inside_null_assert.dart.weak.transformed.expect
index 75e6558d99b..123718ac65d 100644
--- a/pkg/front_end/testcases/patterns/list_pattern_inside_null_assert.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/list_pattern_inside_null_assert.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::List<dynamic> && (#0#0! as{ForNonNullableByDefault} core::List<dynamic>).{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} core::List<dynamic>).{core::List::[]}(0){(core::int) → dynamic}) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::List<dynamic> && (#0#0! as{ForNonNullableByDefault} core::List<dynamic>).{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} core::List<dynamic>).{core::List::[]}(0){(core::int) → dynamic}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/list_pattern_inside_null_check.dart.strong.expect b/pkg/front_end/testcases/patterns/list_pattern_inside_null_check.dart.strong.expect
index 7eb23d7f043..91dc9f6fa09 100644
--- a/pkg/front_end/testcases/patterns/list_pattern_inside_null_check.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/list_pattern_inside_null_check.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/list_pattern_inside_null_check.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/list_pattern_inside_null_check.dart.strong.transformed.expect
index 7eb23d7f043..91dc9f6fa09 100644
--- a/pkg/front_end/testcases/patterns/list_pattern_inside_null_check.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/list_pattern_inside_null_check.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/list_pattern_inside_null_check.dart.weak.expect b/pkg/front_end/testcases/patterns/list_pattern_inside_null_check.dart.weak.expect
index 7eb23d7f043..91dc9f6fa09 100644
--- a/pkg/front_end/testcases/patterns/list_pattern_inside_null_check.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/list_pattern_inside_null_check.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/list_pattern_inside_null_check.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/list_pattern_inside_null_check.dart.weak.modular.expect
index 7eb23d7f043..91dc9f6fa09 100644
--- a/pkg/front_end/testcases/patterns/list_pattern_inside_null_check.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/list_pattern_inside_null_check.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/list_pattern_inside_null_check.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/list_pattern_inside_null_check.dart.weak.transformed.expect
index 7eb23d7f043..91dc9f6fa09 100644
--- a/pkg/front_end/testcases/patterns/list_pattern_inside_null_check.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/list_pattern_inside_null_check.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/local_shadows_pattern.dart.strong.expect b/pkg/front_end/testcases/patterns/local_shadows_pattern.dart.strong.expect
index ffc3c6cc07a..55a0b8cd424 100644
--- a/pkg/front_end/testcases/patterns/local_shadows_pattern.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/local_shadows_pattern.dart.strong.expect
@@ -5,19 +5,23 @@ import "dart:core" as core;
 static method test1(dynamic x) → dynamic {
   #L1:
   {
-    core::int x;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = x = #0#0{core::int} in true)) {
-      {
+    {
+      core::int x;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = x = #0#0{core::int} in true)) {
         {
-          core::String x = "foo";
-          return x;
+          {
+            core::String x = "foo";
+            return x;
+          }
         }
       }
     }
-    else {
+    {
       {
-        return "bar";
+        {
+          return "bar";
+        }
       }
     }
   }
@@ -25,21 +29,25 @@ static method test1(dynamic x) → dynamic {
 static method test2(dynamic x) → dynamic {
   #L2:
   {
-    core::int x;
-    core::int x#1;
     final synthesized dynamic #0#0 = x;
     late final synthesized core::bool #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1;
     late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
     late final synthesized dynamic #0#7 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = x = #0#6{core::int} in true)) && (let final dynamic #t3 = #0#7 in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (let final dynamic #t4 = #0#6 in true) && (#0#7 is{ForNonNullableByDefault} core::int && (let final dynamic #t5 = x#1 = #0#7{core::int} in true))) {
-      {
-        core::String x = "foo";
-        return x;
+    {
+      lowered core::int x#case#0;
+      lowered core::int x#case#1;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = x#case#0 = #0#6{core::int} in true)) && (let final dynamic #t3 = #0#7 in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (let final dynamic #t4 = #0#6 in true) && (#0#7 is{ForNonNullableByDefault} core::int && (let final dynamic #t5 = x#case#1 = #0#7{core::int} in true))) {
+        {
+          core::String x = "foo";
+          return x;
+        }
       }
     }
-    else {
+    {
       {
-        return "bar";
+        {
+          return "bar";
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/local_shadows_pattern.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/local_shadows_pattern.dart.strong.transformed.expect
index a5c4cd2cd05..ff8206af03d 100644
--- a/pkg/front_end/testcases/patterns/local_shadows_pattern.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/local_shadows_pattern.dart.strong.transformed.expect
@@ -5,19 +5,23 @@ import "dart:core" as core;
 static method test1(dynamic x) → dynamic {
   #L1:
   {
-    core::int x;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = x = #0#0{core::int} in true)) {
-      {
+    {
+      core::int x;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = x = #0#0{core::int} in true)) {
         {
-          core::String x = "foo";
-          return x;
+          {
+            core::String x = "foo";
+            return x;
+          }
         }
       }
     }
-    else {
+    {
       {
-        return "bar";
+        {
+          return "bar";
+        }
       }
     }
   }
@@ -25,8 +29,6 @@ static method test1(dynamic x) → dynamic {
 static method test2(dynamic x) → dynamic {
   #L2:
   {
-    core::int x;
-    core::int x#1;
     final synthesized dynamic #0#0 = x;
     function ##0#4#initializer() → core::bool
       return #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1;
@@ -37,15 +39,21 @@ static method test2(dynamic x) → dynamic {
     function ##0#7#initializer() → dynamic
       return #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic};
     late final synthesized dynamic #0#7 = ##0#7#initializer(){() → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final core::int #t2 = x = #0#6{core::int} in true)) && (let final dynamic #t3 = #0#7 in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (let final dynamic #t4 = #0#6 in true) && (#0#7 is{ForNonNullableByDefault} core::int && (let final core::int #t5 = x#1 = #0#7{core::int} in true))) {
-      {
-        core::String x = "foo";
-        return x;
+    {
+      lowered core::int x#case#0;
+      lowered core::int x#case#1;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final core::int #t2 = x#case#0 = #0#6{core::int} in true)) && (let final dynamic #t3 = #0#7 in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (let final dynamic #t4 = #0#6 in true) && (#0#7 is{ForNonNullableByDefault} core::int && (let final core::int #t5 = x#case#1 = #0#7{core::int} in true))) {
+        {
+          core::String x = "foo";
+          return x;
+        }
       }
     }
-    else {
+    {
       {
-        return "bar";
+        {
+          return "bar";
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/local_shadows_pattern.dart.weak.expect b/pkg/front_end/testcases/patterns/local_shadows_pattern.dart.weak.expect
index ffc3c6cc07a..55a0b8cd424 100644
--- a/pkg/front_end/testcases/patterns/local_shadows_pattern.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/local_shadows_pattern.dart.weak.expect
@@ -5,19 +5,23 @@ import "dart:core" as core;
 static method test1(dynamic x) → dynamic {
   #L1:
   {
-    core::int x;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = x = #0#0{core::int} in true)) {
-      {
+    {
+      core::int x;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = x = #0#0{core::int} in true)) {
         {
-          core::String x = "foo";
-          return x;
+          {
+            core::String x = "foo";
+            return x;
+          }
         }
       }
     }
-    else {
+    {
       {
-        return "bar";
+        {
+          return "bar";
+        }
       }
     }
   }
@@ -25,21 +29,25 @@ static method test1(dynamic x) → dynamic {
 static method test2(dynamic x) → dynamic {
   #L2:
   {
-    core::int x;
-    core::int x#1;
     final synthesized dynamic #0#0 = x;
     late final synthesized core::bool #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1;
     late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
     late final synthesized dynamic #0#7 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = x = #0#6{core::int} in true)) && (let final dynamic #t3 = #0#7 in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (let final dynamic #t4 = #0#6 in true) && (#0#7 is{ForNonNullableByDefault} core::int && (let final dynamic #t5 = x#1 = #0#7{core::int} in true))) {
-      {
-        core::String x = "foo";
-        return x;
+    {
+      lowered core::int x#case#0;
+      lowered core::int x#case#1;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = x#case#0 = #0#6{core::int} in true)) && (let final dynamic #t3 = #0#7 in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (let final dynamic #t4 = #0#6 in true) && (#0#7 is{ForNonNullableByDefault} core::int && (let final dynamic #t5 = x#case#1 = #0#7{core::int} in true))) {
+        {
+          core::String x = "foo";
+          return x;
+        }
       }
     }
-    else {
+    {
       {
-        return "bar";
+        {
+          return "bar";
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/local_shadows_pattern.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/local_shadows_pattern.dart.weak.modular.expect
index ffc3c6cc07a..55a0b8cd424 100644
--- a/pkg/front_end/testcases/patterns/local_shadows_pattern.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/local_shadows_pattern.dart.weak.modular.expect
@@ -5,19 +5,23 @@ import "dart:core" as core;
 static method test1(dynamic x) → dynamic {
   #L1:
   {
-    core::int x;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = x = #0#0{core::int} in true)) {
-      {
+    {
+      core::int x;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = x = #0#0{core::int} in true)) {
         {
-          core::String x = "foo";
-          return x;
+          {
+            core::String x = "foo";
+            return x;
+          }
         }
       }
     }
-    else {
+    {
       {
-        return "bar";
+        {
+          return "bar";
+        }
       }
     }
   }
@@ -25,21 +29,25 @@ static method test1(dynamic x) → dynamic {
 static method test2(dynamic x) → dynamic {
   #L2:
   {
-    core::int x;
-    core::int x#1;
     final synthesized dynamic #0#0 = x;
     late final synthesized core::bool #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1;
     late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
     late final synthesized dynamic #0#7 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = x = #0#6{core::int} in true)) && (let final dynamic #t3 = #0#7 in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (let final dynamic #t4 = #0#6 in true) && (#0#7 is{ForNonNullableByDefault} core::int && (let final dynamic #t5 = x#1 = #0#7{core::int} in true))) {
-      {
-        core::String x = "foo";
-        return x;
+    {
+      lowered core::int x#case#0;
+      lowered core::int x#case#1;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = x#case#0 = #0#6{core::int} in true)) && (let final dynamic #t3 = #0#7 in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (let final dynamic #t4 = #0#6 in true) && (#0#7 is{ForNonNullableByDefault} core::int && (let final dynamic #t5 = x#case#1 = #0#7{core::int} in true))) {
+        {
+          core::String x = "foo";
+          return x;
+        }
       }
     }
-    else {
+    {
       {
-        return "bar";
+        {
+          return "bar";
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/local_shadows_pattern.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/local_shadows_pattern.dart.weak.transformed.expect
index a5c4cd2cd05..ff8206af03d 100644
--- a/pkg/front_end/testcases/patterns/local_shadows_pattern.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/local_shadows_pattern.dart.weak.transformed.expect
@@ -5,19 +5,23 @@ import "dart:core" as core;
 static method test1(dynamic x) → dynamic {
   #L1:
   {
-    core::int x;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = x = #0#0{core::int} in true)) {
-      {
+    {
+      core::int x;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = x = #0#0{core::int} in true)) {
         {
-          core::String x = "foo";
-          return x;
+          {
+            core::String x = "foo";
+            return x;
+          }
         }
       }
     }
-    else {
+    {
       {
-        return "bar";
+        {
+          return "bar";
+        }
       }
     }
   }
@@ -25,8 +29,6 @@ static method test1(dynamic x) → dynamic {
 static method test2(dynamic x) → dynamic {
   #L2:
   {
-    core::int x;
-    core::int x#1;
     final synthesized dynamic #0#0 = x;
     function ##0#4#initializer() → core::bool
       return #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1;
@@ -37,15 +39,21 @@ static method test2(dynamic x) → dynamic {
     function ##0#7#initializer() → dynamic
       return #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic};
     late final synthesized dynamic #0#7 = ##0#7#initializer(){() → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final core::int #t2 = x = #0#6{core::int} in true)) && (let final dynamic #t3 = #0#7 in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (let final dynamic #t4 = #0#6 in true) && (#0#7 is{ForNonNullableByDefault} core::int && (let final core::int #t5 = x#1 = #0#7{core::int} in true))) {
-      {
-        core::String x = "foo";
-        return x;
+    {
+      lowered core::int x#case#0;
+      lowered core::int x#case#1;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final core::int #t2 = x#case#0 = #0#6{core::int} in true)) && (let final dynamic #t3 = #0#7 in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (let final dynamic #t4 = #0#6 in true) && (#0#7 is{ForNonNullableByDefault} core::int && (let final core::int #t5 = x#case#1 = #0#7{core::int} in true))) {
+        {
+          core::String x = "foo";
+          return x;
+        }
       }
     }
-    else {
+    {
       {
-        return "bar";
+        {
+          return "bar";
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/logical_and_inside_logical_and_lhs.dart.strong.expect b/pkg/front_end/testcases/patterns/logical_and_inside_logical_and_lhs.dart.strong.expect
index dc79ab6c4f6..bd3436a72c4 100644
--- a/pkg/front_end/testcases/patterns/logical_and_inside_logical_and_lhs.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/logical_and_inside_logical_and_lhs.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int? && #0#0 is{ForNonNullableByDefault} core::double? && #0#0 is{ForNonNullableByDefault} core::Object?) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::int? && #0#0 is{ForNonNullableByDefault} core::double? && #0#0 is{ForNonNullableByDefault} core::Object?) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/logical_and_inside_logical_and_lhs.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/logical_and_inside_logical_and_lhs.dart.strong.transformed.expect
index dc79ab6c4f6..bd3436a72c4 100644
--- a/pkg/front_end/testcases/patterns/logical_and_inside_logical_and_lhs.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/logical_and_inside_logical_and_lhs.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int? && #0#0 is{ForNonNullableByDefault} core::double? && #0#0 is{ForNonNullableByDefault} core::Object?) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::int? && #0#0 is{ForNonNullableByDefault} core::double? && #0#0 is{ForNonNullableByDefault} core::Object?) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/logical_and_inside_logical_and_lhs.dart.weak.expect b/pkg/front_end/testcases/patterns/logical_and_inside_logical_and_lhs.dart.weak.expect
index dc79ab6c4f6..bd3436a72c4 100644
--- a/pkg/front_end/testcases/patterns/logical_and_inside_logical_and_lhs.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/logical_and_inside_logical_and_lhs.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int? && #0#0 is{ForNonNullableByDefault} core::double? && #0#0 is{ForNonNullableByDefault} core::Object?) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::int? && #0#0 is{ForNonNullableByDefault} core::double? && #0#0 is{ForNonNullableByDefault} core::Object?) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/logical_and_inside_logical_and_lhs.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/logical_and_inside_logical_and_lhs.dart.weak.modular.expect
index dc79ab6c4f6..bd3436a72c4 100644
--- a/pkg/front_end/testcases/patterns/logical_and_inside_logical_and_lhs.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/logical_and_inside_logical_and_lhs.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int? && #0#0 is{ForNonNullableByDefault} core::double? && #0#0 is{ForNonNullableByDefault} core::Object?) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::int? && #0#0 is{ForNonNullableByDefault} core::double? && #0#0 is{ForNonNullableByDefault} core::Object?) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/logical_and_inside_logical_and_lhs.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/logical_and_inside_logical_and_lhs.dart.weak.transformed.expect
index dc79ab6c4f6..bd3436a72c4 100644
--- a/pkg/front_end/testcases/patterns/logical_and_inside_logical_and_lhs.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/logical_and_inside_logical_and_lhs.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int? && #0#0 is{ForNonNullableByDefault} core::double? && #0#0 is{ForNonNullableByDefault} core::Object?) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::int? && #0#0 is{ForNonNullableByDefault} core::double? && #0#0 is{ForNonNullableByDefault} core::Object?) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/logical_and_inside_logical_or_lhs.dart.strong.expect b/pkg/front_end/testcases/patterns/logical_and_inside_logical_or_lhs.dart.strong.expect
index 30d101faba6..236453b25d2 100644
--- a/pkg/front_end/testcases/patterns/logical_and_inside_logical_or_lhs.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/logical_and_inside_logical_or_lhs.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int? && #0#0 is{ForNonNullableByDefault} core::double? || #0#0 is{ForNonNullableByDefault} core::Object?) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::int? && #0#0 is{ForNonNullableByDefault} core::double? || #0#0 is{ForNonNullableByDefault} core::Object?) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/logical_and_inside_logical_or_lhs.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/logical_and_inside_logical_or_lhs.dart.strong.transformed.expect
index 30d101faba6..236453b25d2 100644
--- a/pkg/front_end/testcases/patterns/logical_and_inside_logical_or_lhs.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/logical_and_inside_logical_or_lhs.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int? && #0#0 is{ForNonNullableByDefault} core::double? || #0#0 is{ForNonNullableByDefault} core::Object?) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::int? && #0#0 is{ForNonNullableByDefault} core::double? || #0#0 is{ForNonNullableByDefault} core::Object?) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/logical_and_inside_logical_or_lhs.dart.weak.expect b/pkg/front_end/testcases/patterns/logical_and_inside_logical_or_lhs.dart.weak.expect
index 30d101faba6..236453b25d2 100644
--- a/pkg/front_end/testcases/patterns/logical_and_inside_logical_or_lhs.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/logical_and_inside_logical_or_lhs.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int? && #0#0 is{ForNonNullableByDefault} core::double? || #0#0 is{ForNonNullableByDefault} core::Object?) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::int? && #0#0 is{ForNonNullableByDefault} core::double? || #0#0 is{ForNonNullableByDefault} core::Object?) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/logical_and_inside_logical_or_lhs.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/logical_and_inside_logical_or_lhs.dart.weak.modular.expect
index 30d101faba6..236453b25d2 100644
--- a/pkg/front_end/testcases/patterns/logical_and_inside_logical_or_lhs.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/logical_and_inside_logical_or_lhs.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int? && #0#0 is{ForNonNullableByDefault} core::double? || #0#0 is{ForNonNullableByDefault} core::Object?) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::int? && #0#0 is{ForNonNullableByDefault} core::double? || #0#0 is{ForNonNullableByDefault} core::Object?) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/logical_and_inside_logical_or_lhs.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/logical_and_inside_logical_or_lhs.dart.weak.transformed.expect
index 30d101faba6..236453b25d2 100644
--- a/pkg/front_end/testcases/patterns/logical_and_inside_logical_or_lhs.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/logical_and_inside_logical_or_lhs.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int? && #0#0 is{ForNonNullableByDefault} core::double? || #0#0 is{ForNonNullableByDefault} core::Object?) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::int? && #0#0 is{ForNonNullableByDefault} core::double? || #0#0 is{ForNonNullableByDefault} core::Object?) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/logical_and_inside_logical_or_rhs.dart.strong.expect b/pkg/front_end/testcases/patterns/logical_and_inside_logical_or_rhs.dart.strong.expect
index 6b9391d1d08..2101c91358e 100644
--- a/pkg/front_end/testcases/patterns/logical_and_inside_logical_or_rhs.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/logical_and_inside_logical_or_rhs.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int? || #0#0 is{ForNonNullableByDefault} core::double? && #0#0 is{ForNonNullableByDefault} core::Object?) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::int? || #0#0 is{ForNonNullableByDefault} core::double? && #0#0 is{ForNonNullableByDefault} core::Object?) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/logical_and_inside_logical_or_rhs.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/logical_and_inside_logical_or_rhs.dart.strong.transformed.expect
index 6b9391d1d08..2101c91358e 100644
--- a/pkg/front_end/testcases/patterns/logical_and_inside_logical_or_rhs.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/logical_and_inside_logical_or_rhs.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int? || #0#0 is{ForNonNullableByDefault} core::double? && #0#0 is{ForNonNullableByDefault} core::Object?) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::int? || #0#0 is{ForNonNullableByDefault} core::double? && #0#0 is{ForNonNullableByDefault} core::Object?) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/logical_and_inside_logical_or_rhs.dart.weak.expect b/pkg/front_end/testcases/patterns/logical_and_inside_logical_or_rhs.dart.weak.expect
index 6b9391d1d08..2101c91358e 100644
--- a/pkg/front_end/testcases/patterns/logical_and_inside_logical_or_rhs.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/logical_and_inside_logical_or_rhs.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int? || #0#0 is{ForNonNullableByDefault} core::double? && #0#0 is{ForNonNullableByDefault} core::Object?) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::int? || #0#0 is{ForNonNullableByDefault} core::double? && #0#0 is{ForNonNullableByDefault} core::Object?) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/logical_and_inside_logical_or_rhs.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/logical_and_inside_logical_or_rhs.dart.weak.modular.expect
index 6b9391d1d08..2101c91358e 100644
--- a/pkg/front_end/testcases/patterns/logical_and_inside_logical_or_rhs.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/logical_and_inside_logical_or_rhs.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int? || #0#0 is{ForNonNullableByDefault} core::double? && #0#0 is{ForNonNullableByDefault} core::Object?) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::int? || #0#0 is{ForNonNullableByDefault} core::double? && #0#0 is{ForNonNullableByDefault} core::Object?) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/logical_and_inside_logical_or_rhs.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/logical_and_inside_logical_or_rhs.dart.weak.transformed.expect
index 6b9391d1d08..2101c91358e 100644
--- a/pkg/front_end/testcases/patterns/logical_and_inside_logical_or_rhs.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/logical_and_inside_logical_or_rhs.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int? || #0#0 is{ForNonNullableByDefault} core::double? && #0#0 is{ForNonNullableByDefault} core::Object?) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::int? || #0#0 is{ForNonNullableByDefault} core::double? && #0#0 is{ForNonNullableByDefault} core::Object?) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/logical_or_inside_logical_or_lhs.dart.strong.expect b/pkg/front_end/testcases/patterns/logical_or_inside_logical_or_lhs.dart.strong.expect
index 68819f35b06..2fd72ac9809 100644
--- a/pkg/front_end/testcases/patterns/logical_or_inside_logical_or_lhs.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/logical_or_inside_logical_or_lhs.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int? || #0#0 is{ForNonNullableByDefault} core::double? || #0#0 is{ForNonNullableByDefault} core::Object?) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::int? || #0#0 is{ForNonNullableByDefault} core::double? || #0#0 is{ForNonNullableByDefault} core::Object?) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/logical_or_inside_logical_or_lhs.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/logical_or_inside_logical_or_lhs.dart.strong.transformed.expect
index 68819f35b06..2fd72ac9809 100644
--- a/pkg/front_end/testcases/patterns/logical_or_inside_logical_or_lhs.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/logical_or_inside_logical_or_lhs.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int? || #0#0 is{ForNonNullableByDefault} core::double? || #0#0 is{ForNonNullableByDefault} core::Object?) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::int? || #0#0 is{ForNonNullableByDefault} core::double? || #0#0 is{ForNonNullableByDefault} core::Object?) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/logical_or_inside_logical_or_lhs.dart.weak.expect b/pkg/front_end/testcases/patterns/logical_or_inside_logical_or_lhs.dart.weak.expect
index 68819f35b06..2fd72ac9809 100644
--- a/pkg/front_end/testcases/patterns/logical_or_inside_logical_or_lhs.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/logical_or_inside_logical_or_lhs.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int? || #0#0 is{ForNonNullableByDefault} core::double? || #0#0 is{ForNonNullableByDefault} core::Object?) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::int? || #0#0 is{ForNonNullableByDefault} core::double? || #0#0 is{ForNonNullableByDefault} core::Object?) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/logical_or_inside_logical_or_lhs.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/logical_or_inside_logical_or_lhs.dart.weak.modular.expect
index 68819f35b06..2fd72ac9809 100644
--- a/pkg/front_end/testcases/patterns/logical_or_inside_logical_or_lhs.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/logical_or_inside_logical_or_lhs.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int? || #0#0 is{ForNonNullableByDefault} core::double? || #0#0 is{ForNonNullableByDefault} core::Object?) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::int? || #0#0 is{ForNonNullableByDefault} core::double? || #0#0 is{ForNonNullableByDefault} core::Object?) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/logical_or_inside_logical_or_lhs.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/logical_or_inside_logical_or_lhs.dart.weak.transformed.expect
index 68819f35b06..2fd72ac9809 100644
--- a/pkg/front_end/testcases/patterns/logical_or_inside_logical_or_lhs.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/logical_or_inside_logical_or_lhs.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int? || #0#0 is{ForNonNullableByDefault} core::double? || #0#0 is{ForNonNullableByDefault} core::Object?) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::int? || #0#0 is{ForNonNullableByDefault} core::double? || #0#0 is{ForNonNullableByDefault} core::Object?) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/map_pattern_errors.dart.strong.expect b/pkg/front_end/testcases/patterns/map_pattern_errors.dart.strong.expect
index 64187bbb9dc..13259972d69 100644
--- a/pkg/front_end/testcases/patterns/map_pattern_errors.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/map_pattern_errors.dart.strong.expect
@@ -18,7 +18,9 @@ static method test(dynamic o) → dynamic {
   {
     final synthesized dynamic #0#0 = o;
     late final synthesized core::bool #0#4 = #0#0{core::Map<invalid-type, invalid-type>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1;
-    if(#0#0 is{ForNonNullableByDefault} core::Map<invalid-type, invalid-type> && #0#4 || #0#0 is{ForNonNullableByDefault} core::Map<invalid-type, invalid-type> && #0#4) {
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<invalid-type, invalid-type> && #0#4 || #0#0 is{ForNonNullableByDefault} core::Map<invalid-type, invalid-type> && #0#4) {
+      }
     }
   }
 }
diff --git a/pkg/front_end/testcases/patterns/map_pattern_errors.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/map_pattern_errors.dart.strong.transformed.expect
index 50592b24652..7d3294f5173 100644
--- a/pkg/front_end/testcases/patterns/map_pattern_errors.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/map_pattern_errors.dart.strong.transformed.expect
@@ -20,7 +20,9 @@ static method test(dynamic o) → dynamic {
     function ##0#4#initializer() → core::bool
       return #0#0{core::Map<invalid-type, invalid-type>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1;
     late final synthesized core::bool #0#4 = ##0#4#initializer(){() → core::bool};
-    if(#0#0 is{ForNonNullableByDefault} core::Map<invalid-type, invalid-type> && #0#4 || #0#0 is{ForNonNullableByDefault} core::Map<invalid-type, invalid-type> && #0#4) {
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<invalid-type, invalid-type> && #0#4 || #0#0 is{ForNonNullableByDefault} core::Map<invalid-type, invalid-type> && #0#4) {
+      }
     }
   }
 }
diff --git a/pkg/front_end/testcases/patterns/map_pattern_errors.dart.weak.expect b/pkg/front_end/testcases/patterns/map_pattern_errors.dart.weak.expect
index 64187bbb9dc..13259972d69 100644
--- a/pkg/front_end/testcases/patterns/map_pattern_errors.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/map_pattern_errors.dart.weak.expect
@@ -18,7 +18,9 @@ static method test(dynamic o) → dynamic {
   {
     final synthesized dynamic #0#0 = o;
     late final synthesized core::bool #0#4 = #0#0{core::Map<invalid-type, invalid-type>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1;
-    if(#0#0 is{ForNonNullableByDefault} core::Map<invalid-type, invalid-type> && #0#4 || #0#0 is{ForNonNullableByDefault} core::Map<invalid-type, invalid-type> && #0#4) {
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<invalid-type, invalid-type> && #0#4 || #0#0 is{ForNonNullableByDefault} core::Map<invalid-type, invalid-type> && #0#4) {
+      }
     }
   }
 }
diff --git a/pkg/front_end/testcases/patterns/map_pattern_errors.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/map_pattern_errors.dart.weak.modular.expect
index 64187bbb9dc..13259972d69 100644
--- a/pkg/front_end/testcases/patterns/map_pattern_errors.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/map_pattern_errors.dart.weak.modular.expect
@@ -18,7 +18,9 @@ static method test(dynamic o) → dynamic {
   {
     final synthesized dynamic #0#0 = o;
     late final synthesized core::bool #0#4 = #0#0{core::Map<invalid-type, invalid-type>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1;
-    if(#0#0 is{ForNonNullableByDefault} core::Map<invalid-type, invalid-type> && #0#4 || #0#0 is{ForNonNullableByDefault} core::Map<invalid-type, invalid-type> && #0#4) {
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<invalid-type, invalid-type> && #0#4 || #0#0 is{ForNonNullableByDefault} core::Map<invalid-type, invalid-type> && #0#4) {
+      }
     }
   }
 }
diff --git a/pkg/front_end/testcases/patterns/map_pattern_errors.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/map_pattern_errors.dart.weak.transformed.expect
index 50592b24652..7d3294f5173 100644
--- a/pkg/front_end/testcases/patterns/map_pattern_errors.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/map_pattern_errors.dart.weak.transformed.expect
@@ -20,7 +20,9 @@ static method test(dynamic o) → dynamic {
     function ##0#4#initializer() → core::bool
       return #0#0{core::Map<invalid-type, invalid-type>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1;
     late final synthesized core::bool #0#4 = ##0#4#initializer(){() → core::bool};
-    if(#0#0 is{ForNonNullableByDefault} core::Map<invalid-type, invalid-type> && #0#4 || #0#0 is{ForNonNullableByDefault} core::Map<invalid-type, invalid-type> && #0#4) {
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<invalid-type, invalid-type> && #0#4 || #0#0 is{ForNonNullableByDefault} core::Map<invalid-type, invalid-type> && #0#4) {
+      }
     }
   }
 }
diff --git a/pkg/front_end/testcases/patterns/map_pattern_inside_case.dart.strong.expect b/pkg/front_end/testcases/patterns/map_pattern_inside_case.dart.strong.expect
index b3fa75e928d..c8fd42151c2 100644
--- a/pkg/front_end/testcases/patterns/map_pattern_inside_case.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/map_pattern_inside_case.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C4){(core::Object?) → dynamic}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C4){(core::Object?) → dynamic}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/map_pattern_inside_case.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/map_pattern_inside_case.dart.strong.transformed.expect
index b3fa75e928d..c8fd42151c2 100644
--- a/pkg/front_end/testcases/patterns/map_pattern_inside_case.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/map_pattern_inside_case.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C4){(core::Object?) → dynamic}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C4){(core::Object?) → dynamic}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/map_pattern_inside_case.dart.weak.expect b/pkg/front_end/testcases/patterns/map_pattern_inside_case.dart.weak.expect
index b3fa75e928d..c8fd42151c2 100644
--- a/pkg/front_end/testcases/patterns/map_pattern_inside_case.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/map_pattern_inside_case.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C4){(core::Object?) → dynamic}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C4){(core::Object?) → dynamic}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/map_pattern_inside_case.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/map_pattern_inside_case.dart.weak.modular.expect
index b3fa75e928d..c8fd42151c2 100644
--- a/pkg/front_end/testcases/patterns/map_pattern_inside_case.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/map_pattern_inside_case.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C4){(core::Object?) → dynamic}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C4){(core::Object?) → dynamic}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/map_pattern_inside_case.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/map_pattern_inside_case.dart.weak.transformed.expect
index b3fa75e928d..c8fd42151c2 100644
--- a/pkg/front_end/testcases/patterns/map_pattern_inside_case.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/map_pattern_inside_case.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C4){(core::Object?) → dynamic}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C4){(core::Object?) → dynamic}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/map_pattern_inside_case_empty.dart.strong.expect b/pkg/front_end/testcases/patterns/map_pattern_inside_case_empty.dart.strong.expect
index 2e9a37d30fc..f021ad84c24 100644
--- a/pkg/front_end/testcases/patterns/map_pattern_inside_case_empty.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/map_pattern_inside_case_empty.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/map_pattern_inside_case_empty.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/map_pattern_inside_case_empty.dart.strong.transformed.expect
index 2e9a37d30fc..f021ad84c24 100644
--- a/pkg/front_end/testcases/patterns/map_pattern_inside_case_empty.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/map_pattern_inside_case_empty.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/map_pattern_inside_case_empty.dart.weak.expect b/pkg/front_end/testcases/patterns/map_pattern_inside_case_empty.dart.weak.expect
index 2e9a37d30fc..f021ad84c24 100644
--- a/pkg/front_end/testcases/patterns/map_pattern_inside_case_empty.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/map_pattern_inside_case_empty.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/map_pattern_inside_case_empty.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/map_pattern_inside_case_empty.dart.weak.modular.expect
index 2e9a37d30fc..f021ad84c24 100644
--- a/pkg/front_end/testcases/patterns/map_pattern_inside_case_empty.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/map_pattern_inside_case_empty.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/map_pattern_inside_case_empty.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/map_pattern_inside_case_empty.dart.weak.transformed.expect
index 2e9a37d30fc..f021ad84c24 100644
--- a/pkg/front_end/testcases/patterns/map_pattern_inside_case_empty.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/map_pattern_inside_case_empty.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/map_pattern_inside_case_with_type_arguments.dart.strong.expect b/pkg/front_end/testcases/patterns/map_pattern_inside_case_with_type_arguments.dart.strong.expect
index 70ce83a64be..125c9b4d09d 100644
--- a/pkg/front_end/testcases/patterns/map_pattern_inside_case_with_type_arguments.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/map_pattern_inside_case_with_type_arguments.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::Map<core::String, core::int> && #0#0{core::Map<core::String, core::int>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::Map<core::String, core::int>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#0{core::Map<core::String, core::int>}.{core::Map::[]}(#C2){(core::Object?) → core::int?} as{ForNonNullableByDefault} core::int && #0#0{core::Map<core::String, core::int>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::Map<core::String, core::int>}.{core::Map::[]}(#C4){(core::Object?) → core::int?} as{ForNonNullableByDefault} core::int) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<core::String, core::int> && #0#0{core::Map<core::String, core::int>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::Map<core::String, core::int>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#0{core::Map<core::String, core::int>}.{core::Map::[]}(#C2){(core::Object?) → core::int?} as{ForNonNullableByDefault} core::int && #0#0{core::Map<core::String, core::int>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::Map<core::String, core::int>}.{core::Map::[]}(#C4){(core::Object?) → core::int?} as{ForNonNullableByDefault} core::int) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/map_pattern_inside_case_with_type_arguments.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/map_pattern_inside_case_with_type_arguments.dart.strong.transformed.expect
index 457b07549bb..92b7442d0e6 100644
--- a/pkg/front_end/testcases/patterns/map_pattern_inside_case_with_type_arguments.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/map_pattern_inside_case_with_type_arguments.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::Map<core::String, core::int> && #0#0{core::Map<core::String, core::int>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::Map<core::String, core::int>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C3 =={core::num::==}{(core::Object) → core::bool} (let core::int? #t1 = #0#0{core::Map<core::String, core::int>}.{core::Map::[]}(#C2){(core::Object?) → core::int?} in #t1 == null ?{core::int} #t1 as{ForNonNullableByDefault} core::int : #t1{core::int}) && #0#0{core::Map<core::String, core::int>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} (let core::int? #t2 = #0#0{core::Map<core::String, core::int>}.{core::Map::[]}(#C4){(core::Object?) → core::int?} in #t2 == null ?{core::int} #t2 as{ForNonNullableByDefault} core::int : #t2{core::int})) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<core::String, core::int> && #0#0{core::Map<core::String, core::int>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::Map<core::String, core::int>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C3 =={core::num::==}{(core::Object) → core::bool} (let core::int? #t1 = #0#0{core::Map<core::String, core::int>}.{core::Map::[]}(#C2){(core::Object?) → core::int?} in #t1 == null ?{core::int} #t1 as{ForNonNullableByDefault} core::int : #t1{core::int}) && #0#0{core::Map<core::String, core::int>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} (let core::int? #t2 = #0#0{core::Map<core::String, core::int>}.{core::Map::[]}(#C4){(core::Object?) → core::int?} in #t2 == null ?{core::int} #t2 as{ForNonNullableByDefault} core::int : #t2{core::int})) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/map_pattern_inside_case_with_type_arguments.dart.weak.expect b/pkg/front_end/testcases/patterns/map_pattern_inside_case_with_type_arguments.dart.weak.expect
index 70ce83a64be..125c9b4d09d 100644
--- a/pkg/front_end/testcases/patterns/map_pattern_inside_case_with_type_arguments.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/map_pattern_inside_case_with_type_arguments.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::Map<core::String, core::int> && #0#0{core::Map<core::String, core::int>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::Map<core::String, core::int>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#0{core::Map<core::String, core::int>}.{core::Map::[]}(#C2){(core::Object?) → core::int?} as{ForNonNullableByDefault} core::int && #0#0{core::Map<core::String, core::int>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::Map<core::String, core::int>}.{core::Map::[]}(#C4){(core::Object?) → core::int?} as{ForNonNullableByDefault} core::int) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<core::String, core::int> && #0#0{core::Map<core::String, core::int>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::Map<core::String, core::int>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#0{core::Map<core::String, core::int>}.{core::Map::[]}(#C2){(core::Object?) → core::int?} as{ForNonNullableByDefault} core::int && #0#0{core::Map<core::String, core::int>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::Map<core::String, core::int>}.{core::Map::[]}(#C4){(core::Object?) → core::int?} as{ForNonNullableByDefault} core::int) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/map_pattern_inside_case_with_type_arguments.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/map_pattern_inside_case_with_type_arguments.dart.weak.modular.expect
index 70ce83a64be..125c9b4d09d 100644
--- a/pkg/front_end/testcases/patterns/map_pattern_inside_case_with_type_arguments.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/map_pattern_inside_case_with_type_arguments.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::Map<core::String, core::int> && #0#0{core::Map<core::String, core::int>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::Map<core::String, core::int>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#0{core::Map<core::String, core::int>}.{core::Map::[]}(#C2){(core::Object?) → core::int?} as{ForNonNullableByDefault} core::int && #0#0{core::Map<core::String, core::int>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::Map<core::String, core::int>}.{core::Map::[]}(#C4){(core::Object?) → core::int?} as{ForNonNullableByDefault} core::int) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<core::String, core::int> && #0#0{core::Map<core::String, core::int>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::Map<core::String, core::int>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#0{core::Map<core::String, core::int>}.{core::Map::[]}(#C2){(core::Object?) → core::int?} as{ForNonNullableByDefault} core::int && #0#0{core::Map<core::String, core::int>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::Map<core::String, core::int>}.{core::Map::[]}(#C4){(core::Object?) → core::int?} as{ForNonNullableByDefault} core::int) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/map_pattern_inside_case_with_type_arguments.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/map_pattern_inside_case_with_type_arguments.dart.weak.transformed.expect
index 0e22e5121bd..6f5264fc32a 100644
--- a/pkg/front_end/testcases/patterns/map_pattern_inside_case_with_type_arguments.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/map_pattern_inside_case_with_type_arguments.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::Map<core::String, core::int> && #0#0{core::Map<core::String, core::int>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::Map<core::String, core::int>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#0{core::Map<core::String, core::int>}.{core::Map::[]}(#C2){(core::Object?) → core::int?} && #0#0{core::Map<core::String, core::int>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::Map<core::String, core::int>}.{core::Map::[]}(#C4){(core::Object?) → core::int?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<core::String, core::int> && #0#0{core::Map<core::String, core::int>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::Map<core::String, core::int>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C3 =={core::num::==}{(core::Object) → core::bool} #0#0{core::Map<core::String, core::int>}.{core::Map::[]}(#C2){(core::Object?) → core::int?} && #0#0{core::Map<core::String, core::int>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::Map<core::String, core::int>}.{core::Map::[]}(#C4){(core::Object?) → core::int?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/map_pattern_inside_cast.dart.strong.expect b/pkg/front_end/testcases/patterns/map_pattern_inside_cast.dart.strong.expect
index d363bb5cc65..e72a1e939c2 100644
--- a/pkg/front_end/testcases/patterns/map_pattern_inside_cast.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/map_pattern_inside_cast.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in (#0#0 as{ForNonNullableByDefault} core::Object) is{ForNonNullableByDefault} core::Map<core::Object?, core::Object?> && ((#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} core::Map<core::Object?, core::Object?>).{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && ((#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} core::Map<core::Object?, core::Object?>).{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} ((#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} core::Map<core::Object?, core::Object?>).{core::Map::[]}(#C2){(core::Object?) → core::Object?}) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in (#0#0 as{ForNonNullableByDefault} core::Object) is{ForNonNullableByDefault} core::Map<core::Object?, core::Object?> && ((#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} core::Map<core::Object?, core::Object?>).{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && ((#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} core::Map<core::Object?, core::Object?>).{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} ((#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} core::Map<core::Object?, core::Object?>).{core::Map::[]}(#C2){(core::Object?) → core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/map_pattern_inside_cast.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/map_pattern_inside_cast.dart.strong.transformed.expect
index f4697ecc0f6..69264125368 100644
--- a/pkg/front_end/testcases/patterns/map_pattern_inside_cast.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/map_pattern_inside_cast.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final core::Object #t1 = let dynamic #t2 = #0#0 in #t2 == null ?{core::Object} #t2 as{ForNonNullableByDefault} core::Object : #t2{core::Object} in (let dynamic #t3 = #0#0 in #t3 == null ?{core::Object} #t3 as{ForNonNullableByDefault} core::Object : #t3{core::Object}) is{ForNonNullableByDefault} core::Map<core::Object?, core::Object?> && ((let dynamic #t4 = #0#0 in #t4 == null ?{core::Object} #t4 as{ForNonNullableByDefault} core::Object : #t4{core::Object}) as{ForNonNullableByDefault} core::Map<core::Object?, core::Object?>).{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && ((let dynamic #t5 = #0#0 in #t5 == null ?{core::Object} #t5 as{ForNonNullableByDefault} core::Object : #t5{core::Object}) as{ForNonNullableByDefault} core::Map<core::Object?, core::Object?>).{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} ((let dynamic #t6 = #0#0 in #t6 == null ?{core::Object} #t6 as{ForNonNullableByDefault} core::Object : #t6{core::Object}) as{ForNonNullableByDefault} core::Map<core::Object?, core::Object?>).{core::Map::[]}(#C2){(core::Object?) → core::Object?}) {
-      {
-        break #L1;
+    {
+      if(let final core::Object #t1 = let dynamic #t2 = #0#0 in #t2 == null ?{core::Object} #t2 as{ForNonNullableByDefault} core::Object : #t2{core::Object} in (let dynamic #t3 = #0#0 in #t3 == null ?{core::Object} #t3 as{ForNonNullableByDefault} core::Object : #t3{core::Object}) is{ForNonNullableByDefault} core::Map<core::Object?, core::Object?> && ((let dynamic #t4 = #0#0 in #t4 == null ?{core::Object} #t4 as{ForNonNullableByDefault} core::Object : #t4{core::Object}) as{ForNonNullableByDefault} core::Map<core::Object?, core::Object?>).{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && ((let dynamic #t5 = #0#0 in #t5 == null ?{core::Object} #t5 as{ForNonNullableByDefault} core::Object : #t5{core::Object}) as{ForNonNullableByDefault} core::Map<core::Object?, core::Object?>).{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} ((let dynamic #t6 = #0#0 in #t6 == null ?{core::Object} #t6 as{ForNonNullableByDefault} core::Object : #t6{core::Object}) as{ForNonNullableByDefault} core::Map<core::Object?, core::Object?>).{core::Map::[]}(#C2){(core::Object?) → core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/map_pattern_inside_cast.dart.weak.expect b/pkg/front_end/testcases/patterns/map_pattern_inside_cast.dart.weak.expect
index d363bb5cc65..e72a1e939c2 100644
--- a/pkg/front_end/testcases/patterns/map_pattern_inside_cast.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/map_pattern_inside_cast.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in (#0#0 as{ForNonNullableByDefault} core::Object) is{ForNonNullableByDefault} core::Map<core::Object?, core::Object?> && ((#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} core::Map<core::Object?, core::Object?>).{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && ((#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} core::Map<core::Object?, core::Object?>).{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} ((#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} core::Map<core::Object?, core::Object?>).{core::Map::[]}(#C2){(core::Object?) → core::Object?}) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in (#0#0 as{ForNonNullableByDefault} core::Object) is{ForNonNullableByDefault} core::Map<core::Object?, core::Object?> && ((#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} core::Map<core::Object?, core::Object?>).{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && ((#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} core::Map<core::Object?, core::Object?>).{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} ((#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} core::Map<core::Object?, core::Object?>).{core::Map::[]}(#C2){(core::Object?) → core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/map_pattern_inside_cast.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/map_pattern_inside_cast.dart.weak.modular.expect
index d363bb5cc65..e72a1e939c2 100644
--- a/pkg/front_end/testcases/patterns/map_pattern_inside_cast.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/map_pattern_inside_cast.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in (#0#0 as{ForNonNullableByDefault} core::Object) is{ForNonNullableByDefault} core::Map<core::Object?, core::Object?> && ((#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} core::Map<core::Object?, core::Object?>).{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && ((#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} core::Map<core::Object?, core::Object?>).{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} ((#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} core::Map<core::Object?, core::Object?>).{core::Map::[]}(#C2){(core::Object?) → core::Object?}) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in (#0#0 as{ForNonNullableByDefault} core::Object) is{ForNonNullableByDefault} core::Map<core::Object?, core::Object?> && ((#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} core::Map<core::Object?, core::Object?>).{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && ((#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} core::Map<core::Object?, core::Object?>).{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} ((#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} core::Map<core::Object?, core::Object?>).{core::Map::[]}(#C2){(core::Object?) → core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/map_pattern_inside_cast.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/map_pattern_inside_cast.dart.weak.transformed.expect
index c7f24ca9e05..4fc3a7d1074 100644
--- a/pkg/front_end/testcases/patterns/map_pattern_inside_cast.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/map_pattern_inside_cast.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final core::Object #t1 = #0#0 in #0#0 is{ForNonNullableByDefault} core::Map<core::Object?, core::Object?> && (#0#0 as{ForNonNullableByDefault} core::Map<core::Object?, core::Object?>).{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (#0#0 as{ForNonNullableByDefault} core::Map<core::Object?, core::Object?>).{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0 as{ForNonNullableByDefault} core::Map<core::Object?, core::Object?>).{core::Map::[]}(#C2){(core::Object?) → core::Object?}) {
-      {
-        break #L1;
+    {
+      if(let final core::Object #t1 = #0#0 in #0#0 is{ForNonNullableByDefault} core::Map<core::Object?, core::Object?> && (#0#0 as{ForNonNullableByDefault} core::Map<core::Object?, core::Object?>).{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (#0#0 as{ForNonNullableByDefault} core::Map<core::Object?, core::Object?>).{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0 as{ForNonNullableByDefault} core::Map<core::Object?, core::Object?>).{core::Map::[]}(#C2){(core::Object?) → core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/map_pattern_inside_null_assert.dart.strong.expect b/pkg/front_end/testcases/patterns/map_pattern_inside_null_assert.dart.strong.expect
index c3bc79528b8..0db3c5cd17a 100644
--- a/pkg/front_end/testcases/patterns/map_pattern_inside_null_assert.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/map_pattern_inside_null_assert.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#0! as{ForNonNullableByDefault} core::Map<dynamic, dynamic>).{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (#0#0! as{ForNonNullableByDefault} core::Map<dynamic, dynamic>).{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} core::Map<dynamic, dynamic>).{core::Map::[]}(#C2){(core::Object?) → dynamic}) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#0! as{ForNonNullableByDefault} core::Map<dynamic, dynamic>).{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (#0#0! as{ForNonNullableByDefault} core::Map<dynamic, dynamic>).{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} core::Map<dynamic, dynamic>).{core::Map::[]}(#C2){(core::Object?) → dynamic}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/map_pattern_inside_null_assert.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/map_pattern_inside_null_assert.dart.strong.transformed.expect
index c3bc79528b8..0db3c5cd17a 100644
--- a/pkg/front_end/testcases/patterns/map_pattern_inside_null_assert.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/map_pattern_inside_null_assert.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#0! as{ForNonNullableByDefault} core::Map<dynamic, dynamic>).{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (#0#0! as{ForNonNullableByDefault} core::Map<dynamic, dynamic>).{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} core::Map<dynamic, dynamic>).{core::Map::[]}(#C2){(core::Object?) → dynamic}) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#0! as{ForNonNullableByDefault} core::Map<dynamic, dynamic>).{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (#0#0! as{ForNonNullableByDefault} core::Map<dynamic, dynamic>).{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} core::Map<dynamic, dynamic>).{core::Map::[]}(#C2){(core::Object?) → dynamic}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/map_pattern_inside_null_assert.dart.weak.expect b/pkg/front_end/testcases/patterns/map_pattern_inside_null_assert.dart.weak.expect
index c3bc79528b8..0db3c5cd17a 100644
--- a/pkg/front_end/testcases/patterns/map_pattern_inside_null_assert.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/map_pattern_inside_null_assert.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#0! as{ForNonNullableByDefault} core::Map<dynamic, dynamic>).{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (#0#0! as{ForNonNullableByDefault} core::Map<dynamic, dynamic>).{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} core::Map<dynamic, dynamic>).{core::Map::[]}(#C2){(core::Object?) → dynamic}) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#0! as{ForNonNullableByDefault} core::Map<dynamic, dynamic>).{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (#0#0! as{ForNonNullableByDefault} core::Map<dynamic, dynamic>).{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} core::Map<dynamic, dynamic>).{core::Map::[]}(#C2){(core::Object?) → dynamic}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/map_pattern_inside_null_assert.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/map_pattern_inside_null_assert.dart.weak.modular.expect
index c3bc79528b8..0db3c5cd17a 100644
--- a/pkg/front_end/testcases/patterns/map_pattern_inside_null_assert.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/map_pattern_inside_null_assert.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#0! as{ForNonNullableByDefault} core::Map<dynamic, dynamic>).{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (#0#0! as{ForNonNullableByDefault} core::Map<dynamic, dynamic>).{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} core::Map<dynamic, dynamic>).{core::Map::[]}(#C2){(core::Object?) → dynamic}) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#0! as{ForNonNullableByDefault} core::Map<dynamic, dynamic>).{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (#0#0! as{ForNonNullableByDefault} core::Map<dynamic, dynamic>).{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} core::Map<dynamic, dynamic>).{core::Map::[]}(#C2){(core::Object?) → dynamic}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/map_pattern_inside_null_assert.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/map_pattern_inside_null_assert.dart.weak.transformed.expect
index c3bc79528b8..0db3c5cd17a 100644
--- a/pkg/front_end/testcases/patterns/map_pattern_inside_null_assert.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/map_pattern_inside_null_assert.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#0! as{ForNonNullableByDefault} core::Map<dynamic, dynamic>).{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (#0#0! as{ForNonNullableByDefault} core::Map<dynamic, dynamic>).{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} core::Map<dynamic, dynamic>).{core::Map::[]}(#C2){(core::Object?) → dynamic}) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#0! as{ForNonNullableByDefault} core::Map<dynamic, dynamic>).{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (#0#0! as{ForNonNullableByDefault} core::Map<dynamic, dynamic>).{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} core::Map<dynamic, dynamic>).{core::Map::[]}(#C2){(core::Object?) → dynamic}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/map_pattern_inside_null_check.dart.strong.expect b/pkg/front_end/testcases/patterns/map_pattern_inside_null_check.dart.strong.expect
index cd24a842cd1..782922fc45c 100644
--- a/pkg/front_end/testcases/patterns/map_pattern_inside_null_check.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/map_pattern_inside_null_check.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic} : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic} : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/map_pattern_inside_null_check.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/map_pattern_inside_null_check.dart.strong.transformed.expect
index cd24a842cd1..782922fc45c 100644
--- a/pkg/front_end/testcases/patterns/map_pattern_inside_null_check.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/map_pattern_inside_null_check.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic} : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic} : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/map_pattern_inside_null_check.dart.weak.expect b/pkg/front_end/testcases/patterns/map_pattern_inside_null_check.dart.weak.expect
index cd24a842cd1..782922fc45c 100644
--- a/pkg/front_end/testcases/patterns/map_pattern_inside_null_check.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/map_pattern_inside_null_check.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic} : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic} : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/map_pattern_inside_null_check.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/map_pattern_inside_null_check.dart.weak.modular.expect
index cd24a842cd1..782922fc45c 100644
--- a/pkg/front_end/testcases/patterns/map_pattern_inside_null_check.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/map_pattern_inside_null_check.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic} : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic} : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/map_pattern_inside_null_check.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/map_pattern_inside_null_check.dart.weak.transformed.expect
index cd24a842cd1..782922fc45c 100644
--- a/pkg/front_end/testcases/patterns/map_pattern_inside_null_check.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/map_pattern_inside_null_check.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic} : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic} : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/multiple_targets.dart.strong.expect b/pkg/front_end/testcases/patterns/multiple_targets.dart.strong.expect
index e7477e6be0e..a8d5c951574 100644
--- a/pkg/front_end/testcases/patterns/multiple_targets.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/multiple_targets.dart.strong.expect
@@ -40,65 +40,76 @@ static method test(dynamic o) → dynamic {
     synthesized core::bool #0#24#isSet = false;
     synthesized dynamic #0#34;
     synthesized core::bool #0#34#isSet = false;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t1 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t2 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool}) && #C2 =={core::num::==}{(core::Object) → core::bool} (#0#6#isSet ?{dynamic} #0#6{dynamic} : let final dynamic #t3 = #0#6#isSet = true in #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic}) && #C3 =={core::num::==}{(core::Object) → core::bool} (#0#9#isSet ?{dynamic} #0#9{dynamic} : let final dynamic #t4 = #0#9#isSet = true in #0#9 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic})) {
-      {
-        return 0;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t1 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t2 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool}) && #C2 =={core::num::==}{(core::Object) → core::bool} (#0#6#isSet ?{dynamic} #0#6{dynamic} : let final dynamic #t3 = #0#6#isSet = true in #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic}) && #C3 =={core::num::==}{(core::Object) → core::bool} (#0#9#isSet ?{dynamic} #0#9{dynamic} : let final dynamic #t4 = #0#9#isSet = true in #0#9 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic})) {
+        {
+          return 0;
+        }
       }
     }
-    else
+    {
       if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t5 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t6 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool}) && #C3 =={core::num::==}{(core::Object) → core::bool} (#0#6#isSet ?{dynamic} #0#6{dynamic} : let final dynamic #t7 = #0#6#isSet = true in #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic}) && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#9#isSet ?{dynamic} #0#9{dynamic} : let final dynamic #t8 = #0#9#isSet = true in #0#9 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic})) {
         {
           return 1;
         }
       }
-      else
-        if(#0#0 is{ForNonNullableByDefault} core::List<core::int> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t9 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t10 = #0#2#isSet = true in #0#2 = #0#0{core::List<core::int>}.{core::List::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool}) && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#6#isSet ?{core::int} #0#6{core::int} : let final dynamic #t11 = #0#6#isSet = true in #0#6 = #0#0{core::List<core::int>}.{core::List::[]}(0){(core::int) → core::int}) && #C4 =={core::num::==}{(core::Object) → core::bool} (#0#9#isSet ?{core::int} #0#9{core::int} : let final dynamic #t12 = #0#9#isSet = true in #0#9 = #0#0{core::List<core::int>}.{core::List::[]}(1){(core::int) → core::int})) {
-          {
-            return 2;
-          }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<core::int> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t9 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t10 = #0#2#isSet = true in #0#2 = #0#0{core::List<core::int>}.{core::List::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool}) && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#6#isSet ?{core::int} #0#6{core::int} : let final dynamic #t11 = #0#6#isSet = true in #0#6 = #0#0{core::List<core::int>}.{core::List::[]}(0){(core::int) → core::int}) && #C4 =={core::num::==}{(core::Object) → core::bool} (#0#9#isSet ?{core::int} #0#9{core::int} : let final dynamic #t12 = #0#9#isSet = true in #0#9 = #0#0{core::List<core::int>}.{core::List::[]}(1){(core::int) → core::int})) {
+        {
+          return 2;
         }
-        else
-          if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#20#isSet ?{core::bool} #0#20{core::bool} : let final dynamic #t13 = #0#20#isSet = true in #0#20 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t14 = #0#2#isSet = true in #0#2 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C3){(core::num) → core::bool}) && (#0#23#isSet ?{core::bool} #0#23{core::bool} : let final dynamic #t15 = #0#23#isSet = true in #0#23 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C5){(core::Object?) → core::bool}) && #C6 =={core::num::==}{(core::Object) → core::bool} (#0#24#isSet ?{dynamic} #0#24{dynamic} : let final dynamic #t16 = #0#24#isSet = true in #0#24 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C5){(core::Object?) → dynamic})) {
-            {
-              return 3;
-            }
-          }
-          else
-            if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#20#isSet ?{core::bool} #0#20{core::bool} : let final dynamic #t17 = #0#20#isSet = true in #0#20 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t18 = #0#2#isSet = true in #0#2 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C3){(core::num) → core::bool}) && (#0#23#isSet ?{core::bool} #0#23{core::bool} : let final dynamic #t19 = #0#23#isSet = true in #0#23 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C5){(core::Object?) → core::bool}) && #C7 =={core::num::==}{(core::Object) → core::bool} (#0#24#isSet ?{dynamic} #0#24{dynamic} : let final dynamic #t20 = #0#24#isSet = true in #0#24 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C5){(core::Object?) → dynamic})) {
-              {
-                return 4;
-              }
-            }
-            else
-              if(#0#0 is{ForNonNullableByDefault} core::Map<core::String, core::int> && (#0#20#isSet ?{core::bool} #0#20{core::bool} : let final dynamic #t21 = #0#20#isSet = true in #0#20 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t22 = #0#2#isSet = true in #0#2 = #0#0{core::Map<core::String, core::int>}.{core::Map::length}{core::int}).{core::num::>=}(#C3){(core::num) → core::bool}) && (#0#23#isSet ?{core::bool} #0#23{core::bool} : let final dynamic #t23 = #0#23#isSet = true in #0#23 = #0#0{core::Map<core::String, core::int>}.{core::Map::containsKey}(#C5){(core::Object?) → core::bool}) && #C8 =={core::num::==}{(core::Object) → core::bool} (#0#24#isSet ?{core::int?} #0#24{core::int?} : let final dynamic #t24 = #0#24#isSet = true in #0#24 = #0#0{core::Map<core::String, core::int>}.{core::Map::[]}(#C5){(core::Object?) → core::int?}) as{ForNonNullableByDefault} core::int) {
-                {
-                  return 5;
-                }
-              }
-              else
-                if(#0#0 is{ForNonNullableByDefault} self::A<dynamic> && #C6 =={core::num::==}{(core::Object) → core::bool} (#0#34#isSet ?{dynamic} #0#34{dynamic} : let final dynamic #t25 = #0#34#isSet = true in #0#34 = #0#0{self::A<dynamic>}.{self::A::foo}{dynamic})) {
-                  {
-                    return 6;
-                  }
-                }
-                else
-                  if(#0#0 is{ForNonNullableByDefault} self::A<core::int> && #C7 =={core::num::==}{(core::Object) → core::bool} (#0#34#isSet ?{core::int} #0#34{core::int} : let final dynamic #t26 = #0#34#isSet = true in #0#34 = #0#0{self::A<core::int>}.{self::A::foo}{core::int})) {
-                    {
-                      return 7;
-                    }
-                  }
-                  else
-                    if(#0#0 is{ForNonNullableByDefault} self::B && #C8 =={core::num::==}{(core::Object) → core::bool} (#0#34#isSet ?{core::num} #0#34{core::num} : let final dynamic #t27 = #0#34#isSet = true in #0#34 = #0#0{self::B}.{self::B::foo}{core::num})) {
-                      {
-                        return 8;
-                      }
-                    }
-                    else
-                      if(#0#0 is{ForNonNullableByDefault} ({foo: core::Object?}) && #C9 =={core::num::==}{(core::Object) → core::bool} (#0#34#isSet ?{core::Object?} #0#34{core::Object?} : let final dynamic #t28 = #0#34#isSet = true in #0#34 = #0#0{({foo: core::Object?})}.foo{core::Object?})) {
-                        {
-                          return 9;
-                        }
-                      }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#20#isSet ?{core::bool} #0#20{core::bool} : let final dynamic #t13 = #0#20#isSet = true in #0#20 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t14 = #0#2#isSet = true in #0#2 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C3){(core::num) → core::bool}) && (#0#23#isSet ?{core::bool} #0#23{core::bool} : let final dynamic #t15 = #0#23#isSet = true in #0#23 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C5){(core::Object?) → core::bool}) && #C6 =={core::num::==}{(core::Object) → core::bool} (#0#24#isSet ?{dynamic} #0#24{dynamic} : let final dynamic #t16 = #0#24#isSet = true in #0#24 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C5){(core::Object?) → dynamic})) {
+        {
+          return 3;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#20#isSet ?{core::bool} #0#20{core::bool} : let final dynamic #t17 = #0#20#isSet = true in #0#20 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t18 = #0#2#isSet = true in #0#2 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C3){(core::num) → core::bool}) && (#0#23#isSet ?{core::bool} #0#23{core::bool} : let final dynamic #t19 = #0#23#isSet = true in #0#23 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C5){(core::Object?) → core::bool}) && #C7 =={core::num::==}{(core::Object) → core::bool} (#0#24#isSet ?{dynamic} #0#24{dynamic} : let final dynamic #t20 = #0#24#isSet = true in #0#24 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C5){(core::Object?) → dynamic})) {
+        {
+          return 4;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<core::String, core::int> && (#0#20#isSet ?{core::bool} #0#20{core::bool} : let final dynamic #t21 = #0#20#isSet = true in #0#20 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t22 = #0#2#isSet = true in #0#2 = #0#0{core::Map<core::String, core::int>}.{core::Map::length}{core::int}).{core::num::>=}(#C3){(core::num) → core::bool}) && (#0#23#isSet ?{core::bool} #0#23{core::bool} : let final dynamic #t23 = #0#23#isSet = true in #0#23 = #0#0{core::Map<core::String, core::int>}.{core::Map::containsKey}(#C5){(core::Object?) → core::bool}) && #C8 =={core::num::==}{(core::Object) → core::bool} (#0#24#isSet ?{core::int?} #0#24{core::int?} : let final dynamic #t24 = #0#24#isSet = true in #0#24 = #0#0{core::Map<core::String, core::int>}.{core::Map::[]}(#C5){(core::Object?) → core::int?}) as{ForNonNullableByDefault} core::int) {
+        {
+          return 5;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::A<dynamic> && #C6 =={core::num::==}{(core::Object) → core::bool} (#0#34#isSet ?{dynamic} #0#34{dynamic} : let final dynamic #t25 = #0#34#isSet = true in #0#34 = #0#0{self::A<dynamic>}.{self::A::foo}{dynamic})) {
+        {
+          return 6;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::A<core::int> && #C7 =={core::num::==}{(core::Object) → core::bool} (#0#34#isSet ?{core::int} #0#34{core::int} : let final dynamic #t26 = #0#34#isSet = true in #0#34 = #0#0{self::A<core::int>}.{self::A::foo}{core::int})) {
+        {
+          return 7;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::B && #C8 =={core::num::==}{(core::Object) → core::bool} (#0#34#isSet ?{core::num} #0#34{core::num} : let final dynamic #t27 = #0#34#isSet = true in #0#34 = #0#0{self::B}.{self::B::foo}{core::num})) {
+        {
+          return 8;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} ({foo: core::Object?}) && #C9 =={core::num::==}{(core::Object) → core::bool} (#0#34#isSet ?{core::Object?} #0#34{core::Object?} : let final dynamic #t28 = #0#34#isSet = true in #0#34 = #0#0{({foo: core::Object?})}.foo{core::Object?})) {
+        {
+          return 9;
+        }
+      }
+    }
   }
   return 1.{core::int::unary-}(){() → core::int};
 }
diff --git a/pkg/front_end/testcases/patterns/multiple_targets.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/multiple_targets.dart.strong.transformed.expect
index 044491f7d8c..1b9e73b0e02 100644
--- a/pkg/front_end/testcases/patterns/multiple_targets.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/multiple_targets.dart.strong.transformed.expect
@@ -40,65 +40,76 @@ static method test(dynamic o) → dynamic {
     synthesized core::bool #0#24#isSet = false;
     synthesized dynamic #0#34;
     synthesized core::bool #0#34#isSet = false;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t1 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t2 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool}) && #C2 =={core::num::==}{(core::Object) → core::bool} (#0#6#isSet ?{dynamic} #0#6{dynamic} : let final core::bool* #t3 = #0#6#isSet = true in #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic}) && #C3 =={core::num::==}{(core::Object) → core::bool} (#0#9#isSet ?{dynamic} #0#9{dynamic} : let final core::bool* #t4 = #0#9#isSet = true in #0#9 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic})) {
-      {
-        return 0;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t1 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t2 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool}) && #C2 =={core::num::==}{(core::Object) → core::bool} (#0#6#isSet ?{dynamic} #0#6{dynamic} : let final core::bool* #t3 = #0#6#isSet = true in #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic}) && #C3 =={core::num::==}{(core::Object) → core::bool} (#0#9#isSet ?{dynamic} #0#9{dynamic} : let final core::bool* #t4 = #0#9#isSet = true in #0#9 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic})) {
+        {
+          return 0;
+        }
       }
     }
-    else
+    {
       if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t5 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t6 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool}) && #C3 =={core::num::==}{(core::Object) → core::bool} (#0#6#isSet ?{dynamic} #0#6{dynamic} : let final core::bool* #t7 = #0#6#isSet = true in #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic}) && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#9#isSet ?{dynamic} #0#9{dynamic} : let final core::bool* #t8 = #0#9#isSet = true in #0#9 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic})) {
         {
           return 1;
         }
       }
-      else
-        if(#0#0 is{ForNonNullableByDefault} core::List<core::int> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t9 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t10 = #0#2#isSet = true in #0#2 = #0#0{core::List<core::int>}.{core::List::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool}) && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#6#isSet ?{core::int} #0#6{core::int} : let final core::bool* #t11 = #0#6#isSet = true in #0#6 = #0#0{core::List<core::int>}.{core::List::[]}(0){(core::int) → core::int}) && #C4 =={core::num::==}{(core::Object) → core::bool} (#0#9#isSet ?{core::int} #0#9{core::int} : let final core::bool* #t12 = #0#9#isSet = true in #0#9 = #0#0{core::List<core::int>}.{core::List::[]}(1){(core::int) → core::int})) {
-          {
-            return 2;
-          }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<core::int> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t9 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t10 = #0#2#isSet = true in #0#2 = #0#0{core::List<core::int>}.{core::List::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool}) && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#6#isSet ?{core::int} #0#6{core::int} : let final core::bool* #t11 = #0#6#isSet = true in #0#6 = #0#0{core::List<core::int>}.{core::List::[]}(0){(core::int) → core::int}) && #C4 =={core::num::==}{(core::Object) → core::bool} (#0#9#isSet ?{core::int} #0#9{core::int} : let final core::bool* #t12 = #0#9#isSet = true in #0#9 = #0#0{core::List<core::int>}.{core::List::[]}(1){(core::int) → core::int})) {
+        {
+          return 2;
         }
-        else
-          if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#20#isSet ?{core::bool} #0#20{core::bool} : let final core::bool* #t13 = #0#20#isSet = true in #0#20 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t14 = #0#2#isSet = true in #0#2 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C3){(core::num) → core::bool}) && (#0#23#isSet ?{core::bool} #0#23{core::bool} : let final core::bool* #t15 = #0#23#isSet = true in #0#23 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C5){(core::Object?) → core::bool}) && #C6 =={core::num::==}{(core::Object) → core::bool} (#0#24#isSet ?{dynamic} #0#24{dynamic} : let final core::bool* #t16 = #0#24#isSet = true in #0#24 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C5){(core::Object?) → dynamic})) {
-            {
-              return 3;
-            }
-          }
-          else
-            if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#20#isSet ?{core::bool} #0#20{core::bool} : let final core::bool* #t17 = #0#20#isSet = true in #0#20 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t18 = #0#2#isSet = true in #0#2 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C3){(core::num) → core::bool}) && (#0#23#isSet ?{core::bool} #0#23{core::bool} : let final core::bool* #t19 = #0#23#isSet = true in #0#23 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C5){(core::Object?) → core::bool}) && #C7 =={core::num::==}{(core::Object) → core::bool} (#0#24#isSet ?{dynamic} #0#24{dynamic} : let final core::bool* #t20 = #0#24#isSet = true in #0#24 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C5){(core::Object?) → dynamic})) {
-              {
-                return 4;
-              }
-            }
-            else
-              if(#0#0 is{ForNonNullableByDefault} core::Map<core::String, core::int> && (#0#20#isSet ?{core::bool} #0#20{core::bool} : let final core::bool* #t21 = #0#20#isSet = true in #0#20 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t22 = #0#2#isSet = true in #0#2 = #0#0{core::Map<core::String, core::int>}.{core::Map::length}{core::int}).{core::num::>=}(#C3){(core::num) → core::bool}) && (#0#23#isSet ?{core::bool} #0#23{core::bool} : let final core::bool* #t23 = #0#23#isSet = true in #0#23 = #0#0{core::Map<core::String, core::int>}.{core::Map::containsKey}(#C5){(core::Object?) → core::bool}) && #C8 =={core::num::==}{(core::Object) → core::bool} (let core::int? #t24 = #0#24#isSet ?{core::int?} #0#24{core::int?} : let final core::bool* #t25 = #0#24#isSet = true in #0#24 = #0#0{core::Map<core::String, core::int>}.{core::Map::[]}(#C5){(core::Object?) → core::int?} in #t24 == null ?{core::int} #t24 as{ForNonNullableByDefault} core::int : #t24{core::int})) {
-                {
-                  return 5;
-                }
-              }
-              else
-                if(#0#0 is{ForNonNullableByDefault} self::A<dynamic> && #C6 =={core::num::==}{(core::Object) → core::bool} (#0#34#isSet ?{dynamic} #0#34{dynamic} : let final core::bool* #t26 = #0#34#isSet = true in #0#34 = #0#0{self::A<dynamic>}.{self::A::foo}{dynamic})) {
-                  {
-                    return 6;
-                  }
-                }
-                else
-                  if(#0#0 is{ForNonNullableByDefault} self::A<core::int> && #C7 =={core::num::==}{(core::Object) → core::bool} (#0#34#isSet ?{core::int} #0#34{core::int} : let final core::bool* #t27 = #0#34#isSet = true in #0#34 = #0#0{self::A<core::int>}.{self::A::foo}{core::int})) {
-                    {
-                      return 7;
-                    }
-                  }
-                  else
-                    if(#0#0 is{ForNonNullableByDefault} self::B && #C8 =={core::num::==}{(core::Object) → core::bool} (#0#34#isSet ?{core::num} #0#34{core::num} : let final core::bool* #t28 = #0#34#isSet = true in #0#34 = #0#0{self::B}.{self::B::foo}{core::num})) {
-                      {
-                        return 8;
-                      }
-                    }
-                    else
-                      if(#0#0 is{ForNonNullableByDefault} ({foo: core::Object?}) && #C9 =={core::num::==}{(core::Object) → core::bool} (#0#34#isSet ?{core::Object?} #0#34{core::Object?} : let final core::bool* #t29 = #0#34#isSet = true in #0#34 = #0#0{({foo: core::Object?})}.foo{core::Object?})) {
-                        {
-                          return 9;
-                        }
-                      }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#20#isSet ?{core::bool} #0#20{core::bool} : let final core::bool* #t13 = #0#20#isSet = true in #0#20 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t14 = #0#2#isSet = true in #0#2 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C3){(core::num) → core::bool}) && (#0#23#isSet ?{core::bool} #0#23{core::bool} : let final core::bool* #t15 = #0#23#isSet = true in #0#23 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C5){(core::Object?) → core::bool}) && #C6 =={core::num::==}{(core::Object) → core::bool} (#0#24#isSet ?{dynamic} #0#24{dynamic} : let final core::bool* #t16 = #0#24#isSet = true in #0#24 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C5){(core::Object?) → dynamic})) {
+        {
+          return 3;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#20#isSet ?{core::bool} #0#20{core::bool} : let final core::bool* #t17 = #0#20#isSet = true in #0#20 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t18 = #0#2#isSet = true in #0#2 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C3){(core::num) → core::bool}) && (#0#23#isSet ?{core::bool} #0#23{core::bool} : let final core::bool* #t19 = #0#23#isSet = true in #0#23 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C5){(core::Object?) → core::bool}) && #C7 =={core::num::==}{(core::Object) → core::bool} (#0#24#isSet ?{dynamic} #0#24{dynamic} : let final core::bool* #t20 = #0#24#isSet = true in #0#24 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C5){(core::Object?) → dynamic})) {
+        {
+          return 4;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<core::String, core::int> && (#0#20#isSet ?{core::bool} #0#20{core::bool} : let final core::bool* #t21 = #0#20#isSet = true in #0#20 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t22 = #0#2#isSet = true in #0#2 = #0#0{core::Map<core::String, core::int>}.{core::Map::length}{core::int}).{core::num::>=}(#C3){(core::num) → core::bool}) && (#0#23#isSet ?{core::bool} #0#23{core::bool} : let final core::bool* #t23 = #0#23#isSet = true in #0#23 = #0#0{core::Map<core::String, core::int>}.{core::Map::containsKey}(#C5){(core::Object?) → core::bool}) && #C8 =={core::num::==}{(core::Object) → core::bool} (let core::int? #t24 = #0#24#isSet ?{core::int?} #0#24{core::int?} : let final core::bool* #t25 = #0#24#isSet = true in #0#24 = #0#0{core::Map<core::String, core::int>}.{core::Map::[]}(#C5){(core::Object?) → core::int?} in #t24 == null ?{core::int} #t24 as{ForNonNullableByDefault} core::int : #t24{core::int})) {
+        {
+          return 5;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::A<dynamic> && #C6 =={core::num::==}{(core::Object) → core::bool} (#0#34#isSet ?{dynamic} #0#34{dynamic} : let final core::bool* #t26 = #0#34#isSet = true in #0#34 = #0#0{self::A<dynamic>}.{self::A::foo}{dynamic})) {
+        {
+          return 6;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::A<core::int> && #C7 =={core::num::==}{(core::Object) → core::bool} (#0#34#isSet ?{core::int} #0#34{core::int} : let final core::bool* #t27 = #0#34#isSet = true in #0#34 = #0#0{self::A<core::int>}.{self::A::foo}{core::int})) {
+        {
+          return 7;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::B && #C8 =={core::num::==}{(core::Object) → core::bool} (#0#34#isSet ?{core::num} #0#34{core::num} : let final core::bool* #t28 = #0#34#isSet = true in #0#34 = #0#0{self::B}.{self::B::foo}{core::num})) {
+        {
+          return 8;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} ({foo: core::Object?}) && #C9 =={core::num::==}{(core::Object) → core::bool} (#0#34#isSet ?{core::Object?} #0#34{core::Object?} : let final core::bool* #t29 = #0#34#isSet = true in #0#34 = #0#0{({foo: core::Object?})}.foo{core::Object?})) {
+        {
+          return 9;
+        }
+      }
+    }
   }
   return 1.{core::int::unary-}(){() → core::int};
 }
diff --git a/pkg/front_end/testcases/patterns/multiple_targets.dart.weak.expect b/pkg/front_end/testcases/patterns/multiple_targets.dart.weak.expect
index e7477e6be0e..a8d5c951574 100644
--- a/pkg/front_end/testcases/patterns/multiple_targets.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/multiple_targets.dart.weak.expect
@@ -40,65 +40,76 @@ static method test(dynamic o) → dynamic {
     synthesized core::bool #0#24#isSet = false;
     synthesized dynamic #0#34;
     synthesized core::bool #0#34#isSet = false;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t1 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t2 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool}) && #C2 =={core::num::==}{(core::Object) → core::bool} (#0#6#isSet ?{dynamic} #0#6{dynamic} : let final dynamic #t3 = #0#6#isSet = true in #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic}) && #C3 =={core::num::==}{(core::Object) → core::bool} (#0#9#isSet ?{dynamic} #0#9{dynamic} : let final dynamic #t4 = #0#9#isSet = true in #0#9 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic})) {
-      {
-        return 0;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t1 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t2 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool}) && #C2 =={core::num::==}{(core::Object) → core::bool} (#0#6#isSet ?{dynamic} #0#6{dynamic} : let final dynamic #t3 = #0#6#isSet = true in #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic}) && #C3 =={core::num::==}{(core::Object) → core::bool} (#0#9#isSet ?{dynamic} #0#9{dynamic} : let final dynamic #t4 = #0#9#isSet = true in #0#9 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic})) {
+        {
+          return 0;
+        }
       }
     }
-    else
+    {
       if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t5 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t6 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool}) && #C3 =={core::num::==}{(core::Object) → core::bool} (#0#6#isSet ?{dynamic} #0#6{dynamic} : let final dynamic #t7 = #0#6#isSet = true in #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic}) && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#9#isSet ?{dynamic} #0#9{dynamic} : let final dynamic #t8 = #0#9#isSet = true in #0#9 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic})) {
         {
           return 1;
         }
       }
-      else
-        if(#0#0 is{ForNonNullableByDefault} core::List<core::int> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t9 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t10 = #0#2#isSet = true in #0#2 = #0#0{core::List<core::int>}.{core::List::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool}) && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#6#isSet ?{core::int} #0#6{core::int} : let final dynamic #t11 = #0#6#isSet = true in #0#6 = #0#0{core::List<core::int>}.{core::List::[]}(0){(core::int) → core::int}) && #C4 =={core::num::==}{(core::Object) → core::bool} (#0#9#isSet ?{core::int} #0#9{core::int} : let final dynamic #t12 = #0#9#isSet = true in #0#9 = #0#0{core::List<core::int>}.{core::List::[]}(1){(core::int) → core::int})) {
-          {
-            return 2;
-          }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<core::int> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t9 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t10 = #0#2#isSet = true in #0#2 = #0#0{core::List<core::int>}.{core::List::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool}) && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#6#isSet ?{core::int} #0#6{core::int} : let final dynamic #t11 = #0#6#isSet = true in #0#6 = #0#0{core::List<core::int>}.{core::List::[]}(0){(core::int) → core::int}) && #C4 =={core::num::==}{(core::Object) → core::bool} (#0#9#isSet ?{core::int} #0#9{core::int} : let final dynamic #t12 = #0#9#isSet = true in #0#9 = #0#0{core::List<core::int>}.{core::List::[]}(1){(core::int) → core::int})) {
+        {
+          return 2;
         }
-        else
-          if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#20#isSet ?{core::bool} #0#20{core::bool} : let final dynamic #t13 = #0#20#isSet = true in #0#20 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t14 = #0#2#isSet = true in #0#2 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C3){(core::num) → core::bool}) && (#0#23#isSet ?{core::bool} #0#23{core::bool} : let final dynamic #t15 = #0#23#isSet = true in #0#23 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C5){(core::Object?) → core::bool}) && #C6 =={core::num::==}{(core::Object) → core::bool} (#0#24#isSet ?{dynamic} #0#24{dynamic} : let final dynamic #t16 = #0#24#isSet = true in #0#24 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C5){(core::Object?) → dynamic})) {
-            {
-              return 3;
-            }
-          }
-          else
-            if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#20#isSet ?{core::bool} #0#20{core::bool} : let final dynamic #t17 = #0#20#isSet = true in #0#20 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t18 = #0#2#isSet = true in #0#2 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C3){(core::num) → core::bool}) && (#0#23#isSet ?{core::bool} #0#23{core::bool} : let final dynamic #t19 = #0#23#isSet = true in #0#23 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C5){(core::Object?) → core::bool}) && #C7 =={core::num::==}{(core::Object) → core::bool} (#0#24#isSet ?{dynamic} #0#24{dynamic} : let final dynamic #t20 = #0#24#isSet = true in #0#24 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C5){(core::Object?) → dynamic})) {
-              {
-                return 4;
-              }
-            }
-            else
-              if(#0#0 is{ForNonNullableByDefault} core::Map<core::String, core::int> && (#0#20#isSet ?{core::bool} #0#20{core::bool} : let final dynamic #t21 = #0#20#isSet = true in #0#20 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t22 = #0#2#isSet = true in #0#2 = #0#0{core::Map<core::String, core::int>}.{core::Map::length}{core::int}).{core::num::>=}(#C3){(core::num) → core::bool}) && (#0#23#isSet ?{core::bool} #0#23{core::bool} : let final dynamic #t23 = #0#23#isSet = true in #0#23 = #0#0{core::Map<core::String, core::int>}.{core::Map::containsKey}(#C5){(core::Object?) → core::bool}) && #C8 =={core::num::==}{(core::Object) → core::bool} (#0#24#isSet ?{core::int?} #0#24{core::int?} : let final dynamic #t24 = #0#24#isSet = true in #0#24 = #0#0{core::Map<core::String, core::int>}.{core::Map::[]}(#C5){(core::Object?) → core::int?}) as{ForNonNullableByDefault} core::int) {
-                {
-                  return 5;
-                }
-              }
-              else
-                if(#0#0 is{ForNonNullableByDefault} self::A<dynamic> && #C6 =={core::num::==}{(core::Object) → core::bool} (#0#34#isSet ?{dynamic} #0#34{dynamic} : let final dynamic #t25 = #0#34#isSet = true in #0#34 = #0#0{self::A<dynamic>}.{self::A::foo}{dynamic})) {
-                  {
-                    return 6;
-                  }
-                }
-                else
-                  if(#0#0 is{ForNonNullableByDefault} self::A<core::int> && #C7 =={core::num::==}{(core::Object) → core::bool} (#0#34#isSet ?{core::int} #0#34{core::int} : let final dynamic #t26 = #0#34#isSet = true in #0#34 = #0#0{self::A<core::int>}.{self::A::foo}{core::int})) {
-                    {
-                      return 7;
-                    }
-                  }
-                  else
-                    if(#0#0 is{ForNonNullableByDefault} self::B && #C8 =={core::num::==}{(core::Object) → core::bool} (#0#34#isSet ?{core::num} #0#34{core::num} : let final dynamic #t27 = #0#34#isSet = true in #0#34 = #0#0{self::B}.{self::B::foo}{core::num})) {
-                      {
-                        return 8;
-                      }
-                    }
-                    else
-                      if(#0#0 is{ForNonNullableByDefault} ({foo: core::Object?}) && #C9 =={core::num::==}{(core::Object) → core::bool} (#0#34#isSet ?{core::Object?} #0#34{core::Object?} : let final dynamic #t28 = #0#34#isSet = true in #0#34 = #0#0{({foo: core::Object?})}.foo{core::Object?})) {
-                        {
-                          return 9;
-                        }
-                      }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#20#isSet ?{core::bool} #0#20{core::bool} : let final dynamic #t13 = #0#20#isSet = true in #0#20 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t14 = #0#2#isSet = true in #0#2 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C3){(core::num) → core::bool}) && (#0#23#isSet ?{core::bool} #0#23{core::bool} : let final dynamic #t15 = #0#23#isSet = true in #0#23 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C5){(core::Object?) → core::bool}) && #C6 =={core::num::==}{(core::Object) → core::bool} (#0#24#isSet ?{dynamic} #0#24{dynamic} : let final dynamic #t16 = #0#24#isSet = true in #0#24 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C5){(core::Object?) → dynamic})) {
+        {
+          return 3;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#20#isSet ?{core::bool} #0#20{core::bool} : let final dynamic #t17 = #0#20#isSet = true in #0#20 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t18 = #0#2#isSet = true in #0#2 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C3){(core::num) → core::bool}) && (#0#23#isSet ?{core::bool} #0#23{core::bool} : let final dynamic #t19 = #0#23#isSet = true in #0#23 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C5){(core::Object?) → core::bool}) && #C7 =={core::num::==}{(core::Object) → core::bool} (#0#24#isSet ?{dynamic} #0#24{dynamic} : let final dynamic #t20 = #0#24#isSet = true in #0#24 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C5){(core::Object?) → dynamic})) {
+        {
+          return 4;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<core::String, core::int> && (#0#20#isSet ?{core::bool} #0#20{core::bool} : let final dynamic #t21 = #0#20#isSet = true in #0#20 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t22 = #0#2#isSet = true in #0#2 = #0#0{core::Map<core::String, core::int>}.{core::Map::length}{core::int}).{core::num::>=}(#C3){(core::num) → core::bool}) && (#0#23#isSet ?{core::bool} #0#23{core::bool} : let final dynamic #t23 = #0#23#isSet = true in #0#23 = #0#0{core::Map<core::String, core::int>}.{core::Map::containsKey}(#C5){(core::Object?) → core::bool}) && #C8 =={core::num::==}{(core::Object) → core::bool} (#0#24#isSet ?{core::int?} #0#24{core::int?} : let final dynamic #t24 = #0#24#isSet = true in #0#24 = #0#0{core::Map<core::String, core::int>}.{core::Map::[]}(#C5){(core::Object?) → core::int?}) as{ForNonNullableByDefault} core::int) {
+        {
+          return 5;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::A<dynamic> && #C6 =={core::num::==}{(core::Object) → core::bool} (#0#34#isSet ?{dynamic} #0#34{dynamic} : let final dynamic #t25 = #0#34#isSet = true in #0#34 = #0#0{self::A<dynamic>}.{self::A::foo}{dynamic})) {
+        {
+          return 6;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::A<core::int> && #C7 =={core::num::==}{(core::Object) → core::bool} (#0#34#isSet ?{core::int} #0#34{core::int} : let final dynamic #t26 = #0#34#isSet = true in #0#34 = #0#0{self::A<core::int>}.{self::A::foo}{core::int})) {
+        {
+          return 7;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::B && #C8 =={core::num::==}{(core::Object) → core::bool} (#0#34#isSet ?{core::num} #0#34{core::num} : let final dynamic #t27 = #0#34#isSet = true in #0#34 = #0#0{self::B}.{self::B::foo}{core::num})) {
+        {
+          return 8;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} ({foo: core::Object?}) && #C9 =={core::num::==}{(core::Object) → core::bool} (#0#34#isSet ?{core::Object?} #0#34{core::Object?} : let final dynamic #t28 = #0#34#isSet = true in #0#34 = #0#0{({foo: core::Object?})}.foo{core::Object?})) {
+        {
+          return 9;
+        }
+      }
+    }
   }
   return 1.{core::int::unary-}(){() → core::int};
 }
diff --git a/pkg/front_end/testcases/patterns/multiple_targets.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/multiple_targets.dart.weak.modular.expect
index e7477e6be0e..a8d5c951574 100644
--- a/pkg/front_end/testcases/patterns/multiple_targets.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/multiple_targets.dart.weak.modular.expect
@@ -40,65 +40,76 @@ static method test(dynamic o) → dynamic {
     synthesized core::bool #0#24#isSet = false;
     synthesized dynamic #0#34;
     synthesized core::bool #0#34#isSet = false;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t1 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t2 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool}) && #C2 =={core::num::==}{(core::Object) → core::bool} (#0#6#isSet ?{dynamic} #0#6{dynamic} : let final dynamic #t3 = #0#6#isSet = true in #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic}) && #C3 =={core::num::==}{(core::Object) → core::bool} (#0#9#isSet ?{dynamic} #0#9{dynamic} : let final dynamic #t4 = #0#9#isSet = true in #0#9 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic})) {
-      {
-        return 0;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t1 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t2 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool}) && #C2 =={core::num::==}{(core::Object) → core::bool} (#0#6#isSet ?{dynamic} #0#6{dynamic} : let final dynamic #t3 = #0#6#isSet = true in #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic}) && #C3 =={core::num::==}{(core::Object) → core::bool} (#0#9#isSet ?{dynamic} #0#9{dynamic} : let final dynamic #t4 = #0#9#isSet = true in #0#9 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic})) {
+        {
+          return 0;
+        }
       }
     }
-    else
+    {
       if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t5 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t6 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool}) && #C3 =={core::num::==}{(core::Object) → core::bool} (#0#6#isSet ?{dynamic} #0#6{dynamic} : let final dynamic #t7 = #0#6#isSet = true in #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic}) && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#9#isSet ?{dynamic} #0#9{dynamic} : let final dynamic #t8 = #0#9#isSet = true in #0#9 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic})) {
         {
           return 1;
         }
       }
-      else
-        if(#0#0 is{ForNonNullableByDefault} core::List<core::int> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t9 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t10 = #0#2#isSet = true in #0#2 = #0#0{core::List<core::int>}.{core::List::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool}) && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#6#isSet ?{core::int} #0#6{core::int} : let final dynamic #t11 = #0#6#isSet = true in #0#6 = #0#0{core::List<core::int>}.{core::List::[]}(0){(core::int) → core::int}) && #C4 =={core::num::==}{(core::Object) → core::bool} (#0#9#isSet ?{core::int} #0#9{core::int} : let final dynamic #t12 = #0#9#isSet = true in #0#9 = #0#0{core::List<core::int>}.{core::List::[]}(1){(core::int) → core::int})) {
-          {
-            return 2;
-          }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<core::int> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t9 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t10 = #0#2#isSet = true in #0#2 = #0#0{core::List<core::int>}.{core::List::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool}) && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#6#isSet ?{core::int} #0#6{core::int} : let final dynamic #t11 = #0#6#isSet = true in #0#6 = #0#0{core::List<core::int>}.{core::List::[]}(0){(core::int) → core::int}) && #C4 =={core::num::==}{(core::Object) → core::bool} (#0#9#isSet ?{core::int} #0#9{core::int} : let final dynamic #t12 = #0#9#isSet = true in #0#9 = #0#0{core::List<core::int>}.{core::List::[]}(1){(core::int) → core::int})) {
+        {
+          return 2;
         }
-        else
-          if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#20#isSet ?{core::bool} #0#20{core::bool} : let final dynamic #t13 = #0#20#isSet = true in #0#20 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t14 = #0#2#isSet = true in #0#2 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C3){(core::num) → core::bool}) && (#0#23#isSet ?{core::bool} #0#23{core::bool} : let final dynamic #t15 = #0#23#isSet = true in #0#23 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C5){(core::Object?) → core::bool}) && #C6 =={core::num::==}{(core::Object) → core::bool} (#0#24#isSet ?{dynamic} #0#24{dynamic} : let final dynamic #t16 = #0#24#isSet = true in #0#24 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C5){(core::Object?) → dynamic})) {
-            {
-              return 3;
-            }
-          }
-          else
-            if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#20#isSet ?{core::bool} #0#20{core::bool} : let final dynamic #t17 = #0#20#isSet = true in #0#20 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t18 = #0#2#isSet = true in #0#2 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C3){(core::num) → core::bool}) && (#0#23#isSet ?{core::bool} #0#23{core::bool} : let final dynamic #t19 = #0#23#isSet = true in #0#23 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C5){(core::Object?) → core::bool}) && #C7 =={core::num::==}{(core::Object) → core::bool} (#0#24#isSet ?{dynamic} #0#24{dynamic} : let final dynamic #t20 = #0#24#isSet = true in #0#24 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C5){(core::Object?) → dynamic})) {
-              {
-                return 4;
-              }
-            }
-            else
-              if(#0#0 is{ForNonNullableByDefault} core::Map<core::String, core::int> && (#0#20#isSet ?{core::bool} #0#20{core::bool} : let final dynamic #t21 = #0#20#isSet = true in #0#20 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t22 = #0#2#isSet = true in #0#2 = #0#0{core::Map<core::String, core::int>}.{core::Map::length}{core::int}).{core::num::>=}(#C3){(core::num) → core::bool}) && (#0#23#isSet ?{core::bool} #0#23{core::bool} : let final dynamic #t23 = #0#23#isSet = true in #0#23 = #0#0{core::Map<core::String, core::int>}.{core::Map::containsKey}(#C5){(core::Object?) → core::bool}) && #C8 =={core::num::==}{(core::Object) → core::bool} (#0#24#isSet ?{core::int?} #0#24{core::int?} : let final dynamic #t24 = #0#24#isSet = true in #0#24 = #0#0{core::Map<core::String, core::int>}.{core::Map::[]}(#C5){(core::Object?) → core::int?}) as{ForNonNullableByDefault} core::int) {
-                {
-                  return 5;
-                }
-              }
-              else
-                if(#0#0 is{ForNonNullableByDefault} self::A<dynamic> && #C6 =={core::num::==}{(core::Object) → core::bool} (#0#34#isSet ?{dynamic} #0#34{dynamic} : let final dynamic #t25 = #0#34#isSet = true in #0#34 = #0#0{self::A<dynamic>}.{self::A::foo}{dynamic})) {
-                  {
-                    return 6;
-                  }
-                }
-                else
-                  if(#0#0 is{ForNonNullableByDefault} self::A<core::int> && #C7 =={core::num::==}{(core::Object) → core::bool} (#0#34#isSet ?{core::int} #0#34{core::int} : let final dynamic #t26 = #0#34#isSet = true in #0#34 = #0#0{self::A<core::int>}.{self::A::foo}{core::int})) {
-                    {
-                      return 7;
-                    }
-                  }
-                  else
-                    if(#0#0 is{ForNonNullableByDefault} self::B && #C8 =={core::num::==}{(core::Object) → core::bool} (#0#34#isSet ?{core::num} #0#34{core::num} : let final dynamic #t27 = #0#34#isSet = true in #0#34 = #0#0{self::B}.{self::B::foo}{core::num})) {
-                      {
-                        return 8;
-                      }
-                    }
-                    else
-                      if(#0#0 is{ForNonNullableByDefault} ({foo: core::Object?}) && #C9 =={core::num::==}{(core::Object) → core::bool} (#0#34#isSet ?{core::Object?} #0#34{core::Object?} : let final dynamic #t28 = #0#34#isSet = true in #0#34 = #0#0{({foo: core::Object?})}.foo{core::Object?})) {
-                        {
-                          return 9;
-                        }
-                      }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#20#isSet ?{core::bool} #0#20{core::bool} : let final dynamic #t13 = #0#20#isSet = true in #0#20 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t14 = #0#2#isSet = true in #0#2 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C3){(core::num) → core::bool}) && (#0#23#isSet ?{core::bool} #0#23{core::bool} : let final dynamic #t15 = #0#23#isSet = true in #0#23 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C5){(core::Object?) → core::bool}) && #C6 =={core::num::==}{(core::Object) → core::bool} (#0#24#isSet ?{dynamic} #0#24{dynamic} : let final dynamic #t16 = #0#24#isSet = true in #0#24 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C5){(core::Object?) → dynamic})) {
+        {
+          return 3;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#20#isSet ?{core::bool} #0#20{core::bool} : let final dynamic #t17 = #0#20#isSet = true in #0#20 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t18 = #0#2#isSet = true in #0#2 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C3){(core::num) → core::bool}) && (#0#23#isSet ?{core::bool} #0#23{core::bool} : let final dynamic #t19 = #0#23#isSet = true in #0#23 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C5){(core::Object?) → core::bool}) && #C7 =={core::num::==}{(core::Object) → core::bool} (#0#24#isSet ?{dynamic} #0#24{dynamic} : let final dynamic #t20 = #0#24#isSet = true in #0#24 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C5){(core::Object?) → dynamic})) {
+        {
+          return 4;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<core::String, core::int> && (#0#20#isSet ?{core::bool} #0#20{core::bool} : let final dynamic #t21 = #0#20#isSet = true in #0#20 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t22 = #0#2#isSet = true in #0#2 = #0#0{core::Map<core::String, core::int>}.{core::Map::length}{core::int}).{core::num::>=}(#C3){(core::num) → core::bool}) && (#0#23#isSet ?{core::bool} #0#23{core::bool} : let final dynamic #t23 = #0#23#isSet = true in #0#23 = #0#0{core::Map<core::String, core::int>}.{core::Map::containsKey}(#C5){(core::Object?) → core::bool}) && #C8 =={core::num::==}{(core::Object) → core::bool} (#0#24#isSet ?{core::int?} #0#24{core::int?} : let final dynamic #t24 = #0#24#isSet = true in #0#24 = #0#0{core::Map<core::String, core::int>}.{core::Map::[]}(#C5){(core::Object?) → core::int?}) as{ForNonNullableByDefault} core::int) {
+        {
+          return 5;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::A<dynamic> && #C6 =={core::num::==}{(core::Object) → core::bool} (#0#34#isSet ?{dynamic} #0#34{dynamic} : let final dynamic #t25 = #0#34#isSet = true in #0#34 = #0#0{self::A<dynamic>}.{self::A::foo}{dynamic})) {
+        {
+          return 6;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::A<core::int> && #C7 =={core::num::==}{(core::Object) → core::bool} (#0#34#isSet ?{core::int} #0#34{core::int} : let final dynamic #t26 = #0#34#isSet = true in #0#34 = #0#0{self::A<core::int>}.{self::A::foo}{core::int})) {
+        {
+          return 7;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::B && #C8 =={core::num::==}{(core::Object) → core::bool} (#0#34#isSet ?{core::num} #0#34{core::num} : let final dynamic #t27 = #0#34#isSet = true in #0#34 = #0#0{self::B}.{self::B::foo}{core::num})) {
+        {
+          return 8;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} ({foo: core::Object?}) && #C9 =={core::num::==}{(core::Object) → core::bool} (#0#34#isSet ?{core::Object?} #0#34{core::Object?} : let final dynamic #t28 = #0#34#isSet = true in #0#34 = #0#0{({foo: core::Object?})}.foo{core::Object?})) {
+        {
+          return 9;
+        }
+      }
+    }
   }
   return 1.{core::int::unary-}(){() → core::int};
 }
diff --git a/pkg/front_end/testcases/patterns/multiple_targets.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/multiple_targets.dart.weak.transformed.expect
index 2c8bc545a44..7bdbcd51d0d 100644
--- a/pkg/front_end/testcases/patterns/multiple_targets.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/multiple_targets.dart.weak.transformed.expect
@@ -40,65 +40,76 @@ static method test(dynamic o) → dynamic {
     synthesized core::bool #0#24#isSet = false;
     synthesized dynamic #0#34;
     synthesized core::bool #0#34#isSet = false;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t1 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t2 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool}) && #C2 =={core::num::==}{(core::Object) → core::bool} (#0#6#isSet ?{dynamic} #0#6{dynamic} : let final core::bool* #t3 = #0#6#isSet = true in #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic}) && #C3 =={core::num::==}{(core::Object) → core::bool} (#0#9#isSet ?{dynamic} #0#9{dynamic} : let final core::bool* #t4 = #0#9#isSet = true in #0#9 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic})) {
-      {
-        return 0;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t1 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t2 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool}) && #C2 =={core::num::==}{(core::Object) → core::bool} (#0#6#isSet ?{dynamic} #0#6{dynamic} : let final core::bool* #t3 = #0#6#isSet = true in #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic}) && #C3 =={core::num::==}{(core::Object) → core::bool} (#0#9#isSet ?{dynamic} #0#9{dynamic} : let final core::bool* #t4 = #0#9#isSet = true in #0#9 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic})) {
+        {
+          return 0;
+        }
       }
     }
-    else
+    {
       if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t5 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t6 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool}) && #C3 =={core::num::==}{(core::Object) → core::bool} (#0#6#isSet ?{dynamic} #0#6{dynamic} : let final core::bool* #t7 = #0#6#isSet = true in #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic}) && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#9#isSet ?{dynamic} #0#9{dynamic} : let final core::bool* #t8 = #0#9#isSet = true in #0#9 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic})) {
         {
           return 1;
         }
       }
-      else
-        if(#0#0 is{ForNonNullableByDefault} core::List<core::int> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t9 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t10 = #0#2#isSet = true in #0#2 = #0#0{core::List<core::int>}.{core::List::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool}) && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#6#isSet ?{core::int} #0#6{core::int} : let final core::bool* #t11 = #0#6#isSet = true in #0#6 = #0#0{core::List<core::int>}.{core::List::[]}(0){(core::int) → core::int}) && #C4 =={core::num::==}{(core::Object) → core::bool} (#0#9#isSet ?{core::int} #0#9{core::int} : let final core::bool* #t12 = #0#9#isSet = true in #0#9 = #0#0{core::List<core::int>}.{core::List::[]}(1){(core::int) → core::int})) {
-          {
-            return 2;
-          }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<core::int> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t9 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t10 = #0#2#isSet = true in #0#2 = #0#0{core::List<core::int>}.{core::List::length}{core::int}).{core::num::>=}(#C1){(core::num) → core::bool}) && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#6#isSet ?{core::int} #0#6{core::int} : let final core::bool* #t11 = #0#6#isSet = true in #0#6 = #0#0{core::List<core::int>}.{core::List::[]}(0){(core::int) → core::int}) && #C4 =={core::num::==}{(core::Object) → core::bool} (#0#9#isSet ?{core::int} #0#9{core::int} : let final core::bool* #t12 = #0#9#isSet = true in #0#9 = #0#0{core::List<core::int>}.{core::List::[]}(1){(core::int) → core::int})) {
+        {
+          return 2;
         }
-        else
-          if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#20#isSet ?{core::bool} #0#20{core::bool} : let final core::bool* #t13 = #0#20#isSet = true in #0#20 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t14 = #0#2#isSet = true in #0#2 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C3){(core::num) → core::bool}) && (#0#23#isSet ?{core::bool} #0#23{core::bool} : let final core::bool* #t15 = #0#23#isSet = true in #0#23 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C5){(core::Object?) → core::bool}) && #C6 =={core::num::==}{(core::Object) → core::bool} (#0#24#isSet ?{dynamic} #0#24{dynamic} : let final core::bool* #t16 = #0#24#isSet = true in #0#24 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C5){(core::Object?) → dynamic})) {
-            {
-              return 3;
-            }
-          }
-          else
-            if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#20#isSet ?{core::bool} #0#20{core::bool} : let final core::bool* #t17 = #0#20#isSet = true in #0#20 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t18 = #0#2#isSet = true in #0#2 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C3){(core::num) → core::bool}) && (#0#23#isSet ?{core::bool} #0#23{core::bool} : let final core::bool* #t19 = #0#23#isSet = true in #0#23 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C5){(core::Object?) → core::bool}) && #C7 =={core::num::==}{(core::Object) → core::bool} (#0#24#isSet ?{dynamic} #0#24{dynamic} : let final core::bool* #t20 = #0#24#isSet = true in #0#24 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C5){(core::Object?) → dynamic})) {
-              {
-                return 4;
-              }
-            }
-            else
-              if(#0#0 is{ForNonNullableByDefault} core::Map<core::String, core::int> && (#0#20#isSet ?{core::bool} #0#20{core::bool} : let final core::bool* #t21 = #0#20#isSet = true in #0#20 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t22 = #0#2#isSet = true in #0#2 = #0#0{core::Map<core::String, core::int>}.{core::Map::length}{core::int}).{core::num::>=}(#C3){(core::num) → core::bool}) && (#0#23#isSet ?{core::bool} #0#23{core::bool} : let final core::bool* #t23 = #0#23#isSet = true in #0#23 = #0#0{core::Map<core::String, core::int>}.{core::Map::containsKey}(#C5){(core::Object?) → core::bool}) && #C8 =={core::num::==}{(core::Object) → core::bool} (#0#24#isSet ?{core::int?} #0#24{core::int?} : let final core::bool* #t24 = #0#24#isSet = true in #0#24 = #0#0{core::Map<core::String, core::int>}.{core::Map::[]}(#C5){(core::Object?) → core::int?})) {
-                {
-                  return 5;
-                }
-              }
-              else
-                if(#0#0 is{ForNonNullableByDefault} self::A<dynamic> && #C6 =={core::num::==}{(core::Object) → core::bool} (#0#34#isSet ?{dynamic} #0#34{dynamic} : let final core::bool* #t25 = #0#34#isSet = true in #0#34 = #0#0{self::A<dynamic>}.{self::A::foo}{dynamic})) {
-                  {
-                    return 6;
-                  }
-                }
-                else
-                  if(#0#0 is{ForNonNullableByDefault} self::A<core::int> && #C7 =={core::num::==}{(core::Object) → core::bool} (#0#34#isSet ?{core::int} #0#34{core::int} : let final core::bool* #t26 = #0#34#isSet = true in #0#34 = #0#0{self::A<core::int>}.{self::A::foo}{core::int})) {
-                    {
-                      return 7;
-                    }
-                  }
-                  else
-                    if(#0#0 is{ForNonNullableByDefault} self::B && #C8 =={core::num::==}{(core::Object) → core::bool} (#0#34#isSet ?{core::num} #0#34{core::num} : let final core::bool* #t27 = #0#34#isSet = true in #0#34 = #0#0{self::B}.{self::B::foo}{core::num})) {
-                      {
-                        return 8;
-                      }
-                    }
-                    else
-                      if(#0#0 is{ForNonNullableByDefault} ({foo: core::Object?}) && #C9 =={core::num::==}{(core::Object) → core::bool} (#0#34#isSet ?{core::Object?} #0#34{core::Object?} : let final core::bool* #t28 = #0#34#isSet = true in #0#34 = #0#0{({foo: core::Object?})}.foo{core::Object?})) {
-                        {
-                          return 9;
-                        }
-                      }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#20#isSet ?{core::bool} #0#20{core::bool} : let final core::bool* #t13 = #0#20#isSet = true in #0#20 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t14 = #0#2#isSet = true in #0#2 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C3){(core::num) → core::bool}) && (#0#23#isSet ?{core::bool} #0#23{core::bool} : let final core::bool* #t15 = #0#23#isSet = true in #0#23 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C5){(core::Object?) → core::bool}) && #C6 =={core::num::==}{(core::Object) → core::bool} (#0#24#isSet ?{dynamic} #0#24{dynamic} : let final core::bool* #t16 = #0#24#isSet = true in #0#24 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C5){(core::Object?) → dynamic})) {
+        {
+          return 3;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#20#isSet ?{core::bool} #0#20{core::bool} : let final core::bool* #t17 = #0#20#isSet = true in #0#20 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t18 = #0#2#isSet = true in #0#2 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C3){(core::num) → core::bool}) && (#0#23#isSet ?{core::bool} #0#23{core::bool} : let final core::bool* #t19 = #0#23#isSet = true in #0#23 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C5){(core::Object?) → core::bool}) && #C7 =={core::num::==}{(core::Object) → core::bool} (#0#24#isSet ?{dynamic} #0#24{dynamic} : let final core::bool* #t20 = #0#24#isSet = true in #0#24 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C5){(core::Object?) → dynamic})) {
+        {
+          return 4;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<core::String, core::int> && (#0#20#isSet ?{core::bool} #0#20{core::bool} : let final core::bool* #t21 = #0#20#isSet = true in #0#20 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t22 = #0#2#isSet = true in #0#2 = #0#0{core::Map<core::String, core::int>}.{core::Map::length}{core::int}).{core::num::>=}(#C3){(core::num) → core::bool}) && (#0#23#isSet ?{core::bool} #0#23{core::bool} : let final core::bool* #t23 = #0#23#isSet = true in #0#23 = #0#0{core::Map<core::String, core::int>}.{core::Map::containsKey}(#C5){(core::Object?) → core::bool}) && #C8 =={core::num::==}{(core::Object) → core::bool} (#0#24#isSet ?{core::int?} #0#24{core::int?} : let final core::bool* #t24 = #0#24#isSet = true in #0#24 = #0#0{core::Map<core::String, core::int>}.{core::Map::[]}(#C5){(core::Object?) → core::int?})) {
+        {
+          return 5;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::A<dynamic> && #C6 =={core::num::==}{(core::Object) → core::bool} (#0#34#isSet ?{dynamic} #0#34{dynamic} : let final core::bool* #t25 = #0#34#isSet = true in #0#34 = #0#0{self::A<dynamic>}.{self::A::foo}{dynamic})) {
+        {
+          return 6;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::A<core::int> && #C7 =={core::num::==}{(core::Object) → core::bool} (#0#34#isSet ?{core::int} #0#34{core::int} : let final core::bool* #t26 = #0#34#isSet = true in #0#34 = #0#0{self::A<core::int>}.{self::A::foo}{core::int})) {
+        {
+          return 7;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::B && #C8 =={core::num::==}{(core::Object) → core::bool} (#0#34#isSet ?{core::num} #0#34{core::num} : let final core::bool* #t27 = #0#34#isSet = true in #0#34 = #0#0{self::B}.{self::B::foo}{core::num})) {
+        {
+          return 8;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} ({foo: core::Object?}) && #C9 =={core::num::==}{(core::Object) → core::bool} (#0#34#isSet ?{core::Object?} #0#34{core::Object?} : let final core::bool* #t28 = #0#34#isSet = true in #0#34 = #0#0{({foo: core::Object?})}.foo{core::Object?})) {
+        {
+          return 9;
+        }
+      }
+    }
   }
   return 1.{core::int::unary-}(){() → core::int};
 }
diff --git a/pkg/front_end/testcases/patterns/never_pattern.dart.strong.expect b/pkg/front_end/testcases/patterns/never_pattern.dart.strong.expect
index 11a7cfb1a44..fcb8b6144f9 100644
--- a/pkg/front_end/testcases/patterns/never_pattern.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/never_pattern.dart.strong.expect
@@ -6,7 +6,9 @@ static method method(Never n) → dynamic {
   #L1:
   {
     final synthesized Never #0#0 = n;
-    if(#0#0 =={core::Object::==}{(dynamic) → Never} #C1) {
+    {
+      if(#0#0 =={core::Object::==}{(dynamic) → Never} #C1) {
+      }
     }
   }
 }
diff --git a/pkg/front_end/testcases/patterns/never_pattern.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/never_pattern.dart.strong.transformed.expect
index 11a7cfb1a44..fcb8b6144f9 100644
--- a/pkg/front_end/testcases/patterns/never_pattern.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/never_pattern.dart.strong.transformed.expect
@@ -6,7 +6,9 @@ static method method(Never n) → dynamic {
   #L1:
   {
     final synthesized Never #0#0 = n;
-    if(#0#0 =={core::Object::==}{(dynamic) → Never} #C1) {
+    {
+      if(#0#0 =={core::Object::==}{(dynamic) → Never} #C1) {
+      }
     }
   }
 }
diff --git a/pkg/front_end/testcases/patterns/never_pattern.dart.weak.expect b/pkg/front_end/testcases/patterns/never_pattern.dart.weak.expect
index ac664b1e89d..53a1c5b2617 100644
--- a/pkg/front_end/testcases/patterns/never_pattern.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/never_pattern.dart.weak.expect
@@ -7,7 +7,9 @@ static method method(Never n) → dynamic {
   #L1:
   {
     final synthesized Never #0#0 = let final Never #t1 = n in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.");
-    if(#0#0 =={core::Object::==}{(dynamic) → Never} #C1) {
+    {
+      if(#0#0 =={core::Object::==}{(dynamic) → Never} #C1) {
+      }
     }
   }
 }
diff --git a/pkg/front_end/testcases/patterns/never_pattern.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/never_pattern.dart.weak.modular.expect
index ac664b1e89d..53a1c5b2617 100644
--- a/pkg/front_end/testcases/patterns/never_pattern.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/never_pattern.dart.weak.modular.expect
@@ -7,7 +7,9 @@ static method method(Never n) → dynamic {
   #L1:
   {
     final synthesized Never #0#0 = let final Never #t1 = n in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.");
-    if(#0#0 =={core::Object::==}{(dynamic) → Never} #C1) {
+    {
+      if(#0#0 =={core::Object::==}{(dynamic) → Never} #C1) {
+      }
     }
   }
 }
diff --git a/pkg/front_end/testcases/patterns/never_pattern.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/never_pattern.dart.weak.transformed.expect
index ac664b1e89d..53a1c5b2617 100644
--- a/pkg/front_end/testcases/patterns/never_pattern.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/never_pattern.dart.weak.transformed.expect
@@ -7,7 +7,9 @@ static method method(Never n) → dynamic {
   #L1:
   {
     final synthesized Never #0#0 = let final Never #t1 = n in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.");
-    if(#0#0 =={core::Object::==}{(dynamic) → Never} #C1) {
+    {
+      if(#0#0 =={core::Object::==}{(dynamic) → Never} #C1) {
+      }
     }
   }
 }
diff --git a/pkg/front_end/testcases/patterns/non_bool_guard.dart.strong.expect b/pkg/front_end/testcases/patterns/non_bool_guard.dart.strong.expect
index bcf96f89a5e..daf6483e38f 100644
--- a/pkg/front_end/testcases/patterns/non_bool_guard.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/non_bool_guard.dart.strong.expect
@@ -23,19 +23,23 @@ import "dart:core" as core;
 static method test1(core::List<core::int> v) → core::String {
   #L1:
   {
-    core::int a;
     final synthesized core::List<core::int> #0#0 = v;
-    if(#0#0.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final dynamic #t1 = a = #0#0.{core::List::[]}(0){(core::int) → core::int} in true) && (let final dynamic #t2 = #0#0.{core::List::[]}(1){(core::int) → core::int} in true) && invalid-expression "pkg/front_end/testcases/patterns/non_bool_guard.dart:7:28: Error: Conditions must have a static type of 'bool'.
+    {
+      core::int a;
+      if(#0#0.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final dynamic #t1 = a = #0#0.{core::List::[]}(0){(core::int) → core::int} in true) && (let final dynamic #t2 = #0#0.{core::List::[]}(1){(core::int) → core::int} in true) && invalid-expression "pkg/front_end/testcases/patterns/non_bool_guard.dart:7:28: Error: Conditions must have a static type of 'bool'.
 Try changing the condition.
     case [var a, _] when a - 1:
                            ^") {
-      {
-        return "match";
+        {
+          return "match";
+        }
       }
     }
-    else {
+    {
       {
-        return "no match";
+        {
+          return "no match";
+        }
       }
     }
   }
@@ -56,16 +60,26 @@ Try changing the condition.
 static method test3(core::List<core::int> v) → core::String
   return block {
     core::String #t5;
-    core::int a;
     final synthesized core::List<core::int> #0#0 = v;
-    if(#0#0.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final dynamic #t6 = a = #0#0.{core::List::[]}(0){(core::int) → core::int} in true) && (let final dynamic #t7 = #0#0.{core::List::[]}(1){(core::int) → core::int} in true) && invalid-expression "pkg/front_end/testcases/patterns/non_bool_guard.dart:23:23: Error: Conditions must have a static type of 'bool'.
+    #L2:
+    {
+      {
+        core::int a;
+        if(#0#0.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final dynamic #t6 = a = #0#0.{core::List::[]}(0){(core::int) → core::int} in true) && (let final dynamic #t7 = #0#0.{core::List::[]}(1){(core::int) → core::int} in true) && invalid-expression "pkg/front_end/testcases/patterns/non_bool_guard.dart:23:23: Error: Conditions must have a static type of 'bool'.
 Try changing the condition.
     [var a, _] when a - 1 => \"match\",
-                      ^")
-      #t5 = "match";
-    else
-      if(true)
-        #t5 = "no match";
+                      ^") {
+          #t5 = "match";
+          break #L2;
+        }
+      }
+      {
+        if(true) {
+          #t5 = "no match";
+          break #L2;
+        }
+      }
+    }
   } =>#t5;
 
 constants  {
diff --git a/pkg/front_end/testcases/patterns/non_bool_guard.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/non_bool_guard.dart.strong.transformed.expect
index fa185e2dbb3..1865453b1a8 100644
--- a/pkg/front_end/testcases/patterns/non_bool_guard.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/non_bool_guard.dart.strong.transformed.expect
@@ -23,19 +23,23 @@ import "dart:core" as core;
 static method test1(core::List<core::int> v) → core::String {
   #L1:
   {
-    core::int a;
     final synthesized core::List<core::int> #0#0 = v;
-    if(#0#0.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final core::int #t1 = a = #0#0.{core::List::[]}(0){(core::int) → core::int} in true) && (let final core::int #t2 = #0#0.{core::List::[]}(1){(core::int) → core::int} in true) && invalid-expression "pkg/front_end/testcases/patterns/non_bool_guard.dart:7:28: Error: Conditions must have a static type of 'bool'.
+    {
+      core::int a;
+      if(#0#0.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final core::int #t1 = a = #0#0.{core::List::[]}(0){(core::int) → core::int} in true) && (let final core::int #t2 = #0#0.{core::List::[]}(1){(core::int) → core::int} in true) && invalid-expression "pkg/front_end/testcases/patterns/non_bool_guard.dart:7:28: Error: Conditions must have a static type of 'bool'.
 Try changing the condition.
     case [var a, _] when a - 1:
                            ^") {
-      {
-        return "match";
+        {
+          return "match";
+        }
       }
     }
-    else {
+    {
       {
-        return "no match";
+        {
+          return "no match";
+        }
       }
     }
   }
@@ -56,16 +60,26 @@ Try changing the condition.
 static method test3(core::List<core::int> v) → core::String
   return block {
     core::String #t5;
-    core::int a;
     final synthesized core::List<core::int> #0#0 = v;
-    if(#0#0.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final core::int #t6 = a = #0#0.{core::List::[]}(0){(core::int) → core::int} in true) && (let final core::int #t7 = #0#0.{core::List::[]}(1){(core::int) → core::int} in true) && invalid-expression "pkg/front_end/testcases/patterns/non_bool_guard.dart:23:23: Error: Conditions must have a static type of 'bool'.
+    #L2:
+    {
+      {
+        core::int a;
+        if(#0#0.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final core::int #t6 = a = #0#0.{core::List::[]}(0){(core::int) → core::int} in true) && (let final core::int #t7 = #0#0.{core::List::[]}(1){(core::int) → core::int} in true) && invalid-expression "pkg/front_end/testcases/patterns/non_bool_guard.dart:23:23: Error: Conditions must have a static type of 'bool'.
 Try changing the condition.
     [var a, _] when a - 1 => \"match\",
-                      ^")
-      #t5 = "match";
-    else
-      if(true)
-        #t5 = "no match";
+                      ^") {
+          #t5 = "match";
+          break #L2;
+        }
+      }
+      {
+        if(true) {
+          #t5 = "no match";
+          break #L2;
+        }
+      }
+    }
   } =>#t5;
 
 constants  {
diff --git a/pkg/front_end/testcases/patterns/non_bool_guard.dart.weak.expect b/pkg/front_end/testcases/patterns/non_bool_guard.dart.weak.expect
index bcf96f89a5e..daf6483e38f 100644
--- a/pkg/front_end/testcases/patterns/non_bool_guard.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/non_bool_guard.dart.weak.expect
@@ -23,19 +23,23 @@ import "dart:core" as core;
 static method test1(core::List<core::int> v) → core::String {
   #L1:
   {
-    core::int a;
     final synthesized core::List<core::int> #0#0 = v;
-    if(#0#0.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final dynamic #t1 = a = #0#0.{core::List::[]}(0){(core::int) → core::int} in true) && (let final dynamic #t2 = #0#0.{core::List::[]}(1){(core::int) → core::int} in true) && invalid-expression "pkg/front_end/testcases/patterns/non_bool_guard.dart:7:28: Error: Conditions must have a static type of 'bool'.
+    {
+      core::int a;
+      if(#0#0.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final dynamic #t1 = a = #0#0.{core::List::[]}(0){(core::int) → core::int} in true) && (let final dynamic #t2 = #0#0.{core::List::[]}(1){(core::int) → core::int} in true) && invalid-expression "pkg/front_end/testcases/patterns/non_bool_guard.dart:7:28: Error: Conditions must have a static type of 'bool'.
 Try changing the condition.
     case [var a, _] when a - 1:
                            ^") {
-      {
-        return "match";
+        {
+          return "match";
+        }
       }
     }
-    else {
+    {
       {
-        return "no match";
+        {
+          return "no match";
+        }
       }
     }
   }
@@ -56,16 +60,26 @@ Try changing the condition.
 static method test3(core::List<core::int> v) → core::String
   return block {
     core::String #t5;
-    core::int a;
     final synthesized core::List<core::int> #0#0 = v;
-    if(#0#0.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final dynamic #t6 = a = #0#0.{core::List::[]}(0){(core::int) → core::int} in true) && (let final dynamic #t7 = #0#0.{core::List::[]}(1){(core::int) → core::int} in true) && invalid-expression "pkg/front_end/testcases/patterns/non_bool_guard.dart:23:23: Error: Conditions must have a static type of 'bool'.
+    #L2:
+    {
+      {
+        core::int a;
+        if(#0#0.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final dynamic #t6 = a = #0#0.{core::List::[]}(0){(core::int) → core::int} in true) && (let final dynamic #t7 = #0#0.{core::List::[]}(1){(core::int) → core::int} in true) && invalid-expression "pkg/front_end/testcases/patterns/non_bool_guard.dart:23:23: Error: Conditions must have a static type of 'bool'.
 Try changing the condition.
     [var a, _] when a - 1 => \"match\",
-                      ^")
-      #t5 = "match";
-    else
-      if(true)
-        #t5 = "no match";
+                      ^") {
+          #t5 = "match";
+          break #L2;
+        }
+      }
+      {
+        if(true) {
+          #t5 = "no match";
+          break #L2;
+        }
+      }
+    }
   } =>#t5;
 
 constants  {
diff --git a/pkg/front_end/testcases/patterns/non_bool_guard.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/non_bool_guard.dart.weak.modular.expect
index bcf96f89a5e..daf6483e38f 100644
--- a/pkg/front_end/testcases/patterns/non_bool_guard.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/non_bool_guard.dart.weak.modular.expect
@@ -23,19 +23,23 @@ import "dart:core" as core;
 static method test1(core::List<core::int> v) → core::String {
   #L1:
   {
-    core::int a;
     final synthesized core::List<core::int> #0#0 = v;
-    if(#0#0.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final dynamic #t1 = a = #0#0.{core::List::[]}(0){(core::int) → core::int} in true) && (let final dynamic #t2 = #0#0.{core::List::[]}(1){(core::int) → core::int} in true) && invalid-expression "pkg/front_end/testcases/patterns/non_bool_guard.dart:7:28: Error: Conditions must have a static type of 'bool'.
+    {
+      core::int a;
+      if(#0#0.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final dynamic #t1 = a = #0#0.{core::List::[]}(0){(core::int) → core::int} in true) && (let final dynamic #t2 = #0#0.{core::List::[]}(1){(core::int) → core::int} in true) && invalid-expression "pkg/front_end/testcases/patterns/non_bool_guard.dart:7:28: Error: Conditions must have a static type of 'bool'.
 Try changing the condition.
     case [var a, _] when a - 1:
                            ^") {
-      {
-        return "match";
+        {
+          return "match";
+        }
       }
     }
-    else {
+    {
       {
-        return "no match";
+        {
+          return "no match";
+        }
       }
     }
   }
@@ -56,16 +60,26 @@ Try changing the condition.
 static method test3(core::List<core::int> v) → core::String
   return block {
     core::String #t5;
-    core::int a;
     final synthesized core::List<core::int> #0#0 = v;
-    if(#0#0.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final dynamic #t6 = a = #0#0.{core::List::[]}(0){(core::int) → core::int} in true) && (let final dynamic #t7 = #0#0.{core::List::[]}(1){(core::int) → core::int} in true) && invalid-expression "pkg/front_end/testcases/patterns/non_bool_guard.dart:23:23: Error: Conditions must have a static type of 'bool'.
+    #L2:
+    {
+      {
+        core::int a;
+        if(#0#0.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final dynamic #t6 = a = #0#0.{core::List::[]}(0){(core::int) → core::int} in true) && (let final dynamic #t7 = #0#0.{core::List::[]}(1){(core::int) → core::int} in true) && invalid-expression "pkg/front_end/testcases/patterns/non_bool_guard.dart:23:23: Error: Conditions must have a static type of 'bool'.
 Try changing the condition.
     [var a, _] when a - 1 => \"match\",
-                      ^")
-      #t5 = "match";
-    else
-      if(true)
-        #t5 = "no match";
+                      ^") {
+          #t5 = "match";
+          break #L2;
+        }
+      }
+      {
+        if(true) {
+          #t5 = "no match";
+          break #L2;
+        }
+      }
+    }
   } =>#t5;
 
 constants  {
diff --git a/pkg/front_end/testcases/patterns/non_bool_guard.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/non_bool_guard.dart.weak.transformed.expect
index fa185e2dbb3..1865453b1a8 100644
--- a/pkg/front_end/testcases/patterns/non_bool_guard.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/non_bool_guard.dart.weak.transformed.expect
@@ -23,19 +23,23 @@ import "dart:core" as core;
 static method test1(core::List<core::int> v) → core::String {
   #L1:
   {
-    core::int a;
     final synthesized core::List<core::int> #0#0 = v;
-    if(#0#0.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final core::int #t1 = a = #0#0.{core::List::[]}(0){(core::int) → core::int} in true) && (let final core::int #t2 = #0#0.{core::List::[]}(1){(core::int) → core::int} in true) && invalid-expression "pkg/front_end/testcases/patterns/non_bool_guard.dart:7:28: Error: Conditions must have a static type of 'bool'.
+    {
+      core::int a;
+      if(#0#0.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final core::int #t1 = a = #0#0.{core::List::[]}(0){(core::int) → core::int} in true) && (let final core::int #t2 = #0#0.{core::List::[]}(1){(core::int) → core::int} in true) && invalid-expression "pkg/front_end/testcases/patterns/non_bool_guard.dart:7:28: Error: Conditions must have a static type of 'bool'.
 Try changing the condition.
     case [var a, _] when a - 1:
                            ^") {
-      {
-        return "match";
+        {
+          return "match";
+        }
       }
     }
-    else {
+    {
       {
-        return "no match";
+        {
+          return "no match";
+        }
       }
     }
   }
@@ -56,16 +60,26 @@ Try changing the condition.
 static method test3(core::List<core::int> v) → core::String
   return block {
     core::String #t5;
-    core::int a;
     final synthesized core::List<core::int> #0#0 = v;
-    if(#0#0.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final core::int #t6 = a = #0#0.{core::List::[]}(0){(core::int) → core::int} in true) && (let final core::int #t7 = #0#0.{core::List::[]}(1){(core::int) → core::int} in true) && invalid-expression "pkg/front_end/testcases/patterns/non_bool_guard.dart:23:23: Error: Conditions must have a static type of 'bool'.
+    #L2:
+    {
+      {
+        core::int a;
+        if(#0#0.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final core::int #t6 = a = #0#0.{core::List::[]}(0){(core::int) → core::int} in true) && (let final core::int #t7 = #0#0.{core::List::[]}(1){(core::int) → core::int} in true) && invalid-expression "pkg/front_end/testcases/patterns/non_bool_guard.dart:23:23: Error: Conditions must have a static type of 'bool'.
 Try changing the condition.
     [var a, _] when a - 1 => \"match\",
-                      ^")
-      #t5 = "match";
-    else
-      if(true)
-        #t5 = "no match";
+                      ^") {
+          #t5 = "match";
+          break #L2;
+        }
+      }
+      {
+        if(true) {
+          #t5 = "no match";
+          break #L2;
+        }
+      }
+    }
   } =>#t5;
 
 constants  {
diff --git a/pkg/front_end/testcases/patterns/non_constant_pattern_in_switch.dart.strong.expect b/pkg/front_end/testcases/patterns/non_constant_pattern_in_switch.dart.strong.expect
index 67ac7cb5567..ec33d2f3d4f 100644
--- a/pkg/front_end/testcases/patterns/non_constant_pattern_in_switch.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/non_constant_pattern_in_switch.dart.strong.expect
@@ -49,53 +49,62 @@ static method test(dynamic value, core::bool expected) → void {
     synthesized core::bool #0#13#isSet = false;
     synthesized core::bool #0#16;
     synthesized core::bool #0#16#isSet = false;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t1 = #0#4#isSet = true in #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C9) && (#0#8#isSet ?{core::bool} #0#8{core::bool} : let final dynamic #t2 = #0#8#isSet = true in #0#8 = #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic})) {
-      {
-        matched = true;
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t1 = #0#4#isSet = true in #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C9) && (#0#8#isSet ?{core::bool} #0#8{core::bool} : let final dynamic #t2 = #0#8#isSet = true in #0#8 = #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic})) {
+        {
+          matched = true;
+          break #L1;
+        }
       }
     }
-    else
+    {
       if(#0#0 is{ForNonNullableByDefault} core::List<core::num> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t3 = #0#4#isSet = true in #0#4 = #0#0{core::List<core::num>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C9) && (#0#8#isSet ?{core::bool} #0#8{core::bool} : let final dynamic #t4 = #0#8#isSet = true in #0#8 = #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::num>}.{core::List::[]}(0){(core::int) → core::num})) {
         {
           matched = true;
           break #L1;
         }
       }
-      else
-        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t5 = #0#4#isSet = true in #0#4 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C9) && (#0#13#isSet ?{core::bool} #0#13{core::bool} : let final dynamic #t6 = #0#13#isSet = true in #0#13 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool}) && (#0#16#isSet ?{core::bool} #0#16{core::bool} : let final dynamic #t7 = #0#16#isSet = true in #0#16 = #C4 =={core::String::==}{(core::Object) → core::bool} #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic})) {
-          {
-            matched = true;
-            break #L1;
-          }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t5 = #0#4#isSet = true in #0#4 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C9) && (#0#13#isSet ?{core::bool} #0#13{core::bool} : let final dynamic #t6 = #0#13#isSet = true in #0#13 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool}) && (#0#16#isSet ?{core::bool} #0#16{core::bool} : let final dynamic #t7 = #0#16#isSet = true in #0#16 = #C4 =={core::String::==}{(core::Object) → core::bool} #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic})) {
+        {
+          matched = true;
+          break #L1;
         }
-        else
-          if(#0#0 is{ForNonNullableByDefault} core::Map<core::num, core::Object> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t8 = #0#4#isSet = true in #0#4 = #0#0{core::Map<core::num, core::Object>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C9) && (#0#13#isSet ?{core::bool} #0#13{core::bool} : let final dynamic #t9 = #0#13#isSet = true in #0#13 = #0#0{core::Map<core::num, core::Object>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool}) && (#0#16#isSet ?{core::bool} #0#16{core::bool} : let final dynamic #t10 = #0#16#isSet = true in #0#16 = #C4 =={core::String::==}{(core::Object) → core::bool} #0#0{core::Map<core::num, core::Object>}.{core::Map::[]}(#C1){(core::Object?) → core::Object?} as{ForNonNullableByDefault} core::Object)) {
-            {
-              matched = true;
-              break #L1;
-            }
-          }
-          else
-            if(#0#0 is{ForNonNullableByDefault} self::Const<dynamic>) {
-              {
-                matched = true;
-                break #L1;
-              }
-            }
-            else
-              if(#0#0 is{ForNonNullableByDefault} self::Const<core::num>) {
-                {
-                  matched = true;
-                  break #L1;
-                }
-              }
-              else {
-                {
-                  matched = false;
-                  break #L1;
-                }
-              }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<core::num, core::Object> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t8 = #0#4#isSet = true in #0#4 = #0#0{core::Map<core::num, core::Object>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C9) && (#0#13#isSet ?{core::bool} #0#13{core::bool} : let final dynamic #t9 = #0#13#isSet = true in #0#13 = #0#0{core::Map<core::num, core::Object>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool}) && (#0#16#isSet ?{core::bool} #0#16{core::bool} : let final dynamic #t10 = #0#16#isSet = true in #0#16 = #C4 =={core::String::==}{(core::Object) → core::bool} #0#0{core::Map<core::num, core::Object>}.{core::Map::[]}(#C1){(core::Object?) → core::Object?} as{ForNonNullableByDefault} core::Object)) {
+        {
+          matched = true;
+          break #L1;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Const<dynamic>) {
+        {
+          matched = true;
+          break #L1;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Const<core::num>) {
+        {
+          matched = true;
+          break #L1;
+        }
+      }
+    }
+    {
+      {
+        {
+          matched = false;
+          break #L1;
+        }
+      }
+    }
   }
   if(!(matched =={core::Object::==}{(core::Object) → core::bool} expected)) {
     core::print("FAIL: ${value} ${matched ?{core::String} "matched" : "didn't match"}");
diff --git a/pkg/front_end/testcases/patterns/non_constant_pattern_in_switch.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/non_constant_pattern_in_switch.dart.strong.transformed.expect
index 8289a736279..c6a787dd5fc 100644
--- a/pkg/front_end/testcases/patterns/non_constant_pattern_in_switch.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/non_constant_pattern_in_switch.dart.strong.transformed.expect
@@ -49,53 +49,62 @@ static method test(dynamic value, core::bool expected) → void {
     synthesized core::bool #0#13#isSet = false;
     synthesized core::bool #0#16;
     synthesized core::bool #0#16#isSet = false;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t1 = #0#4#isSet = true in #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C9) && (#0#8#isSet ?{core::bool} #0#8{core::bool} : let final core::bool* #t2 = #0#8#isSet = true in #0#8 = #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic})) {
-      {
-        matched = true;
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t1 = #0#4#isSet = true in #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C9) && (#0#8#isSet ?{core::bool} #0#8{core::bool} : let final core::bool* #t2 = #0#8#isSet = true in #0#8 = #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic})) {
+        {
+          matched = true;
+          break #L1;
+        }
       }
     }
-    else
+    {
       if(#0#0 is{ForNonNullableByDefault} core::List<core::num> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t3 = #0#4#isSet = true in #0#4 = #0#0{core::List<core::num>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C9) && (#0#8#isSet ?{core::bool} #0#8{core::bool} : let final core::bool* #t4 = #0#8#isSet = true in #0#8 = #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::num>}.{core::List::[]}(0){(core::int) → core::num})) {
         {
           matched = true;
           break #L1;
         }
       }
-      else
-        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t5 = #0#4#isSet = true in #0#4 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C9) && (#0#13#isSet ?{core::bool} #0#13{core::bool} : let final core::bool* #t6 = #0#13#isSet = true in #0#13 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool}) && (#0#16#isSet ?{core::bool} #0#16{core::bool} : let final core::bool* #t7 = #0#16#isSet = true in #0#16 = #C4 =={core::String::==}{(core::Object) → core::bool} #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic})) {
-          {
-            matched = true;
-            break #L1;
-          }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t5 = #0#4#isSet = true in #0#4 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C9) && (#0#13#isSet ?{core::bool} #0#13{core::bool} : let final core::bool* #t6 = #0#13#isSet = true in #0#13 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool}) && (#0#16#isSet ?{core::bool} #0#16{core::bool} : let final core::bool* #t7 = #0#16#isSet = true in #0#16 = #C4 =={core::String::==}{(core::Object) → core::bool} #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic})) {
+        {
+          matched = true;
+          break #L1;
         }
-        else
-          if(#0#0 is{ForNonNullableByDefault} core::Map<core::num, core::Object> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t8 = #0#4#isSet = true in #0#4 = #0#0{core::Map<core::num, core::Object>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C9) && (#0#13#isSet ?{core::bool} #0#13{core::bool} : let final core::bool* #t9 = #0#13#isSet = true in #0#13 = #0#0{core::Map<core::num, core::Object>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool}) && (#0#16#isSet ?{core::bool} #0#16{core::bool} : let final core::bool* #t10 = #0#16#isSet = true in #0#16 = #C4 =={core::String::==}{(core::Object) → core::bool} (let core::Object? #t11 = #0#0{core::Map<core::num, core::Object>}.{core::Map::[]}(#C1){(core::Object?) → core::Object?} in #t11 == null ?{core::Object} #t11 as{ForNonNullableByDefault} core::Object : #t11{core::Object}))) {
-            {
-              matched = true;
-              break #L1;
-            }
-          }
-          else
-            if(#0#0 is{ForNonNullableByDefault} self::Const<dynamic>) {
-              {
-                matched = true;
-                break #L1;
-              }
-            }
-            else
-              if(#0#0 is{ForNonNullableByDefault} self::Const<core::num>) {
-                {
-                  matched = true;
-                  break #L1;
-                }
-              }
-              else {
-                {
-                  matched = false;
-                  break #L1;
-                }
-              }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<core::num, core::Object> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t8 = #0#4#isSet = true in #0#4 = #0#0{core::Map<core::num, core::Object>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C9) && (#0#13#isSet ?{core::bool} #0#13{core::bool} : let final core::bool* #t9 = #0#13#isSet = true in #0#13 = #0#0{core::Map<core::num, core::Object>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool}) && (#0#16#isSet ?{core::bool} #0#16{core::bool} : let final core::bool* #t10 = #0#16#isSet = true in #0#16 = #C4 =={core::String::==}{(core::Object) → core::bool} (let core::Object? #t11 = #0#0{core::Map<core::num, core::Object>}.{core::Map::[]}(#C1){(core::Object?) → core::Object?} in #t11 == null ?{core::Object} #t11 as{ForNonNullableByDefault} core::Object : #t11{core::Object}))) {
+        {
+          matched = true;
+          break #L1;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Const<dynamic>) {
+        {
+          matched = true;
+          break #L1;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Const<core::num>) {
+        {
+          matched = true;
+          break #L1;
+        }
+      }
+    }
+    {
+      {
+        {
+          matched = false;
+          break #L1;
+        }
+      }
+    }
   }
   if(!(matched =={core::Object::==}{(core::Object) → core::bool} expected)) {
     core::print("FAIL: ${value} ${matched ?{core::String} "matched" : "didn't match"}");
diff --git a/pkg/front_end/testcases/patterns/non_constant_pattern_in_switch.dart.weak.expect b/pkg/front_end/testcases/patterns/non_constant_pattern_in_switch.dart.weak.expect
index 10f75370f29..198fe6d82be 100644
--- a/pkg/front_end/testcases/patterns/non_constant_pattern_in_switch.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/non_constant_pattern_in_switch.dart.weak.expect
@@ -49,53 +49,62 @@ static method test(dynamic value, core::bool expected) → void {
     synthesized core::bool #0#13#isSet = false;
     synthesized core::bool #0#16;
     synthesized core::bool #0#16#isSet = false;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t1 = #0#4#isSet = true in #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C9) && (#0#8#isSet ?{core::bool} #0#8{core::bool} : let final dynamic #t2 = #0#8#isSet = true in #0#8 = #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic})) {
-      {
-        matched = true;
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t1 = #0#4#isSet = true in #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C9) && (#0#8#isSet ?{core::bool} #0#8{core::bool} : let final dynamic #t2 = #0#8#isSet = true in #0#8 = #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic})) {
+        {
+          matched = true;
+          break #L1;
+        }
       }
     }
-    else
+    {
       if(#0#0 is{ForNonNullableByDefault} core::List<core::num> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t3 = #0#4#isSet = true in #0#4 = #0#0{core::List<core::num>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C9) && (#0#8#isSet ?{core::bool} #0#8{core::bool} : let final dynamic #t4 = #0#8#isSet = true in #0#8 = #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::num>}.{core::List::[]}(0){(core::int) → core::num})) {
         {
           matched = true;
           break #L1;
         }
       }
-      else
-        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t5 = #0#4#isSet = true in #0#4 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C9) && (#0#13#isSet ?{core::bool} #0#13{core::bool} : let final dynamic #t6 = #0#13#isSet = true in #0#13 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool}) && (#0#16#isSet ?{core::bool} #0#16{core::bool} : let final dynamic #t7 = #0#16#isSet = true in #0#16 = #C4 =={core::String::==}{(core::Object) → core::bool} #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic})) {
-          {
-            matched = true;
-            break #L1;
-          }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t5 = #0#4#isSet = true in #0#4 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C9) && (#0#13#isSet ?{core::bool} #0#13{core::bool} : let final dynamic #t6 = #0#13#isSet = true in #0#13 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool}) && (#0#16#isSet ?{core::bool} #0#16{core::bool} : let final dynamic #t7 = #0#16#isSet = true in #0#16 = #C4 =={core::String::==}{(core::Object) → core::bool} #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic})) {
+        {
+          matched = true;
+          break #L1;
         }
-        else
-          if(#0#0 is{ForNonNullableByDefault} core::Map<core::num, core::Object> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t8 = #0#4#isSet = true in #0#4 = #0#0{core::Map<core::num, core::Object>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C9) && (#0#13#isSet ?{core::bool} #0#13{core::bool} : let final dynamic #t9 = #0#13#isSet = true in #0#13 = #0#0{core::Map<core::num, core::Object>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool}) && (#0#16#isSet ?{core::bool} #0#16{core::bool} : let final dynamic #t10 = #0#16#isSet = true in #0#16 = #C4 =={core::String::==}{(core::Object) → core::bool} #0#0{core::Map<core::num, core::Object>}.{core::Map::[]}(#C1){(core::Object?) → core::Object?} as{ForNonNullableByDefault} core::Object)) {
-            {
-              matched = true;
-              break #L1;
-            }
-          }
-          else
-            if(#0#0 is{ForNonNullableByDefault} self::Const<dynamic>) {
-              {
-                matched = true;
-                break #L1;
-              }
-            }
-            else
-              if(#0#0 is{ForNonNullableByDefault} self::Const<core::num>) {
-                {
-                  matched = true;
-                  break #L1;
-                }
-              }
-              else {
-                {
-                  matched = false;
-                  break #L1;
-                }
-              }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<core::num, core::Object> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t8 = #0#4#isSet = true in #0#4 = #0#0{core::Map<core::num, core::Object>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C9) && (#0#13#isSet ?{core::bool} #0#13{core::bool} : let final dynamic #t9 = #0#13#isSet = true in #0#13 = #0#0{core::Map<core::num, core::Object>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool}) && (#0#16#isSet ?{core::bool} #0#16{core::bool} : let final dynamic #t10 = #0#16#isSet = true in #0#16 = #C4 =={core::String::==}{(core::Object) → core::bool} #0#0{core::Map<core::num, core::Object>}.{core::Map::[]}(#C1){(core::Object?) → core::Object?} as{ForNonNullableByDefault} core::Object)) {
+        {
+          matched = true;
+          break #L1;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Const<dynamic>) {
+        {
+          matched = true;
+          break #L1;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Const<core::num>) {
+        {
+          matched = true;
+          break #L1;
+        }
+      }
+    }
+    {
+      {
+        {
+          matched = false;
+          break #L1;
+        }
+      }
+    }
   }
   if(!(matched =={core::Object::==}{(core::Object) → core::bool} expected)) {
     core::print("FAIL: ${value} ${matched ?{core::String} "matched" : "didn't match"}");
diff --git a/pkg/front_end/testcases/patterns/non_constant_pattern_in_switch.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/non_constant_pattern_in_switch.dart.weak.modular.expect
index 10f75370f29..198fe6d82be 100644
--- a/pkg/front_end/testcases/patterns/non_constant_pattern_in_switch.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/non_constant_pattern_in_switch.dart.weak.modular.expect
@@ -49,53 +49,62 @@ static method test(dynamic value, core::bool expected) → void {
     synthesized core::bool #0#13#isSet = false;
     synthesized core::bool #0#16;
     synthesized core::bool #0#16#isSet = false;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t1 = #0#4#isSet = true in #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C9) && (#0#8#isSet ?{core::bool} #0#8{core::bool} : let final dynamic #t2 = #0#8#isSet = true in #0#8 = #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic})) {
-      {
-        matched = true;
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t1 = #0#4#isSet = true in #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C9) && (#0#8#isSet ?{core::bool} #0#8{core::bool} : let final dynamic #t2 = #0#8#isSet = true in #0#8 = #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic})) {
+        {
+          matched = true;
+          break #L1;
+        }
       }
     }
-    else
+    {
       if(#0#0 is{ForNonNullableByDefault} core::List<core::num> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t3 = #0#4#isSet = true in #0#4 = #0#0{core::List<core::num>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C9) && (#0#8#isSet ?{core::bool} #0#8{core::bool} : let final dynamic #t4 = #0#8#isSet = true in #0#8 = #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::num>}.{core::List::[]}(0){(core::int) → core::num})) {
         {
           matched = true;
           break #L1;
         }
       }
-      else
-        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t5 = #0#4#isSet = true in #0#4 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C9) && (#0#13#isSet ?{core::bool} #0#13{core::bool} : let final dynamic #t6 = #0#13#isSet = true in #0#13 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool}) && (#0#16#isSet ?{core::bool} #0#16{core::bool} : let final dynamic #t7 = #0#16#isSet = true in #0#16 = #C4 =={core::String::==}{(core::Object) → core::bool} #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic})) {
-          {
-            matched = true;
-            break #L1;
-          }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t5 = #0#4#isSet = true in #0#4 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C9) && (#0#13#isSet ?{core::bool} #0#13{core::bool} : let final dynamic #t6 = #0#13#isSet = true in #0#13 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool}) && (#0#16#isSet ?{core::bool} #0#16{core::bool} : let final dynamic #t7 = #0#16#isSet = true in #0#16 = #C4 =={core::String::==}{(core::Object) → core::bool} #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic})) {
+        {
+          matched = true;
+          break #L1;
         }
-        else
-          if(#0#0 is{ForNonNullableByDefault} core::Map<core::num, core::Object> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t8 = #0#4#isSet = true in #0#4 = #0#0{core::Map<core::num, core::Object>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C9) && (#0#13#isSet ?{core::bool} #0#13{core::bool} : let final dynamic #t9 = #0#13#isSet = true in #0#13 = #0#0{core::Map<core::num, core::Object>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool}) && (#0#16#isSet ?{core::bool} #0#16{core::bool} : let final dynamic #t10 = #0#16#isSet = true in #0#16 = #C4 =={core::String::==}{(core::Object) → core::bool} #0#0{core::Map<core::num, core::Object>}.{core::Map::[]}(#C1){(core::Object?) → core::Object?} as{ForNonNullableByDefault} core::Object)) {
-            {
-              matched = true;
-              break #L1;
-            }
-          }
-          else
-            if(#0#0 is{ForNonNullableByDefault} self::Const<dynamic>) {
-              {
-                matched = true;
-                break #L1;
-              }
-            }
-            else
-              if(#0#0 is{ForNonNullableByDefault} self::Const<core::num>) {
-                {
-                  matched = true;
-                  break #L1;
-                }
-              }
-              else {
-                {
-                  matched = false;
-                  break #L1;
-                }
-              }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<core::num, core::Object> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t8 = #0#4#isSet = true in #0#4 = #0#0{core::Map<core::num, core::Object>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C9) && (#0#13#isSet ?{core::bool} #0#13{core::bool} : let final dynamic #t9 = #0#13#isSet = true in #0#13 = #0#0{core::Map<core::num, core::Object>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool}) && (#0#16#isSet ?{core::bool} #0#16{core::bool} : let final dynamic #t10 = #0#16#isSet = true in #0#16 = #C4 =={core::String::==}{(core::Object) → core::bool} #0#0{core::Map<core::num, core::Object>}.{core::Map::[]}(#C1){(core::Object?) → core::Object?} as{ForNonNullableByDefault} core::Object)) {
+        {
+          matched = true;
+          break #L1;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Const<dynamic>) {
+        {
+          matched = true;
+          break #L1;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Const<core::num>) {
+        {
+          matched = true;
+          break #L1;
+        }
+      }
+    }
+    {
+      {
+        {
+          matched = false;
+          break #L1;
+        }
+      }
+    }
   }
   if(!(matched =={core::Object::==}{(core::Object) → core::bool} expected)) {
     core::print("FAIL: ${value} ${matched ?{core::String} "matched" : "didn't match"}");
diff --git a/pkg/front_end/testcases/patterns/non_constant_pattern_in_switch.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/non_constant_pattern_in_switch.dart.weak.transformed.expect
index c9e949ba1f5..b812437eb9c 100644
--- a/pkg/front_end/testcases/patterns/non_constant_pattern_in_switch.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/non_constant_pattern_in_switch.dart.weak.transformed.expect
@@ -49,53 +49,62 @@ static method test(dynamic value, core::bool expected) → void {
     synthesized core::bool #0#13#isSet = false;
     synthesized core::bool #0#16;
     synthesized core::bool #0#16#isSet = false;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t1 = #0#4#isSet = true in #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C9) && (#0#8#isSet ?{core::bool} #0#8{core::bool} : let final core::bool* #t2 = #0#8#isSet = true in #0#8 = #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic})) {
-      {
-        matched = true;
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t1 = #0#4#isSet = true in #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C9) && (#0#8#isSet ?{core::bool} #0#8{core::bool} : let final core::bool* #t2 = #0#8#isSet = true in #0#8 = #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic})) {
+        {
+          matched = true;
+          break #L1;
+        }
       }
     }
-    else
+    {
       if(#0#0 is{ForNonNullableByDefault} core::List<core::num> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t3 = #0#4#isSet = true in #0#4 = #0#0{core::List<core::num>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C9) && (#0#8#isSet ?{core::bool} #0#8{core::bool} : let final core::bool* #t4 = #0#8#isSet = true in #0#8 = #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<core::num>}.{core::List::[]}(0){(core::int) → core::num})) {
         {
           matched = true;
           break #L1;
         }
       }
-      else
-        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t5 = #0#4#isSet = true in #0#4 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C9) && (#0#13#isSet ?{core::bool} #0#13{core::bool} : let final core::bool* #t6 = #0#13#isSet = true in #0#13 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool}) && (#0#16#isSet ?{core::bool} #0#16{core::bool} : let final core::bool* #t7 = #0#16#isSet = true in #0#16 = #C4 =={core::String::==}{(core::Object) → core::bool} #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic})) {
-          {
-            matched = true;
-            break #L1;
-          }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t5 = #0#4#isSet = true in #0#4 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C9) && (#0#13#isSet ?{core::bool} #0#13{core::bool} : let final core::bool* #t6 = #0#13#isSet = true in #0#13 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool}) && (#0#16#isSet ?{core::bool} #0#16{core::bool} : let final core::bool* #t7 = #0#16#isSet = true in #0#16 = #C4 =={core::String::==}{(core::Object) → core::bool} #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic})) {
+        {
+          matched = true;
+          break #L1;
         }
-        else
-          if(#0#0 is{ForNonNullableByDefault} core::Map<core::num, core::Object> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t8 = #0#4#isSet = true in #0#4 = #0#0{core::Map<core::num, core::Object>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C9) && (#0#13#isSet ?{core::bool} #0#13{core::bool} : let final core::bool* #t9 = #0#13#isSet = true in #0#13 = #0#0{core::Map<core::num, core::Object>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool}) && (#0#16#isSet ?{core::bool} #0#16{core::bool} : let final core::bool* #t10 = #0#16#isSet = true in #0#16 = #C4 =={core::String::==}{(core::Object) → core::bool} #0#0{core::Map<core::num, core::Object>}.{core::Map::[]}(#C1){(core::Object?) → core::Object?})) {
-            {
-              matched = true;
-              break #L1;
-            }
-          }
-          else
-            if(#0#0 is{ForNonNullableByDefault} self::Const<dynamic>) {
-              {
-                matched = true;
-                break #L1;
-              }
-            }
-            else
-              if(#0#0 is{ForNonNullableByDefault} self::Const<core::num>) {
-                {
-                  matched = true;
-                  break #L1;
-                }
-              }
-              else {
-                {
-                  matched = false;
-                  break #L1;
-                }
-              }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<core::num, core::Object> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t8 = #0#4#isSet = true in #0#4 = #0#0{core::Map<core::num, core::Object>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C9) && (#0#13#isSet ?{core::bool} #0#13{core::bool} : let final core::bool* #t9 = #0#13#isSet = true in #0#13 = #0#0{core::Map<core::num, core::Object>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool}) && (#0#16#isSet ?{core::bool} #0#16{core::bool} : let final core::bool* #t10 = #0#16#isSet = true in #0#16 = #C4 =={core::String::==}{(core::Object) → core::bool} #0#0{core::Map<core::num, core::Object>}.{core::Map::[]}(#C1){(core::Object?) → core::Object?})) {
+        {
+          matched = true;
+          break #L1;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Const<dynamic>) {
+        {
+          matched = true;
+          break #L1;
+        }
+      }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::Const<core::num>) {
+        {
+          matched = true;
+          break #L1;
+        }
+      }
+    }
+    {
+      {
+        {
+          matched = false;
+          break #L1;
+        }
+      }
+    }
   }
   if(!(matched =={core::Object::==}{(core::Object) → core::bool} expected)) {
     core::print("FAIL: ${value} ${matched ?{core::String} "matched" : "didn't match"}");
diff --git a/pkg/front_end/testcases/patterns/non_pattern_case_among_pattern_cases_in_switch.dart.strong.expect b/pkg/front_end/testcases/patterns/non_pattern_case_among_pattern_cases_in_switch.dart.strong.expect
index 21b24a34ca7..1eb71940d8c 100644
--- a/pkg/front_end/testcases/patterns/non_pattern_case_among_pattern_cases_in_switch.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/non_pattern_case_among_pattern_cases_in_switch.dart.strong.expect
@@ -12,19 +12,23 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final dynamic a;
-    final dynamic a#1;
     final synthesized dynamic #0#0 = x;
-    if((let final dynamic #t1 = a = #0#0 in true) && a{dynamic}.>(0) || #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || (let final dynamic #t2 = a#1 = #0#0 in true)) {
-      {
-        return invalid-expression "pkg/front_end/testcases/patterns/non_pattern_case_among_pattern_cases_in_switch.dart:10:14: Error: Undefined name 'a'.
+    {
+      lowered final dynamic a#case#0;
+      lowered final dynamic a#case#1;
+      if((let final dynamic #t1 = a#case#0 = #0#0 in true) && a#case#0{dynamic}.>(0) || #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || (let final dynamic #t2 = a#case#1 = #0#0 in true)) {
+        {
+          return invalid-expression "pkg/front_end/testcases/patterns/non_pattern_case_among_pattern_cases_in_switch.dart:10:14: Error: Undefined name 'a'.
       return a; // Error.
              ^";
+        }
       }
     }
-    else {
+    {
       {
-        return null;
+        {
+          return null;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/non_pattern_case_among_pattern_cases_in_switch.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/non_pattern_case_among_pattern_cases_in_switch.dart.strong.transformed.expect
index 21b24a34ca7..1eb71940d8c 100644
--- a/pkg/front_end/testcases/patterns/non_pattern_case_among_pattern_cases_in_switch.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/non_pattern_case_among_pattern_cases_in_switch.dart.strong.transformed.expect
@@ -12,19 +12,23 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final dynamic a;
-    final dynamic a#1;
     final synthesized dynamic #0#0 = x;
-    if((let final dynamic #t1 = a = #0#0 in true) && a{dynamic}.>(0) || #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || (let final dynamic #t2 = a#1 = #0#0 in true)) {
-      {
-        return invalid-expression "pkg/front_end/testcases/patterns/non_pattern_case_among_pattern_cases_in_switch.dart:10:14: Error: Undefined name 'a'.
+    {
+      lowered final dynamic a#case#0;
+      lowered final dynamic a#case#1;
+      if((let final dynamic #t1 = a#case#0 = #0#0 in true) && a#case#0{dynamic}.>(0) || #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || (let final dynamic #t2 = a#case#1 = #0#0 in true)) {
+        {
+          return invalid-expression "pkg/front_end/testcases/patterns/non_pattern_case_among_pattern_cases_in_switch.dart:10:14: Error: Undefined name 'a'.
       return a; // Error.
              ^";
+        }
       }
     }
-    else {
+    {
       {
-        return null;
+        {
+          return null;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/non_pattern_case_among_pattern_cases_in_switch.dart.weak.expect b/pkg/front_end/testcases/patterns/non_pattern_case_among_pattern_cases_in_switch.dart.weak.expect
index 21b24a34ca7..1eb71940d8c 100644
--- a/pkg/front_end/testcases/patterns/non_pattern_case_among_pattern_cases_in_switch.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/non_pattern_case_among_pattern_cases_in_switch.dart.weak.expect
@@ -12,19 +12,23 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final dynamic a;
-    final dynamic a#1;
     final synthesized dynamic #0#0 = x;
-    if((let final dynamic #t1 = a = #0#0 in true) && a{dynamic}.>(0) || #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || (let final dynamic #t2 = a#1 = #0#0 in true)) {
-      {
-        return invalid-expression "pkg/front_end/testcases/patterns/non_pattern_case_among_pattern_cases_in_switch.dart:10:14: Error: Undefined name 'a'.
+    {
+      lowered final dynamic a#case#0;
+      lowered final dynamic a#case#1;
+      if((let final dynamic #t1 = a#case#0 = #0#0 in true) && a#case#0{dynamic}.>(0) || #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || (let final dynamic #t2 = a#case#1 = #0#0 in true)) {
+        {
+          return invalid-expression "pkg/front_end/testcases/patterns/non_pattern_case_among_pattern_cases_in_switch.dart:10:14: Error: Undefined name 'a'.
       return a; // Error.
              ^";
+        }
       }
     }
-    else {
+    {
       {
-        return null;
+        {
+          return null;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/non_pattern_case_among_pattern_cases_in_switch.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/non_pattern_case_among_pattern_cases_in_switch.dart.weak.modular.expect
index 21b24a34ca7..1eb71940d8c 100644
--- a/pkg/front_end/testcases/patterns/non_pattern_case_among_pattern_cases_in_switch.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/non_pattern_case_among_pattern_cases_in_switch.dart.weak.modular.expect
@@ -12,19 +12,23 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final dynamic a;
-    final dynamic a#1;
     final synthesized dynamic #0#0 = x;
-    if((let final dynamic #t1 = a = #0#0 in true) && a{dynamic}.>(0) || #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || (let final dynamic #t2 = a#1 = #0#0 in true)) {
-      {
-        return invalid-expression "pkg/front_end/testcases/patterns/non_pattern_case_among_pattern_cases_in_switch.dart:10:14: Error: Undefined name 'a'.
+    {
+      lowered final dynamic a#case#0;
+      lowered final dynamic a#case#1;
+      if((let final dynamic #t1 = a#case#0 = #0#0 in true) && a#case#0{dynamic}.>(0) || #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || (let final dynamic #t2 = a#case#1 = #0#0 in true)) {
+        {
+          return invalid-expression "pkg/front_end/testcases/patterns/non_pattern_case_among_pattern_cases_in_switch.dart:10:14: Error: Undefined name 'a'.
       return a; // Error.
              ^";
+        }
       }
     }
-    else {
+    {
       {
-        return null;
+        {
+          return null;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/non_pattern_case_among_pattern_cases_in_switch.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/non_pattern_case_among_pattern_cases_in_switch.dart.weak.transformed.expect
index 21b24a34ca7..1eb71940d8c 100644
--- a/pkg/front_end/testcases/patterns/non_pattern_case_among_pattern_cases_in_switch.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/non_pattern_case_among_pattern_cases_in_switch.dart.weak.transformed.expect
@@ -12,19 +12,23 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final dynamic a;
-    final dynamic a#1;
     final synthesized dynamic #0#0 = x;
-    if((let final dynamic #t1 = a = #0#0 in true) && a{dynamic}.>(0) || #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || (let final dynamic #t2 = a#1 = #0#0 in true)) {
-      {
-        return invalid-expression "pkg/front_end/testcases/patterns/non_pattern_case_among_pattern_cases_in_switch.dart:10:14: Error: Undefined name 'a'.
+    {
+      lowered final dynamic a#case#0;
+      lowered final dynamic a#case#1;
+      if((let final dynamic #t1 = a#case#0 = #0#0 in true) && a#case#0{dynamic}.>(0) || #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || (let final dynamic #t2 = a#case#1 = #0#0 in true)) {
+        {
+          return invalid-expression "pkg/front_end/testcases/patterns/non_pattern_case_among_pattern_cases_in_switch.dart:10:14: Error: Undefined name 'a'.
       return a; // Error.
              ^";
+        }
       }
     }
-    else {
+    {
       {
-        return null;
+        {
+          return null;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/non_type_object_pattern.dart.strong.expect b/pkg/front_end/testcases/patterns/non_type_object_pattern.dart.strong.expect
index 5714a8a3506..59a2113633a 100644
--- a/pkg/front_end/testcases/patterns/non_type_object_pattern.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/non_type_object_pattern.dart.strong.expect
@@ -273,23 +273,35 @@ static method testUnresolved(dynamic o) → dynamic {
   }
   #L1:
   {
-    invalid-type field;
     final synthesized invalid-type #3#0 = o{invalid-type};
-    if(let final dynamic #t4 = field = #3#0{<invalid>}.field in true) {
-      {
-        break #L1;
+    {
+      invalid-type field;
+      if(let final dynamic #t4 = field = #3#0{<invalid>}.field in true) {
+        {
+          break #L1;
+        }
       }
     }
   }
   o = block {
     core::String #t5;
-    invalid-type field;
     final synthesized invalid-type #4#0 = o{invalid-type};
-    if(let final dynamic #t6 = field = #4#0{<invalid>}.field in true)
-      #t5 = "matched";
-    else
-      if(true)
-        #t5 = "";
+    #L2:
+    {
+      {
+        invalid-type field;
+        if(let final dynamic #t6 = field = #4#0{<invalid>}.field in true) {
+          #t5 = "matched";
+          break #L2;
+        }
+      }
+      {
+        if(true) {
+          #t5 = "";
+          break #L2;
+        }
+      }
+    }
   } =>#t5;
 }
 static method testNonType(dynamic o) → dynamic {
@@ -314,25 +326,37 @@ static method testNonType(dynamic o) → dynamic {
     if(let final dynamic #t9 = field = #2#0{<invalid>}.field in true) {
     }
   }
-  #L2:
+  #L3:
   {
-    invalid-type field;
     final synthesized invalid-type #3#0 = o{invalid-type};
-    if(let final dynamic #t10 = field = #3#0{<invalid>}.field in true) {
-      {
-        break #L2;
+    {
+      invalid-type field;
+      if(let final dynamic #t10 = field = #3#0{<invalid>}.field in true) {
+        {
+          break #L3;
+        }
       }
     }
   }
   o = block {
     core::String #t11;
-    invalid-type field;
     final synthesized invalid-type #4#0 = o{invalid-type};
-    if(let final dynamic #t12 = field = #4#0{<invalid>}.field in true)
-      #t11 = "matched";
-    else
-      if(true)
-        #t11 = "";
+    #L4:
+    {
+      {
+        invalid-type field;
+        if(let final dynamic #t12 = field = #4#0{<invalid>}.field in true) {
+          #t11 = "matched";
+          break #L4;
+        }
+      }
+      {
+        if(true) {
+          #t11 = "";
+          break #L4;
+        }
+      }
+    }
   } =>#t11;
 }
 static method testExtension(dynamic o) → dynamic {
@@ -357,25 +381,37 @@ static method testExtension(dynamic o) → dynamic {
     if(let final dynamic #t15 = field = #2#0{<invalid>}.field in true) {
     }
   }
-  #L3:
+  #L5:
   {
-    invalid-type field;
     final synthesized invalid-type #3#0 = o{invalid-type};
-    if(let final dynamic #t16 = field = #3#0{<invalid>}.field in true) {
-      {
-        break #L3;
+    {
+      invalid-type field;
+      if(let final dynamic #t16 = field = #3#0{<invalid>}.field in true) {
+        {
+          break #L5;
+        }
       }
     }
   }
   o = block {
     core::String #t17;
-    invalid-type field;
     final synthesized invalid-type #4#0 = o{invalid-type};
-    if(let final dynamic #t18 = field = #4#0{<invalid>}.field in true)
-      #t17 = "matched";
-    else
-      if(true)
-        #t17 = "";
+    #L6:
+    {
+      {
+        invalid-type field;
+        if(let final dynamic #t18 = field = #4#0{<invalid>}.field in true) {
+          #t17 = "matched";
+          break #L6;
+        }
+      }
+      {
+        if(true) {
+          #t17 = "";
+          break #L6;
+        }
+      }
+    }
   } =>#t17;
 }
 static method testPrefixedUnresolved(dynamic o) → dynamic {
@@ -400,25 +436,37 @@ static method testPrefixedUnresolved(dynamic o) → dynamic {
     if(let final dynamic #t21 = field = #2#0{<invalid>}.field in true) {
     }
   }
-  #L4:
+  #L7:
   {
-    invalid-type field;
     final synthesized invalid-type #3#0 = o{invalid-type};
-    if(let final dynamic #t22 = field = #3#0{<invalid>}.field in true) {
-      {
-        break #L4;
+    {
+      invalid-type field;
+      if(let final dynamic #t22 = field = #3#0{<invalid>}.field in true) {
+        {
+          break #L7;
+        }
       }
     }
   }
   o = block {
     core::String #t23;
-    invalid-type field;
     final synthesized invalid-type #4#0 = o{invalid-type};
-    if(let final dynamic #t24 = field = #4#0{<invalid>}.field in true)
-      #t23 = "matched";
-    else
-      if(true)
-        #t23 = "";
+    #L8:
+    {
+      {
+        invalid-type field;
+        if(let final dynamic #t24 = field = #4#0{<invalid>}.field in true) {
+          #t23 = "matched";
+          break #L8;
+        }
+      }
+      {
+        if(true) {
+          #t23 = "";
+          break #L8;
+        }
+      }
+    }
   } =>#t23;
 }
 static method testPrefixedNonType(dynamic o) → dynamic {
@@ -443,25 +491,37 @@ static method testPrefixedNonType(dynamic o) → dynamic {
     if(let final dynamic #t27 = field = #2#0{<invalid>}.field in true) {
     }
   }
-  #L5:
+  #L9:
   {
-    invalid-type field;
     final synthesized invalid-type #3#0 = o{invalid-type};
-    if(let final dynamic #t28 = field = #3#0{<invalid>}.field in true) {
-      {
-        break #L5;
+    {
+      invalid-type field;
+      if(let final dynamic #t28 = field = #3#0{<invalid>}.field in true) {
+        {
+          break #L9;
+        }
       }
     }
   }
   o = block {
     core::String #t29;
-    invalid-type field;
     final synthesized invalid-type #4#0 = o{invalid-type};
-    if(let final dynamic #t30 = field = #4#0{<invalid>}.field in true)
-      #t29 = "matched";
-    else
-      if(true)
-        #t29 = "";
+    #L10:
+    {
+      {
+        invalid-type field;
+        if(let final dynamic #t30 = field = #4#0{<invalid>}.field in true) {
+          #t29 = "matched";
+          break #L10;
+        }
+      }
+      {
+        if(true) {
+          #t29 = "";
+          break #L10;
+        }
+      }
+    }
   } =>#t29;
 }
 static method testPrefixedExtension(dynamic o) → dynamic {
@@ -486,25 +546,37 @@ static method testPrefixedExtension(dynamic o) → dynamic {
     if(let final dynamic #t33 = field = #2#0{<invalid>}.field in true) {
     }
   }
-  #L6:
+  #L11:
   {
-    invalid-type field;
     final synthesized invalid-type #3#0 = o{invalid-type};
-    if(let final dynamic #t34 = field = #3#0{<invalid>}.field in true) {
-      {
-        break #L6;
+    {
+      invalid-type field;
+      if(let final dynamic #t34 = field = #3#0{<invalid>}.field in true) {
+        {
+          break #L11;
+        }
       }
     }
   }
   o = block {
     core::String #t35;
-    invalid-type field;
     final synthesized invalid-type #4#0 = o{invalid-type};
-    if(let final dynamic #t36 = field = #4#0{<invalid>}.field in true)
-      #t35 = "matched";
-    else
-      if(true)
-        #t35 = "";
+    #L12:
+    {
+      {
+        invalid-type field;
+        if(let final dynamic #t36 = field = #4#0{<invalid>}.field in true) {
+          #t35 = "matched";
+          break #L12;
+        }
+      }
+      {
+        if(true) {
+          #t35 = "";
+          break #L12;
+        }
+      }
+    }
   } =>#t35;
 }
 static method testUnresolvedPrefix(dynamic o) → dynamic {
@@ -529,25 +601,37 @@ static method testUnresolvedPrefix(dynamic o) → dynamic {
     if(let final dynamic #t39 = field = #2#0{<invalid>}.field in true) {
     }
   }
-  #L7:
+  #L13:
   {
-    invalid-type field;
     final synthesized invalid-type #3#0 = o{invalid-type};
-    if(let final dynamic #t40 = field = #3#0{<invalid>}.field in true) {
-      {
-        break #L7;
+    {
+      invalid-type field;
+      if(let final dynamic #t40 = field = #3#0{<invalid>}.field in true) {
+        {
+          break #L13;
+        }
       }
     }
   }
   o = block {
     core::String #t41;
-    invalid-type field;
     final synthesized invalid-type #4#0 = o{invalid-type};
-    if(let final dynamic #t42 = field = #4#0{<invalid>}.field in true)
-      #t41 = "matched";
-    else
-      if(true)
-        #t41 = "";
+    #L14:
+    {
+      {
+        invalid-type field;
+        if(let final dynamic #t42 = field = #4#0{<invalid>}.field in true) {
+          #t41 = "matched";
+          break #L14;
+        }
+      }
+      {
+        if(true) {
+          #t41 = "";
+          break #L14;
+        }
+      }
+    }
   } =>#t41;
 }
 static method testMemberAccess(dynamic o) → dynamic {
@@ -572,24 +656,36 @@ static method testMemberAccess(dynamic o) → dynamic {
     if(let final dynamic #t45 = field = #2#0{<invalid>}.field in true) {
     }
   }
-  #L8:
+  #L15:
   {
-    invalid-type field;
     final synthesized invalid-type #3#0 = o{invalid-type};
-    if(let final dynamic #t46 = field = #3#0{<invalid>}.field in true) {
-      {
-        break #L8;
+    {
+      invalid-type field;
+      if(let final dynamic #t46 = field = #3#0{<invalid>}.field in true) {
+        {
+          break #L15;
+        }
       }
     }
   }
   o = block {
     core::String #t47;
-    invalid-type field;
     final synthesized invalid-type #4#0 = o{invalid-type};
-    if(let final dynamic #t48 = field = #4#0{<invalid>}.field in true)
-      #t47 = "matched";
-    else
-      if(true)
-        #t47 = "";
+    #L16:
+    {
+      {
+        invalid-type field;
+        if(let final dynamic #t48 = field = #4#0{<invalid>}.field in true) {
+          #t47 = "matched";
+          break #L16;
+        }
+      }
+      {
+        if(true) {
+          #t47 = "";
+          break #L16;
+        }
+      }
+    }
   } =>#t47;
 }
diff --git a/pkg/front_end/testcases/patterns/non_type_object_pattern.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/non_type_object_pattern.dart.strong.transformed.expect
index 2d0a8b1571e..dc52462714b 100644
--- a/pkg/front_end/testcases/patterns/non_type_object_pattern.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/non_type_object_pattern.dart.strong.transformed.expect
@@ -275,23 +275,35 @@ static method testUnresolved(dynamic o) → dynamic {
   }
   #L1:
   {
-    invalid-type field;
     final synthesized invalid-type #3#0 = o{invalid-type};
-    if(let final invalid-type #t4 = field = #3#0{<invalid>}.field in true) {
-      {
-        break #L1;
+    {
+      invalid-type field;
+      if(let final invalid-type #t4 = field = #3#0{<invalid>}.field in true) {
+        {
+          break #L1;
+        }
       }
     }
   }
   o = block {
     core::String #t5;
-    invalid-type field;
     final synthesized invalid-type #4#0 = o{invalid-type};
-    if(let final invalid-type #t6 = field = #4#0{<invalid>}.field in true)
-      #t5 = "matched";
-    else
-      if(true)
-        #t5 = "";
+    #L2:
+    {
+      {
+        invalid-type field;
+        if(let final invalid-type #t6 = field = #4#0{<invalid>}.field in true) {
+          #t5 = "matched";
+          break #L2;
+        }
+      }
+      {
+        if(true) {
+          #t5 = "";
+          break #L2;
+        }
+      }
+    }
   } =>#t5;
 }
 static method testNonType(dynamic o) → dynamic {
@@ -318,25 +330,37 @@ static method testNonType(dynamic o) → dynamic {
     if(let final invalid-type #t9 = field = #2#0{<invalid>}.field in true) {
     }
   }
-  #L2:
+  #L3:
   {
-    invalid-type field;
     final synthesized invalid-type #3#0 = o{invalid-type};
-    if(let final invalid-type #t10 = field = #3#0{<invalid>}.field in true) {
-      {
-        break #L2;
+    {
+      invalid-type field;
+      if(let final invalid-type #t10 = field = #3#0{<invalid>}.field in true) {
+        {
+          break #L3;
+        }
       }
     }
   }
   o = block {
     core::String #t11;
-    invalid-type field;
     final synthesized invalid-type #4#0 = o{invalid-type};
-    if(let final invalid-type #t12 = field = #4#0{<invalid>}.field in true)
-      #t11 = "matched";
-    else
-      if(true)
-        #t11 = "";
+    #L4:
+    {
+      {
+        invalid-type field;
+        if(let final invalid-type #t12 = field = #4#0{<invalid>}.field in true) {
+          #t11 = "matched";
+          break #L4;
+        }
+      }
+      {
+        if(true) {
+          #t11 = "";
+          break #L4;
+        }
+      }
+    }
   } =>#t11;
 }
 static method testExtension(dynamic o) → dynamic {
@@ -363,25 +387,37 @@ static method testExtension(dynamic o) → dynamic {
     if(let final invalid-type #t15 = field = #2#0{<invalid>}.field in true) {
     }
   }
-  #L3:
+  #L5:
   {
-    invalid-type field;
     final synthesized invalid-type #3#0 = o{invalid-type};
-    if(let final invalid-type #t16 = field = #3#0{<invalid>}.field in true) {
-      {
-        break #L3;
+    {
+      invalid-type field;
+      if(let final invalid-type #t16 = field = #3#0{<invalid>}.field in true) {
+        {
+          break #L5;
+        }
       }
     }
   }
   o = block {
     core::String #t17;
-    invalid-type field;
     final synthesized invalid-type #4#0 = o{invalid-type};
-    if(let final invalid-type #t18 = field = #4#0{<invalid>}.field in true)
-      #t17 = "matched";
-    else
-      if(true)
-        #t17 = "";
+    #L6:
+    {
+      {
+        invalid-type field;
+        if(let final invalid-type #t18 = field = #4#0{<invalid>}.field in true) {
+          #t17 = "matched";
+          break #L6;
+        }
+      }
+      {
+        if(true) {
+          #t17 = "";
+          break #L6;
+        }
+      }
+    }
   } =>#t17;
 }
 static method testPrefixedUnresolved(dynamic o) → dynamic {
@@ -408,25 +444,37 @@ static method testPrefixedUnresolved(dynamic o) → dynamic {
     if(let final invalid-type #t21 = field = #2#0{<invalid>}.field in true) {
     }
   }
-  #L4:
+  #L7:
   {
-    invalid-type field;
     final synthesized invalid-type #3#0 = o{invalid-type};
-    if(let final invalid-type #t22 = field = #3#0{<invalid>}.field in true) {
-      {
-        break #L4;
+    {
+      invalid-type field;
+      if(let final invalid-type #t22 = field = #3#0{<invalid>}.field in true) {
+        {
+          break #L7;
+        }
       }
     }
   }
   o = block {
     core::String #t23;
-    invalid-type field;
     final synthesized invalid-type #4#0 = o{invalid-type};
-    if(let final invalid-type #t24 = field = #4#0{<invalid>}.field in true)
-      #t23 = "matched";
-    else
-      if(true)
-        #t23 = "";
+    #L8:
+    {
+      {
+        invalid-type field;
+        if(let final invalid-type #t24 = field = #4#0{<invalid>}.field in true) {
+          #t23 = "matched";
+          break #L8;
+        }
+      }
+      {
+        if(true) {
+          #t23 = "";
+          break #L8;
+        }
+      }
+    }
   } =>#t23;
 }
 static method testPrefixedNonType(dynamic o) → dynamic {
@@ -453,25 +501,37 @@ static method testPrefixedNonType(dynamic o) → dynamic {
     if(let final invalid-type #t27 = field = #2#0{<invalid>}.field in true) {
     }
   }
-  #L5:
+  #L9:
   {
-    invalid-type field;
     final synthesized invalid-type #3#0 = o{invalid-type};
-    if(let final invalid-type #t28 = field = #3#0{<invalid>}.field in true) {
-      {
-        break #L5;
+    {
+      invalid-type field;
+      if(let final invalid-type #t28 = field = #3#0{<invalid>}.field in true) {
+        {
+          break #L9;
+        }
       }
     }
   }
   o = block {
     core::String #t29;
-    invalid-type field;
     final synthesized invalid-type #4#0 = o{invalid-type};
-    if(let final invalid-type #t30 = field = #4#0{<invalid>}.field in true)
-      #t29 = "matched";
-    else
-      if(true)
-        #t29 = "";
+    #L10:
+    {
+      {
+        invalid-type field;
+        if(let final invalid-type #t30 = field = #4#0{<invalid>}.field in true) {
+          #t29 = "matched";
+          break #L10;
+        }
+      }
+      {
+        if(true) {
+          #t29 = "";
+          break #L10;
+        }
+      }
+    }
   } =>#t29;
 }
 static method testPrefixedExtension(dynamic o) → dynamic {
@@ -498,25 +558,37 @@ static method testPrefixedExtension(dynamic o) → dynamic {
     if(let final invalid-type #t33 = field = #2#0{<invalid>}.field in true) {
     }
   }
-  #L6:
+  #L11:
   {
-    invalid-type field;
     final synthesized invalid-type #3#0 = o{invalid-type};
-    if(let final invalid-type #t34 = field = #3#0{<invalid>}.field in true) {
-      {
-        break #L6;
+    {
+      invalid-type field;
+      if(let final invalid-type #t34 = field = #3#0{<invalid>}.field in true) {
+        {
+          break #L11;
+        }
       }
     }
   }
   o = block {
     core::String #t35;
-    invalid-type field;
     final synthesized invalid-type #4#0 = o{invalid-type};
-    if(let final invalid-type #t36 = field = #4#0{<invalid>}.field in true)
-      #t35 = "matched";
-    else
-      if(true)
-        #t35 = "";
+    #L12:
+    {
+      {
+        invalid-type field;
+        if(let final invalid-type #t36 = field = #4#0{<invalid>}.field in true) {
+          #t35 = "matched";
+          break #L12;
+        }
+      }
+      {
+        if(true) {
+          #t35 = "";
+          break #L12;
+        }
+      }
+    }
   } =>#t35;
 }
 static method testUnresolvedPrefix(dynamic o) → dynamic {
@@ -543,25 +615,37 @@ static method testUnresolvedPrefix(dynamic o) → dynamic {
     if(let final invalid-type #t39 = field = #2#0{<invalid>}.field in true) {
     }
   }
-  #L7:
+  #L13:
   {
-    invalid-type field;
     final synthesized invalid-type #3#0 = o{invalid-type};
-    if(let final invalid-type #t40 = field = #3#0{<invalid>}.field in true) {
-      {
-        break #L7;
+    {
+      invalid-type field;
+      if(let final invalid-type #t40 = field = #3#0{<invalid>}.field in true) {
+        {
+          break #L13;
+        }
       }
     }
   }
   o = block {
     core::String #t41;
-    invalid-type field;
     final synthesized invalid-type #4#0 = o{invalid-type};
-    if(let final invalid-type #t42 = field = #4#0{<invalid>}.field in true)
-      #t41 = "matched";
-    else
-      if(true)
-        #t41 = "";
+    #L14:
+    {
+      {
+        invalid-type field;
+        if(let final invalid-type #t42 = field = #4#0{<invalid>}.field in true) {
+          #t41 = "matched";
+          break #L14;
+        }
+      }
+      {
+        if(true) {
+          #t41 = "";
+          break #L14;
+        }
+      }
+    }
   } =>#t41;
 }
 static method testMemberAccess(dynamic o) → dynamic {
@@ -588,24 +672,36 @@ static method testMemberAccess(dynamic o) → dynamic {
     if(let final invalid-type #t45 = field = #2#0{<invalid>}.field in true) {
     }
   }
-  #L8:
+  #L15:
   {
-    invalid-type field;
     final synthesized invalid-type #3#0 = o{invalid-type};
-    if(let final invalid-type #t46 = field = #3#0{<invalid>}.field in true) {
-      {
-        break #L8;
+    {
+      invalid-type field;
+      if(let final invalid-type #t46 = field = #3#0{<invalid>}.field in true) {
+        {
+          break #L15;
+        }
       }
     }
   }
   o = block {
     core::String #t47;
-    invalid-type field;
     final synthesized invalid-type #4#0 = o{invalid-type};
-    if(let final invalid-type #t48 = field = #4#0{<invalid>}.field in true)
-      #t47 = "matched";
-    else
-      if(true)
-        #t47 = "";
+    #L16:
+    {
+      {
+        invalid-type field;
+        if(let final invalid-type #t48 = field = #4#0{<invalid>}.field in true) {
+          #t47 = "matched";
+          break #L16;
+        }
+      }
+      {
+        if(true) {
+          #t47 = "";
+          break #L16;
+        }
+      }
+    }
   } =>#t47;
 }
diff --git a/pkg/front_end/testcases/patterns/non_type_object_pattern.dart.weak.expect b/pkg/front_end/testcases/patterns/non_type_object_pattern.dart.weak.expect
index 5714a8a3506..59a2113633a 100644
--- a/pkg/front_end/testcases/patterns/non_type_object_pattern.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/non_type_object_pattern.dart.weak.expect
@@ -273,23 +273,35 @@ static method testUnresolved(dynamic o) → dynamic {
   }
   #L1:
   {
-    invalid-type field;
     final synthesized invalid-type #3#0 = o{invalid-type};
-    if(let final dynamic #t4 = field = #3#0{<invalid>}.field in true) {
-      {
-        break #L1;
+    {
+      invalid-type field;
+      if(let final dynamic #t4 = field = #3#0{<invalid>}.field in true) {
+        {
+          break #L1;
+        }
       }
     }
   }
   o = block {
     core::String #t5;
-    invalid-type field;
     final synthesized invalid-type #4#0 = o{invalid-type};
-    if(let final dynamic #t6 = field = #4#0{<invalid>}.field in true)
-      #t5 = "matched";
-    else
-      if(true)
-        #t5 = "";
+    #L2:
+    {
+      {
+        invalid-type field;
+        if(let final dynamic #t6 = field = #4#0{<invalid>}.field in true) {
+          #t5 = "matched";
+          break #L2;
+        }
+      }
+      {
+        if(true) {
+          #t5 = "";
+          break #L2;
+        }
+      }
+    }
   } =>#t5;
 }
 static method testNonType(dynamic o) → dynamic {
@@ -314,25 +326,37 @@ static method testNonType(dynamic o) → dynamic {
     if(let final dynamic #t9 = field = #2#0{<invalid>}.field in true) {
     }
   }
-  #L2:
+  #L3:
   {
-    invalid-type field;
     final synthesized invalid-type #3#0 = o{invalid-type};
-    if(let final dynamic #t10 = field = #3#0{<invalid>}.field in true) {
-      {
-        break #L2;
+    {
+      invalid-type field;
+      if(let final dynamic #t10 = field = #3#0{<invalid>}.field in true) {
+        {
+          break #L3;
+        }
       }
     }
   }
   o = block {
     core::String #t11;
-    invalid-type field;
     final synthesized invalid-type #4#0 = o{invalid-type};
-    if(let final dynamic #t12 = field = #4#0{<invalid>}.field in true)
-      #t11 = "matched";
-    else
-      if(true)
-        #t11 = "";
+    #L4:
+    {
+      {
+        invalid-type field;
+        if(let final dynamic #t12 = field = #4#0{<invalid>}.field in true) {
+          #t11 = "matched";
+          break #L4;
+        }
+      }
+      {
+        if(true) {
+          #t11 = "";
+          break #L4;
+        }
+      }
+    }
   } =>#t11;
 }
 static method testExtension(dynamic o) → dynamic {
@@ -357,25 +381,37 @@ static method testExtension(dynamic o) → dynamic {
     if(let final dynamic #t15 = field = #2#0{<invalid>}.field in true) {
     }
   }
-  #L3:
+  #L5:
   {
-    invalid-type field;
     final synthesized invalid-type #3#0 = o{invalid-type};
-    if(let final dynamic #t16 = field = #3#0{<invalid>}.field in true) {
-      {
-        break #L3;
+    {
+      invalid-type field;
+      if(let final dynamic #t16 = field = #3#0{<invalid>}.field in true) {
+        {
+          break #L5;
+        }
       }
     }
   }
   o = block {
     core::String #t17;
-    invalid-type field;
     final synthesized invalid-type #4#0 = o{invalid-type};
-    if(let final dynamic #t18 = field = #4#0{<invalid>}.field in true)
-      #t17 = "matched";
-    else
-      if(true)
-        #t17 = "";
+    #L6:
+    {
+      {
+        invalid-type field;
+        if(let final dynamic #t18 = field = #4#0{<invalid>}.field in true) {
+          #t17 = "matched";
+          break #L6;
+        }
+      }
+      {
+        if(true) {
+          #t17 = "";
+          break #L6;
+        }
+      }
+    }
   } =>#t17;
 }
 static method testPrefixedUnresolved(dynamic o) → dynamic {
@@ -400,25 +436,37 @@ static method testPrefixedUnresolved(dynamic o) → dynamic {
     if(let final dynamic #t21 = field = #2#0{<invalid>}.field in true) {
     }
   }
-  #L4:
+  #L7:
   {
-    invalid-type field;
     final synthesized invalid-type #3#0 = o{invalid-type};
-    if(let final dynamic #t22 = field = #3#0{<invalid>}.field in true) {
-      {
-        break #L4;
+    {
+      invalid-type field;
+      if(let final dynamic #t22 = field = #3#0{<invalid>}.field in true) {
+        {
+          break #L7;
+        }
       }
     }
   }
   o = block {
     core::String #t23;
-    invalid-type field;
     final synthesized invalid-type #4#0 = o{invalid-type};
-    if(let final dynamic #t24 = field = #4#0{<invalid>}.field in true)
-      #t23 = "matched";
-    else
-      if(true)
-        #t23 = "";
+    #L8:
+    {
+      {
+        invalid-type field;
+        if(let final dynamic #t24 = field = #4#0{<invalid>}.field in true) {
+          #t23 = "matched";
+          break #L8;
+        }
+      }
+      {
+        if(true) {
+          #t23 = "";
+          break #L8;
+        }
+      }
+    }
   } =>#t23;
 }
 static method testPrefixedNonType(dynamic o) → dynamic {
@@ -443,25 +491,37 @@ static method testPrefixedNonType(dynamic o) → dynamic {
     if(let final dynamic #t27 = field = #2#0{<invalid>}.field in true) {
     }
   }
-  #L5:
+  #L9:
   {
-    invalid-type field;
     final synthesized invalid-type #3#0 = o{invalid-type};
-    if(let final dynamic #t28 = field = #3#0{<invalid>}.field in true) {
-      {
-        break #L5;
+    {
+      invalid-type field;
+      if(let final dynamic #t28 = field = #3#0{<invalid>}.field in true) {
+        {
+          break #L9;
+        }
       }
     }
   }
   o = block {
     core::String #t29;
-    invalid-type field;
     final synthesized invalid-type #4#0 = o{invalid-type};
-    if(let final dynamic #t30 = field = #4#0{<invalid>}.field in true)
-      #t29 = "matched";
-    else
-      if(true)
-        #t29 = "";
+    #L10:
+    {
+      {
+        invalid-type field;
+        if(let final dynamic #t30 = field = #4#0{<invalid>}.field in true) {
+          #t29 = "matched";
+          break #L10;
+        }
+      }
+      {
+        if(true) {
+          #t29 = "";
+          break #L10;
+        }
+      }
+    }
   } =>#t29;
 }
 static method testPrefixedExtension(dynamic o) → dynamic {
@@ -486,25 +546,37 @@ static method testPrefixedExtension(dynamic o) → dynamic {
     if(let final dynamic #t33 = field = #2#0{<invalid>}.field in true) {
     }
   }
-  #L6:
+  #L11:
   {
-    invalid-type field;
     final synthesized invalid-type #3#0 = o{invalid-type};
-    if(let final dynamic #t34 = field = #3#0{<invalid>}.field in true) {
-      {
-        break #L6;
+    {
+      invalid-type field;
+      if(let final dynamic #t34 = field = #3#0{<invalid>}.field in true) {
+        {
+          break #L11;
+        }
       }
     }
   }
   o = block {
     core::String #t35;
-    invalid-type field;
     final synthesized invalid-type #4#0 = o{invalid-type};
-    if(let final dynamic #t36 = field = #4#0{<invalid>}.field in true)
-      #t35 = "matched";
-    else
-      if(true)
-        #t35 = "";
+    #L12:
+    {
+      {
+        invalid-type field;
+        if(let final dynamic #t36 = field = #4#0{<invalid>}.field in true) {
+          #t35 = "matched";
+          break #L12;
+        }
+      }
+      {
+        if(true) {
+          #t35 = "";
+          break #L12;
+        }
+      }
+    }
   } =>#t35;
 }
 static method testUnresolvedPrefix(dynamic o) → dynamic {
@@ -529,25 +601,37 @@ static method testUnresolvedPrefix(dynamic o) → dynamic {
     if(let final dynamic #t39 = field = #2#0{<invalid>}.field in true) {
     }
   }
-  #L7:
+  #L13:
   {
-    invalid-type field;
     final synthesized invalid-type #3#0 = o{invalid-type};
-    if(let final dynamic #t40 = field = #3#0{<invalid>}.field in true) {
-      {
-        break #L7;
+    {
+      invalid-type field;
+      if(let final dynamic #t40 = field = #3#0{<invalid>}.field in true) {
+        {
+          break #L13;
+        }
       }
     }
   }
   o = block {
     core::String #t41;
-    invalid-type field;
     final synthesized invalid-type #4#0 = o{invalid-type};
-    if(let final dynamic #t42 = field = #4#0{<invalid>}.field in true)
-      #t41 = "matched";
-    else
-      if(true)
-        #t41 = "";
+    #L14:
+    {
+      {
+        invalid-type field;
+        if(let final dynamic #t42 = field = #4#0{<invalid>}.field in true) {
+          #t41 = "matched";
+          break #L14;
+        }
+      }
+      {
+        if(true) {
+          #t41 = "";
+          break #L14;
+        }
+      }
+    }
   } =>#t41;
 }
 static method testMemberAccess(dynamic o) → dynamic {
@@ -572,24 +656,36 @@ static method testMemberAccess(dynamic o) → dynamic {
     if(let final dynamic #t45 = field = #2#0{<invalid>}.field in true) {
     }
   }
-  #L8:
+  #L15:
   {
-    invalid-type field;
     final synthesized invalid-type #3#0 = o{invalid-type};
-    if(let final dynamic #t46 = field = #3#0{<invalid>}.field in true) {
-      {
-        break #L8;
+    {
+      invalid-type field;
+      if(let final dynamic #t46 = field = #3#0{<invalid>}.field in true) {
+        {
+          break #L15;
+        }
       }
     }
   }
   o = block {
     core::String #t47;
-    invalid-type field;
     final synthesized invalid-type #4#0 = o{invalid-type};
-    if(let final dynamic #t48 = field = #4#0{<invalid>}.field in true)
-      #t47 = "matched";
-    else
-      if(true)
-        #t47 = "";
+    #L16:
+    {
+      {
+        invalid-type field;
+        if(let final dynamic #t48 = field = #4#0{<invalid>}.field in true) {
+          #t47 = "matched";
+          break #L16;
+        }
+      }
+      {
+        if(true) {
+          #t47 = "";
+          break #L16;
+        }
+      }
+    }
   } =>#t47;
 }
diff --git a/pkg/front_end/testcases/patterns/non_type_object_pattern.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/non_type_object_pattern.dart.weak.modular.expect
index 5714a8a3506..59a2113633a 100644
--- a/pkg/front_end/testcases/patterns/non_type_object_pattern.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/non_type_object_pattern.dart.weak.modular.expect
@@ -273,23 +273,35 @@ static method testUnresolved(dynamic o) → dynamic {
   }
   #L1:
   {
-    invalid-type field;
     final synthesized invalid-type #3#0 = o{invalid-type};
-    if(let final dynamic #t4 = field = #3#0{<invalid>}.field in true) {
-      {
-        break #L1;
+    {
+      invalid-type field;
+      if(let final dynamic #t4 = field = #3#0{<invalid>}.field in true) {
+        {
+          break #L1;
+        }
       }
     }
   }
   o = block {
     core::String #t5;
-    invalid-type field;
     final synthesized invalid-type #4#0 = o{invalid-type};
-    if(let final dynamic #t6 = field = #4#0{<invalid>}.field in true)
-      #t5 = "matched";
-    else
-      if(true)
-        #t5 = "";
+    #L2:
+    {
+      {
+        invalid-type field;
+        if(let final dynamic #t6 = field = #4#0{<invalid>}.field in true) {
+          #t5 = "matched";
+          break #L2;
+        }
+      }
+      {
+        if(true) {
+          #t5 = "";
+          break #L2;
+        }
+      }
+    }
   } =>#t5;
 }
 static method testNonType(dynamic o) → dynamic {
@@ -314,25 +326,37 @@ static method testNonType(dynamic o) → dynamic {
     if(let final dynamic #t9 = field = #2#0{<invalid>}.field in true) {
     }
   }
-  #L2:
+  #L3:
   {
-    invalid-type field;
     final synthesized invalid-type #3#0 = o{invalid-type};
-    if(let final dynamic #t10 = field = #3#0{<invalid>}.field in true) {
-      {
-        break #L2;
+    {
+      invalid-type field;
+      if(let final dynamic #t10 = field = #3#0{<invalid>}.field in true) {
+        {
+          break #L3;
+        }
       }
     }
   }
   o = block {
     core::String #t11;
-    invalid-type field;
     final synthesized invalid-type #4#0 = o{invalid-type};
-    if(let final dynamic #t12 = field = #4#0{<invalid>}.field in true)
-      #t11 = "matched";
-    else
-      if(true)
-        #t11 = "";
+    #L4:
+    {
+      {
+        invalid-type field;
+        if(let final dynamic #t12 = field = #4#0{<invalid>}.field in true) {
+          #t11 = "matched";
+          break #L4;
+        }
+      }
+      {
+        if(true) {
+          #t11 = "";
+          break #L4;
+        }
+      }
+    }
   } =>#t11;
 }
 static method testExtension(dynamic o) → dynamic {
@@ -357,25 +381,37 @@ static method testExtension(dynamic o) → dynamic {
     if(let final dynamic #t15 = field = #2#0{<invalid>}.field in true) {
     }
   }
-  #L3:
+  #L5:
   {
-    invalid-type field;
     final synthesized invalid-type #3#0 = o{invalid-type};
-    if(let final dynamic #t16 = field = #3#0{<invalid>}.field in true) {
-      {
-        break #L3;
+    {
+      invalid-type field;
+      if(let final dynamic #t16 = field = #3#0{<invalid>}.field in true) {
+        {
+          break #L5;
+        }
       }
     }
   }
   o = block {
     core::String #t17;
-    invalid-type field;
     final synthesized invalid-type #4#0 = o{invalid-type};
-    if(let final dynamic #t18 = field = #4#0{<invalid>}.field in true)
-      #t17 = "matched";
-    else
-      if(true)
-        #t17 = "";
+    #L6:
+    {
+      {
+        invalid-type field;
+        if(let final dynamic #t18 = field = #4#0{<invalid>}.field in true) {
+          #t17 = "matched";
+          break #L6;
+        }
+      }
+      {
+        if(true) {
+          #t17 = "";
+          break #L6;
+        }
+      }
+    }
   } =>#t17;
 }
 static method testPrefixedUnresolved(dynamic o) → dynamic {
@@ -400,25 +436,37 @@ static method testPrefixedUnresolved(dynamic o) → dynamic {
     if(let final dynamic #t21 = field = #2#0{<invalid>}.field in true) {
     }
   }
-  #L4:
+  #L7:
   {
-    invalid-type field;
     final synthesized invalid-type #3#0 = o{invalid-type};
-    if(let final dynamic #t22 = field = #3#0{<invalid>}.field in true) {
-      {
-        break #L4;
+    {
+      invalid-type field;
+      if(let final dynamic #t22 = field = #3#0{<invalid>}.field in true) {
+        {
+          break #L7;
+        }
       }
     }
   }
   o = block {
     core::String #t23;
-    invalid-type field;
     final synthesized invalid-type #4#0 = o{invalid-type};
-    if(let final dynamic #t24 = field = #4#0{<invalid>}.field in true)
-      #t23 = "matched";
-    else
-      if(true)
-        #t23 = "";
+    #L8:
+    {
+      {
+        invalid-type field;
+        if(let final dynamic #t24 = field = #4#0{<invalid>}.field in true) {
+          #t23 = "matched";
+          break #L8;
+        }
+      }
+      {
+        if(true) {
+          #t23 = "";
+          break #L8;
+        }
+      }
+    }
   } =>#t23;
 }
 static method testPrefixedNonType(dynamic o) → dynamic {
@@ -443,25 +491,37 @@ static method testPrefixedNonType(dynamic o) → dynamic {
     if(let final dynamic #t27 = field = #2#0{<invalid>}.field in true) {
     }
   }
-  #L5:
+  #L9:
   {
-    invalid-type field;
     final synthesized invalid-type #3#0 = o{invalid-type};
-    if(let final dynamic #t28 = field = #3#0{<invalid>}.field in true) {
-      {
-        break #L5;
+    {
+      invalid-type field;
+      if(let final dynamic #t28 = field = #3#0{<invalid>}.field in true) {
+        {
+          break #L9;
+        }
       }
     }
   }
   o = block {
     core::String #t29;
-    invalid-type field;
     final synthesized invalid-type #4#0 = o{invalid-type};
-    if(let final dynamic #t30 = field = #4#0{<invalid>}.field in true)
-      #t29 = "matched";
-    else
-      if(true)
-        #t29 = "";
+    #L10:
+    {
+      {
+        invalid-type field;
+        if(let final dynamic #t30 = field = #4#0{<invalid>}.field in true) {
+          #t29 = "matched";
+          break #L10;
+        }
+      }
+      {
+        if(true) {
+          #t29 = "";
+          break #L10;
+        }
+      }
+    }
   } =>#t29;
 }
 static method testPrefixedExtension(dynamic o) → dynamic {
@@ -486,25 +546,37 @@ static method testPrefixedExtension(dynamic o) → dynamic {
     if(let final dynamic #t33 = field = #2#0{<invalid>}.field in true) {
     }
   }
-  #L6:
+  #L11:
   {
-    invalid-type field;
     final synthesized invalid-type #3#0 = o{invalid-type};
-    if(let final dynamic #t34 = field = #3#0{<invalid>}.field in true) {
-      {
-        break #L6;
+    {
+      invalid-type field;
+      if(let final dynamic #t34 = field = #3#0{<invalid>}.field in true) {
+        {
+          break #L11;
+        }
       }
     }
   }
   o = block {
     core::String #t35;
-    invalid-type field;
     final synthesized invalid-type #4#0 = o{invalid-type};
-    if(let final dynamic #t36 = field = #4#0{<invalid>}.field in true)
-      #t35 = "matched";
-    else
-      if(true)
-        #t35 = "";
+    #L12:
+    {
+      {
+        invalid-type field;
+        if(let final dynamic #t36 = field = #4#0{<invalid>}.field in true) {
+          #t35 = "matched";
+          break #L12;
+        }
+      }
+      {
+        if(true) {
+          #t35 = "";
+          break #L12;
+        }
+      }
+    }
   } =>#t35;
 }
 static method testUnresolvedPrefix(dynamic o) → dynamic {
@@ -529,25 +601,37 @@ static method testUnresolvedPrefix(dynamic o) → dynamic {
     if(let final dynamic #t39 = field = #2#0{<invalid>}.field in true) {
     }
   }
-  #L7:
+  #L13:
   {
-    invalid-type field;
     final synthesized invalid-type #3#0 = o{invalid-type};
-    if(let final dynamic #t40 = field = #3#0{<invalid>}.field in true) {
-      {
-        break #L7;
+    {
+      invalid-type field;
+      if(let final dynamic #t40 = field = #3#0{<invalid>}.field in true) {
+        {
+          break #L13;
+        }
       }
     }
   }
   o = block {
     core::String #t41;
-    invalid-type field;
     final synthesized invalid-type #4#0 = o{invalid-type};
-    if(let final dynamic #t42 = field = #4#0{<invalid>}.field in true)
-      #t41 = "matched";
-    else
-      if(true)
-        #t41 = "";
+    #L14:
+    {
+      {
+        invalid-type field;
+        if(let final dynamic #t42 = field = #4#0{<invalid>}.field in true) {
+          #t41 = "matched";
+          break #L14;
+        }
+      }
+      {
+        if(true) {
+          #t41 = "";
+          break #L14;
+        }
+      }
+    }
   } =>#t41;
 }
 static method testMemberAccess(dynamic o) → dynamic {
@@ -572,24 +656,36 @@ static method testMemberAccess(dynamic o) → dynamic {
     if(let final dynamic #t45 = field = #2#0{<invalid>}.field in true) {
     }
   }
-  #L8:
+  #L15:
   {
-    invalid-type field;
     final synthesized invalid-type #3#0 = o{invalid-type};
-    if(let final dynamic #t46 = field = #3#0{<invalid>}.field in true) {
-      {
-        break #L8;
+    {
+      invalid-type field;
+      if(let final dynamic #t46 = field = #3#0{<invalid>}.field in true) {
+        {
+          break #L15;
+        }
       }
     }
   }
   o = block {
     core::String #t47;
-    invalid-type field;
     final synthesized invalid-type #4#0 = o{invalid-type};
-    if(let final dynamic #t48 = field = #4#0{<invalid>}.field in true)
-      #t47 = "matched";
-    else
-      if(true)
-        #t47 = "";
+    #L16:
+    {
+      {
+        invalid-type field;
+        if(let final dynamic #t48 = field = #4#0{<invalid>}.field in true) {
+          #t47 = "matched";
+          break #L16;
+        }
+      }
+      {
+        if(true) {
+          #t47 = "";
+          break #L16;
+        }
+      }
+    }
   } =>#t47;
 }
diff --git a/pkg/front_end/testcases/patterns/non_type_object_pattern.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/non_type_object_pattern.dart.weak.transformed.expect
index 2d0a8b1571e..dc52462714b 100644
--- a/pkg/front_end/testcases/patterns/non_type_object_pattern.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/non_type_object_pattern.dart.weak.transformed.expect
@@ -275,23 +275,35 @@ static method testUnresolved(dynamic o) → dynamic {
   }
   #L1:
   {
-    invalid-type field;
     final synthesized invalid-type #3#0 = o{invalid-type};
-    if(let final invalid-type #t4 = field = #3#0{<invalid>}.field in true) {
-      {
-        break #L1;
+    {
+      invalid-type field;
+      if(let final invalid-type #t4 = field = #3#0{<invalid>}.field in true) {
+        {
+          break #L1;
+        }
       }
     }
   }
   o = block {
     core::String #t5;
-    invalid-type field;
     final synthesized invalid-type #4#0 = o{invalid-type};
-    if(let final invalid-type #t6 = field = #4#0{<invalid>}.field in true)
-      #t5 = "matched";
-    else
-      if(true)
-        #t5 = "";
+    #L2:
+    {
+      {
+        invalid-type field;
+        if(let final invalid-type #t6 = field = #4#0{<invalid>}.field in true) {
+          #t5 = "matched";
+          break #L2;
+        }
+      }
+      {
+        if(true) {
+          #t5 = "";
+          break #L2;
+        }
+      }
+    }
   } =>#t5;
 }
 static method testNonType(dynamic o) → dynamic {
@@ -318,25 +330,37 @@ static method testNonType(dynamic o) → dynamic {
     if(let final invalid-type #t9 = field = #2#0{<invalid>}.field in true) {
     }
   }
-  #L2:
+  #L3:
   {
-    invalid-type field;
     final synthesized invalid-type #3#0 = o{invalid-type};
-    if(let final invalid-type #t10 = field = #3#0{<invalid>}.field in true) {
-      {
-        break #L2;
+    {
+      invalid-type field;
+      if(let final invalid-type #t10 = field = #3#0{<invalid>}.field in true) {
+        {
+          break #L3;
+        }
       }
     }
   }
   o = block {
     core::String #t11;
-    invalid-type field;
     final synthesized invalid-type #4#0 = o{invalid-type};
-    if(let final invalid-type #t12 = field = #4#0{<invalid>}.field in true)
-      #t11 = "matched";
-    else
-      if(true)
-        #t11 = "";
+    #L4:
+    {
+      {
+        invalid-type field;
+        if(let final invalid-type #t12 = field = #4#0{<invalid>}.field in true) {
+          #t11 = "matched";
+          break #L4;
+        }
+      }
+      {
+        if(true) {
+          #t11 = "";
+          break #L4;
+        }
+      }
+    }
   } =>#t11;
 }
 static method testExtension(dynamic o) → dynamic {
@@ -363,25 +387,37 @@ static method testExtension(dynamic o) → dynamic {
     if(let final invalid-type #t15 = field = #2#0{<invalid>}.field in true) {
     }
   }
-  #L3:
+  #L5:
   {
-    invalid-type field;
     final synthesized invalid-type #3#0 = o{invalid-type};
-    if(let final invalid-type #t16 = field = #3#0{<invalid>}.field in true) {
-      {
-        break #L3;
+    {
+      invalid-type field;
+      if(let final invalid-type #t16 = field = #3#0{<invalid>}.field in true) {
+        {
+          break #L5;
+        }
       }
     }
   }
   o = block {
     core::String #t17;
-    invalid-type field;
     final synthesized invalid-type #4#0 = o{invalid-type};
-    if(let final invalid-type #t18 = field = #4#0{<invalid>}.field in true)
-      #t17 = "matched";
-    else
-      if(true)
-        #t17 = "";
+    #L6:
+    {
+      {
+        invalid-type field;
+        if(let final invalid-type #t18 = field = #4#0{<invalid>}.field in true) {
+          #t17 = "matched";
+          break #L6;
+        }
+      }
+      {
+        if(true) {
+          #t17 = "";
+          break #L6;
+        }
+      }
+    }
   } =>#t17;
 }
 static method testPrefixedUnresolved(dynamic o) → dynamic {
@@ -408,25 +444,37 @@ static method testPrefixedUnresolved(dynamic o) → dynamic {
     if(let final invalid-type #t21 = field = #2#0{<invalid>}.field in true) {
     }
   }
-  #L4:
+  #L7:
   {
-    invalid-type field;
     final synthesized invalid-type #3#0 = o{invalid-type};
-    if(let final invalid-type #t22 = field = #3#0{<invalid>}.field in true) {
-      {
-        break #L4;
+    {
+      invalid-type field;
+      if(let final invalid-type #t22 = field = #3#0{<invalid>}.field in true) {
+        {
+          break #L7;
+        }
       }
     }
   }
   o = block {
     core::String #t23;
-    invalid-type field;
     final synthesized invalid-type #4#0 = o{invalid-type};
-    if(let final invalid-type #t24 = field = #4#0{<invalid>}.field in true)
-      #t23 = "matched";
-    else
-      if(true)
-        #t23 = "";
+    #L8:
+    {
+      {
+        invalid-type field;
+        if(let final invalid-type #t24 = field = #4#0{<invalid>}.field in true) {
+          #t23 = "matched";
+          break #L8;
+        }
+      }
+      {
+        if(true) {
+          #t23 = "";
+          break #L8;
+        }
+      }
+    }
   } =>#t23;
 }
 static method testPrefixedNonType(dynamic o) → dynamic {
@@ -453,25 +501,37 @@ static method testPrefixedNonType(dynamic o) → dynamic {
     if(let final invalid-type #t27 = field = #2#0{<invalid>}.field in true) {
     }
   }
-  #L5:
+  #L9:
   {
-    invalid-type field;
     final synthesized invalid-type #3#0 = o{invalid-type};
-    if(let final invalid-type #t28 = field = #3#0{<invalid>}.field in true) {
-      {
-        break #L5;
+    {
+      invalid-type field;
+      if(let final invalid-type #t28 = field = #3#0{<invalid>}.field in true) {
+        {
+          break #L9;
+        }
       }
     }
   }
   o = block {
     core::String #t29;
-    invalid-type field;
     final synthesized invalid-type #4#0 = o{invalid-type};
-    if(let final invalid-type #t30 = field = #4#0{<invalid>}.field in true)
-      #t29 = "matched";
-    else
-      if(true)
-        #t29 = "";
+    #L10:
+    {
+      {
+        invalid-type field;
+        if(let final invalid-type #t30 = field = #4#0{<invalid>}.field in true) {
+          #t29 = "matched";
+          break #L10;
+        }
+      }
+      {
+        if(true) {
+          #t29 = "";
+          break #L10;
+        }
+      }
+    }
   } =>#t29;
 }
 static method testPrefixedExtension(dynamic o) → dynamic {
@@ -498,25 +558,37 @@ static method testPrefixedExtension(dynamic o) → dynamic {
     if(let final invalid-type #t33 = field = #2#0{<invalid>}.field in true) {
     }
   }
-  #L6:
+  #L11:
   {
-    invalid-type field;
     final synthesized invalid-type #3#0 = o{invalid-type};
-    if(let final invalid-type #t34 = field = #3#0{<invalid>}.field in true) {
-      {
-        break #L6;
+    {
+      invalid-type field;
+      if(let final invalid-type #t34 = field = #3#0{<invalid>}.field in true) {
+        {
+          break #L11;
+        }
       }
     }
   }
   o = block {
     core::String #t35;
-    invalid-type field;
     final synthesized invalid-type #4#0 = o{invalid-type};
-    if(let final invalid-type #t36 = field = #4#0{<invalid>}.field in true)
-      #t35 = "matched";
-    else
-      if(true)
-        #t35 = "";
+    #L12:
+    {
+      {
+        invalid-type field;
+        if(let final invalid-type #t36 = field = #4#0{<invalid>}.field in true) {
+          #t35 = "matched";
+          break #L12;
+        }
+      }
+      {
+        if(true) {
+          #t35 = "";
+          break #L12;
+        }
+      }
+    }
   } =>#t35;
 }
 static method testUnresolvedPrefix(dynamic o) → dynamic {
@@ -543,25 +615,37 @@ static method testUnresolvedPrefix(dynamic o) → dynamic {
     if(let final invalid-type #t39 = field = #2#0{<invalid>}.field in true) {
     }
   }
-  #L7:
+  #L13:
   {
-    invalid-type field;
     final synthesized invalid-type #3#0 = o{invalid-type};
-    if(let final invalid-type #t40 = field = #3#0{<invalid>}.field in true) {
-      {
-        break #L7;
+    {
+      invalid-type field;
+      if(let final invalid-type #t40 = field = #3#0{<invalid>}.field in true) {
+        {
+          break #L13;
+        }
       }
     }
   }
   o = block {
     core::String #t41;
-    invalid-type field;
     final synthesized invalid-type #4#0 = o{invalid-type};
-    if(let final invalid-type #t42 = field = #4#0{<invalid>}.field in true)
-      #t41 = "matched";
-    else
-      if(true)
-        #t41 = "";
+    #L14:
+    {
+      {
+        invalid-type field;
+        if(let final invalid-type #t42 = field = #4#0{<invalid>}.field in true) {
+          #t41 = "matched";
+          break #L14;
+        }
+      }
+      {
+        if(true) {
+          #t41 = "";
+          break #L14;
+        }
+      }
+    }
   } =>#t41;
 }
 static method testMemberAccess(dynamic o) → dynamic {
@@ -588,24 +672,36 @@ static method testMemberAccess(dynamic o) → dynamic {
     if(let final invalid-type #t45 = field = #2#0{<invalid>}.field in true) {
     }
   }
-  #L8:
+  #L15:
   {
-    invalid-type field;
     final synthesized invalid-type #3#0 = o{invalid-type};
-    if(let final invalid-type #t46 = field = #3#0{<invalid>}.field in true) {
-      {
-        break #L8;
+    {
+      invalid-type field;
+      if(let final invalid-type #t46 = field = #3#0{<invalid>}.field in true) {
+        {
+          break #L15;
+        }
       }
     }
   }
   o = block {
     core::String #t47;
-    invalid-type field;
     final synthesized invalid-type #4#0 = o{invalid-type};
-    if(let final invalid-type #t48 = field = #4#0{<invalid>}.field in true)
-      #t47 = "matched";
-    else
-      if(true)
-        #t47 = "";
+    #L16:
+    {
+      {
+        invalid-type field;
+        if(let final invalid-type #t48 = field = #4#0{<invalid>}.field in true) {
+          #t47 = "matched";
+          break #L16;
+        }
+      }
+      {
+        if(true) {
+          #t47 = "";
+          break #L16;
+        }
+      }
+    }
   } =>#t47;
 }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_case.dart.strong.expect b/pkg/front_end/testcases/patterns/null_assert_inside_case.dart.strong.expect
index 7d8550841b3..b2bc2051445 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_case.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_case.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_case.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/null_assert_inside_case.dart.strong.transformed.expect
index 7d8550841b3..b2bc2051445 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_case.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_case.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_case.dart.weak.expect b/pkg/front_end/testcases/patterns/null_assert_inside_case.dart.weak.expect
index 7d8550841b3..b2bc2051445 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_case.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_case.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_case.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/null_assert_inside_case.dart.weak.modular.expect
index 7d8550841b3..b2bc2051445 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_case.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_case.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_case.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/null_assert_inside_case.dart.weak.transformed.expect
index 7d8550841b3..b2bc2051445 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_case.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_case.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_extractor_pattern.dart.strong.expect b/pkg/front_end/testcases/patterns/null_assert_inside_extractor_pattern.dart.strong.expect
index f129adb02d9..d65a20c8ea1 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_extractor_pattern.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_extractor_pattern.dart.strong.expect
@@ -13,9 +13,11 @@ static method test(dynamic x) → dynamic {
   {
     final synthesized dynamic #0#0 = x;
     late final synthesized core::int? #0#2 = #0#0{self::C}.{self::C::f}{core::int?};
-    if(#0#0 is{ForNonNullableByDefault} self::C && (let final dynamic #t1 = #0#2! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2!)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::C && (let final dynamic #t1 = #0#2! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2!)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_extractor_pattern.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/null_assert_inside_extractor_pattern.dart.strong.transformed.expect
index 9ed34f21b32..62795a2571f 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_extractor_pattern.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_extractor_pattern.dart.strong.transformed.expect
@@ -15,9 +15,11 @@ static method test(dynamic x) → dynamic {
     function ##0#2#initializer() → core::int?
       return #0#0{self::C}.{self::C::f}{core::int?};
     late final synthesized core::int? #0#2 = ##0#2#initializer(){() → core::int?};
-    if(#0#0 is{ForNonNullableByDefault} self::C && (let final core::int? #t1 = #0#2! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2!)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::C && (let final core::int? #t1 = #0#2! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2!)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_extractor_pattern.dart.weak.expect b/pkg/front_end/testcases/patterns/null_assert_inside_extractor_pattern.dart.weak.expect
index f129adb02d9..d65a20c8ea1 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_extractor_pattern.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_extractor_pattern.dart.weak.expect
@@ -13,9 +13,11 @@ static method test(dynamic x) → dynamic {
   {
     final synthesized dynamic #0#0 = x;
     late final synthesized core::int? #0#2 = #0#0{self::C}.{self::C::f}{core::int?};
-    if(#0#0 is{ForNonNullableByDefault} self::C && (let final dynamic #t1 = #0#2! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2!)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::C && (let final dynamic #t1 = #0#2! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2!)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_extractor_pattern.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/null_assert_inside_extractor_pattern.dart.weak.modular.expect
index f129adb02d9..d65a20c8ea1 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_extractor_pattern.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_extractor_pattern.dart.weak.modular.expect
@@ -13,9 +13,11 @@ static method test(dynamic x) → dynamic {
   {
     final synthesized dynamic #0#0 = x;
     late final synthesized core::int? #0#2 = #0#0{self::C}.{self::C::f}{core::int?};
-    if(#0#0 is{ForNonNullableByDefault} self::C && (let final dynamic #t1 = #0#2! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2!)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::C && (let final dynamic #t1 = #0#2! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2!)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_extractor_pattern.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/null_assert_inside_extractor_pattern.dart.weak.transformed.expect
index 9ed34f21b32..62795a2571f 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_extractor_pattern.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_extractor_pattern.dart.weak.transformed.expect
@@ -15,9 +15,11 @@ static method test(dynamic x) → dynamic {
     function ##0#2#initializer() → core::int?
       return #0#0{self::C}.{self::C::f}{core::int?};
     late final synthesized core::int? #0#2 = ##0#2#initializer(){() → core::int?};
-    if(#0#0 is{ForNonNullableByDefault} self::C && (let final core::int? #t1 = #0#2! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2!)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::C && (let final core::int? #t1 = #0#2! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2!)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_extractor_pattern_implicitly_named.dart.strong.expect b/pkg/front_end/testcases/patterns/null_assert_inside_extractor_pattern_implicitly_named.dart.strong.expect
index 55fa7193751..c0f65177b45 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_extractor_pattern_implicitly_named.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_extractor_pattern_implicitly_named.dart.strong.expect
@@ -11,12 +11,14 @@ class C extends core::Object {
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int f;
     final synthesized dynamic #0#0 = x;
     late final synthesized core::int? #0#2 = #0#0{self::C}.{self::C::f}{core::int?};
-    if(#0#0 is{ForNonNullableByDefault} self::C && (let final dynamic #t1 = #0#2! in let final dynamic #t2 = f = #0#2! in true)) {
-      {
-        break #L1;
+    {
+      core::int f;
+      if(#0#0 is{ForNonNullableByDefault} self::C && (let final dynamic #t1 = #0#2! in let final dynamic #t2 = f = #0#2! in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_extractor_pattern_implicitly_named.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/null_assert_inside_extractor_pattern_implicitly_named.dart.strong.transformed.expect
index 36203b94369..19cc2367c39 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_extractor_pattern_implicitly_named.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_extractor_pattern_implicitly_named.dart.strong.transformed.expect
@@ -11,14 +11,16 @@ class C extends core::Object {
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int f;
     final synthesized dynamic #0#0 = x;
     function ##0#2#initializer() → core::int?
       return #0#0{self::C}.{self::C::f}{core::int?};
     late final synthesized core::int? #0#2 = ##0#2#initializer(){() → core::int?};
-    if(#0#0 is{ForNonNullableByDefault} self::C && (let final core::int? #t1 = #0#2! in let final core::int? #t2 = f = #0#2! in true)) {
-      {
-        break #L1;
+    {
+      core::int f;
+      if(#0#0 is{ForNonNullableByDefault} self::C && (let final core::int? #t1 = #0#2! in let final core::int? #t2 = f = #0#2! in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_extractor_pattern_implicitly_named.dart.weak.expect b/pkg/front_end/testcases/patterns/null_assert_inside_extractor_pattern_implicitly_named.dart.weak.expect
index 55fa7193751..c0f65177b45 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_extractor_pattern_implicitly_named.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_extractor_pattern_implicitly_named.dart.weak.expect
@@ -11,12 +11,14 @@ class C extends core::Object {
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int f;
     final synthesized dynamic #0#0 = x;
     late final synthesized core::int? #0#2 = #0#0{self::C}.{self::C::f}{core::int?};
-    if(#0#0 is{ForNonNullableByDefault} self::C && (let final dynamic #t1 = #0#2! in let final dynamic #t2 = f = #0#2! in true)) {
-      {
-        break #L1;
+    {
+      core::int f;
+      if(#0#0 is{ForNonNullableByDefault} self::C && (let final dynamic #t1 = #0#2! in let final dynamic #t2 = f = #0#2! in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_extractor_pattern_implicitly_named.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/null_assert_inside_extractor_pattern_implicitly_named.dart.weak.modular.expect
index 55fa7193751..c0f65177b45 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_extractor_pattern_implicitly_named.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_extractor_pattern_implicitly_named.dart.weak.modular.expect
@@ -11,12 +11,14 @@ class C extends core::Object {
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int f;
     final synthesized dynamic #0#0 = x;
     late final synthesized core::int? #0#2 = #0#0{self::C}.{self::C::f}{core::int?};
-    if(#0#0 is{ForNonNullableByDefault} self::C && (let final dynamic #t1 = #0#2! in let final dynamic #t2 = f = #0#2! in true)) {
-      {
-        break #L1;
+    {
+      core::int f;
+      if(#0#0 is{ForNonNullableByDefault} self::C && (let final dynamic #t1 = #0#2! in let final dynamic #t2 = f = #0#2! in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_extractor_pattern_implicitly_named.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/null_assert_inside_extractor_pattern_implicitly_named.dart.weak.transformed.expect
index 36203b94369..19cc2367c39 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_extractor_pattern_implicitly_named.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_extractor_pattern_implicitly_named.dart.weak.transformed.expect
@@ -11,14 +11,16 @@ class C extends core::Object {
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int f;
     final synthesized dynamic #0#0 = x;
     function ##0#2#initializer() → core::int?
       return #0#0{self::C}.{self::C::f}{core::int?};
     late final synthesized core::int? #0#2 = ##0#2#initializer(){() → core::int?};
-    if(#0#0 is{ForNonNullableByDefault} self::C && (let final core::int? #t1 = #0#2! in let final core::int? #t2 = f = #0#2! in true)) {
-      {
-        break #L1;
+    {
+      core::int f;
+      if(#0#0 is{ForNonNullableByDefault} self::C && (let final core::int? #t1 = #0#2! in let final core::int? #t2 = f = #0#2! in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_list_pattern.dart.strong.expect b/pkg/front_end/testcases/patterns/null_assert_inside_list_pattern.dart.strong.expect
index 7b9b3f483c6..6a81e95f2c6 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_list_pattern.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_list_pattern.dart.strong.expect
@@ -7,9 +7,11 @@ static method test(dynamic x) → dynamic {
   {
     final synthesized dynamic #0#0 = x;
     late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final dynamic #t1 = #0#6! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#6!)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final dynamic #t1 = #0#6! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#6!)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_list_pattern.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/null_assert_inside_list_pattern.dart.strong.transformed.expect
index 6734b1e2582..b6cb74b67bc 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_list_pattern.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_list_pattern.dart.strong.transformed.expect
@@ -9,9 +9,11 @@ static method test(dynamic x) → dynamic {
     function ##0#6#initializer() → dynamic
       return #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
     late final synthesized dynamic #0#6 = ##0#6#initializer(){() → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final dynamic #t1 = #0#6! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#6!)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final dynamic #t1 = #0#6! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#6!)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_list_pattern.dart.weak.expect b/pkg/front_end/testcases/patterns/null_assert_inside_list_pattern.dart.weak.expect
index 7b9b3f483c6..6a81e95f2c6 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_list_pattern.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_list_pattern.dart.weak.expect
@@ -7,9 +7,11 @@ static method test(dynamic x) → dynamic {
   {
     final synthesized dynamic #0#0 = x;
     late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final dynamic #t1 = #0#6! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#6!)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final dynamic #t1 = #0#6! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#6!)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_list_pattern.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/null_assert_inside_list_pattern.dart.weak.modular.expect
index 7b9b3f483c6..6a81e95f2c6 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_list_pattern.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_list_pattern.dart.weak.modular.expect
@@ -7,9 +7,11 @@ static method test(dynamic x) → dynamic {
   {
     final synthesized dynamic #0#0 = x;
     late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final dynamic #t1 = #0#6! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#6!)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final dynamic #t1 = #0#6! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#6!)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_list_pattern.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/null_assert_inside_list_pattern.dart.weak.transformed.expect
index 6734b1e2582..b6cb74b67bc 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_list_pattern.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_list_pattern.dart.weak.transformed.expect
@@ -9,9 +9,11 @@ static method test(dynamic x) → dynamic {
     function ##0#6#initializer() → dynamic
       return #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
     late final synthesized dynamic #0#6 = ##0#6#initializer(){() → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final dynamic #t1 = #0#6! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#6!)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final dynamic #t1 = #0#6! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#6!)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_logical_and_lhs.dart.strong.expect b/pkg/front_end/testcases/patterns/null_assert_inside_logical_and_lhs.dart.strong.expect
index f3e009e339b..cae181bb57e 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_logical_and_lhs.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_logical_and_lhs.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if((let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        break #L1;
+    {
+      if((let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_logical_and_lhs.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/null_assert_inside_logical_and_lhs.dart.strong.transformed.expect
index f3e009e339b..cae181bb57e 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_logical_and_lhs.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_logical_and_lhs.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if((let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        break #L1;
+    {
+      if((let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_logical_and_lhs.dart.weak.expect b/pkg/front_end/testcases/patterns/null_assert_inside_logical_and_lhs.dart.weak.expect
index f3e009e339b..cae181bb57e 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_logical_and_lhs.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_logical_and_lhs.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if((let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        break #L1;
+    {
+      if((let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_logical_and_lhs.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/null_assert_inside_logical_and_lhs.dart.weak.modular.expect
index f3e009e339b..cae181bb57e 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_logical_and_lhs.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_logical_and_lhs.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if((let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        break #L1;
+    {
+      if((let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_logical_and_lhs.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/null_assert_inside_logical_and_lhs.dart.weak.transformed.expect
index f3e009e339b..cae181bb57e 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_logical_and_lhs.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_logical_and_lhs.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if((let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        break #L1;
+    {
+      if((let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_logical_and_rhs.dart.strong.expect b/pkg/front_end/testcases/patterns/null_assert_inside_logical_and_rhs.dart.strong.expect
index d29d7d1eff3..c801fc63a63 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_logical_and_rhs.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_logical_and_rhs.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && (let final dynamic #t1 = #0#0! in #C2 =={core::num::==}{(core::Object) → core::bool} #0#0!)) {
-      {
-        break #L1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && (let final dynamic #t1 = #0#0! in #C2 =={core::num::==}{(core::Object) → core::bool} #0#0!)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_logical_and_rhs.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/null_assert_inside_logical_and_rhs.dart.strong.transformed.expect
index d29d7d1eff3..c801fc63a63 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_logical_and_rhs.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_logical_and_rhs.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && (let final dynamic #t1 = #0#0! in #C2 =={core::num::==}{(core::Object) → core::bool} #0#0!)) {
-      {
-        break #L1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && (let final dynamic #t1 = #0#0! in #C2 =={core::num::==}{(core::Object) → core::bool} #0#0!)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_logical_and_rhs.dart.weak.expect b/pkg/front_end/testcases/patterns/null_assert_inside_logical_and_rhs.dart.weak.expect
index d29d7d1eff3..c801fc63a63 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_logical_and_rhs.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_logical_and_rhs.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && (let final dynamic #t1 = #0#0! in #C2 =={core::num::==}{(core::Object) → core::bool} #0#0!)) {
-      {
-        break #L1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && (let final dynamic #t1 = #0#0! in #C2 =={core::num::==}{(core::Object) → core::bool} #0#0!)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_logical_and_rhs.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/null_assert_inside_logical_and_rhs.dart.weak.modular.expect
index d29d7d1eff3..c801fc63a63 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_logical_and_rhs.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_logical_and_rhs.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && (let final dynamic #t1 = #0#0! in #C2 =={core::num::==}{(core::Object) → core::bool} #0#0!)) {
-      {
-        break #L1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && (let final dynamic #t1 = #0#0! in #C2 =={core::num::==}{(core::Object) → core::bool} #0#0!)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_logical_and_rhs.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/null_assert_inside_logical_and_rhs.dart.weak.transformed.expect
index d29d7d1eff3..c801fc63a63 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_logical_and_rhs.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_logical_and_rhs.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && (let final dynamic #t1 = #0#0! in #C2 =={core::num::==}{(core::Object) → core::bool} #0#0!)) {
-      {
-        break #L1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && (let final dynamic #t1 = #0#0! in #C2 =={core::num::==}{(core::Object) → core::bool} #0#0!)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_logical_or_lhs.dart.strong.expect b/pkg/front_end/testcases/patterns/null_assert_inside_logical_or_lhs.dart.strong.expect
index be9e7a1e85e..ba1efef6bed 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_logical_or_lhs.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_logical_or_lhs.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if((let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) || #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        break #L1;
+    {
+      if((let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) || #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_logical_or_lhs.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/null_assert_inside_logical_or_lhs.dart.strong.transformed.expect
index be9e7a1e85e..ba1efef6bed 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_logical_or_lhs.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_logical_or_lhs.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if((let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) || #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        break #L1;
+    {
+      if((let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) || #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_logical_or_lhs.dart.weak.expect b/pkg/front_end/testcases/patterns/null_assert_inside_logical_or_lhs.dart.weak.expect
index be9e7a1e85e..ba1efef6bed 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_logical_or_lhs.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_logical_or_lhs.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if((let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) || #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        break #L1;
+    {
+      if((let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) || #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_logical_or_lhs.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/null_assert_inside_logical_or_lhs.dart.weak.modular.expect
index be9e7a1e85e..ba1efef6bed 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_logical_or_lhs.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_logical_or_lhs.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if((let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) || #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        break #L1;
+    {
+      if((let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) || #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_logical_or_lhs.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/null_assert_inside_logical_or_lhs.dart.weak.transformed.expect
index be9e7a1e85e..ba1efef6bed 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_logical_or_lhs.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_logical_or_lhs.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if((let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) || #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        break #L1;
+    {
+      if((let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) || #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_logical_or_rhs.dart.strong.expect b/pkg/front_end/testcases/patterns/null_assert_inside_logical_or_rhs.dart.strong.expect
index 6b318bb9595..e78bca8ffd5 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_logical_or_rhs.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_logical_or_rhs.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || (let final dynamic #t1 = #0#0! in #C2 =={core::num::==}{(core::Object) → core::bool} #0#0!)) {
-      {
-        break #L1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || (let final dynamic #t1 = #0#0! in #C2 =={core::num::==}{(core::Object) → core::bool} #0#0!)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_logical_or_rhs.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/null_assert_inside_logical_or_rhs.dart.strong.transformed.expect
index 6b318bb9595..e78bca8ffd5 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_logical_or_rhs.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_logical_or_rhs.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || (let final dynamic #t1 = #0#0! in #C2 =={core::num::==}{(core::Object) → core::bool} #0#0!)) {
-      {
-        break #L1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || (let final dynamic #t1 = #0#0! in #C2 =={core::num::==}{(core::Object) → core::bool} #0#0!)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_logical_or_rhs.dart.weak.expect b/pkg/front_end/testcases/patterns/null_assert_inside_logical_or_rhs.dart.weak.expect
index 6b318bb9595..e78bca8ffd5 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_logical_or_rhs.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_logical_or_rhs.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || (let final dynamic #t1 = #0#0! in #C2 =={core::num::==}{(core::Object) → core::bool} #0#0!)) {
-      {
-        break #L1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || (let final dynamic #t1 = #0#0! in #C2 =={core::num::==}{(core::Object) → core::bool} #0#0!)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_logical_or_rhs.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/null_assert_inside_logical_or_rhs.dart.weak.modular.expect
index 6b318bb9595..e78bca8ffd5 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_logical_or_rhs.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_logical_or_rhs.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || (let final dynamic #t1 = #0#0! in #C2 =={core::num::==}{(core::Object) → core::bool} #0#0!)) {
-      {
-        break #L1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || (let final dynamic #t1 = #0#0! in #C2 =={core::num::==}{(core::Object) → core::bool} #0#0!)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_logical_or_rhs.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/null_assert_inside_logical_or_rhs.dart.weak.transformed.expect
index 6b318bb9595..e78bca8ffd5 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_logical_or_rhs.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_logical_or_rhs.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || (let final dynamic #t1 = #0#0! in #C2 =={core::num::==}{(core::Object) → core::bool} #0#0!)) {
-      {
-        break #L1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || (let final dynamic #t1 = #0#0! in #C2 =={core::num::==}{(core::Object) → core::bool} #0#0!)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_map_pattern.dart.strong.expect b/pkg/front_end/testcases/patterns/null_assert_inside_map_pattern.dart.strong.expect
index 6682b11a6a1..a3f0486b7fe 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_map_pattern.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_map_pattern.dart.strong.expect
@@ -7,9 +7,11 @@ static method test(dynamic x) → dynamic {
   {
     final synthesized dynamic #0#0 = x;
     late final synthesized dynamic #0#8 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (let final dynamic #t1 = #0#8! in #C2 =={core::num::==}{(core::Object) → core::bool} #0#8!)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (let final dynamic #t1 = #0#8! in #C2 =={core::num::==}{(core::Object) → core::bool} #0#8!)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_map_pattern.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/null_assert_inside_map_pattern.dart.strong.transformed.expect
index 18b9f44aaee..26d1ac4a13a 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_map_pattern.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_map_pattern.dart.strong.transformed.expect
@@ -9,9 +9,11 @@ static method test(dynamic x) → dynamic {
     function ##0#8#initializer() → dynamic
       return #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic};
     late final synthesized dynamic #0#8 = ##0#8#initializer(){() → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (let final dynamic #t1 = #0#8! in #C2 =={core::num::==}{(core::Object) → core::bool} #0#8!)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (let final dynamic #t1 = #0#8! in #C2 =={core::num::==}{(core::Object) → core::bool} #0#8!)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_map_pattern.dart.weak.expect b/pkg/front_end/testcases/patterns/null_assert_inside_map_pattern.dart.weak.expect
index 6682b11a6a1..a3f0486b7fe 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_map_pattern.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_map_pattern.dart.weak.expect
@@ -7,9 +7,11 @@ static method test(dynamic x) → dynamic {
   {
     final synthesized dynamic #0#0 = x;
     late final synthesized dynamic #0#8 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (let final dynamic #t1 = #0#8! in #C2 =={core::num::==}{(core::Object) → core::bool} #0#8!)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (let final dynamic #t1 = #0#8! in #C2 =={core::num::==}{(core::Object) → core::bool} #0#8!)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_map_pattern.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/null_assert_inside_map_pattern.dart.weak.modular.expect
index 6682b11a6a1..a3f0486b7fe 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_map_pattern.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_map_pattern.dart.weak.modular.expect
@@ -7,9 +7,11 @@ static method test(dynamic x) → dynamic {
   {
     final synthesized dynamic #0#0 = x;
     late final synthesized dynamic #0#8 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (let final dynamic #t1 = #0#8! in #C2 =={core::num::==}{(core::Object) → core::bool} #0#8!)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (let final dynamic #t1 = #0#8! in #C2 =={core::num::==}{(core::Object) → core::bool} #0#8!)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_map_pattern.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/null_assert_inside_map_pattern.dart.weak.transformed.expect
index 18b9f44aaee..26d1ac4a13a 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_map_pattern.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_map_pattern.dart.weak.transformed.expect
@@ -9,9 +9,11 @@ static method test(dynamic x) → dynamic {
     function ##0#8#initializer() → dynamic
       return #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic};
     late final synthesized dynamic #0#8 = ##0#8#initializer(){() → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (let final dynamic #t1 = #0#8! in #C2 =={core::num::==}{(core::Object) → core::bool} #0#8!)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (let final dynamic #t1 = #0#8! in #C2 =={core::num::==}{(core::Object) → core::bool} #0#8!)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_parenthesized_pattern.dart.strong.expect b/pkg/front_end/testcases/patterns/null_assert_inside_parenthesized_pattern.dart.strong.expect
index 7d8550841b3..b2bc2051445 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_parenthesized_pattern.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_parenthesized_pattern.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_parenthesized_pattern.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/null_assert_inside_parenthesized_pattern.dart.strong.transformed.expect
index 7d8550841b3..b2bc2051445 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_parenthesized_pattern.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_parenthesized_pattern.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_parenthesized_pattern.dart.weak.expect b/pkg/front_end/testcases/patterns/null_assert_inside_parenthesized_pattern.dart.weak.expect
index 7d8550841b3..b2bc2051445 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_parenthesized_pattern.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_parenthesized_pattern.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_parenthesized_pattern.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/null_assert_inside_parenthesized_pattern.dart.weak.modular.expect
index 7d8550841b3..b2bc2051445 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_parenthesized_pattern.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_parenthesized_pattern.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_parenthesized_pattern.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/null_assert_inside_parenthesized_pattern.dart.weak.transformed.expect
index 7d8550841b3..b2bc2051445 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_parenthesized_pattern.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_parenthesized_pattern.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_implicitly_named.dart.strong.expect b/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_implicitly_named.dart.strong.expect
index 085751d555e..b512a8d544e 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_implicitly_named.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_implicitly_named.dart.strong.expect
@@ -5,12 +5,14 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    dynamic n;
     final synthesized dynamic #0#0 = x;
     late final synthesized core::Object? #0#2 = #0#0{(core::Object?, {n: core::Object?})}.n{core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (let final dynamic #t1 = #0#2! in let final dynamic #t2 = n = #0#2! in true) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      dynamic n;
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (let final dynamic #t1 = #0#2! in let final dynamic #t2 = n = #0#2! in true) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_implicitly_named.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_implicitly_named.dart.strong.transformed.expect
index 938adfcd7c1..d935ee12ce5 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_implicitly_named.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_implicitly_named.dart.strong.transformed.expect
@@ -5,14 +5,16 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    dynamic n;
     final synthesized dynamic #0#0 = x;
     function ##0#2#initializer() → core::Object?
       return #0#0{(core::Object?, {n: core::Object?})}.n{core::Object?};
     late final synthesized core::Object? #0#2 = ##0#2#initializer(){() → core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (let final core::Object? #t1 = #0#2! in let final core::Object? #t2 = n = #0#2! in true) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      dynamic n;
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (let final core::Object? #t1 = #0#2! in let final core::Object? #t2 = n = #0#2! in true) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_implicitly_named.dart.weak.expect b/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_implicitly_named.dart.weak.expect
index 085751d555e..b512a8d544e 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_implicitly_named.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_implicitly_named.dart.weak.expect
@@ -5,12 +5,14 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    dynamic n;
     final synthesized dynamic #0#0 = x;
     late final synthesized core::Object? #0#2 = #0#0{(core::Object?, {n: core::Object?})}.n{core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (let final dynamic #t1 = #0#2! in let final dynamic #t2 = n = #0#2! in true) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      dynamic n;
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (let final dynamic #t1 = #0#2! in let final dynamic #t2 = n = #0#2! in true) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_implicitly_named.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_implicitly_named.dart.weak.modular.expect
index 085751d555e..b512a8d544e 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_implicitly_named.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_implicitly_named.dart.weak.modular.expect
@@ -5,12 +5,14 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    dynamic n;
     final synthesized dynamic #0#0 = x;
     late final synthesized core::Object? #0#2 = #0#0{(core::Object?, {n: core::Object?})}.n{core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (let final dynamic #t1 = #0#2! in let final dynamic #t2 = n = #0#2! in true) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      dynamic n;
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (let final dynamic #t1 = #0#2! in let final dynamic #t2 = n = #0#2! in true) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_implicitly_named.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_implicitly_named.dart.weak.transformed.expect
index 938adfcd7c1..d935ee12ce5 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_implicitly_named.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_implicitly_named.dart.weak.transformed.expect
@@ -5,14 +5,16 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    dynamic n;
     final synthesized dynamic #0#0 = x;
     function ##0#2#initializer() → core::Object?
       return #0#0{(core::Object?, {n: core::Object?})}.n{core::Object?};
     late final synthesized core::Object? #0#2 = ##0#2#initializer(){() → core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (let final core::Object? #t1 = #0#2! in let final core::Object? #t2 = n = #0#2! in true) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      dynamic n;
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (let final core::Object? #t1 = #0#2! in let final core::Object? #t2 = n = #0#2! in true) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_named.dart.strong.expect b/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_named.dart.strong.expect
index 928ba0f1d7e..c3533b96789 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_named.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_named.dart.strong.expect
@@ -7,9 +7,11 @@ static method test(dynamic x) → dynamic {
   {
     final synthesized dynamic #0#0 = x;
     late final synthesized core::Object? #0#2 = #0#0{(core::Object?, {n: core::Object?})}.n{core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (let final dynamic #t1 = #0#2! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2!) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (let final dynamic #t1 = #0#2! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2!) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_named.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_named.dart.strong.transformed.expect
index 6bc269150bb..be0ada860ab 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_named.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_named.dart.strong.transformed.expect
@@ -9,9 +9,11 @@ static method test(dynamic x) → dynamic {
     function ##0#2#initializer() → core::Object?
       return #0#0{(core::Object?, {n: core::Object?})}.n{core::Object?};
     late final synthesized core::Object? #0#2 = ##0#2#initializer(){() → core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (let final core::Object? #t1 = #0#2! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2!) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (let final core::Object? #t1 = #0#2! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2!) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_named.dart.weak.expect b/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_named.dart.weak.expect
index 928ba0f1d7e..c3533b96789 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_named.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_named.dart.weak.expect
@@ -7,9 +7,11 @@ static method test(dynamic x) → dynamic {
   {
     final synthesized dynamic #0#0 = x;
     late final synthesized core::Object? #0#2 = #0#0{(core::Object?, {n: core::Object?})}.n{core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (let final dynamic #t1 = #0#2! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2!) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (let final dynamic #t1 = #0#2! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2!) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_named.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_named.dart.weak.modular.expect
index 928ba0f1d7e..c3533b96789 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_named.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_named.dart.weak.modular.expect
@@ -7,9 +7,11 @@ static method test(dynamic x) → dynamic {
   {
     final synthesized dynamic #0#0 = x;
     late final synthesized core::Object? #0#2 = #0#0{(core::Object?, {n: core::Object?})}.n{core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (let final dynamic #t1 = #0#2! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2!) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (let final dynamic #t1 = #0#2! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2!) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_named.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_named.dart.weak.transformed.expect
index 6bc269150bb..be0ada860ab 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_named.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_named.dart.weak.transformed.expect
@@ -9,9 +9,11 @@ static method test(dynamic x) → dynamic {
     function ##0#2#initializer() → core::Object?
       return #0#0{(core::Object?, {n: core::Object?})}.n{core::Object?};
     late final synthesized core::Object? #0#2 = ##0#2#initializer(){() → core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (let final core::Object? #t1 = #0#2! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2!) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (let final core::Object? #t1 = #0#2! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2!) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_unnamed.dart.strong.expect b/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_unnamed.dart.strong.expect
index 7bb246eb981..92b254c0895 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_unnamed.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_unnamed.dart.strong.expect
@@ -7,9 +7,11 @@ static method test(dynamic x) → dynamic {
   {
     final synthesized dynamic #0#0 = x;
     late final synthesized core::Object? #0#2 = #0#0{(core::Object?, core::Object?)}.$1{core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && (let final dynamic #t1 = #0#2! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2!) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && (let final dynamic #t1 = #0#2! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2!) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_unnamed.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_unnamed.dart.strong.transformed.expect
index e6337a0ab9e..07779eee937 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_unnamed.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_unnamed.dart.strong.transformed.expect
@@ -9,9 +9,11 @@ static method test(dynamic x) → dynamic {
     function ##0#2#initializer() → core::Object?
       return #0#0{(core::Object?, core::Object?)}.$1{core::Object?};
     late final synthesized core::Object? #0#2 = ##0#2#initializer(){() → core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && (let final core::Object? #t1 = #0#2! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2!) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && (let final core::Object? #t1 = #0#2! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2!) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_unnamed.dart.weak.expect b/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_unnamed.dart.weak.expect
index 7bb246eb981..92b254c0895 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_unnamed.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_unnamed.dart.weak.expect
@@ -7,9 +7,11 @@ static method test(dynamic x) → dynamic {
   {
     final synthesized dynamic #0#0 = x;
     late final synthesized core::Object? #0#2 = #0#0{(core::Object?, core::Object?)}.$1{core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && (let final dynamic #t1 = #0#2! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2!) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && (let final dynamic #t1 = #0#2! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2!) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_unnamed.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_unnamed.dart.weak.modular.expect
index 7bb246eb981..92b254c0895 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_unnamed.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_unnamed.dart.weak.modular.expect
@@ -7,9 +7,11 @@ static method test(dynamic x) → dynamic {
   {
     final synthesized dynamic #0#0 = x;
     late final synthesized core::Object? #0#2 = #0#0{(core::Object?, core::Object?)}.$1{core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && (let final dynamic #t1 = #0#2! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2!) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && (let final dynamic #t1 = #0#2! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2!) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_unnamed.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_unnamed.dart.weak.transformed.expect
index e6337a0ab9e..07779eee937 100644
--- a/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_unnamed.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_assert_inside_record_pattern_unnamed.dart.weak.transformed.expect
@@ -9,9 +9,11 @@ static method test(dynamic x) → dynamic {
     function ##0#2#initializer() → core::Object?
       return #0#0{(core::Object?, core::Object?)}.$1{core::Object?};
     late final synthesized core::Object? #0#2 = ##0#2#initializer(){() → core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && (let final core::Object? #t1 = #0#2! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2!) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && (let final core::Object? #t1 = #0#2! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#2!) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_case.dart.strong.expect b/pkg/front_end/testcases/patterns/null_check_inside_case.dart.strong.expect
index bce0857c6fe..0217a608547 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_case.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_case.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_case.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/null_check_inside_case.dart.strong.transformed.expect
index bce0857c6fe..0217a608547 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_case.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_case.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_case.dart.weak.expect b/pkg/front_end/testcases/patterns/null_check_inside_case.dart.weak.expect
index bce0857c6fe..0217a608547 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_case.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_case.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_case.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/null_check_inside_case.dart.weak.modular.expect
index bce0857c6fe..0217a608547 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_case.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_case.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_case.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/null_check_inside_case.dart.weak.transformed.expect
index bce0857c6fe..0217a608547 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_case.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_case.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_extractor_pattern.dart.strong.expect b/pkg/front_end/testcases/patterns/null_check_inside_extractor_pattern.dart.strong.expect
index 71ebb360086..8af06875cf6 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_extractor_pattern.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_extractor_pattern.dart.strong.expect
@@ -13,9 +13,11 @@ static method test(dynamic x) → dynamic {
   {
     final synthesized dynamic #0#0 = x;
     late final synthesized core::int? #0#2 = #0#0{self::C}.{self::C::f}{core::int?};
-    if(#0#0 is{ForNonNullableByDefault} self::C && (!(#0#2 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 : false)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::C && (!(#0#2 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 : false)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_extractor_pattern.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/null_check_inside_extractor_pattern.dart.strong.transformed.expect
index 158c6b072bf..8007e55c2bf 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_extractor_pattern.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_extractor_pattern.dart.strong.transformed.expect
@@ -15,9 +15,11 @@ static method test(dynamic x) → dynamic {
     function ##0#2#initializer() → core::int?
       return #0#0{self::C}.{self::C::f}{core::int?};
     late final synthesized core::int? #0#2 = ##0#2#initializer(){() → core::int?};
-    if(#0#0 is{ForNonNullableByDefault} self::C && (!(#0#2 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 : false)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::C && (!(#0#2 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 : false)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_extractor_pattern.dart.weak.expect b/pkg/front_end/testcases/patterns/null_check_inside_extractor_pattern.dart.weak.expect
index 71ebb360086..8af06875cf6 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_extractor_pattern.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_extractor_pattern.dart.weak.expect
@@ -13,9 +13,11 @@ static method test(dynamic x) → dynamic {
   {
     final synthesized dynamic #0#0 = x;
     late final synthesized core::int? #0#2 = #0#0{self::C}.{self::C::f}{core::int?};
-    if(#0#0 is{ForNonNullableByDefault} self::C && (!(#0#2 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 : false)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::C && (!(#0#2 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 : false)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_extractor_pattern.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/null_check_inside_extractor_pattern.dart.weak.modular.expect
index 71ebb360086..8af06875cf6 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_extractor_pattern.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_extractor_pattern.dart.weak.modular.expect
@@ -13,9 +13,11 @@ static method test(dynamic x) → dynamic {
   {
     final synthesized dynamic #0#0 = x;
     late final synthesized core::int? #0#2 = #0#0{self::C}.{self::C::f}{core::int?};
-    if(#0#0 is{ForNonNullableByDefault} self::C && (!(#0#2 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 : false)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::C && (!(#0#2 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 : false)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_extractor_pattern.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/null_check_inside_extractor_pattern.dart.weak.transformed.expect
index 158c6b072bf..8007e55c2bf 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_extractor_pattern.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_extractor_pattern.dart.weak.transformed.expect
@@ -15,9 +15,11 @@ static method test(dynamic x) → dynamic {
     function ##0#2#initializer() → core::int?
       return #0#0{self::C}.{self::C::f}{core::int?};
     late final synthesized core::int? #0#2 = ##0#2#initializer(){() → core::int?};
-    if(#0#0 is{ForNonNullableByDefault} self::C && (!(#0#2 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 : false)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::C && (!(#0#2 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 : false)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_extractor_pattern_implicitly_named.dart.strong.expect b/pkg/front_end/testcases/patterns/null_check_inside_extractor_pattern_implicitly_named.dart.strong.expect
index e9eb00859b6..cea268f33aa 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_extractor_pattern_implicitly_named.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_extractor_pattern_implicitly_named.dart.strong.expect
@@ -11,12 +11,14 @@ class C extends core::Object {
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int f;
     final synthesized dynamic #0#0 = x;
     late final synthesized core::int? #0#2 = #0#0{self::C}.{self::C::f}{core::int?};
-    if(#0#0 is{ForNonNullableByDefault} self::C && (!(#0#2 == null) ?{core::bool} let final dynamic #t1 = f = #0#2{core::int} in true : false)) {
-      {
-        break #L1;
+    {
+      core::int f;
+      if(#0#0 is{ForNonNullableByDefault} self::C && (!(#0#2 == null) ?{core::bool} let final dynamic #t1 = f = #0#2{core::int} in true : false)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_extractor_pattern_implicitly_named.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/null_check_inside_extractor_pattern_implicitly_named.dart.strong.transformed.expect
index 29d370b8399..964242a4cb3 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_extractor_pattern_implicitly_named.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_extractor_pattern_implicitly_named.dart.strong.transformed.expect
@@ -11,14 +11,16 @@ class C extends core::Object {
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int f;
     final synthesized dynamic #0#0 = x;
     function ##0#2#initializer() → core::int?
       return #0#0{self::C}.{self::C::f}{core::int?};
     late final synthesized core::int? #0#2 = ##0#2#initializer(){() → core::int?};
-    if(#0#0 is{ForNonNullableByDefault} self::C && (!(#0#2 == null) ?{core::bool} let final core::int #t1 = f = #0#2{core::int} in true : false)) {
-      {
-        break #L1;
+    {
+      core::int f;
+      if(#0#0 is{ForNonNullableByDefault} self::C && (!(#0#2 == null) ?{core::bool} let final core::int #t1 = f = #0#2{core::int} in true : false)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_extractor_pattern_implicitly_named.dart.weak.expect b/pkg/front_end/testcases/patterns/null_check_inside_extractor_pattern_implicitly_named.dart.weak.expect
index e9eb00859b6..cea268f33aa 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_extractor_pattern_implicitly_named.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_extractor_pattern_implicitly_named.dart.weak.expect
@@ -11,12 +11,14 @@ class C extends core::Object {
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int f;
     final synthesized dynamic #0#0 = x;
     late final synthesized core::int? #0#2 = #0#0{self::C}.{self::C::f}{core::int?};
-    if(#0#0 is{ForNonNullableByDefault} self::C && (!(#0#2 == null) ?{core::bool} let final dynamic #t1 = f = #0#2{core::int} in true : false)) {
-      {
-        break #L1;
+    {
+      core::int f;
+      if(#0#0 is{ForNonNullableByDefault} self::C && (!(#0#2 == null) ?{core::bool} let final dynamic #t1 = f = #0#2{core::int} in true : false)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_extractor_pattern_implicitly_named.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/null_check_inside_extractor_pattern_implicitly_named.dart.weak.modular.expect
index e9eb00859b6..cea268f33aa 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_extractor_pattern_implicitly_named.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_extractor_pattern_implicitly_named.dart.weak.modular.expect
@@ -11,12 +11,14 @@ class C extends core::Object {
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int f;
     final synthesized dynamic #0#0 = x;
     late final synthesized core::int? #0#2 = #0#0{self::C}.{self::C::f}{core::int?};
-    if(#0#0 is{ForNonNullableByDefault} self::C && (!(#0#2 == null) ?{core::bool} let final dynamic #t1 = f = #0#2{core::int} in true : false)) {
-      {
-        break #L1;
+    {
+      core::int f;
+      if(#0#0 is{ForNonNullableByDefault} self::C && (!(#0#2 == null) ?{core::bool} let final dynamic #t1 = f = #0#2{core::int} in true : false)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_extractor_pattern_implicitly_named.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/null_check_inside_extractor_pattern_implicitly_named.dart.weak.transformed.expect
index 29d370b8399..964242a4cb3 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_extractor_pattern_implicitly_named.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_extractor_pattern_implicitly_named.dart.weak.transformed.expect
@@ -11,14 +11,16 @@ class C extends core::Object {
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int f;
     final synthesized dynamic #0#0 = x;
     function ##0#2#initializer() → core::int?
       return #0#0{self::C}.{self::C::f}{core::int?};
     late final synthesized core::int? #0#2 = ##0#2#initializer(){() → core::int?};
-    if(#0#0 is{ForNonNullableByDefault} self::C && (!(#0#2 == null) ?{core::bool} let final core::int #t1 = f = #0#2{core::int} in true : false)) {
-      {
-        break #L1;
+    {
+      core::int f;
+      if(#0#0 is{ForNonNullableByDefault} self::C && (!(#0#2 == null) ?{core::bool} let final core::int #t1 = f = #0#2{core::int} in true : false)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_list_pattern.dart.strong.expect b/pkg/front_end/testcases/patterns/null_check_inside_list_pattern.dart.strong.expect
index f70e5b09af9..be2b2b42ad8 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_list_pattern.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_list_pattern.dart.strong.expect
@@ -7,9 +7,11 @@ static method test(dynamic x) → dynamic {
   {
     final synthesized dynamic #0#0 = x;
     late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (!(#0#6 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#6 : false)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (!(#0#6 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#6 : false)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_list_pattern.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/null_check_inside_list_pattern.dart.strong.transformed.expect
index 7244ec62e02..cf15bc38fcd 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_list_pattern.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_list_pattern.dart.strong.transformed.expect
@@ -9,9 +9,11 @@ static method test(dynamic x) → dynamic {
     function ##0#6#initializer() → dynamic
       return #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
     late final synthesized dynamic #0#6 = ##0#6#initializer(){() → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (!(#0#6 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#6 : false)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (!(#0#6 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#6 : false)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_list_pattern.dart.weak.expect b/pkg/front_end/testcases/patterns/null_check_inside_list_pattern.dart.weak.expect
index f70e5b09af9..be2b2b42ad8 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_list_pattern.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_list_pattern.dart.weak.expect
@@ -7,9 +7,11 @@ static method test(dynamic x) → dynamic {
   {
     final synthesized dynamic #0#0 = x;
     late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (!(#0#6 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#6 : false)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (!(#0#6 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#6 : false)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_list_pattern.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/null_check_inside_list_pattern.dart.weak.modular.expect
index f70e5b09af9..be2b2b42ad8 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_list_pattern.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_list_pattern.dart.weak.modular.expect
@@ -7,9 +7,11 @@ static method test(dynamic x) → dynamic {
   {
     final synthesized dynamic #0#0 = x;
     late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (!(#0#6 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#6 : false)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (!(#0#6 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#6 : false)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_list_pattern.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/null_check_inside_list_pattern.dart.weak.transformed.expect
index 7244ec62e02..cf15bc38fcd 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_list_pattern.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_list_pattern.dart.weak.transformed.expect
@@ -9,9 +9,11 @@ static method test(dynamic x) → dynamic {
     function ##0#6#initializer() → dynamic
       return #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
     late final synthesized dynamic #0#6 = ##0#6#initializer(){() → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (!(#0#6 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#6 : false)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (!(#0#6 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#6 : false)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_logical_and_lhs.dart.strong.expect b/pkg/front_end/testcases/patterns/null_check_inside_logical_and_lhs.dart.strong.expect
index 8b67d3742d8..ed263e7843a 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_logical_and_lhs.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_logical_and_lhs.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if((!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        break #L1;
+    {
+      if((!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_logical_and_lhs.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/null_check_inside_logical_and_lhs.dart.strong.transformed.expect
index 8b67d3742d8..ed263e7843a 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_logical_and_lhs.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_logical_and_lhs.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if((!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        break #L1;
+    {
+      if((!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_logical_and_lhs.dart.weak.expect b/pkg/front_end/testcases/patterns/null_check_inside_logical_and_lhs.dart.weak.expect
index 8b67d3742d8..ed263e7843a 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_logical_and_lhs.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_logical_and_lhs.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if((!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        break #L1;
+    {
+      if((!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_logical_and_lhs.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/null_check_inside_logical_and_lhs.dart.weak.modular.expect
index 8b67d3742d8..ed263e7843a 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_logical_and_lhs.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_logical_and_lhs.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if((!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        break #L1;
+    {
+      if((!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_logical_and_lhs.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/null_check_inside_logical_and_lhs.dart.weak.transformed.expect
index 8b67d3742d8..ed263e7843a 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_logical_and_lhs.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_logical_and_lhs.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if((!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        break #L1;
+    {
+      if((!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_logical_and_rhs.dart.strong.expect b/pkg/front_end/testcases/patterns/null_check_inside_logical_and_rhs.dart.strong.expect
index 481723e95a4..b422140143e 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_logical_and_rhs.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_logical_and_rhs.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && (!(#0#0 == null) ?{core::bool} #C2 =={core::num::==}{(core::Object) → core::bool} #0#0 : false)) {
-      {
-        break #L1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && (!(#0#0 == null) ?{core::bool} #C2 =={core::num::==}{(core::Object) → core::bool} #0#0 : false)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_logical_and_rhs.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/null_check_inside_logical_and_rhs.dart.strong.transformed.expect
index 481723e95a4..b422140143e 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_logical_and_rhs.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_logical_and_rhs.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && (!(#0#0 == null) ?{core::bool} #C2 =={core::num::==}{(core::Object) → core::bool} #0#0 : false)) {
-      {
-        break #L1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && (!(#0#0 == null) ?{core::bool} #C2 =={core::num::==}{(core::Object) → core::bool} #0#0 : false)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_logical_and_rhs.dart.weak.expect b/pkg/front_end/testcases/patterns/null_check_inside_logical_and_rhs.dart.weak.expect
index 481723e95a4..b422140143e 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_logical_and_rhs.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_logical_and_rhs.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && (!(#0#0 == null) ?{core::bool} #C2 =={core::num::==}{(core::Object) → core::bool} #0#0 : false)) {
-      {
-        break #L1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && (!(#0#0 == null) ?{core::bool} #C2 =={core::num::==}{(core::Object) → core::bool} #0#0 : false)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_logical_and_rhs.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/null_check_inside_logical_and_rhs.dart.weak.modular.expect
index 481723e95a4..b422140143e 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_logical_and_rhs.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_logical_and_rhs.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && (!(#0#0 == null) ?{core::bool} #C2 =={core::num::==}{(core::Object) → core::bool} #0#0 : false)) {
-      {
-        break #L1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && (!(#0#0 == null) ?{core::bool} #C2 =={core::num::==}{(core::Object) → core::bool} #0#0 : false)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_logical_and_rhs.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/null_check_inside_logical_and_rhs.dart.weak.transformed.expect
index 481723e95a4..b422140143e 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_logical_and_rhs.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_logical_and_rhs.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && (!(#0#0 == null) ?{core::bool} #C2 =={core::num::==}{(core::Object) → core::bool} #0#0 : false)) {
-      {
-        break #L1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && (!(#0#0 == null) ?{core::bool} #C2 =={core::num::==}{(core::Object) → core::bool} #0#0 : false)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_logical_or_lhs.dart.strong.expect b/pkg/front_end/testcases/patterns/null_check_inside_logical_or_lhs.dart.strong.expect
index 9b2d2243bc6..6aacb84a727 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_logical_or_lhs.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_logical_or_lhs.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if((!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) || #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        break #L1;
+    {
+      if((!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) || #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_logical_or_lhs.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/null_check_inside_logical_or_lhs.dart.strong.transformed.expect
index 9b2d2243bc6..6aacb84a727 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_logical_or_lhs.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_logical_or_lhs.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if((!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) || #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        break #L1;
+    {
+      if((!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) || #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_logical_or_lhs.dart.weak.expect b/pkg/front_end/testcases/patterns/null_check_inside_logical_or_lhs.dart.weak.expect
index 9b2d2243bc6..6aacb84a727 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_logical_or_lhs.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_logical_or_lhs.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if((!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) || #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        break #L1;
+    {
+      if((!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) || #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_logical_or_lhs.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/null_check_inside_logical_or_lhs.dart.weak.modular.expect
index 9b2d2243bc6..6aacb84a727 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_logical_or_lhs.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_logical_or_lhs.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if((!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) || #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        break #L1;
+    {
+      if((!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) || #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_logical_or_lhs.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/null_check_inside_logical_or_lhs.dart.weak.transformed.expect
index 9b2d2243bc6..6aacb84a727 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_logical_or_lhs.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_logical_or_lhs.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if((!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) || #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        break #L1;
+    {
+      if((!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) || #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_logical_or_rhs.dart.strong.expect b/pkg/front_end/testcases/patterns/null_check_inside_logical_or_rhs.dart.strong.expect
index 36ad922a481..24e25b87040 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_logical_or_rhs.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_logical_or_rhs.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || (!(#0#0 == null) ?{core::bool} #C2 =={core::num::==}{(core::Object) → core::bool} #0#0 : false)) {
-      {
-        break #L1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || (!(#0#0 == null) ?{core::bool} #C2 =={core::num::==}{(core::Object) → core::bool} #0#0 : false)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_logical_or_rhs.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/null_check_inside_logical_or_rhs.dart.strong.transformed.expect
index 36ad922a481..24e25b87040 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_logical_or_rhs.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_logical_or_rhs.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || (!(#0#0 == null) ?{core::bool} #C2 =={core::num::==}{(core::Object) → core::bool} #0#0 : false)) {
-      {
-        break #L1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || (!(#0#0 == null) ?{core::bool} #C2 =={core::num::==}{(core::Object) → core::bool} #0#0 : false)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_logical_or_rhs.dart.weak.expect b/pkg/front_end/testcases/patterns/null_check_inside_logical_or_rhs.dart.weak.expect
index 36ad922a481..24e25b87040 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_logical_or_rhs.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_logical_or_rhs.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || (!(#0#0 == null) ?{core::bool} #C2 =={core::num::==}{(core::Object) → core::bool} #0#0 : false)) {
-      {
-        break #L1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || (!(#0#0 == null) ?{core::bool} #C2 =={core::num::==}{(core::Object) → core::bool} #0#0 : false)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_logical_or_rhs.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/null_check_inside_logical_or_rhs.dart.weak.modular.expect
index 36ad922a481..24e25b87040 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_logical_or_rhs.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_logical_or_rhs.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || (!(#0#0 == null) ?{core::bool} #C2 =={core::num::==}{(core::Object) → core::bool} #0#0 : false)) {
-      {
-        break #L1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || (!(#0#0 == null) ?{core::bool} #C2 =={core::num::==}{(core::Object) → core::bool} #0#0 : false)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_logical_or_rhs.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/null_check_inside_logical_or_rhs.dart.weak.transformed.expect
index 36ad922a481..24e25b87040 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_logical_or_rhs.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_logical_or_rhs.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || (!(#0#0 == null) ?{core::bool} #C2 =={core::num::==}{(core::Object) → core::bool} #0#0 : false)) {
-      {
-        break #L1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || (!(#0#0 == null) ?{core::bool} #C2 =={core::num::==}{(core::Object) → core::bool} #0#0 : false)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_map_pattern.dart.strong.expect b/pkg/front_end/testcases/patterns/null_check_inside_map_pattern.dart.strong.expect
index 5d6c60c0854..7c2781c43e1 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_map_pattern.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_map_pattern.dart.strong.expect
@@ -7,9 +7,11 @@ static method test(dynamic x) → dynamic {
   {
     final synthesized dynamic #0#0 = x;
     late final synthesized dynamic #0#8 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (!(#0#8 == null) ?{core::bool} #C2 =={core::num::==}{(core::Object) → core::bool} #0#8 : false)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (!(#0#8 == null) ?{core::bool} #C2 =={core::num::==}{(core::Object) → core::bool} #0#8 : false)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_map_pattern.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/null_check_inside_map_pattern.dart.strong.transformed.expect
index 3e52d2f8491..2d33b6fa533 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_map_pattern.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_map_pattern.dart.strong.transformed.expect
@@ -9,9 +9,11 @@ static method test(dynamic x) → dynamic {
     function ##0#8#initializer() → dynamic
       return #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic};
     late final synthesized dynamic #0#8 = ##0#8#initializer(){() → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (!(#0#8 == null) ?{core::bool} #C2 =={core::num::==}{(core::Object) → core::bool} #0#8 : false)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (!(#0#8 == null) ?{core::bool} #C2 =={core::num::==}{(core::Object) → core::bool} #0#8 : false)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_map_pattern.dart.weak.expect b/pkg/front_end/testcases/patterns/null_check_inside_map_pattern.dart.weak.expect
index 5d6c60c0854..7c2781c43e1 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_map_pattern.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_map_pattern.dart.weak.expect
@@ -7,9 +7,11 @@ static method test(dynamic x) → dynamic {
   {
     final synthesized dynamic #0#0 = x;
     late final synthesized dynamic #0#8 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (!(#0#8 == null) ?{core::bool} #C2 =={core::num::==}{(core::Object) → core::bool} #0#8 : false)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (!(#0#8 == null) ?{core::bool} #C2 =={core::num::==}{(core::Object) → core::bool} #0#8 : false)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_map_pattern.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/null_check_inside_map_pattern.dart.weak.modular.expect
index 5d6c60c0854..7c2781c43e1 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_map_pattern.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_map_pattern.dart.weak.modular.expect
@@ -7,9 +7,11 @@ static method test(dynamic x) → dynamic {
   {
     final synthesized dynamic #0#0 = x;
     late final synthesized dynamic #0#8 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (!(#0#8 == null) ?{core::bool} #C2 =={core::num::==}{(core::Object) → core::bool} #0#8 : false)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (!(#0#8 == null) ?{core::bool} #C2 =={core::num::==}{(core::Object) → core::bool} #0#8 : false)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_map_pattern.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/null_check_inside_map_pattern.dart.weak.transformed.expect
index 3e52d2f8491..2d33b6fa533 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_map_pattern.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_map_pattern.dart.weak.transformed.expect
@@ -9,9 +9,11 @@ static method test(dynamic x) → dynamic {
     function ##0#8#initializer() → dynamic
       return #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic};
     late final synthesized dynamic #0#8 = ##0#8#initializer(){() → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (!(#0#8 == null) ?{core::bool} #C2 =={core::num::==}{(core::Object) → core::bool} #0#8 : false)) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (!(#0#8 == null) ?{core::bool} #C2 =={core::num::==}{(core::Object) → core::bool} #0#8 : false)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_parenthesized_pattern.dart.strong.expect b/pkg/front_end/testcases/patterns/null_check_inside_parenthesized_pattern.dart.strong.expect
index bce0857c6fe..0217a608547 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_parenthesized_pattern.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_parenthesized_pattern.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_parenthesized_pattern.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/null_check_inside_parenthesized_pattern.dart.strong.transformed.expect
index bce0857c6fe..0217a608547 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_parenthesized_pattern.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_parenthesized_pattern.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_parenthesized_pattern.dart.weak.expect b/pkg/front_end/testcases/patterns/null_check_inside_parenthesized_pattern.dart.weak.expect
index bce0857c6fe..0217a608547 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_parenthesized_pattern.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_parenthesized_pattern.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_parenthesized_pattern.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/null_check_inside_parenthesized_pattern.dart.weak.modular.expect
index bce0857c6fe..0217a608547 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_parenthesized_pattern.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_parenthesized_pattern.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_parenthesized_pattern.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/null_check_inside_parenthesized_pattern.dart.weak.transformed.expect
index bce0857c6fe..0217a608547 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_parenthesized_pattern.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_parenthesized_pattern.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_implicitly_named.dart.strong.expect b/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_implicitly_named.dart.strong.expect
index 9dbd52cbdbc..fedf1510b1a 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_implicitly_named.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_implicitly_named.dart.strong.expect
@@ -5,12 +5,14 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    dynamic n;
     final synthesized dynamic #0#0 = x;
     late final synthesized core::Object? #0#2 = #0#0{(core::Object?, {n: core::Object?})}.n{core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (!(#0#2 == null) ?{core::bool} let final dynamic #t1 = n = #0#2 in true : false) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      dynamic n;
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (!(#0#2 == null) ?{core::bool} let final dynamic #t1 = n = #0#2 in true : false) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_implicitly_named.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_implicitly_named.dart.strong.transformed.expect
index 97da959efd3..02bb57eae7f 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_implicitly_named.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_implicitly_named.dart.strong.transformed.expect
@@ -5,14 +5,16 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    dynamic n;
     final synthesized dynamic #0#0 = x;
     function ##0#2#initializer() → core::Object?
       return #0#0{(core::Object?, {n: core::Object?})}.n{core::Object?};
     late final synthesized core::Object? #0#2 = ##0#2#initializer(){() → core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (!(#0#2 == null) ?{core::bool} let final core::Object? #t1 = n = #0#2 in true : false) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      dynamic n;
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (!(#0#2 == null) ?{core::bool} let final core::Object? #t1 = n = #0#2 in true : false) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_implicitly_named.dart.weak.expect b/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_implicitly_named.dart.weak.expect
index 9dbd52cbdbc..fedf1510b1a 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_implicitly_named.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_implicitly_named.dart.weak.expect
@@ -5,12 +5,14 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    dynamic n;
     final synthesized dynamic #0#0 = x;
     late final synthesized core::Object? #0#2 = #0#0{(core::Object?, {n: core::Object?})}.n{core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (!(#0#2 == null) ?{core::bool} let final dynamic #t1 = n = #0#2 in true : false) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      dynamic n;
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (!(#0#2 == null) ?{core::bool} let final dynamic #t1 = n = #0#2 in true : false) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_implicitly_named.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_implicitly_named.dart.weak.modular.expect
index 9dbd52cbdbc..fedf1510b1a 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_implicitly_named.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_implicitly_named.dart.weak.modular.expect
@@ -5,12 +5,14 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    dynamic n;
     final synthesized dynamic #0#0 = x;
     late final synthesized core::Object? #0#2 = #0#0{(core::Object?, {n: core::Object?})}.n{core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (!(#0#2 == null) ?{core::bool} let final dynamic #t1 = n = #0#2 in true : false) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      dynamic n;
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (!(#0#2 == null) ?{core::bool} let final dynamic #t1 = n = #0#2 in true : false) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_implicitly_named.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_implicitly_named.dart.weak.transformed.expect
index 97da959efd3..02bb57eae7f 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_implicitly_named.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_implicitly_named.dart.weak.transformed.expect
@@ -5,14 +5,16 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    dynamic n;
     final synthesized dynamic #0#0 = x;
     function ##0#2#initializer() → core::Object?
       return #0#0{(core::Object?, {n: core::Object?})}.n{core::Object?};
     late final synthesized core::Object? #0#2 = ##0#2#initializer(){() → core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (!(#0#2 == null) ?{core::bool} let final core::Object? #t1 = n = #0#2 in true : false) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      dynamic n;
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (!(#0#2 == null) ?{core::bool} let final core::Object? #t1 = n = #0#2 in true : false) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_named.dart.strong.expect b/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_named.dart.strong.expect
index 10c597504f7..c7051b7422a 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_named.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_named.dart.strong.expect
@@ -7,9 +7,11 @@ static method test(dynamic x) → dynamic {
   {
     final synthesized dynamic #0#0 = x;
     late final synthesized core::Object? #0#2 = #0#0{(core::Object?, {n: core::Object?})}.n{core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (!(#0#2 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 : false) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (!(#0#2 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 : false) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_named.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_named.dart.strong.transformed.expect
index d24d3f0b682..3dd2d3f4fb5 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_named.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_named.dart.strong.transformed.expect
@@ -9,9 +9,11 @@ static method test(dynamic x) → dynamic {
     function ##0#2#initializer() → core::Object?
       return #0#0{(core::Object?, {n: core::Object?})}.n{core::Object?};
     late final synthesized core::Object? #0#2 = ##0#2#initializer(){() → core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (!(#0#2 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 : false) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (!(#0#2 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 : false) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_named.dart.weak.expect b/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_named.dart.weak.expect
index 10c597504f7..c7051b7422a 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_named.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_named.dart.weak.expect
@@ -7,9 +7,11 @@ static method test(dynamic x) → dynamic {
   {
     final synthesized dynamic #0#0 = x;
     late final synthesized core::Object? #0#2 = #0#0{(core::Object?, {n: core::Object?})}.n{core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (!(#0#2 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 : false) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (!(#0#2 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 : false) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_named.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_named.dart.weak.modular.expect
index 10c597504f7..c7051b7422a 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_named.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_named.dart.weak.modular.expect
@@ -7,9 +7,11 @@ static method test(dynamic x) → dynamic {
   {
     final synthesized dynamic #0#0 = x;
     late final synthesized core::Object? #0#2 = #0#0{(core::Object?, {n: core::Object?})}.n{core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (!(#0#2 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 : false) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (!(#0#2 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 : false) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_named.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_named.dart.weak.transformed.expect
index d24d3f0b682..3dd2d3f4fb5 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_named.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_named.dart.weak.transformed.expect
@@ -9,9 +9,11 @@ static method test(dynamic x) → dynamic {
     function ##0#2#initializer() → core::Object?
       return #0#0{(core::Object?, {n: core::Object?})}.n{core::Object?};
     late final synthesized core::Object? #0#2 = ##0#2#initializer(){() → core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (!(#0#2 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 : false) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (!(#0#2 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 : false) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_unnamed.dart.strong.expect b/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_unnamed.dart.strong.expect
index 6a53996684f..2b13da9337b 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_unnamed.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_unnamed.dart.strong.expect
@@ -7,9 +7,11 @@ static method test(dynamic x) → dynamic {
   {
     final synthesized dynamic #0#0 = x;
     late final synthesized core::Object? #0#2 = #0#0{(core::Object?, core::Object?)}.$1{core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && (!(#0#2 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 : false) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && (!(#0#2 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 : false) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_unnamed.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_unnamed.dart.strong.transformed.expect
index 54e89da9873..6639d853b85 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_unnamed.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_unnamed.dart.strong.transformed.expect
@@ -9,9 +9,11 @@ static method test(dynamic x) → dynamic {
     function ##0#2#initializer() → core::Object?
       return #0#0{(core::Object?, core::Object?)}.$1{core::Object?};
     late final synthesized core::Object? #0#2 = ##0#2#initializer(){() → core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && (!(#0#2 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 : false) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && (!(#0#2 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 : false) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_unnamed.dart.weak.expect b/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_unnamed.dart.weak.expect
index 6a53996684f..2b13da9337b 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_unnamed.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_unnamed.dart.weak.expect
@@ -7,9 +7,11 @@ static method test(dynamic x) → dynamic {
   {
     final synthesized dynamic #0#0 = x;
     late final synthesized core::Object? #0#2 = #0#0{(core::Object?, core::Object?)}.$1{core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && (!(#0#2 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 : false) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && (!(#0#2 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 : false) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_unnamed.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_unnamed.dart.weak.modular.expect
index 6a53996684f..2b13da9337b 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_unnamed.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_unnamed.dart.weak.modular.expect
@@ -7,9 +7,11 @@ static method test(dynamic x) → dynamic {
   {
     final synthesized dynamic #0#0 = x;
     late final synthesized core::Object? #0#2 = #0#0{(core::Object?, core::Object?)}.$1{core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && (!(#0#2 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 : false) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && (!(#0#2 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 : false) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_unnamed.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_unnamed.dart.weak.transformed.expect
index 54e89da9873..6639d853b85 100644
--- a/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_unnamed.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_check_inside_record_pattern_unnamed.dart.weak.transformed.expect
@@ -9,9 +9,11 @@ static method test(dynamic x) → dynamic {
     function ##0#2#initializer() → core::Object?
       return #0#0{(core::Object?, core::Object?)}.$1{core::Object?};
     late final synthesized core::Object? #0#2 = ##0#2#initializer(){() → core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && (!(#0#2 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 : false) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && (!(#0#2 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#2 : false) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_literal_inside_case.dart.strong.expect b/pkg/front_end/testcases/patterns/null_literal_inside_case.dart.strong.expect
index 612fac718c9..c4a01a2fd5f 100644
--- a/pkg/front_end/testcases/patterns/null_literal_inside_case.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/null_literal_inside_case.dart.strong.expect
@@ -3,12 +3,15 @@ import self as self;
 
 static method test(dynamic x) → dynamic {
   #L1:
-  {
-    final synthesized dynamic #0#0 = x;
-    if(#0#0 == null) {
+  switch(x) {
+    #L2:
+    case #C1:
       {
         break #L1;
       }
-    }
   }
 }
+
+constants  {
+  #C1 = null
+}
diff --git a/pkg/front_end/testcases/patterns/null_literal_inside_case.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/null_literal_inside_case.dart.strong.transformed.expect
index 612fac718c9..c4a01a2fd5f 100644
--- a/pkg/front_end/testcases/patterns/null_literal_inside_case.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_literal_inside_case.dart.strong.transformed.expect
@@ -3,12 +3,15 @@ import self as self;
 
 static method test(dynamic x) → dynamic {
   #L1:
-  {
-    final synthesized dynamic #0#0 = x;
-    if(#0#0 == null) {
+  switch(x) {
+    #L2:
+    case #C1:
       {
         break #L1;
       }
-    }
   }
 }
+
+constants  {
+  #C1 = null
+}
diff --git a/pkg/front_end/testcases/patterns/null_literal_inside_case.dart.weak.expect b/pkg/front_end/testcases/patterns/null_literal_inside_case.dart.weak.expect
index 612fac718c9..c4a01a2fd5f 100644
--- a/pkg/front_end/testcases/patterns/null_literal_inside_case.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/null_literal_inside_case.dart.weak.expect
@@ -3,12 +3,15 @@ import self as self;
 
 static method test(dynamic x) → dynamic {
   #L1:
-  {
-    final synthesized dynamic #0#0 = x;
-    if(#0#0 == null) {
+  switch(x) {
+    #L2:
+    case #C1:
       {
         break #L1;
       }
-    }
   }
 }
+
+constants  {
+  #C1 = null
+}
diff --git a/pkg/front_end/testcases/patterns/null_literal_inside_case.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/null_literal_inside_case.dart.weak.modular.expect
index 612fac718c9..c4a01a2fd5f 100644
--- a/pkg/front_end/testcases/patterns/null_literal_inside_case.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/null_literal_inside_case.dart.weak.modular.expect
@@ -3,12 +3,15 @@ import self as self;
 
 static method test(dynamic x) → dynamic {
   #L1:
-  {
-    final synthesized dynamic #0#0 = x;
-    if(#0#0 == null) {
+  switch(x) {
+    #L2:
+    case #C1:
       {
         break #L1;
       }
-    }
   }
 }
+
+constants  {
+  #C1 = null
+}
diff --git a/pkg/front_end/testcases/patterns/null_literal_inside_case.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/null_literal_inside_case.dart.weak.transformed.expect
index 612fac718c9..c4a01a2fd5f 100644
--- a/pkg/front_end/testcases/patterns/null_literal_inside_case.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_literal_inside_case.dart.weak.transformed.expect
@@ -3,12 +3,15 @@ import self as self;
 
 static method test(dynamic x) → dynamic {
   #L1:
-  {
-    final synthesized dynamic #0#0 = x;
-    if(#0#0 == null) {
+  switch(x) {
+    #L2:
+    case #C1:
       {
         break #L1;
       }
-    }
   }
 }
+
+constants  {
+  #C1 = null
+}
diff --git a/pkg/front_end/testcases/patterns/null_literal_inside_cast.dart.strong.expect b/pkg/front_end/testcases/patterns/null_literal_inside_cast.dart.strong.expect
index 274cbc4bde7..29eac210bc9 100644
--- a/pkg/front_end/testcases/patterns/null_literal_inside_cast.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/null_literal_inside_cast.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in #0#0 as{ForNonNullableByDefault} core::Object == null) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in #0#0 as{ForNonNullableByDefault} core::Object == null) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_literal_inside_cast.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/null_literal_inside_cast.dart.strong.transformed.expect
index 5a1fa2f9e53..884b48a2b3b 100644
--- a/pkg/front_end/testcases/patterns/null_literal_inside_cast.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_literal_inside_cast.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final core::Object #t1 = let dynamic #t2 = #0#0 in #t2 == null ?{core::Object} #t2 as{ForNonNullableByDefault} core::Object : #t2{core::Object} in (let dynamic #t3 = #0#0 in #t3 == null ?{core::Object} #t3 as{ForNonNullableByDefault} core::Object : #t3{core::Object}) == null) {
-      {
-        break #L1;
+    {
+      if(let final core::Object #t1 = let dynamic #t2 = #0#0 in #t2 == null ?{core::Object} #t2 as{ForNonNullableByDefault} core::Object : #t2{core::Object} in (let dynamic #t3 = #0#0 in #t3 == null ?{core::Object} #t3 as{ForNonNullableByDefault} core::Object : #t3{core::Object}) == null) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_literal_inside_cast.dart.weak.expect b/pkg/front_end/testcases/patterns/null_literal_inside_cast.dart.weak.expect
index 274cbc4bde7..29eac210bc9 100644
--- a/pkg/front_end/testcases/patterns/null_literal_inside_cast.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/null_literal_inside_cast.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in #0#0 as{ForNonNullableByDefault} core::Object == null) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in #0#0 as{ForNonNullableByDefault} core::Object == null) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_literal_inside_cast.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/null_literal_inside_cast.dart.weak.modular.expect
index 274cbc4bde7..29eac210bc9 100644
--- a/pkg/front_end/testcases/patterns/null_literal_inside_cast.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/null_literal_inside_cast.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in #0#0 as{ForNonNullableByDefault} core::Object == null) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in #0#0 as{ForNonNullableByDefault} core::Object == null) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_literal_inside_cast.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/null_literal_inside_cast.dart.weak.transformed.expect
index 8ac510063ba..c4ed574b2b8 100644
--- a/pkg/front_end/testcases/patterns/null_literal_inside_cast.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_literal_inside_cast.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final core::Object #t1 = #0#0 in #0#0 == null) {
-      {
-        break #L1;
+    {
+      if(let final core::Object #t1 = #0#0 in #0#0 == null) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_literal_inside_null_assert.dart.strong.expect b/pkg/front_end/testcases/patterns/null_literal_inside_null_assert.dart.strong.expect
index f6f513da527..1804e942051 100644
--- a/pkg/front_end/testcases/patterns/null_literal_inside_null_assert.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/null_literal_inside_null_assert.dart.strong.expect
@@ -5,9 +5,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! == null) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #0#0! == null) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_literal_inside_null_assert.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/null_literal_inside_null_assert.dart.strong.transformed.expect
index f6f513da527..1804e942051 100644
--- a/pkg/front_end/testcases/patterns/null_literal_inside_null_assert.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_literal_inside_null_assert.dart.strong.transformed.expect
@@ -5,9 +5,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! == null) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #0#0! == null) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_literal_inside_null_assert.dart.weak.expect b/pkg/front_end/testcases/patterns/null_literal_inside_null_assert.dart.weak.expect
index f6f513da527..1804e942051 100644
--- a/pkg/front_end/testcases/patterns/null_literal_inside_null_assert.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/null_literal_inside_null_assert.dart.weak.expect
@@ -5,9 +5,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! == null) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #0#0! == null) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_literal_inside_null_assert.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/null_literal_inside_null_assert.dart.weak.modular.expect
index f6f513da527..1804e942051 100644
--- a/pkg/front_end/testcases/patterns/null_literal_inside_null_assert.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/null_literal_inside_null_assert.dart.weak.modular.expect
@@ -5,9 +5,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! == null) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #0#0! == null) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_literal_inside_null_assert.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/null_literal_inside_null_assert.dart.weak.transformed.expect
index f6f513da527..1804e942051 100644
--- a/pkg/front_end/testcases/patterns/null_literal_inside_null_assert.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_literal_inside_null_assert.dart.weak.transformed.expect
@@ -5,9 +5,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! == null) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #0#0! == null) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_literal_inside_null_check.dart.strong.expect b/pkg/front_end/testcases/patterns/null_literal_inside_null_check.dart.strong.expect
index e4a56641577..ac7db2ec253 100644
--- a/pkg/front_end/testcases/patterns/null_literal_inside_null_check.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/null_literal_inside_null_check.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #0#0 == null : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #0#0 == null : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_literal_inside_null_check.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/null_literal_inside_null_check.dart.strong.transformed.expect
index e4a56641577..ac7db2ec253 100644
--- a/pkg/front_end/testcases/patterns/null_literal_inside_null_check.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_literal_inside_null_check.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #0#0 == null : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #0#0 == null : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_literal_inside_null_check.dart.weak.expect b/pkg/front_end/testcases/patterns/null_literal_inside_null_check.dart.weak.expect
index e4a56641577..ac7db2ec253 100644
--- a/pkg/front_end/testcases/patterns/null_literal_inside_null_check.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/null_literal_inside_null_check.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #0#0 == null : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #0#0 == null : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_literal_inside_null_check.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/null_literal_inside_null_check.dart.weak.modular.expect
index e4a56641577..ac7db2ec253 100644
--- a/pkg/front_end/testcases/patterns/null_literal_inside_null_check.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/null_literal_inside_null_check.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #0#0 == null : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #0#0 == null : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/null_literal_inside_null_check.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/null_literal_inside_null_check.dart.weak.transformed.expect
index e4a56641577..ac7db2ec253 100644
--- a/pkg/front_end/testcases/patterns/null_literal_inside_null_check.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/null_literal_inside_null_check.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #0#0 == null : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #0#0 == null : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/omitted_break.dart.strong.expect b/pkg/front_end/testcases/patterns/omitted_break.dart.strong.expect
index 34c1039672a..37e66905fd1 100644
--- a/pkg/front_end/testcases/patterns/omitted_break.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/omitted_break.dart.strong.expect
@@ -15,75 +15,73 @@ class Enum extends core::_Enum /*isEnum*/  {
 }
 static method method(dynamic e) → dynamic {
   #L1:
-  {
-    final synthesized dynamic #0#0 = e;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+  switch(e) {
+    #L2:
+    case #C1:
       {
         core::print(0);
         break #L1;
       }
-    }
-    else
-      if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print(1);
-          break #L1;
-        }
-      }
-      else
-        if(#C7 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-          {
-            core::print(2);
-          }
-        }
-  }
-  #L2:
-  {
-    final synthesized dynamic #1#0 = e;
-    if(#1#0 is{ForNonNullableByDefault} core::int && e{core::int} =={core::num::==}{(core::Object) → core::bool} 0) {
+    #L3:
+    case #C4:
       {
-        core::print(0);
-        break #L2;
+        core::print(1);
+        break #L1;
+      }
+    #L4:
+    case #C7:
+      {
+        core::print(2);
+      }
+  }
+  #L5:
+  {
+    final synthesized dynamic #0#0 = e;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::int && e{core::int} =={core::num::==}{(core::Object) → core::bool} 0) {
+        {
+          core::print(0);
+          break #L5;
+        }
       }
     }
-    else
-      if(#1#0 is{ForNonNullableByDefault} core::int && e{core::int} =={core::num::==}{(core::Object) → core::bool} 1) {
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::int && e{core::int} =={core::num::==}{(core::Object) → core::bool} 1) {
         {
           core::print(1);
-          break #L2;
+          break #L5;
         }
       }
-      else
-        if(#1#0 is{ForNonNullableByDefault} core::int && e{core::int} =={core::num::==}{(core::Object) → core::bool} 2) {
-          {
-            core::print(2);
-          }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::int && e{core::int} =={core::num::==}{(core::Object) → core::bool} 2) {
+        {
+          core::print(2);
         }
+      }
+    }
   }
 }
 static method method2(self::Enum e) → dynamic {
-  #L3:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L6:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L7:
+    case #C3:
       {
         core::print(0);
-        break #L3;
+        break #L6;
       }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print(1);
-          break #L3;
-        }
+    #L8:
+    case #C6:
+      {
+        core::print(1);
+        break #L6;
+      }
+    #L9:
+    case #C9:
+      {
+        core::print(2);
       }
-      else
-        if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-          {
-            core::print(2);
-          }
-        }
   }
 }
 
diff --git a/pkg/front_end/testcases/patterns/omitted_break.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/omitted_break.dart.strong.transformed.expect
index 34c1039672a..37e66905fd1 100644
--- a/pkg/front_end/testcases/patterns/omitted_break.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/omitted_break.dart.strong.transformed.expect
@@ -15,75 +15,73 @@ class Enum extends core::_Enum /*isEnum*/  {
 }
 static method method(dynamic e) → dynamic {
   #L1:
-  {
-    final synthesized dynamic #0#0 = e;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+  switch(e) {
+    #L2:
+    case #C1:
       {
         core::print(0);
         break #L1;
       }
-    }
-    else
-      if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print(1);
-          break #L1;
-        }
-      }
-      else
-        if(#C7 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-          {
-            core::print(2);
-          }
-        }
-  }
-  #L2:
-  {
-    final synthesized dynamic #1#0 = e;
-    if(#1#0 is{ForNonNullableByDefault} core::int && e{core::int} =={core::num::==}{(core::Object) → core::bool} 0) {
+    #L3:
+    case #C4:
       {
-        core::print(0);
-        break #L2;
+        core::print(1);
+        break #L1;
+      }
+    #L4:
+    case #C7:
+      {
+        core::print(2);
+      }
+  }
+  #L5:
+  {
+    final synthesized dynamic #0#0 = e;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::int && e{core::int} =={core::num::==}{(core::Object) → core::bool} 0) {
+        {
+          core::print(0);
+          break #L5;
+        }
       }
     }
-    else
-      if(#1#0 is{ForNonNullableByDefault} core::int && e{core::int} =={core::num::==}{(core::Object) → core::bool} 1) {
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::int && e{core::int} =={core::num::==}{(core::Object) → core::bool} 1) {
         {
           core::print(1);
-          break #L2;
+          break #L5;
         }
       }
-      else
-        if(#1#0 is{ForNonNullableByDefault} core::int && e{core::int} =={core::num::==}{(core::Object) → core::bool} 2) {
-          {
-            core::print(2);
-          }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::int && e{core::int} =={core::num::==}{(core::Object) → core::bool} 2) {
+        {
+          core::print(2);
         }
+      }
+    }
   }
 }
 static method method2(self::Enum e) → dynamic {
-  #L3:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L6:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L7:
+    case #C3:
       {
         core::print(0);
-        break #L3;
+        break #L6;
       }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print(1);
-          break #L3;
-        }
+    #L8:
+    case #C6:
+      {
+        core::print(1);
+        break #L6;
+      }
+    #L9:
+    case #C9:
+      {
+        core::print(2);
       }
-      else
-        if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-          {
-            core::print(2);
-          }
-        }
   }
 }
 
diff --git a/pkg/front_end/testcases/patterns/omitted_break.dart.weak.expect b/pkg/front_end/testcases/patterns/omitted_break.dart.weak.expect
index 14e0912e0d1..87c3cbb1b87 100644
--- a/pkg/front_end/testcases/patterns/omitted_break.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/omitted_break.dart.weak.expect
@@ -15,75 +15,73 @@ class Enum extends core::_Enum /*isEnum*/  {
 }
 static method method(dynamic e) → dynamic {
   #L1:
-  {
-    final synthesized dynamic #0#0 = e;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+  switch(e) {
+    #L2:
+    case #C1:
       {
         core::print(0);
         break #L1;
       }
-    }
-    else
-      if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print(1);
-          break #L1;
-        }
-      }
-      else
-        if(#C7 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-          {
-            core::print(2);
-          }
-        }
-  }
-  #L2:
-  {
-    final synthesized dynamic #1#0 = e;
-    if(#1#0 is{ForNonNullableByDefault} core::int && e{core::int} =={core::num::==}{(core::Object) → core::bool} 0) {
+    #L3:
+    case #C4:
       {
-        core::print(0);
-        break #L2;
+        core::print(1);
+        break #L1;
+      }
+    #L4:
+    case #C7:
+      {
+        core::print(2);
+      }
+  }
+  #L5:
+  {
+    final synthesized dynamic #0#0 = e;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::int && e{core::int} =={core::num::==}{(core::Object) → core::bool} 0) {
+        {
+          core::print(0);
+          break #L5;
+        }
       }
     }
-    else
-      if(#1#0 is{ForNonNullableByDefault} core::int && e{core::int} =={core::num::==}{(core::Object) → core::bool} 1) {
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::int && e{core::int} =={core::num::==}{(core::Object) → core::bool} 1) {
         {
           core::print(1);
-          break #L2;
+          break #L5;
         }
       }
-      else
-        if(#1#0 is{ForNonNullableByDefault} core::int && e{core::int} =={core::num::==}{(core::Object) → core::bool} 2) {
-          {
-            core::print(2);
-          }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::int && e{core::int} =={core::num::==}{(core::Object) → core::bool} 2) {
+        {
+          core::print(2);
         }
+      }
+    }
   }
 }
 static method method2(self::Enum e) → dynamic {
-  #L3:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L6:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L7:
+    case #C3:
       {
         core::print(0);
-        break #L3;
+        break #L6;
       }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print(1);
-          break #L3;
-        }
+    #L8:
+    case #C6:
+      {
+        core::print(1);
+        break #L6;
+      }
+    #L9:
+    case #C9:
+      {
+        core::print(2);
       }
-      else
-        if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-          {
-            core::print(2);
-          }
-        }
   }
 }
 
diff --git a/pkg/front_end/testcases/patterns/omitted_break.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/omitted_break.dart.weak.modular.expect
index 14e0912e0d1..87c3cbb1b87 100644
--- a/pkg/front_end/testcases/patterns/omitted_break.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/omitted_break.dart.weak.modular.expect
@@ -15,75 +15,73 @@ class Enum extends core::_Enum /*isEnum*/  {
 }
 static method method(dynamic e) → dynamic {
   #L1:
-  {
-    final synthesized dynamic #0#0 = e;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+  switch(e) {
+    #L2:
+    case #C1:
       {
         core::print(0);
         break #L1;
       }
-    }
-    else
-      if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print(1);
-          break #L1;
-        }
-      }
-      else
-        if(#C7 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-          {
-            core::print(2);
-          }
-        }
-  }
-  #L2:
-  {
-    final synthesized dynamic #1#0 = e;
-    if(#1#0 is{ForNonNullableByDefault} core::int && e{core::int} =={core::num::==}{(core::Object) → core::bool} 0) {
+    #L3:
+    case #C4:
       {
-        core::print(0);
-        break #L2;
+        core::print(1);
+        break #L1;
+      }
+    #L4:
+    case #C7:
+      {
+        core::print(2);
+      }
+  }
+  #L5:
+  {
+    final synthesized dynamic #0#0 = e;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::int && e{core::int} =={core::num::==}{(core::Object) → core::bool} 0) {
+        {
+          core::print(0);
+          break #L5;
+        }
       }
     }
-    else
-      if(#1#0 is{ForNonNullableByDefault} core::int && e{core::int} =={core::num::==}{(core::Object) → core::bool} 1) {
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::int && e{core::int} =={core::num::==}{(core::Object) → core::bool} 1) {
         {
           core::print(1);
-          break #L2;
+          break #L5;
         }
       }
-      else
-        if(#1#0 is{ForNonNullableByDefault} core::int && e{core::int} =={core::num::==}{(core::Object) → core::bool} 2) {
-          {
-            core::print(2);
-          }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::int && e{core::int} =={core::num::==}{(core::Object) → core::bool} 2) {
+        {
+          core::print(2);
         }
+      }
+    }
   }
 }
 static method method2(self::Enum e) → dynamic {
-  #L3:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L6:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L7:
+    case #C3:
       {
         core::print(0);
-        break #L3;
+        break #L6;
       }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print(1);
-          break #L3;
-        }
+    #L8:
+    case #C6:
+      {
+        core::print(1);
+        break #L6;
+      }
+    #L9:
+    case #C9:
+      {
+        core::print(2);
       }
-      else
-        if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-          {
-            core::print(2);
-          }
-        }
   }
 }
 
diff --git a/pkg/front_end/testcases/patterns/omitted_break.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/omitted_break.dart.weak.transformed.expect
index 14e0912e0d1..87c3cbb1b87 100644
--- a/pkg/front_end/testcases/patterns/omitted_break.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/omitted_break.dart.weak.transformed.expect
@@ -15,75 +15,73 @@ class Enum extends core::_Enum /*isEnum*/  {
 }
 static method method(dynamic e) → dynamic {
   #L1:
-  {
-    final synthesized dynamic #0#0 = e;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+  switch(e) {
+    #L2:
+    case #C1:
       {
         core::print(0);
         break #L1;
       }
-    }
-    else
-      if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print(1);
-          break #L1;
-        }
-      }
-      else
-        if(#C7 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-          {
-            core::print(2);
-          }
-        }
-  }
-  #L2:
-  {
-    final synthesized dynamic #1#0 = e;
-    if(#1#0 is{ForNonNullableByDefault} core::int && e{core::int} =={core::num::==}{(core::Object) → core::bool} 0) {
+    #L3:
+    case #C4:
       {
-        core::print(0);
-        break #L2;
+        core::print(1);
+        break #L1;
+      }
+    #L4:
+    case #C7:
+      {
+        core::print(2);
+      }
+  }
+  #L5:
+  {
+    final synthesized dynamic #0#0 = e;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::int && e{core::int} =={core::num::==}{(core::Object) → core::bool} 0) {
+        {
+          core::print(0);
+          break #L5;
+        }
       }
     }
-    else
-      if(#1#0 is{ForNonNullableByDefault} core::int && e{core::int} =={core::num::==}{(core::Object) → core::bool} 1) {
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::int && e{core::int} =={core::num::==}{(core::Object) → core::bool} 1) {
         {
           core::print(1);
-          break #L2;
+          break #L5;
         }
       }
-      else
-        if(#1#0 is{ForNonNullableByDefault} core::int && e{core::int} =={core::num::==}{(core::Object) → core::bool} 2) {
-          {
-            core::print(2);
-          }
+    }
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::int && e{core::int} =={core::num::==}{(core::Object) → core::bool} 2) {
+        {
+          core::print(2);
         }
+      }
+    }
   }
 }
 static method method2(self::Enum e) → dynamic {
-  #L3:
-  {
-    final synthesized self::Enum #0#0 = e;
-    if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+  #L6:
+  switch(e) /*isExplicitlyExhaustive*/ {
+    #L7:
+    case #C3:
       {
         core::print(0);
-        break #L3;
+        break #L6;
       }
-    }
-    else
-      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-        {
-          core::print(1);
-          break #L3;
-        }
+    #L8:
+    case #C6:
+      {
+        core::print(1);
+        break #L6;
+      }
+    #L9:
+    case #C9:
+      {
+        core::print(2);
       }
-      else
-        if(#C9 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
-          {
-            core::print(2);
-          }
-        }
   }
 }
 
diff --git a/pkg/front_end/testcases/patterns/or_pattern_errors.dart.strong.expect b/pkg/front_end/testcases/patterns/or_pattern_errors.dart.strong.expect
index cbc38280a8a..d91c784fcef 100644
--- a/pkg/front_end/testcases/patterns/or_pattern_errors.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/or_pattern_errors.dart.strong.expect
@@ -41,33 +41,38 @@ class Class extends core::Object {
 static method test(dynamic o) → dynamic {
   #L1:
   {
-    core::int? s1;
-    core::int? s1#1;
-    core::int? field1;
-    core::int? f;
     core::int? s2;
     core::int? field2;
     final synthesized dynamic #0#0 = o;
     late final synthesized core::int? #0#2 = #0#0{self::Class}.{self::Class::field1}{core::int?};
     late final synthesized core::int? #0#3 = #0#0{self::Class}.{self::Class::field2}{core::int?};
-    if(#0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t1 = s1 = #0#2 in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t2 = s2 = #0#2 in true)) {
-      {
-        break #L1;
-      }
-    }
-    else
-      if(#0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t3 = s1#1 = #0#2 in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t4 = #0#2 in true)) {
+    {
+      core::int? s1;
+      if(#0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t1 = s1 = #0#2 in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t2 = s2 = #0#2 in true)) {
         {
           break #L1;
         }
       }
-      else
-        if(#0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t5 = field1 = #0#2 in true) && (let final dynamic #t6 = f = #0#3 in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t7 = field1 = #0#2 in true) && (let final dynamic #t8 = field2 = #0#3 in true)) {
-          {
-            break #L1;
-          }
+    }
+    {
+      core::int? s1;
+      if(#0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t3 = s1 = #0#2 in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t4 = #0#2 in true)) {
+        {
+          break #L1;
         }
-        else {
+      }
+    }
+    {
+      core::int? field1;
+      core::int? f;
+      if(#0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t5 = field1 = #0#2 in true) && (let final dynamic #t6 = f = #0#3 in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t7 = field1 = #0#2 in true) && (let final dynamic #t8 = field2 = #0#3 in true)) {
+        {
+          break #L1;
         }
+      }
+    }
+    {
+      {}
+    }
   }
 }
diff --git a/pkg/front_end/testcases/patterns/or_pattern_errors.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/or_pattern_errors.dart.strong.transformed.expect
index 9ed2eccd4e3..ccef48fd5fe 100644
--- a/pkg/front_end/testcases/patterns/or_pattern_errors.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/or_pattern_errors.dart.strong.transformed.expect
@@ -41,10 +41,6 @@ class Class extends core::Object {
 static method test(dynamic o) → dynamic {
   #L1:
   {
-    core::int? s1;
-    core::int? s1#1;
-    core::int? field1;
-    core::int? f;
     core::int? s2;
     core::int? field2;
     final synthesized dynamic #0#0 = o;
@@ -54,24 +50,33 @@ static method test(dynamic o) → dynamic {
     function ##0#3#initializer() → core::int?
       return #0#0{self::Class}.{self::Class::field2}{core::int?};
     late final synthesized core::int? #0#3 = ##0#3#initializer(){() → core::int?};
-    if(#0#0 is{ForNonNullableByDefault} self::Class && (let final core::int? #t1 = s1 = #0#2 in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final core::int? #t2 = s2 = #0#2 in true)) {
-      {
-        break #L1;
-      }
-    }
-    else
-      if(#0#0 is{ForNonNullableByDefault} self::Class && (let final core::int? #t3 = s1#1 = #0#2 in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final core::int? #t4 = #0#2 in true)) {
+    {
+      core::int? s1;
+      if(#0#0 is{ForNonNullableByDefault} self::Class && (let final core::int? #t1 = s1 = #0#2 in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final core::int? #t2 = s2 = #0#2 in true)) {
         {
           break #L1;
         }
       }
-      else
-        if(#0#0 is{ForNonNullableByDefault} self::Class && (let final core::int? #t5 = field1 = #0#2 in true) && (let final core::int? #t6 = f = #0#3 in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final core::int? #t7 = field1 = #0#2 in true) && (let final core::int? #t8 = field2 = #0#3 in true)) {
-          {
-            break #L1;
-          }
+    }
+    {
+      core::int? s1;
+      if(#0#0 is{ForNonNullableByDefault} self::Class && (let final core::int? #t3 = s1 = #0#2 in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final core::int? #t4 = #0#2 in true)) {
+        {
+          break #L1;
         }
-        else {
+      }
+    }
+    {
+      core::int? field1;
+      core::int? f;
+      if(#0#0 is{ForNonNullableByDefault} self::Class && (let final core::int? #t5 = field1 = #0#2 in true) && (let final core::int? #t6 = f = #0#3 in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final core::int? #t7 = field1 = #0#2 in true) && (let final core::int? #t8 = field2 = #0#3 in true)) {
+        {
+          break #L1;
         }
+      }
+    }
+    {
+      {}
+    }
   }
 }
diff --git a/pkg/front_end/testcases/patterns/or_pattern_errors.dart.weak.expect b/pkg/front_end/testcases/patterns/or_pattern_errors.dart.weak.expect
index cbc38280a8a..d91c784fcef 100644
--- a/pkg/front_end/testcases/patterns/or_pattern_errors.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/or_pattern_errors.dart.weak.expect
@@ -41,33 +41,38 @@ class Class extends core::Object {
 static method test(dynamic o) → dynamic {
   #L1:
   {
-    core::int? s1;
-    core::int? s1#1;
-    core::int? field1;
-    core::int? f;
     core::int? s2;
     core::int? field2;
     final synthesized dynamic #0#0 = o;
     late final synthesized core::int? #0#2 = #0#0{self::Class}.{self::Class::field1}{core::int?};
     late final synthesized core::int? #0#3 = #0#0{self::Class}.{self::Class::field2}{core::int?};
-    if(#0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t1 = s1 = #0#2 in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t2 = s2 = #0#2 in true)) {
-      {
-        break #L1;
-      }
-    }
-    else
-      if(#0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t3 = s1#1 = #0#2 in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t4 = #0#2 in true)) {
+    {
+      core::int? s1;
+      if(#0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t1 = s1 = #0#2 in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t2 = s2 = #0#2 in true)) {
         {
           break #L1;
         }
       }
-      else
-        if(#0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t5 = field1 = #0#2 in true) && (let final dynamic #t6 = f = #0#3 in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t7 = field1 = #0#2 in true) && (let final dynamic #t8 = field2 = #0#3 in true)) {
-          {
-            break #L1;
-          }
+    }
+    {
+      core::int? s1;
+      if(#0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t3 = s1 = #0#2 in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t4 = #0#2 in true)) {
+        {
+          break #L1;
         }
-        else {
+      }
+    }
+    {
+      core::int? field1;
+      core::int? f;
+      if(#0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t5 = field1 = #0#2 in true) && (let final dynamic #t6 = f = #0#3 in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t7 = field1 = #0#2 in true) && (let final dynamic #t8 = field2 = #0#3 in true)) {
+        {
+          break #L1;
         }
+      }
+    }
+    {
+      {}
+    }
   }
 }
diff --git a/pkg/front_end/testcases/patterns/or_pattern_errors.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/or_pattern_errors.dart.weak.modular.expect
index cbc38280a8a..d91c784fcef 100644
--- a/pkg/front_end/testcases/patterns/or_pattern_errors.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/or_pattern_errors.dart.weak.modular.expect
@@ -41,33 +41,38 @@ class Class extends core::Object {
 static method test(dynamic o) → dynamic {
   #L1:
   {
-    core::int? s1;
-    core::int? s1#1;
-    core::int? field1;
-    core::int? f;
     core::int? s2;
     core::int? field2;
     final synthesized dynamic #0#0 = o;
     late final synthesized core::int? #0#2 = #0#0{self::Class}.{self::Class::field1}{core::int?};
     late final synthesized core::int? #0#3 = #0#0{self::Class}.{self::Class::field2}{core::int?};
-    if(#0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t1 = s1 = #0#2 in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t2 = s2 = #0#2 in true)) {
-      {
-        break #L1;
-      }
-    }
-    else
-      if(#0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t3 = s1#1 = #0#2 in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t4 = #0#2 in true)) {
+    {
+      core::int? s1;
+      if(#0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t1 = s1 = #0#2 in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t2 = s2 = #0#2 in true)) {
         {
           break #L1;
         }
       }
-      else
-        if(#0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t5 = field1 = #0#2 in true) && (let final dynamic #t6 = f = #0#3 in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t7 = field1 = #0#2 in true) && (let final dynamic #t8 = field2 = #0#3 in true)) {
-          {
-            break #L1;
-          }
+    }
+    {
+      core::int? s1;
+      if(#0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t3 = s1 = #0#2 in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t4 = #0#2 in true)) {
+        {
+          break #L1;
         }
-        else {
+      }
+    }
+    {
+      core::int? field1;
+      core::int? f;
+      if(#0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t5 = field1 = #0#2 in true) && (let final dynamic #t6 = f = #0#3 in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t7 = field1 = #0#2 in true) && (let final dynamic #t8 = field2 = #0#3 in true)) {
+        {
+          break #L1;
         }
+      }
+    }
+    {
+      {}
+    }
   }
 }
diff --git a/pkg/front_end/testcases/patterns/or_pattern_errors.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/or_pattern_errors.dart.weak.transformed.expect
index 9ed2eccd4e3..ccef48fd5fe 100644
--- a/pkg/front_end/testcases/patterns/or_pattern_errors.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/or_pattern_errors.dart.weak.transformed.expect
@@ -41,10 +41,6 @@ class Class extends core::Object {
 static method test(dynamic o) → dynamic {
   #L1:
   {
-    core::int? s1;
-    core::int? s1#1;
-    core::int? field1;
-    core::int? f;
     core::int? s2;
     core::int? field2;
     final synthesized dynamic #0#0 = o;
@@ -54,24 +50,33 @@ static method test(dynamic o) → dynamic {
     function ##0#3#initializer() → core::int?
       return #0#0{self::Class}.{self::Class::field2}{core::int?};
     late final synthesized core::int? #0#3 = ##0#3#initializer(){() → core::int?};
-    if(#0#0 is{ForNonNullableByDefault} self::Class && (let final core::int? #t1 = s1 = #0#2 in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final core::int? #t2 = s2 = #0#2 in true)) {
-      {
-        break #L1;
-      }
-    }
-    else
-      if(#0#0 is{ForNonNullableByDefault} self::Class && (let final core::int? #t3 = s1#1 = #0#2 in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final core::int? #t4 = #0#2 in true)) {
+    {
+      core::int? s1;
+      if(#0#0 is{ForNonNullableByDefault} self::Class && (let final core::int? #t1 = s1 = #0#2 in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final core::int? #t2 = s2 = #0#2 in true)) {
         {
           break #L1;
         }
       }
-      else
-        if(#0#0 is{ForNonNullableByDefault} self::Class && (let final core::int? #t5 = field1 = #0#2 in true) && (let final core::int? #t6 = f = #0#3 in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final core::int? #t7 = field1 = #0#2 in true) && (let final core::int? #t8 = field2 = #0#3 in true)) {
-          {
-            break #L1;
-          }
+    }
+    {
+      core::int? s1;
+      if(#0#0 is{ForNonNullableByDefault} self::Class && (let final core::int? #t3 = s1 = #0#2 in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final core::int? #t4 = #0#2 in true)) {
+        {
+          break #L1;
         }
-        else {
+      }
+    }
+    {
+      core::int? field1;
+      core::int? f;
+      if(#0#0 is{ForNonNullableByDefault} self::Class && (let final core::int? #t5 = field1 = #0#2 in true) && (let final core::int? #t6 = f = #0#3 in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final core::int? #t7 = field1 = #0#2 in true) && (let final core::int? #t8 = field2 = #0#3 in true)) {
+        {
+          break #L1;
         }
+      }
+    }
+    {
+      {}
+    }
   }
 }
diff --git a/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_cast.dart.strong.expect b/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_cast.dart.strong.expect
index 663e02f4ddf..d77d21dfa9c 100644
--- a/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_cast.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_cast.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::Object) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::Object) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_cast.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_cast.dart.strong.transformed.expect
index b4a55240812..488b36eee35 100644
--- a/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_cast.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_cast.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final core::Object #t1 = let dynamic #t2 = #0#0 in #t2 == null ?{core::Object} #t2 as{ForNonNullableByDefault} core::Object : #t2{core::Object} in #C1 =={core::num::==}{(core::Object) → core::bool} (let dynamic #t3 = #0#0 in #t3 == null ?{core::Object} #t3 as{ForNonNullableByDefault} core::Object : #t3{core::Object})) {
-      {
-        break #L1;
+    {
+      if(let final core::Object #t1 = let dynamic #t2 = #0#0 in #t2 == null ?{core::Object} #t2 as{ForNonNullableByDefault} core::Object : #t2{core::Object} in #C1 =={core::num::==}{(core::Object) → core::bool} (let dynamic #t3 = #0#0 in #t3 == null ?{core::Object} #t3 as{ForNonNullableByDefault} core::Object : #t3{core::Object})) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_cast.dart.weak.expect b/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_cast.dart.weak.expect
index 663e02f4ddf..d77d21dfa9c 100644
--- a/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_cast.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_cast.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::Object) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::Object) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_cast.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_cast.dart.weak.modular.expect
index 663e02f4ddf..d77d21dfa9c 100644
--- a/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_cast.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_cast.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::Object) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::Object) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_cast.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_cast.dart.weak.transformed.expect
index 6f92fed796f..5053cc6fde4 100644
--- a/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_cast.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_cast.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final core::Object #t1 = #0#0 in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        break #L1;
+    {
+      if(let final core::Object #t1 = #0#0 in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_null_assert.dart.strong.expect b/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_null_assert.dart.strong.expect
index 7d8550841b3..b2bc2051445 100644
--- a/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_null_assert.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_null_assert.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_null_assert.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_null_assert.dart.strong.transformed.expect
index 7d8550841b3..b2bc2051445 100644
--- a/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_null_assert.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_null_assert.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_null_assert.dart.weak.expect b/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_null_assert.dart.weak.expect
index 7d8550841b3..b2bc2051445 100644
--- a/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_null_assert.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_null_assert.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_null_assert.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_null_assert.dart.weak.modular.expect
index 7d8550841b3..b2bc2051445 100644
--- a/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_null_assert.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_null_assert.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_null_assert.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_null_assert.dart.weak.transformed.expect
index 7d8550841b3..b2bc2051445 100644
--- a/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_null_assert.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_null_assert.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #C1 =={core::num::==}{(core::Object) → core::bool} #0#0!) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_null_check.dart.strong.expect b/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_null_check.dart.strong.expect
index bce0857c6fe..0217a608547 100644
--- a/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_null_check.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_null_check.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_null_check.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_null_check.dart.strong.transformed.expect
index bce0857c6fe..0217a608547 100644
--- a/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_null_check.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_null_check.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_null_check.dart.weak.expect b/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_null_check.dart.weak.expect
index bce0857c6fe..0217a608547 100644
--- a/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_null_check.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_null_check.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_null_check.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_null_check.dart.weak.modular.expect
index bce0857c6fe..0217a608547 100644
--- a/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_null_check.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_null_check.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_null_check.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_null_check.dart.weak.transformed.expect
index bce0857c6fe..0217a608547 100644
--- a/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_null_check.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/parenthesized_pattern_inside_null_check.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #C1 =={core::num::==}{(core::Object) → core::bool} #0#0 : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/pattern_matching.dart.strong.expect b/pkg/front_end/testcases/patterns/pattern_matching.dart.strong.expect
index 845cc8b5d85..17a1fbab41e 100644
--- a/pkg/front_end/testcases/patterns/pattern_matching.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/pattern_matching.dart.strong.expect
@@ -29,14 +29,24 @@ class Circle extends core::Object implements self::Shape {
 static method calculateArea(self::Shape shape) → core::double
   return block {
     core::double #t1;
-    core::double l;
-    core::double r;
     final synthesized self::Shape #0#0 = shape;
-    if(#0#0 is{ForNonNullableByDefault} self::Square && (let final dynamic #t2 = l = #0#0{self::Square}.{self::Square::length}{core::double} in true))
-      #t1 = l.{core::double::*}(l){(core::num) → core::double};
-    else
-      if(#0#0 is{ForNonNullableByDefault} self::Circle && (let final dynamic #t3 = r = #0#0{self::Circle}.{self::Circle::radius}{core::double} in true))
-        #t1 = #C1.{core::double::*}(r){(core::num) → core::double}.{core::double::*}(r){(core::num) → core::double};
+    #L1:
+    {
+      {
+        core::double l;
+        if(#0#0 is{ForNonNullableByDefault} self::Square && (let final dynamic #t2 = l = #0#0{self::Square}.{self::Square::length}{core::double} in true)) {
+          #t1 = l.{core::double::*}(l){(core::num) → core::double};
+          break #L1;
+        }
+      }
+      {
+        core::double r;
+        if(#0#0 is{ForNonNullableByDefault} self::Circle && (let final dynamic #t3 = r = #0#0{self::Circle}.{self::Circle::radius}{core::double} in true)) {
+          #t1 = #C1.{core::double::*}(r){(core::num) → core::double}.{core::double::*}(r){(core::num) → core::double};
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
 static method main() → dynamic {
   self::Square s1 = new self::Square::•(2.0);
diff --git a/pkg/front_end/testcases/patterns/pattern_matching.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/pattern_matching.dart.strong.transformed.expect
index 98027a7a363..c9d93ad11ca 100644
--- a/pkg/front_end/testcases/patterns/pattern_matching.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/pattern_matching.dart.strong.transformed.expect
@@ -29,14 +29,24 @@ class Circle extends core::Object implements self::Shape {
 static method calculateArea(self::Shape shape) → core::double
   return block {
     core::double #t1;
-    core::double l;
-    core::double r;
     final synthesized self::Shape #0#0 = shape;
-    if(#0#0 is{ForNonNullableByDefault} self::Square && (let final core::double #t2 = l = #0#0{self::Square}.{self::Square::length}{core::double} in true))
-      #t1 = l.{core::double::*}(l){(core::num) → core::double};
-    else
-      if(#0#0 is{ForNonNullableByDefault} self::Circle && (let final core::double #t3 = r = #0#0{self::Circle}.{self::Circle::radius}{core::double} in true))
-        #t1 = #C1.{core::double::*}(r){(core::num) → core::double}.{core::double::*}(r){(core::num) → core::double};
+    #L1:
+    {
+      {
+        core::double l;
+        if(#0#0 is{ForNonNullableByDefault} self::Square && (let final core::double #t2 = l = #0#0{self::Square}.{self::Square::length}{core::double} in true)) {
+          #t1 = l.{core::double::*}(l){(core::num) → core::double};
+          break #L1;
+        }
+      }
+      {
+        core::double r;
+        if(#0#0 is{ForNonNullableByDefault} self::Circle && (let final core::double #t3 = r = #0#0{self::Circle}.{self::Circle::radius}{core::double} in true)) {
+          #t1 = #C1.{core::double::*}(r){(core::num) → core::double}.{core::double::*}(r){(core::num) → core::double};
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
 static method main() → dynamic {
   self::Square s1 = new self::Square::•(2.0);
diff --git a/pkg/front_end/testcases/patterns/pattern_matching.dart.weak.expect b/pkg/front_end/testcases/patterns/pattern_matching.dart.weak.expect
index 845cc8b5d85..17a1fbab41e 100644
--- a/pkg/front_end/testcases/patterns/pattern_matching.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/pattern_matching.dart.weak.expect
@@ -29,14 +29,24 @@ class Circle extends core::Object implements self::Shape {
 static method calculateArea(self::Shape shape) → core::double
   return block {
     core::double #t1;
-    core::double l;
-    core::double r;
     final synthesized self::Shape #0#0 = shape;
-    if(#0#0 is{ForNonNullableByDefault} self::Square && (let final dynamic #t2 = l = #0#0{self::Square}.{self::Square::length}{core::double} in true))
-      #t1 = l.{core::double::*}(l){(core::num) → core::double};
-    else
-      if(#0#0 is{ForNonNullableByDefault} self::Circle && (let final dynamic #t3 = r = #0#0{self::Circle}.{self::Circle::radius}{core::double} in true))
-        #t1 = #C1.{core::double::*}(r){(core::num) → core::double}.{core::double::*}(r){(core::num) → core::double};
+    #L1:
+    {
+      {
+        core::double l;
+        if(#0#0 is{ForNonNullableByDefault} self::Square && (let final dynamic #t2 = l = #0#0{self::Square}.{self::Square::length}{core::double} in true)) {
+          #t1 = l.{core::double::*}(l){(core::num) → core::double};
+          break #L1;
+        }
+      }
+      {
+        core::double r;
+        if(#0#0 is{ForNonNullableByDefault} self::Circle && (let final dynamic #t3 = r = #0#0{self::Circle}.{self::Circle::radius}{core::double} in true)) {
+          #t1 = #C1.{core::double::*}(r){(core::num) → core::double}.{core::double::*}(r){(core::num) → core::double};
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
 static method main() → dynamic {
   self::Square s1 = new self::Square::•(2.0);
diff --git a/pkg/front_end/testcases/patterns/pattern_matching.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/pattern_matching.dart.weak.modular.expect
index 845cc8b5d85..17a1fbab41e 100644
--- a/pkg/front_end/testcases/patterns/pattern_matching.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/pattern_matching.dart.weak.modular.expect
@@ -29,14 +29,24 @@ class Circle extends core::Object implements self::Shape {
 static method calculateArea(self::Shape shape) → core::double
   return block {
     core::double #t1;
-    core::double l;
-    core::double r;
     final synthesized self::Shape #0#0 = shape;
-    if(#0#0 is{ForNonNullableByDefault} self::Square && (let final dynamic #t2 = l = #0#0{self::Square}.{self::Square::length}{core::double} in true))
-      #t1 = l.{core::double::*}(l){(core::num) → core::double};
-    else
-      if(#0#0 is{ForNonNullableByDefault} self::Circle && (let final dynamic #t3 = r = #0#0{self::Circle}.{self::Circle::radius}{core::double} in true))
-        #t1 = #C1.{core::double::*}(r){(core::num) → core::double}.{core::double::*}(r){(core::num) → core::double};
+    #L1:
+    {
+      {
+        core::double l;
+        if(#0#0 is{ForNonNullableByDefault} self::Square && (let final dynamic #t2 = l = #0#0{self::Square}.{self::Square::length}{core::double} in true)) {
+          #t1 = l.{core::double::*}(l){(core::num) → core::double};
+          break #L1;
+        }
+      }
+      {
+        core::double r;
+        if(#0#0 is{ForNonNullableByDefault} self::Circle && (let final dynamic #t3 = r = #0#0{self::Circle}.{self::Circle::radius}{core::double} in true)) {
+          #t1 = #C1.{core::double::*}(r){(core::num) → core::double}.{core::double::*}(r){(core::num) → core::double};
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
 static method main() → dynamic {
   self::Square s1 = new self::Square::•(2.0);
diff --git a/pkg/front_end/testcases/patterns/pattern_matching.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/pattern_matching.dart.weak.transformed.expect
index 98027a7a363..c9d93ad11ca 100644
--- a/pkg/front_end/testcases/patterns/pattern_matching.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/pattern_matching.dart.weak.transformed.expect
@@ -29,14 +29,24 @@ class Circle extends core::Object implements self::Shape {
 static method calculateArea(self::Shape shape) → core::double
   return block {
     core::double #t1;
-    core::double l;
-    core::double r;
     final synthesized self::Shape #0#0 = shape;
-    if(#0#0 is{ForNonNullableByDefault} self::Square && (let final core::double #t2 = l = #0#0{self::Square}.{self::Square::length}{core::double} in true))
-      #t1 = l.{core::double::*}(l){(core::num) → core::double};
-    else
-      if(#0#0 is{ForNonNullableByDefault} self::Circle && (let final core::double #t3 = r = #0#0{self::Circle}.{self::Circle::radius}{core::double} in true))
-        #t1 = #C1.{core::double::*}(r){(core::num) → core::double}.{core::double::*}(r){(core::num) → core::double};
+    #L1:
+    {
+      {
+        core::double l;
+        if(#0#0 is{ForNonNullableByDefault} self::Square && (let final core::double #t2 = l = #0#0{self::Square}.{self::Square::length}{core::double} in true)) {
+          #t1 = l.{core::double::*}(l){(core::num) → core::double};
+          break #L1;
+        }
+      }
+      {
+        core::double r;
+        if(#0#0 is{ForNonNullableByDefault} self::Circle && (let final core::double #t3 = r = #0#0{self::Circle}.{self::Circle::radius}{core::double} in true)) {
+          #t1 = #C1.{core::double::*}(r){(core::num) → core::double}.{core::double::*}(r){(core::num) → core::double};
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
 static method main() → dynamic {
   self::Square s1 = new self::Square::•(2.0);
diff --git a/pkg/front_end/testcases/patterns/pattern_types.dart.strong.expect b/pkg/front_end/testcases/patterns/pattern_types.dart.strong.expect
index b0d7e8e4713..827cfb2ebb6 100644
--- a/pkg/front_end/testcases/patterns/pattern_types.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/pattern_types.dart.strong.expect
@@ -196,25 +196,6 @@ static method _extension#3|<=(lowered final core::String #this, dynamic other) 
 static method objectPattern(dynamic o) → dynamic {
   #L1:
   {
-    core::int hashCode;
-    () → core::String toString;
-    dynamic field;
-    () → void method;
-    dynamic extensionGetter;
-    dynamic extensionMethod;
-    dynamic dynamicAccess;
-    () → void call;
-    core::int $1;
-    core::String named;
-    dynamic missing;
-    dynamic field#1;
-    () → void method#1;
-    dynamic extensionGetter#1;
-    dynamic extensionMethod#1;
-    () →? void call#1;
-    core::int $1#1;
-    core::String named#1;
-    dynamic ambiguousField;
     final synthesized dynamic #0#0 = o;
     synthesized dynamic #0#5;
     synthesized core::bool #0#5#isSet = false;
@@ -226,7 +207,27 @@ static method objectPattern(dynamic o) → dynamic {
     synthesized core::bool #0#14#isSet = false;
     synthesized dynamic #0#15;
     synthesized core::bool #0#15#isSet = false;
-    if(#0#0 is{ForNonNullableByDefault} Null && (let final dynamic #t1 = hashCode = #0#0{Null}.{core::Object::hashCode}{core::int} in true) || #0#0 is{ForNonNullableByDefault} Null && (let final dynamic #t2 = toString = #0#0{Null}.{core::Object::toString}{() → core::String} in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t3 = field = #0#5#isSet ?{dynamic} #0#5{dynamic} : let final dynamic #t4 = #0#5#isSet = true in #0#5 = #0#0{self::Class}.{self::Class::field}{dynamic} in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t5 = method = #0#6#isSet ?{() → void} #0#6{() → void} : let final dynamic #t6 = #0#6#isSet = true in #0#6 = #0#0{self::Class}.{self::Class::method}{() → void} in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t7 = extensionGetter = self::_extension#0|get#extensionGetter(#0#0{self::Class}) in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t8 = extensionMethod = self::_extension#0|extensionMethod(#0#0{self::Class}) in true) || #0#0 is{ForNonNullableByDefault} dynamic && (let final dynamic #t9 = dynamicAccess = #0#0{dynamic}.dynamicAccess in true) || #0#0 is{ForNonNullableByDefault} () → void && (let final dynamic #t10 = call = #0#12#isSet ?{() → void} #0#12{() → void} : let final dynamic #t11 = #0#12#isSet = true in #0#12 = #0#0{() → void}.call in true) || #0#0 is{ForNonNullableByDefault} (core::int, {required named: core::String}) && (let final dynamic #t12 = $1 = #0#14#isSet ?{core::int} #0#14{core::int} : let final dynamic #t13 = #0#14#isSet = true in #0#14 = #0#0{(core::int, {required named: core::String})}.$1{core::int} in true) || #0#0 is{ForNonNullableByDefault} (core::int, {required named: core::String}) && (let final dynamic #t14 = named = #0#15#isSet ?{core::String} #0#15{core::String} : let final dynamic #t15 = #0#15#isSet = true in #0#15 = #0#0{(core::int, {required named: core::String})}.named{core::String} in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t16 = invalid-expression "pkg/front_end/testcases/patterns/pattern_types.dart:75:16: Error: The getter 'missing' isn't defined for the class 'Class'.
+    {
+      core::int hashCode;
+      () → core::String toString;
+      lowered dynamic field#case#0;
+      lowered () → void method#case#0;
+      lowered dynamic extensionGetter#case#0;
+      lowered dynamic extensionMethod#case#0;
+      dynamic dynamicAccess;
+      lowered () → void call#case#0;
+      lowered core::int $1#case#0;
+      lowered core::String named#case#0;
+      dynamic missing;
+      lowered dynamic field#case#1;
+      lowered () → void method#case#1;
+      lowered dynamic extensionGetter#case#1;
+      lowered dynamic extensionMethod#case#1;
+      lowered () →? void call#case#1;
+      lowered core::int $1#case#1;
+      lowered core::String named#case#1;
+      dynamic ambiguousField;
+      if(#0#0 is{ForNonNullableByDefault} Null && (let final dynamic #t1 = hashCode = #0#0{Null}.{core::Object::hashCode}{core::int} in true) || #0#0 is{ForNonNullableByDefault} Null && (let final dynamic #t2 = toString = #0#0{Null}.{core::Object::toString}{() → core::String} in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t3 = field#case#0 = #0#5#isSet ?{dynamic} #0#5{dynamic} : let final dynamic #t4 = #0#5#isSet = true in #0#5 = #0#0{self::Class}.{self::Class::field}{dynamic} in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t5 = method#case#0 = #0#6#isSet ?{() → void} #0#6{() → void} : let final dynamic #t6 = #0#6#isSet = true in #0#6 = #0#0{self::Class}.{self::Class::method}{() → void} in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t7 = extensionGetter#case#0 = self::_extension#0|get#extensionGetter(#0#0{self::Class}) in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t8 = extensionMethod#case#0 = self::_extension#0|extensionMethod(#0#0{self::Class}) in true) || #0#0 is{ForNonNullableByDefault} dynamic && (let final dynamic #t9 = dynamicAccess = #0#0{dynamic}.dynamicAccess in true) || #0#0 is{ForNonNullableByDefault} () → void && (let final dynamic #t10 = call#case#0 = #0#12#isSet ?{() → void} #0#12{() → void} : let final dynamic #t11 = #0#12#isSet = true in #0#12 = #0#0{() → void}.call in true) || #0#0 is{ForNonNullableByDefault} (core::int, {required named: core::String}) && (let final dynamic #t12 = $1#case#0 = #0#14#isSet ?{core::int} #0#14{core::int} : let final dynamic #t13 = #0#14#isSet = true in #0#14 = #0#0{(core::int, {required named: core::String})}.$1{core::int} in true) || #0#0 is{ForNonNullableByDefault} (core::int, {required named: core::String}) && (let final dynamic #t14 = named#case#0 = #0#15#isSet ?{core::String} #0#15{core::String} : let final dynamic #t15 = #0#15#isSet = true in #0#15 = #0#0{(core::int, {required named: core::String})}.named{core::String} in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t16 = invalid-expression "pkg/front_end/testcases/patterns/pattern_types.dart:75:16: Error: The getter 'missing' isn't defined for the class 'Class'.
  - 'Class' is from 'pkg/front_end/testcases/patterns/pattern_types.dart'.
 Try correcting the name to the name of an existing getter, or defining a getter or field named 'missing'.
     case Class(: var missing): // Error: missing getter
@@ -293,6 +294,7 @@ Try correcting the name to the name of an existing getter, or defining a getter
 Try correcting the name to the name of an existing getter, or defining a getter or field named 'ambiguousField'.
     case Class(: var ambiguousField): // Error: ambiguous get
                ^^^^^^^^^^^^^^") || #0#0 is{ForNonNullableByDefault} invalid-type) {
+      }
     }
   }
 }
diff --git a/pkg/front_end/testcases/patterns/pattern_types.dart.weak.expect b/pkg/front_end/testcases/patterns/pattern_types.dart.weak.expect
index 84ad2a766e3..ca9e30fea96 100644
--- a/pkg/front_end/testcases/patterns/pattern_types.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/pattern_types.dart.weak.expect
@@ -197,25 +197,6 @@ static method _extension#3|<=(lowered final core::String #this, dynamic other) 
 static method objectPattern(dynamic o) → dynamic {
   #L1:
   {
-    core::int hashCode;
-    () → core::String toString;
-    dynamic field;
-    () → void method;
-    dynamic extensionGetter;
-    dynamic extensionMethod;
-    dynamic dynamicAccess;
-    () → void call;
-    core::int $1;
-    core::String named;
-    dynamic missing;
-    dynamic field#1;
-    () → void method#1;
-    dynamic extensionGetter#1;
-    dynamic extensionMethod#1;
-    () →? void call#1;
-    core::int $1#1;
-    core::String named#1;
-    dynamic ambiguousField;
     final synthesized dynamic #0#0 = o;
     synthesized dynamic #0#5;
     synthesized core::bool #0#5#isSet = false;
@@ -227,7 +208,27 @@ static method objectPattern(dynamic o) → dynamic {
     synthesized core::bool #0#14#isSet = false;
     synthesized dynamic #0#15;
     synthesized core::bool #0#15#isSet = false;
-    if(#0#0 is{ForNonNullableByDefault} Null && (let final dynamic #t1 = hashCode = #0#0{Null}.{core::Object::hashCode}{core::int} in true) || #0#0 is{ForNonNullableByDefault} Null && (let final dynamic #t2 = toString = #0#0{Null}.{core::Object::toString}{() → core::String} in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t3 = field = #0#5#isSet ?{dynamic} #0#5{dynamic} : let final dynamic #t4 = #0#5#isSet = true in #0#5 = #0#0{self::Class}.{self::Class::field}{dynamic} in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t5 = method = #0#6#isSet ?{() → void} #0#6{() → void} : let final dynamic #t6 = #0#6#isSet = true in #0#6 = #0#0{self::Class}.{self::Class::method}{() → void} in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t7 = extensionGetter = self::_extension#0|get#extensionGetter(#0#0{self::Class}) in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t8 = extensionMethod = self::_extension#0|extensionMethod(#0#0{self::Class}) in true) || #0#0 is{ForNonNullableByDefault} dynamic && (let final dynamic #t9 = dynamicAccess = #0#0{dynamic}.dynamicAccess in true) || #0#0 is{ForNonNullableByDefault} () → void && (let final dynamic #t10 = call = #0#12#isSet ?{() → void} #0#12{() → void} : let final dynamic #t11 = #0#12#isSet = true in #0#12 = #0#0{() → void}.call in true) || #0#0 is{ForNonNullableByDefault} (core::int, {required named: core::String}) && (let final dynamic #t12 = $1 = #0#14#isSet ?{core::int} #0#14{core::int} : let final dynamic #t13 = #0#14#isSet = true in #0#14 = #0#0{(core::int, {required named: core::String})}.$1{core::int} in true) || #0#0 is{ForNonNullableByDefault} (core::int, {required named: core::String}) && (let final dynamic #t14 = named = #0#15#isSet ?{core::String} #0#15{core::String} : let final dynamic #t15 = #0#15#isSet = true in #0#15 = #0#0{(core::int, {required named: core::String})}.named{core::String} in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t16 = invalid-expression "pkg/front_end/testcases/patterns/pattern_types.dart:75:16: Error: The getter 'missing' isn't defined for the class 'Class'.
+    {
+      core::int hashCode;
+      () → core::String toString;
+      lowered dynamic field#case#0;
+      lowered () → void method#case#0;
+      lowered dynamic extensionGetter#case#0;
+      lowered dynamic extensionMethod#case#0;
+      dynamic dynamicAccess;
+      lowered () → void call#case#0;
+      lowered core::int $1#case#0;
+      lowered core::String named#case#0;
+      dynamic missing;
+      lowered dynamic field#case#1;
+      lowered () → void method#case#1;
+      lowered dynamic extensionGetter#case#1;
+      lowered dynamic extensionMethod#case#1;
+      lowered () →? void call#case#1;
+      lowered core::int $1#case#1;
+      lowered core::String named#case#1;
+      dynamic ambiguousField;
+      if(#0#0 is{ForNonNullableByDefault} Null && (let final dynamic #t1 = hashCode = #0#0{Null}.{core::Object::hashCode}{core::int} in true) || #0#0 is{ForNonNullableByDefault} Null && (let final dynamic #t2 = toString = #0#0{Null}.{core::Object::toString}{() → core::String} in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t3 = field#case#0 = #0#5#isSet ?{dynamic} #0#5{dynamic} : let final dynamic #t4 = #0#5#isSet = true in #0#5 = #0#0{self::Class}.{self::Class::field}{dynamic} in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t5 = method#case#0 = #0#6#isSet ?{() → void} #0#6{() → void} : let final dynamic #t6 = #0#6#isSet = true in #0#6 = #0#0{self::Class}.{self::Class::method}{() → void} in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t7 = extensionGetter#case#0 = self::_extension#0|get#extensionGetter(#0#0{self::Class}) in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t8 = extensionMethod#case#0 = self::_extension#0|extensionMethod(#0#0{self::Class}) in true) || #0#0 is{ForNonNullableByDefault} dynamic && (let final dynamic #t9 = dynamicAccess = #0#0{dynamic}.dynamicAccess in true) || #0#0 is{ForNonNullableByDefault} () → void && (let final dynamic #t10 = call#case#0 = #0#12#isSet ?{() → void} #0#12{() → void} : let final dynamic #t11 = #0#12#isSet = true in #0#12 = #0#0{() → void}.call in true) || #0#0 is{ForNonNullableByDefault} (core::int, {required named: core::String}) && (let final dynamic #t12 = $1#case#0 = #0#14#isSet ?{core::int} #0#14{core::int} : let final dynamic #t13 = #0#14#isSet = true in #0#14 = #0#0{(core::int, {required named: core::String})}.$1{core::int} in true) || #0#0 is{ForNonNullableByDefault} (core::int, {required named: core::String}) && (let final dynamic #t14 = named#case#0 = #0#15#isSet ?{core::String} #0#15{core::String} : let final dynamic #t15 = #0#15#isSet = true in #0#15 = #0#0{(core::int, {required named: core::String})}.named{core::String} in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t16 = invalid-expression "pkg/front_end/testcases/patterns/pattern_types.dart:75:16: Error: The getter 'missing' isn't defined for the class 'Class'.
  - 'Class' is from 'pkg/front_end/testcases/patterns/pattern_types.dart'.
 Try correcting the name to the name of an existing getter, or defining a getter or field named 'missing'.
     case Class(: var missing): // Error: missing getter
@@ -294,6 +295,7 @@ Try correcting the name to the name of an existing getter, or defining a getter
 Try correcting the name to the name of an existing getter, or defining a getter or field named 'ambiguousField'.
     case Class(: var ambiguousField): // Error: ambiguous get
                ^^^^^^^^^^^^^^") || #0#0 is{ForNonNullableByDefault} invalid-type) {
+      }
     }
   }
 }
diff --git a/pkg/front_end/testcases/patterns/pattern_types.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/pattern_types.dart.weak.modular.expect
index 84ad2a766e3..ca9e30fea96 100644
--- a/pkg/front_end/testcases/patterns/pattern_types.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/pattern_types.dart.weak.modular.expect
@@ -197,25 +197,6 @@ static method _extension#3|<=(lowered final core::String #this, dynamic other) 
 static method objectPattern(dynamic o) → dynamic {
   #L1:
   {
-    core::int hashCode;
-    () → core::String toString;
-    dynamic field;
-    () → void method;
-    dynamic extensionGetter;
-    dynamic extensionMethod;
-    dynamic dynamicAccess;
-    () → void call;
-    core::int $1;
-    core::String named;
-    dynamic missing;
-    dynamic field#1;
-    () → void method#1;
-    dynamic extensionGetter#1;
-    dynamic extensionMethod#1;
-    () →? void call#1;
-    core::int $1#1;
-    core::String named#1;
-    dynamic ambiguousField;
     final synthesized dynamic #0#0 = o;
     synthesized dynamic #0#5;
     synthesized core::bool #0#5#isSet = false;
@@ -227,7 +208,27 @@ static method objectPattern(dynamic o) → dynamic {
     synthesized core::bool #0#14#isSet = false;
     synthesized dynamic #0#15;
     synthesized core::bool #0#15#isSet = false;
-    if(#0#0 is{ForNonNullableByDefault} Null && (let final dynamic #t1 = hashCode = #0#0{Null}.{core::Object::hashCode}{core::int} in true) || #0#0 is{ForNonNullableByDefault} Null && (let final dynamic #t2 = toString = #0#0{Null}.{core::Object::toString}{() → core::String} in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t3 = field = #0#5#isSet ?{dynamic} #0#5{dynamic} : let final dynamic #t4 = #0#5#isSet = true in #0#5 = #0#0{self::Class}.{self::Class::field}{dynamic} in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t5 = method = #0#6#isSet ?{() → void} #0#6{() → void} : let final dynamic #t6 = #0#6#isSet = true in #0#6 = #0#0{self::Class}.{self::Class::method}{() → void} in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t7 = extensionGetter = self::_extension#0|get#extensionGetter(#0#0{self::Class}) in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t8 = extensionMethod = self::_extension#0|extensionMethod(#0#0{self::Class}) in true) || #0#0 is{ForNonNullableByDefault} dynamic && (let final dynamic #t9 = dynamicAccess = #0#0{dynamic}.dynamicAccess in true) || #0#0 is{ForNonNullableByDefault} () → void && (let final dynamic #t10 = call = #0#12#isSet ?{() → void} #0#12{() → void} : let final dynamic #t11 = #0#12#isSet = true in #0#12 = #0#0{() → void}.call in true) || #0#0 is{ForNonNullableByDefault} (core::int, {required named: core::String}) && (let final dynamic #t12 = $1 = #0#14#isSet ?{core::int} #0#14{core::int} : let final dynamic #t13 = #0#14#isSet = true in #0#14 = #0#0{(core::int, {required named: core::String})}.$1{core::int} in true) || #0#0 is{ForNonNullableByDefault} (core::int, {required named: core::String}) && (let final dynamic #t14 = named = #0#15#isSet ?{core::String} #0#15{core::String} : let final dynamic #t15 = #0#15#isSet = true in #0#15 = #0#0{(core::int, {required named: core::String})}.named{core::String} in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t16 = invalid-expression "pkg/front_end/testcases/patterns/pattern_types.dart:75:16: Error: The getter 'missing' isn't defined for the class 'Class'.
+    {
+      core::int hashCode;
+      () → core::String toString;
+      lowered dynamic field#case#0;
+      lowered () → void method#case#0;
+      lowered dynamic extensionGetter#case#0;
+      lowered dynamic extensionMethod#case#0;
+      dynamic dynamicAccess;
+      lowered () → void call#case#0;
+      lowered core::int $1#case#0;
+      lowered core::String named#case#0;
+      dynamic missing;
+      lowered dynamic field#case#1;
+      lowered () → void method#case#1;
+      lowered dynamic extensionGetter#case#1;
+      lowered dynamic extensionMethod#case#1;
+      lowered () →? void call#case#1;
+      lowered core::int $1#case#1;
+      lowered core::String named#case#1;
+      dynamic ambiguousField;
+      if(#0#0 is{ForNonNullableByDefault} Null && (let final dynamic #t1 = hashCode = #0#0{Null}.{core::Object::hashCode}{core::int} in true) || #0#0 is{ForNonNullableByDefault} Null && (let final dynamic #t2 = toString = #0#0{Null}.{core::Object::toString}{() → core::String} in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t3 = field#case#0 = #0#5#isSet ?{dynamic} #0#5{dynamic} : let final dynamic #t4 = #0#5#isSet = true in #0#5 = #0#0{self::Class}.{self::Class::field}{dynamic} in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t5 = method#case#0 = #0#6#isSet ?{() → void} #0#6{() → void} : let final dynamic #t6 = #0#6#isSet = true in #0#6 = #0#0{self::Class}.{self::Class::method}{() → void} in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t7 = extensionGetter#case#0 = self::_extension#0|get#extensionGetter(#0#0{self::Class}) in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t8 = extensionMethod#case#0 = self::_extension#0|extensionMethod(#0#0{self::Class}) in true) || #0#0 is{ForNonNullableByDefault} dynamic && (let final dynamic #t9 = dynamicAccess = #0#0{dynamic}.dynamicAccess in true) || #0#0 is{ForNonNullableByDefault} () → void && (let final dynamic #t10 = call#case#0 = #0#12#isSet ?{() → void} #0#12{() → void} : let final dynamic #t11 = #0#12#isSet = true in #0#12 = #0#0{() → void}.call in true) || #0#0 is{ForNonNullableByDefault} (core::int, {required named: core::String}) && (let final dynamic #t12 = $1#case#0 = #0#14#isSet ?{core::int} #0#14{core::int} : let final dynamic #t13 = #0#14#isSet = true in #0#14 = #0#0{(core::int, {required named: core::String})}.$1{core::int} in true) || #0#0 is{ForNonNullableByDefault} (core::int, {required named: core::String}) && (let final dynamic #t14 = named#case#0 = #0#15#isSet ?{core::String} #0#15{core::String} : let final dynamic #t15 = #0#15#isSet = true in #0#15 = #0#0{(core::int, {required named: core::String})}.named{core::String} in true) || #0#0 is{ForNonNullableByDefault} self::Class && (let final dynamic #t16 = invalid-expression "pkg/front_end/testcases/patterns/pattern_types.dart:75:16: Error: The getter 'missing' isn't defined for the class 'Class'.
  - 'Class' is from 'pkg/front_end/testcases/patterns/pattern_types.dart'.
 Try correcting the name to the name of an existing getter, or defining a getter or field named 'missing'.
     case Class(: var missing): // Error: missing getter
@@ -294,6 +295,7 @@ Try correcting the name to the name of an existing getter, or defining a getter
 Try correcting the name to the name of an existing getter, or defining a getter or field named 'ambiguousField'.
     case Class(: var ambiguousField): // Error: ambiguous get
                ^^^^^^^^^^^^^^") || #0#0 is{ForNonNullableByDefault} invalid-type) {
+      }
     }
   }
 }
diff --git a/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args.dart.strong.expect b/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args.dart.strong.expect
index a44b878b8ea..cda81f8f4de 100644
--- a/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args.dart.strong.expect
@@ -9,9 +9,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} asy::Future<core::int>) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} asy::Future<core::int>) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args.dart.strong.transformed.expect
index a44b878b8ea..cda81f8f4de 100644
--- a/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args.dart.strong.transformed.expect
@@ -9,9 +9,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} asy::Future<core::int>) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} asy::Future<core::int>) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args.dart.weak.expect b/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args.dart.weak.expect
index a44b878b8ea..cda81f8f4de 100644
--- a/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args.dart.weak.expect
@@ -9,9 +9,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} asy::Future<core::int>) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} asy::Future<core::int>) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args.dart.weak.modular.expect
index a44b878b8ea..cda81f8f4de 100644
--- a/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args.dart.weak.modular.expect
@@ -9,9 +9,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} asy::Future<core::int>) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} asy::Future<core::int>) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args.dart.weak.transformed.expect
index a44b878b8ea..cda81f8f4de 100644
--- a/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args.dart.weak.transformed.expect
@@ -9,9 +9,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} asy::Future<core::int>) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} asy::Future<core::int>) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_cast.dart.strong.expect b/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_cast.dart.strong.expect
index 37d5ab77afd..958c969391e 100644
--- a/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_cast.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_cast.dart.strong.expect
@@ -9,9 +9,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in (#0#0 as{ForNonNullableByDefault} core::Object) is{ForNonNullableByDefault} asy::Future<core::int>) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in (#0#0 as{ForNonNullableByDefault} core::Object) is{ForNonNullableByDefault} asy::Future<core::int>) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_cast.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_cast.dart.strong.transformed.expect
index fe50fa6b451..55daf448306 100644
--- a/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_cast.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_cast.dart.strong.transformed.expect
@@ -9,9 +9,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final core::Object #t1 = let dynamic #t2 = #0#0 in #t2 == null ?{core::Object} #t2 as{ForNonNullableByDefault} core::Object : #t2{core::Object} in (let dynamic #t3 = #0#0 in #t3 == null ?{core::Object} #t3 as{ForNonNullableByDefault} core::Object : #t3{core::Object}) is{ForNonNullableByDefault} asy::Future<core::int>) {
-      {
-        break #L1;
+    {
+      if(let final core::Object #t1 = let dynamic #t2 = #0#0 in #t2 == null ?{core::Object} #t2 as{ForNonNullableByDefault} core::Object : #t2{core::Object} in (let dynamic #t3 = #0#0 in #t3 == null ?{core::Object} #t3 as{ForNonNullableByDefault} core::Object : #t3{core::Object}) is{ForNonNullableByDefault} asy::Future<core::int>) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_cast.dart.weak.expect b/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_cast.dart.weak.expect
index 37d5ab77afd..958c969391e 100644
--- a/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_cast.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_cast.dart.weak.expect
@@ -9,9 +9,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in (#0#0 as{ForNonNullableByDefault} core::Object) is{ForNonNullableByDefault} asy::Future<core::int>) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in (#0#0 as{ForNonNullableByDefault} core::Object) is{ForNonNullableByDefault} asy::Future<core::int>) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_cast.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_cast.dart.weak.modular.expect
index 37d5ab77afd..958c969391e 100644
--- a/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_cast.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_cast.dart.weak.modular.expect
@@ -9,9 +9,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in (#0#0 as{ForNonNullableByDefault} core::Object) is{ForNonNullableByDefault} asy::Future<core::int>) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in (#0#0 as{ForNonNullableByDefault} core::Object) is{ForNonNullableByDefault} asy::Future<core::int>) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_cast.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_cast.dart.weak.transformed.expect
index 2275134ec55..433b497c1a3 100644
--- a/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_cast.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_cast.dart.weak.transformed.expect
@@ -9,9 +9,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final core::Object #t1 = #0#0 in #0#0 is{ForNonNullableByDefault} asy::Future<core::int>) {
-      {
-        break #L1;
+    {
+      if(let final core::Object #t1 = #0#0 in #0#0 is{ForNonNullableByDefault} asy::Future<core::int>) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_assert.dart.strong.expect b/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_assert.dart.strong.expect
index d27766479f2..950c9cbcee8 100644
--- a/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_assert.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_assert.dart.strong.expect
@@ -9,9 +9,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} asy::Future<core::int>) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} asy::Future<core::int>) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_assert.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_assert.dart.strong.transformed.expect
index d27766479f2..950c9cbcee8 100644
--- a/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_assert.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_assert.dart.strong.transformed.expect
@@ -9,9 +9,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} asy::Future<core::int>) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} asy::Future<core::int>) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_assert.dart.weak.expect b/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_assert.dart.weak.expect
index d27766479f2..950c9cbcee8 100644
--- a/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_assert.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_assert.dart.weak.expect
@@ -9,9 +9,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} asy::Future<core::int>) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} asy::Future<core::int>) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_assert.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_assert.dart.weak.modular.expect
index d27766479f2..950c9cbcee8 100644
--- a/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_assert.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_assert.dart.weak.modular.expect
@@ -9,9 +9,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} asy::Future<core::int>) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} asy::Future<core::int>) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_assert.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_assert.dart.weak.transformed.expect
index d27766479f2..950c9cbcee8 100644
--- a/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_assert.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_assert.dart.weak.transformed.expect
@@ -9,9 +9,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} asy::Future<core::int>) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} asy::Future<core::int>) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_check.dart.strong.expect b/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_check.dart.strong.expect
index 592130f48a1..2da6f949aef 100644
--- a/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_check.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_check.dart.strong.expect
@@ -9,9 +9,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} asy::Future<core::int> : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} asy::Future<core::int> : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_check.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_check.dart.strong.transformed.expect
index 592130f48a1..2da6f949aef 100644
--- a/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_check.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_check.dart.strong.transformed.expect
@@ -9,9 +9,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} asy::Future<core::int> : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} asy::Future<core::int> : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_check.dart.weak.expect b/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_check.dart.weak.expect
index 592130f48a1..2da6f949aef 100644
--- a/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_check.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_check.dart.weak.expect
@@ -9,9 +9,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} asy::Future<core::int> : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} asy::Future<core::int> : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_check.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_check.dart.weak.modular.expect
index 592130f48a1..2da6f949aef 100644
--- a/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_check.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_check.dart.weak.modular.expect
@@ -9,9 +9,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} asy::Future<core::int> : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} asy::Future<core::int> : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_check.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_check.dart.weak.transformed.expect
index 592130f48a1..2da6f949aef 100644
--- a/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_check.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_check.dart.weak.transformed.expect
@@ -9,9 +9,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} asy::Future<core::int> : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} asy::Future<core::int> : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/private_names_in_object_patterns.dart.strong.expect b/pkg/front_end/testcases/patterns/private_names_in_object_patterns.dart.strong.expect
index 0f2748a2d1f..0337223bfdf 100644
--- a/pkg/front_end/testcases/patterns/private_names_in_object_patterns.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/private_names_in_object_patterns.dart.strong.expect
@@ -12,14 +12,18 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} self::A && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{self::A}.{self::A::_foo}{core::int}) {
-      {
-        return x{self::A};
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::A && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{self::A}.{self::A::_foo}{core::int}) {
+        {
+          return x{self::A};
+        }
       }
     }
-    else {
+    {
       {
-        return null;
+        {
+          return null;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/private_names_in_object_patterns.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/private_names_in_object_patterns.dart.strong.transformed.expect
index 0f2748a2d1f..0337223bfdf 100644
--- a/pkg/front_end/testcases/patterns/private_names_in_object_patterns.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/private_names_in_object_patterns.dart.strong.transformed.expect
@@ -12,14 +12,18 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} self::A && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{self::A}.{self::A::_foo}{core::int}) {
-      {
-        return x{self::A};
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::A && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{self::A}.{self::A::_foo}{core::int}) {
+        {
+          return x{self::A};
+        }
       }
     }
-    else {
+    {
       {
-        return null;
+        {
+          return null;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/private_names_in_object_patterns.dart.weak.expect b/pkg/front_end/testcases/patterns/private_names_in_object_patterns.dart.weak.expect
index 0f2748a2d1f..0337223bfdf 100644
--- a/pkg/front_end/testcases/patterns/private_names_in_object_patterns.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/private_names_in_object_patterns.dart.weak.expect
@@ -12,14 +12,18 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} self::A && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{self::A}.{self::A::_foo}{core::int}) {
-      {
-        return x{self::A};
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::A && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{self::A}.{self::A::_foo}{core::int}) {
+        {
+          return x{self::A};
+        }
       }
     }
-    else {
+    {
       {
-        return null;
+        {
+          return null;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/private_names_in_object_patterns.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/private_names_in_object_patterns.dart.weak.modular.expect
index 0f2748a2d1f..0337223bfdf 100644
--- a/pkg/front_end/testcases/patterns/private_names_in_object_patterns.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/private_names_in_object_patterns.dart.weak.modular.expect
@@ -12,14 +12,18 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} self::A && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{self::A}.{self::A::_foo}{core::int}) {
-      {
-        return x{self::A};
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::A && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{self::A}.{self::A::_foo}{core::int}) {
+        {
+          return x{self::A};
+        }
       }
     }
-    else {
+    {
       {
-        return null;
+        {
+          return null;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/private_names_in_object_patterns.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/private_names_in_object_patterns.dart.weak.transformed.expect
index 0f2748a2d1f..0337223bfdf 100644
--- a/pkg/front_end/testcases/patterns/private_names_in_object_patterns.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/private_names_in_object_patterns.dart.weak.transformed.expect
@@ -12,14 +12,18 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} self::A && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{self::A}.{self::A::_foo}{core::int}) {
-      {
-        return x{self::A};
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::A && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{self::A}.{self::A::_foo}{core::int}) {
+        {
+          return x{self::A};
+        }
       }
     }
-    else {
+    {
       {
-        return null;
+        {
+          return null;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/promotions_in_switch_case_guards.dart.strong.expect b/pkg/front_end/testcases/patterns/promotions_in_switch_case_guards.dart.strong.expect
index c3409a3b136..0f099388428 100644
--- a/pkg/front_end/testcases/patterns/promotions_in_switch_case_guards.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/promotions_in_switch_case_guards.dart.strong.expect
@@ -5,20 +5,24 @@ import "dart:core" as core;
 static method test(core::String? x) → dynamic {
   #L1:
   {
-    core::String? foobar;
-    core::String? foobar#1;
-    core::String? foobar#2;
     final synthesized core::String? #0#0 = x;
     dynamic #t1;
-    if((!(#0#0 == null) ?{core::bool} #0#0{core::String} is{ForNonNullableByDefault} core::String? && (let final dynamic #t2 = foobar = #0#0{core::String} in true) : false) && foobar{core::String} is{ForNonNullableByDefault} Never && (let final dynamic #t3 = #t1 = foobar in true) || #0#0 is{ForNonNullableByDefault} core::String? && (let final dynamic #t4 = foobar#1 = #0#0 in true) && !(foobar#1 == null) && (let final dynamic #t5 = #t1 = foobar#1 in true) || (let final dynamic #t6 = #0#0! in #0#0! is{ForNonNullableByDefault} core::String? && (let final dynamic #t7 = foobar#2 = #0#0! in true)) && foobar#2{core::String} =={core::String::==}{(core::Object) → core::bool} "foobar" && (let final dynamic #t8 = #t1 = foobar#2 in true)) {
-      core::String? foobar = #t1{core::String?};
-      {
-        return foobar{core::String}.{core::String::startsWith}("foo"){(core::Pattern, [core::int]) → core::bool};
+    {
+      lowered core::String? foobar#case#0;
+      lowered core::String? foobar#case#1;
+      lowered core::String? foobar#case#2;
+      if((!(#0#0 == null) ?{core::bool} #0#0{core::String} is{ForNonNullableByDefault} core::String? && (let final dynamic #t2 = foobar#case#0 = #0#0{core::String} in true) : false) && foobar#case#0{core::String} is{ForNonNullableByDefault} Never && (let final dynamic #t3 = #t1 = foobar#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::String? && (let final dynamic #t4 = foobar#case#1 = #0#0 in true) && !(foobar#case#1 == null) && (let final dynamic #t5 = #t1 = foobar#case#1 in true) || (let final dynamic #t6 = #0#0! in #0#0! is{ForNonNullableByDefault} core::String? && (let final dynamic #t7 = foobar#case#2 = #0#0! in true)) && foobar#case#2{core::String} =={core::String::==}{(core::Object) → core::bool} "foobar" && (let final dynamic #t8 = #t1 = foobar#case#2 in true)) {
+        core::String? foobar = #t1{core::String?};
+        {
+          return foobar{core::String}.{core::String::startsWith}("foo"){(core::Pattern, [core::int]) → core::bool};
+        }
       }
     }
-    else {
+    {
       {
-        return null;
+        {
+          return null;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/promotions_in_switch_case_guards.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/promotions_in_switch_case_guards.dart.strong.transformed.expect
index a702ef67b4f..97f472e9779 100644
--- a/pkg/front_end/testcases/patterns/promotions_in_switch_case_guards.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/promotions_in_switch_case_guards.dart.strong.transformed.expect
@@ -5,20 +5,24 @@ import "dart:core" as core;
 static method test(core::String? x) → dynamic {
   #L1:
   {
-    core::String? foobar;
-    core::String? foobar#1;
-    core::String? foobar#2;
     final synthesized core::String? #0#0 = x;
     dynamic #t1;
-    if((!(#0#0 == null) ?{core::bool} #0#0{core::String} is{ForNonNullableByDefault} core::String? && (let final core::String #t2 = foobar = #0#0{core::String} in true) : false) && foobar{core::String} is{ForNonNullableByDefault} Never && (let final core::String? #t3 = #t1 = foobar in true) || #0#0 is{ForNonNullableByDefault} core::String? && (let final core::String? #t4 = foobar#1 = #0#0 in true) && !(foobar#1 == null) && (let final core::String? #t5 = #t1 = foobar#1 in true) || (let final core::String? #t6 = #0#0! in #0#0! is{ForNonNullableByDefault} core::String? && (let final core::String? #t7 = foobar#2 = #0#0! in true)) && foobar#2{core::String} =={core::String::==}{(core::Object) → core::bool} "foobar" && (let final core::String? #t8 = #t1 = foobar#2 in true)) {
-      core::String? foobar = #t1{core::String?};
-      {
-        return foobar{core::String}.{core::String::startsWith}("foo"){(core::Pattern, [core::int]) → core::bool};
+    {
+      lowered core::String? foobar#case#0;
+      lowered core::String? foobar#case#1;
+      lowered core::String? foobar#case#2;
+      if((!(#0#0 == null) ?{core::bool} #0#0{core::String} is{ForNonNullableByDefault} core::String? && (let final core::String #t2 = foobar#case#0 = #0#0{core::String} in true) : false) && foobar#case#0{core::String} is{ForNonNullableByDefault} Never && (let final core::String? #t3 = #t1 = foobar#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::String? && (let final core::String? #t4 = foobar#case#1 = #0#0 in true) && !(foobar#case#1 == null) && (let final core::String? #t5 = #t1 = foobar#case#1 in true) || (let final core::String? #t6 = #0#0! in #0#0! is{ForNonNullableByDefault} core::String? && (let final core::String? #t7 = foobar#case#2 = #0#0! in true)) && foobar#case#2{core::String} =={core::String::==}{(core::Object) → core::bool} "foobar" && (let final core::String? #t8 = #t1 = foobar#case#2 in true)) {
+        core::String? foobar = #t1{core::String?};
+        {
+          return foobar{core::String}.{core::String::startsWith}("foo"){(core::Pattern, [core::int]) → core::bool};
+        }
       }
     }
-    else {
+    {
       {
-        return null;
+        {
+          return null;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/promotions_in_switch_case_guards.dart.weak.expect b/pkg/front_end/testcases/patterns/promotions_in_switch_case_guards.dart.weak.expect
index c3409a3b136..0f099388428 100644
--- a/pkg/front_end/testcases/patterns/promotions_in_switch_case_guards.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/promotions_in_switch_case_guards.dart.weak.expect
@@ -5,20 +5,24 @@ import "dart:core" as core;
 static method test(core::String? x) → dynamic {
   #L1:
   {
-    core::String? foobar;
-    core::String? foobar#1;
-    core::String? foobar#2;
     final synthesized core::String? #0#0 = x;
     dynamic #t1;
-    if((!(#0#0 == null) ?{core::bool} #0#0{core::String} is{ForNonNullableByDefault} core::String? && (let final dynamic #t2 = foobar = #0#0{core::String} in true) : false) && foobar{core::String} is{ForNonNullableByDefault} Never && (let final dynamic #t3 = #t1 = foobar in true) || #0#0 is{ForNonNullableByDefault} core::String? && (let final dynamic #t4 = foobar#1 = #0#0 in true) && !(foobar#1 == null) && (let final dynamic #t5 = #t1 = foobar#1 in true) || (let final dynamic #t6 = #0#0! in #0#0! is{ForNonNullableByDefault} core::String? && (let final dynamic #t7 = foobar#2 = #0#0! in true)) && foobar#2{core::String} =={core::String::==}{(core::Object) → core::bool} "foobar" && (let final dynamic #t8 = #t1 = foobar#2 in true)) {
-      core::String? foobar = #t1{core::String?};
-      {
-        return foobar{core::String}.{core::String::startsWith}("foo"){(core::Pattern, [core::int]) → core::bool};
+    {
+      lowered core::String? foobar#case#0;
+      lowered core::String? foobar#case#1;
+      lowered core::String? foobar#case#2;
+      if((!(#0#0 == null) ?{core::bool} #0#0{core::String} is{ForNonNullableByDefault} core::String? && (let final dynamic #t2 = foobar#case#0 = #0#0{core::String} in true) : false) && foobar#case#0{core::String} is{ForNonNullableByDefault} Never && (let final dynamic #t3 = #t1 = foobar#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::String? && (let final dynamic #t4 = foobar#case#1 = #0#0 in true) && !(foobar#case#1 == null) && (let final dynamic #t5 = #t1 = foobar#case#1 in true) || (let final dynamic #t6 = #0#0! in #0#0! is{ForNonNullableByDefault} core::String? && (let final dynamic #t7 = foobar#case#2 = #0#0! in true)) && foobar#case#2{core::String} =={core::String::==}{(core::Object) → core::bool} "foobar" && (let final dynamic #t8 = #t1 = foobar#case#2 in true)) {
+        core::String? foobar = #t1{core::String?};
+        {
+          return foobar{core::String}.{core::String::startsWith}("foo"){(core::Pattern, [core::int]) → core::bool};
+        }
       }
     }
-    else {
+    {
       {
-        return null;
+        {
+          return null;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/promotions_in_switch_case_guards.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/promotions_in_switch_case_guards.dart.weak.modular.expect
index c3409a3b136..0f099388428 100644
--- a/pkg/front_end/testcases/patterns/promotions_in_switch_case_guards.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/promotions_in_switch_case_guards.dart.weak.modular.expect
@@ -5,20 +5,24 @@ import "dart:core" as core;
 static method test(core::String? x) → dynamic {
   #L1:
   {
-    core::String? foobar;
-    core::String? foobar#1;
-    core::String? foobar#2;
     final synthesized core::String? #0#0 = x;
     dynamic #t1;
-    if((!(#0#0 == null) ?{core::bool} #0#0{core::String} is{ForNonNullableByDefault} core::String? && (let final dynamic #t2 = foobar = #0#0{core::String} in true) : false) && foobar{core::String} is{ForNonNullableByDefault} Never && (let final dynamic #t3 = #t1 = foobar in true) || #0#0 is{ForNonNullableByDefault} core::String? && (let final dynamic #t4 = foobar#1 = #0#0 in true) && !(foobar#1 == null) && (let final dynamic #t5 = #t1 = foobar#1 in true) || (let final dynamic #t6 = #0#0! in #0#0! is{ForNonNullableByDefault} core::String? && (let final dynamic #t7 = foobar#2 = #0#0! in true)) && foobar#2{core::String} =={core::String::==}{(core::Object) → core::bool} "foobar" && (let final dynamic #t8 = #t1 = foobar#2 in true)) {
-      core::String? foobar = #t1{core::String?};
-      {
-        return foobar{core::String}.{core::String::startsWith}("foo"){(core::Pattern, [core::int]) → core::bool};
+    {
+      lowered core::String? foobar#case#0;
+      lowered core::String? foobar#case#1;
+      lowered core::String? foobar#case#2;
+      if((!(#0#0 == null) ?{core::bool} #0#0{core::String} is{ForNonNullableByDefault} core::String? && (let final dynamic #t2 = foobar#case#0 = #0#0{core::String} in true) : false) && foobar#case#0{core::String} is{ForNonNullableByDefault} Never && (let final dynamic #t3 = #t1 = foobar#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::String? && (let final dynamic #t4 = foobar#case#1 = #0#0 in true) && !(foobar#case#1 == null) && (let final dynamic #t5 = #t1 = foobar#case#1 in true) || (let final dynamic #t6 = #0#0! in #0#0! is{ForNonNullableByDefault} core::String? && (let final dynamic #t7 = foobar#case#2 = #0#0! in true)) && foobar#case#2{core::String} =={core::String::==}{(core::Object) → core::bool} "foobar" && (let final dynamic #t8 = #t1 = foobar#case#2 in true)) {
+        core::String? foobar = #t1{core::String?};
+        {
+          return foobar{core::String}.{core::String::startsWith}("foo"){(core::Pattern, [core::int]) → core::bool};
+        }
       }
     }
-    else {
+    {
       {
-        return null;
+        {
+          return null;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/promotions_in_switch_case_guards.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/promotions_in_switch_case_guards.dart.weak.transformed.expect
index a702ef67b4f..97f472e9779 100644
--- a/pkg/front_end/testcases/patterns/promotions_in_switch_case_guards.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/promotions_in_switch_case_guards.dart.weak.transformed.expect
@@ -5,20 +5,24 @@ import "dart:core" as core;
 static method test(core::String? x) → dynamic {
   #L1:
   {
-    core::String? foobar;
-    core::String? foobar#1;
-    core::String? foobar#2;
     final synthesized core::String? #0#0 = x;
     dynamic #t1;
-    if((!(#0#0 == null) ?{core::bool} #0#0{core::String} is{ForNonNullableByDefault} core::String? && (let final core::String #t2 = foobar = #0#0{core::String} in true) : false) && foobar{core::String} is{ForNonNullableByDefault} Never && (let final core::String? #t3 = #t1 = foobar in true) || #0#0 is{ForNonNullableByDefault} core::String? && (let final core::String? #t4 = foobar#1 = #0#0 in true) && !(foobar#1 == null) && (let final core::String? #t5 = #t1 = foobar#1 in true) || (let final core::String? #t6 = #0#0! in #0#0! is{ForNonNullableByDefault} core::String? && (let final core::String? #t7 = foobar#2 = #0#0! in true)) && foobar#2{core::String} =={core::String::==}{(core::Object) → core::bool} "foobar" && (let final core::String? #t8 = #t1 = foobar#2 in true)) {
-      core::String? foobar = #t1{core::String?};
-      {
-        return foobar{core::String}.{core::String::startsWith}("foo"){(core::Pattern, [core::int]) → core::bool};
+    {
+      lowered core::String? foobar#case#0;
+      lowered core::String? foobar#case#1;
+      lowered core::String? foobar#case#2;
+      if((!(#0#0 == null) ?{core::bool} #0#0{core::String} is{ForNonNullableByDefault} core::String? && (let final core::String #t2 = foobar#case#0 = #0#0{core::String} in true) : false) && foobar#case#0{core::String} is{ForNonNullableByDefault} Never && (let final core::String? #t3 = #t1 = foobar#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::String? && (let final core::String? #t4 = foobar#case#1 = #0#0 in true) && !(foobar#case#1 == null) && (let final core::String? #t5 = #t1 = foobar#case#1 in true) || (let final core::String? #t6 = #0#0! in #0#0! is{ForNonNullableByDefault} core::String? && (let final core::String? #t7 = foobar#case#2 = #0#0! in true)) && foobar#case#2{core::String} =={core::String::==}{(core::Object) → core::bool} "foobar" && (let final core::String? #t8 = #t1 = foobar#case#2 in true)) {
+        core::String? foobar = #t1{core::String?};
+        {
+          return foobar{core::String}.{core::String::startsWith}("foo"){(core::Pattern, [core::int]) → core::bool};
+        }
       }
     }
-    else {
+    {
       {
-        return null;
+        {
+          return null;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/record_pattern_inside_case.dart.strong.expect b/pkg/front_end/testcases/patterns/record_pattern_inside_case.dart.strong.expect
index 1007932af00..646cda45ed1 100644
--- a/pkg/front_end/testcases/patterns/record_pattern_inside_case.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/record_pattern_inside_case.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/record_pattern_inside_case.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/record_pattern_inside_case.dart.strong.transformed.expect
index 1007932af00..646cda45ed1 100644
--- a/pkg/front_end/testcases/patterns/record_pattern_inside_case.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/record_pattern_inside_case.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/record_pattern_inside_case.dart.weak.expect b/pkg/front_end/testcases/patterns/record_pattern_inside_case.dart.weak.expect
index 1007932af00..646cda45ed1 100644
--- a/pkg/front_end/testcases/patterns/record_pattern_inside_case.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/record_pattern_inside_case.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/record_pattern_inside_case.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/record_pattern_inside_case.dart.weak.modular.expect
index 1007932af00..646cda45ed1 100644
--- a/pkg/front_end/testcases/patterns/record_pattern_inside_case.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/record_pattern_inside_case.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/record_pattern_inside_case.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/record_pattern_inside_case.dart.weak.transformed.expect
index 1007932af00..646cda45ed1 100644
--- a/pkg/front_end/testcases/patterns/record_pattern_inside_case.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/record_pattern_inside_case.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/record_pattern_inside_case_empty.dart.strong.expect b/pkg/front_end/testcases/patterns/record_pattern_inside_case_empty.dart.strong.expect
index 048cb7a2a0c..94129913fa4 100644
--- a/pkg/front_end/testcases/patterns/record_pattern_inside_case_empty.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/record_pattern_inside_case_empty.dart.strong.expect
@@ -5,9 +5,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} ()) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} ()) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/record_pattern_inside_case_empty.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/record_pattern_inside_case_empty.dart.strong.transformed.expect
index 048cb7a2a0c..94129913fa4 100644
--- a/pkg/front_end/testcases/patterns/record_pattern_inside_case_empty.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/record_pattern_inside_case_empty.dart.strong.transformed.expect
@@ -5,9 +5,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} ()) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} ()) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/record_pattern_inside_case_empty.dart.weak.expect b/pkg/front_end/testcases/patterns/record_pattern_inside_case_empty.dart.weak.expect
index 048cb7a2a0c..94129913fa4 100644
--- a/pkg/front_end/testcases/patterns/record_pattern_inside_case_empty.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/record_pattern_inside_case_empty.dart.weak.expect
@@ -5,9 +5,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} ()) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} ()) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/record_pattern_inside_case_empty.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/record_pattern_inside_case_empty.dart.weak.modular.expect
index 048cb7a2a0c..94129913fa4 100644
--- a/pkg/front_end/testcases/patterns/record_pattern_inside_case_empty.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/record_pattern_inside_case_empty.dart.weak.modular.expect
@@ -5,9 +5,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} ()) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} ()) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/record_pattern_inside_case_empty.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/record_pattern_inside_case_empty.dart.weak.transformed.expect
index 048cb7a2a0c..94129913fa4 100644
--- a/pkg/front_end/testcases/patterns/record_pattern_inside_case_empty.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/record_pattern_inside_case_empty.dart.weak.transformed.expect
@@ -5,9 +5,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} ()) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} ()) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/record_pattern_inside_case_singleton.dart.strong.expect b/pkg/front_end/testcases/patterns/record_pattern_inside_case_singleton.dart.strong.expect
index 1bd84ab527c..7cb4ba09810 100644
--- a/pkg/front_end/testcases/patterns/record_pattern_inside_case_singleton.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/record_pattern_inside_case_singleton.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?)}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?)}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/record_pattern_inside_case_singleton.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/record_pattern_inside_case_singleton.dart.strong.transformed.expect
index 1bd84ab527c..7cb4ba09810 100644
--- a/pkg/front_end/testcases/patterns/record_pattern_inside_case_singleton.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/record_pattern_inside_case_singleton.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?)}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?)}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/record_pattern_inside_case_singleton.dart.weak.expect b/pkg/front_end/testcases/patterns/record_pattern_inside_case_singleton.dart.weak.expect
index 1bd84ab527c..7cb4ba09810 100644
--- a/pkg/front_end/testcases/patterns/record_pattern_inside_case_singleton.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/record_pattern_inside_case_singleton.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?)}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?)}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/record_pattern_inside_case_singleton.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/record_pattern_inside_case_singleton.dart.weak.modular.expect
index 1bd84ab527c..7cb4ba09810 100644
--- a/pkg/front_end/testcases/patterns/record_pattern_inside_case_singleton.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/record_pattern_inside_case_singleton.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?)}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?)}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/record_pattern_inside_case_singleton.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/record_pattern_inside_case_singleton.dart.weak.transformed.expect
index 1bd84ab527c..7cb4ba09810 100644
--- a/pkg/front_end/testcases/patterns/record_pattern_inside_case_singleton.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/record_pattern_inside_case_singleton.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?)}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?)}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/record_pattern_inside_cast.dart.strong.expect b/pkg/front_end/testcases/patterns/record_pattern_inside_cast.dart.strong.expect
index c65f9383c96..1a868bbab19 100644
--- a/pkg/front_end/testcases/patterns/record_pattern_inside_cast.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/record_pattern_inside_cast.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in (#0#0 as{ForNonNullableByDefault} core::Object) is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} ((#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} (core::Object?, core::Object?)).$1{core::Object?} && #C2 =={core::num::==}{(core::Object) → core::bool} ((#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} (core::Object?, core::Object?)).$2{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in (#0#0 as{ForNonNullableByDefault} core::Object) is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} ((#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} (core::Object?, core::Object?)).$1{core::Object?} && #C2 =={core::num::==}{(core::Object) → core::bool} ((#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} (core::Object?, core::Object?)).$2{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/record_pattern_inside_cast.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/record_pattern_inside_cast.dart.strong.transformed.expect
index 737d8ea5d36..051c789151c 100644
--- a/pkg/front_end/testcases/patterns/record_pattern_inside_cast.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/record_pattern_inside_cast.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final core::Object #t1 = let dynamic #t2 = #0#0 in #t2 == null ?{core::Object} #t2 as{ForNonNullableByDefault} core::Object : #t2{core::Object} in (let dynamic #t3 = #0#0 in #t3 == null ?{core::Object} #t3 as{ForNonNullableByDefault} core::Object : #t3{core::Object}) is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} ((let dynamic #t4 = #0#0 in #t4 == null ?{core::Object} #t4 as{ForNonNullableByDefault} core::Object : #t4{core::Object}) as{ForNonNullableByDefault} (core::Object?, core::Object?)).$1{core::Object?} && #C2 =={core::num::==}{(core::Object) → core::bool} ((let dynamic #t5 = #0#0 in #t5 == null ?{core::Object} #t5 as{ForNonNullableByDefault} core::Object : #t5{core::Object}) as{ForNonNullableByDefault} (core::Object?, core::Object?)).$2{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(let final core::Object #t1 = let dynamic #t2 = #0#0 in #t2 == null ?{core::Object} #t2 as{ForNonNullableByDefault} core::Object : #t2{core::Object} in (let dynamic #t3 = #0#0 in #t3 == null ?{core::Object} #t3 as{ForNonNullableByDefault} core::Object : #t3{core::Object}) is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} ((let dynamic #t4 = #0#0 in #t4 == null ?{core::Object} #t4 as{ForNonNullableByDefault} core::Object : #t4{core::Object}) as{ForNonNullableByDefault} (core::Object?, core::Object?)).$1{core::Object?} && #C2 =={core::num::==}{(core::Object) → core::bool} ((let dynamic #t5 = #0#0 in #t5 == null ?{core::Object} #t5 as{ForNonNullableByDefault} core::Object : #t5{core::Object}) as{ForNonNullableByDefault} (core::Object?, core::Object?)).$2{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/record_pattern_inside_cast.dart.weak.expect b/pkg/front_end/testcases/patterns/record_pattern_inside_cast.dart.weak.expect
index c65f9383c96..1a868bbab19 100644
--- a/pkg/front_end/testcases/patterns/record_pattern_inside_cast.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/record_pattern_inside_cast.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in (#0#0 as{ForNonNullableByDefault} core::Object) is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} ((#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} (core::Object?, core::Object?)).$1{core::Object?} && #C2 =={core::num::==}{(core::Object) → core::bool} ((#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} (core::Object?, core::Object?)).$2{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in (#0#0 as{ForNonNullableByDefault} core::Object) is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} ((#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} (core::Object?, core::Object?)).$1{core::Object?} && #C2 =={core::num::==}{(core::Object) → core::bool} ((#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} (core::Object?, core::Object?)).$2{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/record_pattern_inside_cast.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/record_pattern_inside_cast.dart.weak.modular.expect
index c65f9383c96..1a868bbab19 100644
--- a/pkg/front_end/testcases/patterns/record_pattern_inside_cast.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/record_pattern_inside_cast.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in (#0#0 as{ForNonNullableByDefault} core::Object) is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} ((#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} (core::Object?, core::Object?)).$1{core::Object?} && #C2 =={core::num::==}{(core::Object) → core::bool} ((#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} (core::Object?, core::Object?)).$2{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in (#0#0 as{ForNonNullableByDefault} core::Object) is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} ((#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} (core::Object?, core::Object?)).$1{core::Object?} && #C2 =={core::num::==}{(core::Object) → core::bool} ((#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} (core::Object?, core::Object?)).$2{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/record_pattern_inside_cast.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/record_pattern_inside_cast.dart.weak.transformed.expect
index da24e0199b1..b857088266b 100644
--- a/pkg/front_end/testcases/patterns/record_pattern_inside_cast.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/record_pattern_inside_cast.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final core::Object #t1 = #0#0 in #0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0 as{ForNonNullableByDefault} (core::Object?, core::Object?)).$1{core::Object?} && #C2 =={core::num::==}{(core::Object) → core::bool} (#0#0 as{ForNonNullableByDefault} (core::Object?, core::Object?)).$2{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(let final core::Object #t1 = #0#0 in #0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0 as{ForNonNullableByDefault} (core::Object?, core::Object?)).$1{core::Object?} && #C2 =={core::num::==}{(core::Object) → core::bool} (#0#0 as{ForNonNullableByDefault} (core::Object?, core::Object?)).$2{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/record_pattern_inside_null_assert.dart.strong.expect b/pkg/front_end/testcases/patterns/record_pattern_inside_null_assert.dart.strong.expect
index 3d8606e8072..83024bab543 100644
--- a/pkg/front_end/testcases/patterns/record_pattern_inside_null_assert.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/record_pattern_inside_null_assert.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} (core::Object?, core::Object?)).$1{core::Object?} && #C2 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} (core::Object?, core::Object?)).$2{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} (core::Object?, core::Object?)).$1{core::Object?} && #C2 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} (core::Object?, core::Object?)).$2{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/record_pattern_inside_null_assert.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/record_pattern_inside_null_assert.dart.strong.transformed.expect
index 3d8606e8072..83024bab543 100644
--- a/pkg/front_end/testcases/patterns/record_pattern_inside_null_assert.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/record_pattern_inside_null_assert.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} (core::Object?, core::Object?)).$1{core::Object?} && #C2 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} (core::Object?, core::Object?)).$2{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} (core::Object?, core::Object?)).$1{core::Object?} && #C2 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} (core::Object?, core::Object?)).$2{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/record_pattern_inside_null_assert.dart.weak.expect b/pkg/front_end/testcases/patterns/record_pattern_inside_null_assert.dart.weak.expect
index 3d8606e8072..83024bab543 100644
--- a/pkg/front_end/testcases/patterns/record_pattern_inside_null_assert.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/record_pattern_inside_null_assert.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} (core::Object?, core::Object?)).$1{core::Object?} && #C2 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} (core::Object?, core::Object?)).$2{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} (core::Object?, core::Object?)).$1{core::Object?} && #C2 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} (core::Object?, core::Object?)).$2{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/record_pattern_inside_null_assert.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/record_pattern_inside_null_assert.dart.weak.modular.expect
index 3d8606e8072..83024bab543 100644
--- a/pkg/front_end/testcases/patterns/record_pattern_inside_null_assert.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/record_pattern_inside_null_assert.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} (core::Object?, core::Object?)).$1{core::Object?} && #C2 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} (core::Object?, core::Object?)).$2{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} (core::Object?, core::Object?)).$1{core::Object?} && #C2 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} (core::Object?, core::Object?)).$2{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/record_pattern_inside_null_assert.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/record_pattern_inside_null_assert.dart.weak.transformed.expect
index 3d8606e8072..83024bab543 100644
--- a/pkg/front_end/testcases/patterns/record_pattern_inside_null_assert.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/record_pattern_inside_null_assert.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} (core::Object?, core::Object?)).$1{core::Object?} && #C2 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} (core::Object?, core::Object?)).$2{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} (core::Object?, core::Object?)).$1{core::Object?} && #C2 =={core::num::==}{(core::Object) → core::bool} (#0#0! as{ForNonNullableByDefault} (core::Object?, core::Object?)).$2{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/record_pattern_inside_null_check.dart.strong.expect b/pkg/front_end/testcases/patterns/record_pattern_inside_null_check.dart.strong.expect
index d95abe28c75..78cf0162ff0 100644
--- a/pkg/front_end/testcases/patterns/record_pattern_inside_null_check.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/record_pattern_inside_null_check.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?} : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?} : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/record_pattern_inside_null_check.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/record_pattern_inside_null_check.dart.strong.transformed.expect
index d95abe28c75..78cf0162ff0 100644
--- a/pkg/front_end/testcases/patterns/record_pattern_inside_null_check.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/record_pattern_inside_null_check.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?} : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?} : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/record_pattern_inside_null_check.dart.weak.expect b/pkg/front_end/testcases/patterns/record_pattern_inside_null_check.dart.weak.expect
index d95abe28c75..78cf0162ff0 100644
--- a/pkg/front_end/testcases/patterns/record_pattern_inside_null_check.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/record_pattern_inside_null_check.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?} : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?} : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/record_pattern_inside_null_check.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/record_pattern_inside_null_check.dart.weak.modular.expect
index d95abe28c75..78cf0162ff0 100644
--- a/pkg/front_end/testcases/patterns/record_pattern_inside_null_check.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/record_pattern_inside_null_check.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?} : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?} : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/record_pattern_inside_null_check.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/record_pattern_inside_null_check.dart.weak.transformed.expect
index d95abe28c75..78cf0162ff0 100644
--- a/pkg/front_end/testcases/patterns/record_pattern_inside_null_check.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/record_pattern_inside_null_check.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?} : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$1{core::Object?} && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?} : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/records/issue50963.dart.strong.expect b/pkg/front_end/testcases/patterns/records/issue50963.dart.strong.expect
index 80b7d837b12..9bf22651ac8 100644
--- a/pkg/front_end/testcases/patterns/records/issue50963.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/records/issue50963.dart.strong.expect
@@ -6,12 +6,26 @@ static method test() → dynamic {
   final(core::int, core::int) x = (1, 2);
   core::print( block {
     core::int #t1;
-    if(true)
-      #t1 = 1;
+    #L1:
+    {
+      {
+        if(true) {
+          #t1 = 1;
+          break #L1;
+        }
+      }
+    }
   } =>#t1);
   core::print( block {
     core::int #t2;
-    if(true)
-      #t2 = 1;
+    #L2:
+    {
+      {
+        if(true) {
+          #t2 = 1;
+          break #L2;
+        }
+      }
+    }
   } =>#t2);
 }
diff --git a/pkg/front_end/testcases/patterns/records/issue50963.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/records/issue50963.dart.strong.transformed.expect
index 0b8ac794193..9ba572c2109 100644
--- a/pkg/front_end/testcases/patterns/records/issue50963.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/records/issue50963.dart.strong.transformed.expect
@@ -6,13 +6,27 @@ static method test() → dynamic {
   final(core::int, core::int) x = (1, 2);
   core::print( block {
     core::int #t1;
-    if(true)
-      #t1 = 1;
+    #L1:
+    {
+      {
+        if(true) {
+          #t1 = 1;
+          break #L1;
+        }
+      }
+    }
   } =>#t1);
   core::print( block {
     core::int #t2;
-    if(true)
-      #t2 = 1;
+    #L2:
+    {
+      {
+        if(true) {
+          #t2 = 1;
+          break #L2;
+        }
+      }
+    }
   } =>#t2);
 }
 
diff --git a/pkg/front_end/testcases/patterns/records/issue50963.dart.weak.expect b/pkg/front_end/testcases/patterns/records/issue50963.dart.weak.expect
index 80b7d837b12..9bf22651ac8 100644
--- a/pkg/front_end/testcases/patterns/records/issue50963.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/records/issue50963.dart.weak.expect
@@ -6,12 +6,26 @@ static method test() → dynamic {
   final(core::int, core::int) x = (1, 2);
   core::print( block {
     core::int #t1;
-    if(true)
-      #t1 = 1;
+    #L1:
+    {
+      {
+        if(true) {
+          #t1 = 1;
+          break #L1;
+        }
+      }
+    }
   } =>#t1);
   core::print( block {
     core::int #t2;
-    if(true)
-      #t2 = 1;
+    #L2:
+    {
+      {
+        if(true) {
+          #t2 = 1;
+          break #L2;
+        }
+      }
+    }
   } =>#t2);
 }
diff --git a/pkg/front_end/testcases/patterns/records/issue50963.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/records/issue50963.dart.weak.modular.expect
index 80b7d837b12..9bf22651ac8 100644
--- a/pkg/front_end/testcases/patterns/records/issue50963.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/records/issue50963.dart.weak.modular.expect
@@ -6,12 +6,26 @@ static method test() → dynamic {
   final(core::int, core::int) x = (1, 2);
   core::print( block {
     core::int #t1;
-    if(true)
-      #t1 = 1;
+    #L1:
+    {
+      {
+        if(true) {
+          #t1 = 1;
+          break #L1;
+        }
+      }
+    }
   } =>#t1);
   core::print( block {
     core::int #t2;
-    if(true)
-      #t2 = 1;
+    #L2:
+    {
+      {
+        if(true) {
+          #t2 = 1;
+          break #L2;
+        }
+      }
+    }
   } =>#t2);
 }
diff --git a/pkg/front_end/testcases/patterns/records/issue50963.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/records/issue50963.dart.weak.transformed.expect
index 0b8ac794193..9ba572c2109 100644
--- a/pkg/front_end/testcases/patterns/records/issue50963.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/records/issue50963.dart.weak.transformed.expect
@@ -6,13 +6,27 @@ static method test() → dynamic {
   final(core::int, core::int) x = (1, 2);
   core::print( block {
     core::int #t1;
-    if(true)
-      #t1 = 1;
+    #L1:
+    {
+      {
+        if(true) {
+          #t1 = 1;
+          break #L1;
+        }
+      }
+    }
   } =>#t1);
   core::print( block {
     core::int #t2;
-    if(true)
-      #t2 = 1;
+    #L2:
+    {
+      {
+        if(true) {
+          #t2 = 1;
+          break #L2;
+        }
+      }
+    }
   } =>#t2);
 }
 
diff --git a/pkg/front_end/testcases/patterns/relational_inside_case_equal.dart.strong.expect b/pkg/front_end/testcases/patterns/relational_inside_case_equal.dart.strong.expect
index f9bcb7e1163..72d8ca8b7c1 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_case_equal.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_case_equal.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1) {
-      {
-        break #L1;
+    {
+      if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_case_equal.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/relational_inside_case_equal.dart.strong.transformed.expect
index f9bcb7e1163..72d8ca8b7c1 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_case_equal.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_case_equal.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1) {
-      {
-        break #L1;
+    {
+      if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_case_equal.dart.weak.expect b/pkg/front_end/testcases/patterns/relational_inside_case_equal.dart.weak.expect
index f9bcb7e1163..72d8ca8b7c1 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_case_equal.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_case_equal.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1) {
-      {
-        break #L1;
+    {
+      if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_case_equal.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/relational_inside_case_equal.dart.weak.modular.expect
index f9bcb7e1163..72d8ca8b7c1 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_case_equal.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_case_equal.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1) {
-      {
-        break #L1;
+    {
+      if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_case_equal.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/relational_inside_case_equal.dart.weak.transformed.expect
index f9bcb7e1163..72d8ca8b7c1 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_case_equal.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_case_equal.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1) {
-      {
-        break #L1;
+    {
+      if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_case_greater_than.dart.strong.expect b/pkg/front_end/testcases/patterns/relational_inside_case_greater_than.dart.strong.expect
index 5c82863854a..61c62a27cb0 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_case_greater_than.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_case_greater_than.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0{dynamic}.>(#C1)) {
-      {
-        break #L1;
+    {
+      if(#0#0{dynamic}.>(#C1)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_case_greater_than.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/relational_inside_case_greater_than.dart.strong.transformed.expect
index 5c82863854a..61c62a27cb0 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_case_greater_than.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_case_greater_than.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0{dynamic}.>(#C1)) {
-      {
-        break #L1;
+    {
+      if(#0#0{dynamic}.>(#C1)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_case_greater_than.dart.weak.expect b/pkg/front_end/testcases/patterns/relational_inside_case_greater_than.dart.weak.expect
index 5c82863854a..61c62a27cb0 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_case_greater_than.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_case_greater_than.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0{dynamic}.>(#C1)) {
-      {
-        break #L1;
+    {
+      if(#0#0{dynamic}.>(#C1)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_case_greater_than.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/relational_inside_case_greater_than.dart.weak.modular.expect
index 5c82863854a..61c62a27cb0 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_case_greater_than.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_case_greater_than.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0{dynamic}.>(#C1)) {
-      {
-        break #L1;
+    {
+      if(#0#0{dynamic}.>(#C1)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_case_greater_than.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/relational_inside_case_greater_than.dart.weak.transformed.expect
index 5c82863854a..61c62a27cb0 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_case_greater_than.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_case_greater_than.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0{dynamic}.>(#C1)) {
-      {
-        break #L1;
+    {
+      if(#0#0{dynamic}.>(#C1)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_case_greater_than_or_equal.dart.strong.expect b/pkg/front_end/testcases/patterns/relational_inside_case_greater_than_or_equal.dart.strong.expect
index 3649e2c1540..320e77f6a64 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_case_greater_than_or_equal.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_case_greater_than_or_equal.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0{dynamic}.>=(#C1)) {
-      {
-        break #L1;
+    {
+      if(#0#0{dynamic}.>=(#C1)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_case_greater_than_or_equal.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/relational_inside_case_greater_than_or_equal.dart.strong.transformed.expect
index 3649e2c1540..320e77f6a64 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_case_greater_than_or_equal.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_case_greater_than_or_equal.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0{dynamic}.>=(#C1)) {
-      {
-        break #L1;
+    {
+      if(#0#0{dynamic}.>=(#C1)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_case_greater_than_or_equal.dart.weak.expect b/pkg/front_end/testcases/patterns/relational_inside_case_greater_than_or_equal.dart.weak.expect
index 3649e2c1540..320e77f6a64 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_case_greater_than_or_equal.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_case_greater_than_or_equal.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0{dynamic}.>=(#C1)) {
-      {
-        break #L1;
+    {
+      if(#0#0{dynamic}.>=(#C1)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_case_greater_than_or_equal.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/relational_inside_case_greater_than_or_equal.dart.weak.modular.expect
index 3649e2c1540..320e77f6a64 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_case_greater_than_or_equal.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_case_greater_than_or_equal.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0{dynamic}.>=(#C1)) {
-      {
-        break #L1;
+    {
+      if(#0#0{dynamic}.>=(#C1)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_case_greater_than_or_equal.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/relational_inside_case_greater_than_or_equal.dart.weak.transformed.expect
index 3649e2c1540..320e77f6a64 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_case_greater_than_or_equal.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_case_greater_than_or_equal.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0{dynamic}.>=(#C1)) {
-      {
-        break #L1;
+    {
+      if(#0#0{dynamic}.>=(#C1)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_case_less_than.dart.strong.expect b/pkg/front_end/testcases/patterns/relational_inside_case_less_than.dart.strong.expect
index bceaafe5719..b9a7dde836f 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_case_less_than.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_case_less_than.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0{dynamic}.<(#C1)) {
-      {
-        break #L1;
+    {
+      if(#0#0{dynamic}.<(#C1)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_case_less_than.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/relational_inside_case_less_than.dart.strong.transformed.expect
index bceaafe5719..b9a7dde836f 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_case_less_than.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_case_less_than.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0{dynamic}.<(#C1)) {
-      {
-        break #L1;
+    {
+      if(#0#0{dynamic}.<(#C1)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_case_less_than.dart.weak.expect b/pkg/front_end/testcases/patterns/relational_inside_case_less_than.dart.weak.expect
index bceaafe5719..b9a7dde836f 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_case_less_than.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_case_less_than.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0{dynamic}.<(#C1)) {
-      {
-        break #L1;
+    {
+      if(#0#0{dynamic}.<(#C1)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_case_less_than.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/relational_inside_case_less_than.dart.weak.modular.expect
index bceaafe5719..b9a7dde836f 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_case_less_than.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_case_less_than.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0{dynamic}.<(#C1)) {
-      {
-        break #L1;
+    {
+      if(#0#0{dynamic}.<(#C1)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_case_less_than.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/relational_inside_case_less_than.dart.weak.transformed.expect
index bceaafe5719..b9a7dde836f 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_case_less_than.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_case_less_than.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0{dynamic}.<(#C1)) {
-      {
-        break #L1;
+    {
+      if(#0#0{dynamic}.<(#C1)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_case_less_than_or_equal.dart.strong.expect b/pkg/front_end/testcases/patterns/relational_inside_case_less_than_or_equal.dart.strong.expect
index 26dc76c4ab7..5952133460d 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_case_less_than_or_equal.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_case_less_than_or_equal.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0{dynamic}.<=(#C1)) {
-      {
-        break #L1;
+    {
+      if(#0#0{dynamic}.<=(#C1)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_case_less_than_or_equal.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/relational_inside_case_less_than_or_equal.dart.strong.transformed.expect
index 26dc76c4ab7..5952133460d 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_case_less_than_or_equal.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_case_less_than_or_equal.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0{dynamic}.<=(#C1)) {
-      {
-        break #L1;
+    {
+      if(#0#0{dynamic}.<=(#C1)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_case_less_than_or_equal.dart.weak.expect b/pkg/front_end/testcases/patterns/relational_inside_case_less_than_or_equal.dart.weak.expect
index 26dc76c4ab7..5952133460d 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_case_less_than_or_equal.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_case_less_than_or_equal.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0{dynamic}.<=(#C1)) {
-      {
-        break #L1;
+    {
+      if(#0#0{dynamic}.<=(#C1)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_case_less_than_or_equal.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/relational_inside_case_less_than_or_equal.dart.weak.modular.expect
index 26dc76c4ab7..5952133460d 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_case_less_than_or_equal.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_case_less_than_or_equal.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0{dynamic}.<=(#C1)) {
-      {
-        break #L1;
+    {
+      if(#0#0{dynamic}.<=(#C1)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_case_less_than_or_equal.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/relational_inside_case_less_than_or_equal.dart.weak.transformed.expect
index 26dc76c4ab7..5952133460d 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_case_less_than_or_equal.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_case_less_than_or_equal.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0{dynamic}.<=(#C1)) {
-      {
-        break #L1;
+    {
+      if(#0#0{dynamic}.<=(#C1)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_case_not_equal.dart.strong.expect b/pkg/front_end/testcases/patterns/relational_inside_case_not_equal.dart.strong.expect
index fc82e66e569..59f1a99d0bc 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_case_not_equal.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_case_not_equal.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1)) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_case_not_equal.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/relational_inside_case_not_equal.dart.strong.transformed.expect
index fc82e66e569..59f1a99d0bc 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_case_not_equal.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_case_not_equal.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1)) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_case_not_equal.dart.weak.expect b/pkg/front_end/testcases/patterns/relational_inside_case_not_equal.dart.weak.expect
index fc82e66e569..59f1a99d0bc 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_case_not_equal.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_case_not_equal.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1)) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_case_not_equal.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/relational_inside_case_not_equal.dart.weak.modular.expect
index fc82e66e569..59f1a99d0bc 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_case_not_equal.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_case_not_equal.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1)) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_case_not_equal.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/relational_inside_case_not_equal.dart.weak.transformed.expect
index fc82e66e569..59f1a99d0bc 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_case_not_equal.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_case_not_equal.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1)) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_extractor_pattern.dart.strong.expect b/pkg/front_end/testcases/patterns/relational_inside_extractor_pattern.dart.strong.expect
index ec6b90d833d..aee0b5596c7 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_extractor_pattern.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_extractor_pattern.dart.strong.expect
@@ -12,9 +12,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} self::C && #0#0{self::C}.{self::C::f}{core::int?} =={core::num::==}{(core::Object) → core::bool} #C1) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::C && #0#0{self::C}.{self::C::f}{core::int?} =={core::num::==}{(core::Object) → core::bool} #C1) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_extractor_pattern.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/relational_inside_extractor_pattern.dart.strong.transformed.expect
index ec6b90d833d..aee0b5596c7 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_extractor_pattern.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_extractor_pattern.dart.strong.transformed.expect
@@ -12,9 +12,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} self::C && #0#0{self::C}.{self::C::f}{core::int?} =={core::num::==}{(core::Object) → core::bool} #C1) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::C && #0#0{self::C}.{self::C::f}{core::int?} =={core::num::==}{(core::Object) → core::bool} #C1) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_extractor_pattern.dart.weak.expect b/pkg/front_end/testcases/patterns/relational_inside_extractor_pattern.dart.weak.expect
index ec6b90d833d..aee0b5596c7 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_extractor_pattern.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_extractor_pattern.dart.weak.expect
@@ -12,9 +12,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} self::C && #0#0{self::C}.{self::C::f}{core::int?} =={core::num::==}{(core::Object) → core::bool} #C1) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::C && #0#0{self::C}.{self::C::f}{core::int?} =={core::num::==}{(core::Object) → core::bool} #C1) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_extractor_pattern.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/relational_inside_extractor_pattern.dart.weak.modular.expect
index ec6b90d833d..aee0b5596c7 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_extractor_pattern.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_extractor_pattern.dart.weak.modular.expect
@@ -12,9 +12,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} self::C && #0#0{self::C}.{self::C::f}{core::int?} =={core::num::==}{(core::Object) → core::bool} #C1) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::C && #0#0{self::C}.{self::C::f}{core::int?} =={core::num::==}{(core::Object) → core::bool} #C1) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_extractor_pattern.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/relational_inside_extractor_pattern.dart.weak.transformed.expect
index ec6b90d833d..aee0b5596c7 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_extractor_pattern.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_extractor_pattern.dart.weak.transformed.expect
@@ -12,9 +12,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} self::C && #0#0{self::C}.{self::C::f}{core::int?} =={core::num::==}{(core::Object) → core::bool} #C1) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::C && #0#0{self::C}.{self::C::f}{core::int?} =={core::num::==}{(core::Object) → core::bool} #C1) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_list_pattern.dart.strong.expect b/pkg/front_end/testcases/patterns/relational_inside_list_pattern.dart.strong.expect
index df258581c39..7876b736420 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_list_pattern.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_list_pattern.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} =={core::Object::==}{(core::Object) → core::bool} #C1) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} =={core::Object::==}{(core::Object) → core::bool} #C1) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_list_pattern.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/relational_inside_list_pattern.dart.strong.transformed.expect
index df258581c39..7876b736420 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_list_pattern.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_list_pattern.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} =={core::Object::==}{(core::Object) → core::bool} #C1) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} =={core::Object::==}{(core::Object) → core::bool} #C1) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_list_pattern.dart.weak.expect b/pkg/front_end/testcases/patterns/relational_inside_list_pattern.dart.weak.expect
index df258581c39..7876b736420 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_list_pattern.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_list_pattern.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} =={core::Object::==}{(core::Object) → core::bool} #C1) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} =={core::Object::==}{(core::Object) → core::bool} #C1) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_list_pattern.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/relational_inside_list_pattern.dart.weak.modular.expect
index df258581c39..7876b736420 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_list_pattern.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_list_pattern.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} =={core::Object::==}{(core::Object) → core::bool} #C1) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} =={core::Object::==}{(core::Object) → core::bool} #C1) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_list_pattern.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/relational_inside_list_pattern.dart.weak.transformed.expect
index df258581c39..7876b736420 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_list_pattern.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_list_pattern.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} =={core::Object::==}{(core::Object) → core::bool} #C1) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} =={core::Object::==}{(core::Object) → core::bool} #C1) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_logical_and_lhs.dart.strong.expect b/pkg/front_end/testcases/patterns/relational_inside_logical_and_lhs.dart.strong.expect
index 61c7df5e8c4..099ea366cca 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_logical_and_lhs.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_logical_and_lhs.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        break #L1;
+    {
+      if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_logical_and_lhs.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/relational_inside_logical_and_lhs.dart.strong.transformed.expect
index 61c7df5e8c4..099ea366cca 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_logical_and_lhs.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_logical_and_lhs.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        break #L1;
+    {
+      if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_logical_and_lhs.dart.weak.expect b/pkg/front_end/testcases/patterns/relational_inside_logical_and_lhs.dart.weak.expect
index 61c7df5e8c4..099ea366cca 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_logical_and_lhs.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_logical_and_lhs.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        break #L1;
+    {
+      if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_logical_and_lhs.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/relational_inside_logical_and_lhs.dart.weak.modular.expect
index 61c7df5e8c4..099ea366cca 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_logical_and_lhs.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_logical_and_lhs.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        break #L1;
+    {
+      if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_logical_and_lhs.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/relational_inside_logical_and_lhs.dart.weak.transformed.expect
index 61c7df5e8c4..099ea366cca 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_logical_and_lhs.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_logical_and_lhs.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        break #L1;
+    {
+      if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_logical_and_rhs.dart.strong.expect b/pkg/front_end/testcases/patterns/relational_inside_logical_and_rhs.dart.strong.expect
index f6c8b9dc37b..0a87e434d52 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_logical_and_rhs.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_logical_and_rhs.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && #0#0 =={core::Object::==}{(core::Object) → core::bool} #C2) {
-      {
-        break #L1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && #0#0 =={core::Object::==}{(core::Object) → core::bool} #C2) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_logical_and_rhs.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/relational_inside_logical_and_rhs.dart.strong.transformed.expect
index f6c8b9dc37b..0a87e434d52 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_logical_and_rhs.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_logical_and_rhs.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && #0#0 =={core::Object::==}{(core::Object) → core::bool} #C2) {
-      {
-        break #L1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && #0#0 =={core::Object::==}{(core::Object) → core::bool} #C2) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_logical_and_rhs.dart.weak.expect b/pkg/front_end/testcases/patterns/relational_inside_logical_and_rhs.dart.weak.expect
index f6c8b9dc37b..0a87e434d52 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_logical_and_rhs.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_logical_and_rhs.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && #0#0 =={core::Object::==}{(core::Object) → core::bool} #C2) {
-      {
-        break #L1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && #0#0 =={core::Object::==}{(core::Object) → core::bool} #C2) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_logical_and_rhs.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/relational_inside_logical_and_rhs.dart.weak.modular.expect
index f6c8b9dc37b..0a87e434d52 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_logical_and_rhs.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_logical_and_rhs.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && #0#0 =={core::Object::==}{(core::Object) → core::bool} #C2) {
-      {
-        break #L1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && #0#0 =={core::Object::==}{(core::Object) → core::bool} #C2) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_logical_and_rhs.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/relational_inside_logical_and_rhs.dart.weak.transformed.expect
index f6c8b9dc37b..0a87e434d52 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_logical_and_rhs.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_logical_and_rhs.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && #0#0 =={core::Object::==}{(core::Object) → core::bool} #C2) {
-      {
-        break #L1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && #0#0 =={core::Object::==}{(core::Object) → core::bool} #C2) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_logical_or_lhs.dart.strong.expect b/pkg/front_end/testcases/patterns/relational_inside_logical_or_lhs.dart.strong.expect
index 1b4e9c5df6c..41c5dfbc37b 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_logical_or_lhs.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_logical_or_lhs.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1 || #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        break #L1;
+    {
+      if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1 || #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_logical_or_lhs.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/relational_inside_logical_or_lhs.dart.strong.transformed.expect
index 1b4e9c5df6c..41c5dfbc37b 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_logical_or_lhs.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_logical_or_lhs.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1 || #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        break #L1;
+    {
+      if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1 || #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_logical_or_lhs.dart.weak.expect b/pkg/front_end/testcases/patterns/relational_inside_logical_or_lhs.dart.weak.expect
index 1b4e9c5df6c..41c5dfbc37b 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_logical_or_lhs.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_logical_or_lhs.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1 || #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        break #L1;
+    {
+      if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1 || #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_logical_or_lhs.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/relational_inside_logical_or_lhs.dart.weak.modular.expect
index 1b4e9c5df6c..41c5dfbc37b 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_logical_or_lhs.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_logical_or_lhs.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1 || #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        break #L1;
+    {
+      if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1 || #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_logical_or_lhs.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/relational_inside_logical_or_lhs.dart.weak.transformed.expect
index 1b4e9c5df6c..41c5dfbc37b 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_logical_or_lhs.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_logical_or_lhs.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1 || #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        break #L1;
+    {
+      if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1 || #C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_logical_or_rhs.dart.strong.expect b/pkg/front_end/testcases/patterns/relational_inside_logical_or_rhs.dart.strong.expect
index a144897429f..3f229f34e3c 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_logical_or_rhs.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_logical_or_rhs.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || #0#0 =={core::Object::==}{(core::Object) → core::bool} #C2) {
-      {
-        break #L1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || #0#0 =={core::Object::==}{(core::Object) → core::bool} #C2) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_logical_or_rhs.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/relational_inside_logical_or_rhs.dart.strong.transformed.expect
index a144897429f..3f229f34e3c 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_logical_or_rhs.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_logical_or_rhs.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || #0#0 =={core::Object::==}{(core::Object) → core::bool} #C2) {
-      {
-        break #L1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || #0#0 =={core::Object::==}{(core::Object) → core::bool} #C2) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_logical_or_rhs.dart.weak.expect b/pkg/front_end/testcases/patterns/relational_inside_logical_or_rhs.dart.weak.expect
index a144897429f..3f229f34e3c 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_logical_or_rhs.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_logical_or_rhs.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || #0#0 =={core::Object::==}{(core::Object) → core::bool} #C2) {
-      {
-        break #L1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || #0#0 =={core::Object::==}{(core::Object) → core::bool} #C2) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_logical_or_rhs.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/relational_inside_logical_or_rhs.dart.weak.modular.expect
index a144897429f..3f229f34e3c 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_logical_or_rhs.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_logical_or_rhs.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || #0#0 =={core::Object::==}{(core::Object) → core::bool} #C2) {
-      {
-        break #L1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || #0#0 =={core::Object::==}{(core::Object) → core::bool} #C2) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_logical_or_rhs.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/relational_inside_logical_or_rhs.dart.weak.transformed.expect
index a144897429f..3f229f34e3c 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_logical_or_rhs.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_logical_or_rhs.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || #0#0 =={core::Object::==}{(core::Object) → core::bool} #C2) {
-      {
-        break #L1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || #0#0 =={core::Object::==}{(core::Object) → core::bool} #C2) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_map_pattern.dart.strong.expect b/pkg/front_end/testcases/patterns/relational_inside_map_pattern.dart.strong.expect
index ef6b8287242..62964f764b2 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_map_pattern.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_map_pattern.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic} =={core::Object::==}{(core::Object) → core::bool} #C1) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic} =={core::Object::==}{(core::Object) → core::bool} #C1) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_map_pattern.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/relational_inside_map_pattern.dart.strong.transformed.expect
index ef6b8287242..62964f764b2 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_map_pattern.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_map_pattern.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic} =={core::Object::==}{(core::Object) → core::bool} #C1) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic} =={core::Object::==}{(core::Object) → core::bool} #C1) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_map_pattern.dart.weak.expect b/pkg/front_end/testcases/patterns/relational_inside_map_pattern.dart.weak.expect
index ef6b8287242..62964f764b2 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_map_pattern.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_map_pattern.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic} =={core::Object::==}{(core::Object) → core::bool} #C1) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic} =={core::Object::==}{(core::Object) → core::bool} #C1) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_map_pattern.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/relational_inside_map_pattern.dart.weak.modular.expect
index ef6b8287242..62964f764b2 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_map_pattern.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_map_pattern.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic} =={core::Object::==}{(core::Object) → core::bool} #C1) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic} =={core::Object::==}{(core::Object) → core::bool} #C1) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_map_pattern.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/relational_inside_map_pattern.dart.weak.transformed.expect
index ef6b8287242..62964f764b2 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_map_pattern.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_map_pattern.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic} =={core::Object::==}{(core::Object) → core::bool} #C1) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C2){(core::Object?) → core::bool} && #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C2){(core::Object?) → dynamic} =={core::Object::==}{(core::Object) → core::bool} #C1) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_parenthesized_pattern.dart.strong.expect b/pkg/front_end/testcases/patterns/relational_inside_parenthesized_pattern.dart.strong.expect
index effba3f6355..55b662af64c 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_parenthesized_pattern.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_parenthesized_pattern.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1) {
-      {
-        break #L1;
+    {
+      if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_parenthesized_pattern.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/relational_inside_parenthesized_pattern.dart.strong.transformed.expect
index effba3f6355..55b662af64c 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_parenthesized_pattern.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_parenthesized_pattern.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1) {
-      {
-        break #L1;
+    {
+      if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_parenthesized_pattern.dart.weak.expect b/pkg/front_end/testcases/patterns/relational_inside_parenthesized_pattern.dart.weak.expect
index effba3f6355..55b662af64c 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_parenthesized_pattern.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_parenthesized_pattern.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1) {
-      {
-        break #L1;
+    {
+      if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_parenthesized_pattern.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/relational_inside_parenthesized_pattern.dart.weak.modular.expect
index effba3f6355..55b662af64c 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_parenthesized_pattern.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_parenthesized_pattern.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1) {
-      {
-        break #L1;
+    {
+      if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_parenthesized_pattern.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/relational_inside_parenthesized_pattern.dart.weak.transformed.expect
index effba3f6355..55b662af64c 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_parenthesized_pattern.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_parenthesized_pattern.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1) {
-      {
-        break #L1;
+    {
+      if(#0#0 =={core::Object::==}{(core::Object) → core::bool} #C1) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_record_pattern_named.dart.strong.expect b/pkg/front_end/testcases/patterns/relational_inside_record_pattern_named.dart.strong.expect
index 0212d47c8c5..aed8e2b210e 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_record_pattern_named.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_record_pattern_named.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && #0#0{(core::Object?, {n: core::Object?})}.n{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && #0#0{(core::Object?, {n: core::Object?})}.n{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_record_pattern_named.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/relational_inside_record_pattern_named.dart.strong.transformed.expect
index 0212d47c8c5..aed8e2b210e 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_record_pattern_named.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_record_pattern_named.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && #0#0{(core::Object?, {n: core::Object?})}.n{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && #0#0{(core::Object?, {n: core::Object?})}.n{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_record_pattern_named.dart.weak.expect b/pkg/front_end/testcases/patterns/relational_inside_record_pattern_named.dart.weak.expect
index 0212d47c8c5..aed8e2b210e 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_record_pattern_named.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_record_pattern_named.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && #0#0{(core::Object?, {n: core::Object?})}.n{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && #0#0{(core::Object?, {n: core::Object?})}.n{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_record_pattern_named.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/relational_inside_record_pattern_named.dart.weak.modular.expect
index 0212d47c8c5..aed8e2b210e 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_record_pattern_named.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_record_pattern_named.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && #0#0{(core::Object?, {n: core::Object?})}.n{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && #0#0{(core::Object?, {n: core::Object?})}.n{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_record_pattern_named.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/relational_inside_record_pattern_named.dart.weak.transformed.expect
index 0212d47c8c5..aed8e2b210e 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_record_pattern_named.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_record_pattern_named.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && #0#0{(core::Object?, {n: core::Object?})}.n{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && #0#0{(core::Object?, {n: core::Object?})}.n{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_record_pattern_unnamed.dart.strong.expect b/pkg/front_end/testcases/patterns/relational_inside_record_pattern_unnamed.dart.strong.expect
index 5f4123a39ee..39dccd9e971 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_record_pattern_unnamed.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_record_pattern_unnamed.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #0#0{(core::Object?, core::Object?)}.$1{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #0#0{(core::Object?, core::Object?)}.$1{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_record_pattern_unnamed.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/relational_inside_record_pattern_unnamed.dart.strong.transformed.expect
index 5f4123a39ee..39dccd9e971 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_record_pattern_unnamed.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_record_pattern_unnamed.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #0#0{(core::Object?, core::Object?)}.$1{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #0#0{(core::Object?, core::Object?)}.$1{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_record_pattern_unnamed.dart.weak.expect b/pkg/front_end/testcases/patterns/relational_inside_record_pattern_unnamed.dart.weak.expect
index 5f4123a39ee..39dccd9e971 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_record_pattern_unnamed.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_record_pattern_unnamed.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #0#0{(core::Object?, core::Object?)}.$1{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #0#0{(core::Object?, core::Object?)}.$1{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_record_pattern_unnamed.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/relational_inside_record_pattern_unnamed.dart.weak.modular.expect
index 5f4123a39ee..39dccd9e971 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_record_pattern_unnamed.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_record_pattern_unnamed.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #0#0{(core::Object?, core::Object?)}.$1{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #0#0{(core::Object?, core::Object?)}.$1{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/relational_inside_record_pattern_unnamed.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/relational_inside_record_pattern_unnamed.dart.weak.transformed.expect
index 5f4123a39ee..39dccd9e971 100644
--- a/pkg/front_end/testcases/patterns/relational_inside_record_pattern_unnamed.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/relational_inside_record_pattern_unnamed.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #0#0{(core::Object?, core::Object?)}.$1{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
-      {
-        break #L1;
+    {
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && #0#0{(core::Object?, core::Object?)}.$1{core::Object?} =={core::Object::==}{(core::Object) → core::bool} #C1 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/rest_pattern_with_subpattern.dart.strong.expect b/pkg/front_end/testcases/patterns/rest_pattern_with_subpattern.dart.strong.expect
index 3c508583f6b..561929fcee7 100644
--- a/pkg/front_end/testcases/patterns/rest_pattern_with_subpattern.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/rest_pattern_with_subpattern.dart.strong.expect
@@ -5,10 +5,6 @@ import "dart:core" as core;
 static method test(dynamic o, [dynamic expectedRest = #C1]) → dynamic {
   #L1:
   {
-    core::List<dynamic> rest;
-    core::List<dynamic> rest#1;
-    core::List<dynamic> rest#2;
-    core::List<dynamic> rest#3;
     final synthesized dynamic #0#0 = o;
     late final synthesized core::int #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int};
     late final synthesized core::bool #0#4 = #0#2.{core::num::>=}(#C2){(core::num) → core::bool};
@@ -20,45 +16,56 @@ static method test(dynamic o, [dynamic expectedRest = #C1]) → dynamic {
     late final synthesized core::bool #0#24 = #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<dynamic>}.{core::List::[]}(#0#2.{core::num::-}(2){(core::num) → core::int}){(core::int) → dynamic};
     late final synthesized core::bool #0#26 = #C5 =={core::num::==}{(core::Object) → core::bool} #0#12;
     late final synthesized core::int #0#29 = #0#22.{core::List::length}{core::int};
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && #0#8 && #C6 =={core::num::==}{(core::Object) → core::bool} #0#9) {
-      {
-        return 0;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && #0#8 && #C6 =={core::num::==}{(core::Object) → core::bool} #0#9) {
+        {
+          return 0;
+        }
       }
     }
-    else
+    {
       if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && #0#8 && #C6 =={core::num::==}{(core::Object) → core::bool} #0#12) {
         {
           return 1;
         }
       }
-      else
-        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && #0#8 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#9 && (let final dynamic #t1 = rest = #0#0{core::List<dynamic>}.{core::List::sublist}(2){(core::int, [core::int?]) → core::List<dynamic>} in true)) {
-          {
-            self::expect(expectedRest, rest);
-            return 2;
-          }
+    }
+    {
+      core::List<dynamic> rest;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && #0#8 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#9 && (let final dynamic #t1 = rest = #0#0{core::List<dynamic>}.{core::List::sublist}(2){(core::int, [core::int?]) → core::List<dynamic>} in true)) {
+        {
+          self::expect(expectedRest, rest);
+          return 2;
         }
-        else
-          if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && #0#8 && (let final dynamic #t2 = rest#1 = #0#0{core::List<dynamic>}.{core::List::sublist}(1, #0#2.{core::num::-}(1){(core::num) → core::int}){(core::int, [core::int?]) → core::List<dynamic>} in true) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#12) {
-            {
-              self::expect(expectedRest, rest#1);
-              return 3;
-            }
-          }
-          else
-            if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#19 && #0#8 && #C4 =={core::num::==}{(core::Object) → core::bool} #0#9 && (let final dynamic #t3 = rest#2 = #0#22 in true) && #0#24 && #0#26) {
-              {
-                self::expect(expectedRest, rest#2);
-                return 4;
-              }
-            }
-            else
-              if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#19 && #0#8 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#9 && (#0#29.{core::num::>=}(#C2){(core::num) → core::bool} && #C6 =={core::num::==}{(core::Object) → core::bool} #0#22.{core::List::[]}(0){(core::int) → dynamic} && (let final dynamic #t4 = rest#3 = #0#22.{core::List::sublist}(1, #0#29.{core::num::-}(1){(core::num) → core::int}){(core::int, [core::int?]) → core::List<dynamic>} in true) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#22.{core::List::[]}(#0#29.{core::num::-}(1){(core::num) → core::int}){(core::int) → dynamic}) && #0#24 && #0#26) {
-                {
-                  self::expect(expectedRest, rest#3);
-                  return 5;
-                }
-              }
+      }
+    }
+    {
+      core::List<dynamic> rest;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && #0#8 && (let final dynamic #t2 = rest = #0#0{core::List<dynamic>}.{core::List::sublist}(1, #0#2.{core::num::-}(1){(core::num) → core::int}){(core::int, [core::int?]) → core::List<dynamic>} in true) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#12) {
+        {
+          self::expect(expectedRest, rest);
+          return 3;
+        }
+      }
+    }
+    {
+      core::List<dynamic> rest;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#19 && #0#8 && #C4 =={core::num::==}{(core::Object) → core::bool} #0#9 && (let final dynamic #t3 = rest = #0#22 in true) && #0#24 && #0#26) {
+        {
+          self::expect(expectedRest, rest);
+          return 4;
+        }
+      }
+    }
+    {
+      core::List<dynamic> rest;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#19 && #0#8 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#9 && (#0#29.{core::num::>=}(#C2){(core::num) → core::bool} && #C6 =={core::num::==}{(core::Object) → core::bool} #0#22.{core::List::[]}(0){(core::int) → dynamic} && (let final dynamic #t4 = rest = #0#22.{core::List::sublist}(1, #0#29.{core::num::-}(1){(core::num) → core::int}){(core::int, [core::int?]) → core::List<dynamic>} in true) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#22.{core::List::[]}(#0#29.{core::num::-}(1){(core::num) → core::int}){(core::int) → dynamic}) && #0#24 && #0#26) {
+        {
+          self::expect(expectedRest, rest);
+          return 5;
+        }
+      }
+    }
   }
 }
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/patterns/rest_pattern_with_subpattern.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/rest_pattern_with_subpattern.dart.strong.transformed.expect
index 5a86c0006f9..b1fbe2b8260 100644
--- a/pkg/front_end/testcases/patterns/rest_pattern_with_subpattern.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/rest_pattern_with_subpattern.dart.strong.transformed.expect
@@ -5,10 +5,6 @@ import "dart:core" as core;
 static method test(dynamic o, [dynamic expectedRest = #C1]) → dynamic {
   #L1:
   {
-    core::List<dynamic> rest;
-    core::List<dynamic> rest#1;
-    core::List<dynamic> rest#2;
-    core::List<dynamic> rest#3;
     final synthesized dynamic #0#0 = o;
     function ##0#2#initializer() → core::int
       return #0#0{core::List<dynamic>}.{core::List::length}{core::int};
@@ -40,45 +36,56 @@ static method test(dynamic o, [dynamic expectedRest = #C1]) → dynamic {
     function ##0#29#initializer() → core::int
       return #0#22.{core::List::length}{core::int};
     late final synthesized core::int #0#29 = ##0#29#initializer(){() → core::int};
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && #0#8 && #C6 =={core::num::==}{(core::Object) → core::bool} #0#9) {
-      {
-        return 0;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && #0#8 && #C6 =={core::num::==}{(core::Object) → core::bool} #0#9) {
+        {
+          return 0;
+        }
       }
     }
-    else
+    {
       if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && #0#8 && #C6 =={core::num::==}{(core::Object) → core::bool} #0#12) {
         {
           return 1;
         }
       }
-      else
-        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && #0#8 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#9 && (let final core::List<dynamic> #t1 = rest = #0#0{core::List<dynamic>}.{core::List::sublist}(2){(core::int, [core::int?]) → core::List<dynamic>} in true)) {
-          {
-            self::expect(expectedRest, rest);
-            return 2;
-          }
+    }
+    {
+      core::List<dynamic> rest;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && #0#8 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#9 && (let final core::List<dynamic> #t1 = rest = #0#0{core::List<dynamic>}.{core::List::sublist}(2){(core::int, [core::int?]) → core::List<dynamic>} in true)) {
+        {
+          self::expect(expectedRest, rest);
+          return 2;
         }
-        else
-          if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && #0#8 && (let final core::List<dynamic> #t2 = rest#1 = #0#0{core::List<dynamic>}.{core::List::sublist}(1, #0#2.{core::num::-}(1){(core::num) → core::int}){(core::int, [core::int?]) → core::List<dynamic>} in true) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#12) {
-            {
-              self::expect(expectedRest, rest#1);
-              return 3;
-            }
-          }
-          else
-            if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#19 && #0#8 && #C4 =={core::num::==}{(core::Object) → core::bool} #0#9 && (let final core::List<dynamic> #t3 = rest#2 = #0#22 in true) && #0#24 && #0#26) {
-              {
-                self::expect(expectedRest, rest#2);
-                return 4;
-              }
-            }
-            else
-              if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#19 && #0#8 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#9 && (#0#29.{core::num::>=}(#C2){(core::num) → core::bool} && #C6 =={core::num::==}{(core::Object) → core::bool} #0#22.{core::List::[]}(0){(core::int) → dynamic} && (let final core::List<dynamic> #t4 = rest#3 = #0#22.{core::List::sublist}(1, #0#29.{core::num::-}(1){(core::num) → core::int}){(core::int, [core::int?]) → core::List<dynamic>} in true) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#22.{core::List::[]}(#0#29.{core::num::-}(1){(core::num) → core::int}){(core::int) → dynamic}) && #0#24 && #0#26) {
-                {
-                  self::expect(expectedRest, rest#3);
-                  return 5;
-                }
-              }
+      }
+    }
+    {
+      core::List<dynamic> rest;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && #0#8 && (let final core::List<dynamic> #t2 = rest = #0#0{core::List<dynamic>}.{core::List::sublist}(1, #0#2.{core::num::-}(1){(core::num) → core::int}){(core::int, [core::int?]) → core::List<dynamic>} in true) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#12) {
+        {
+          self::expect(expectedRest, rest);
+          return 3;
+        }
+      }
+    }
+    {
+      core::List<dynamic> rest;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#19 && #0#8 && #C4 =={core::num::==}{(core::Object) → core::bool} #0#9 && (let final core::List<dynamic> #t3 = rest = #0#22 in true) && #0#24 && #0#26) {
+        {
+          self::expect(expectedRest, rest);
+          return 4;
+        }
+      }
+    }
+    {
+      core::List<dynamic> rest;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#19 && #0#8 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#9 && (#0#29.{core::num::>=}(#C2){(core::num) → core::bool} && #C6 =={core::num::==}{(core::Object) → core::bool} #0#22.{core::List::[]}(0){(core::int) → dynamic} && (let final core::List<dynamic> #t4 = rest = #0#22.{core::List::sublist}(1, #0#29.{core::num::-}(1){(core::num) → core::int}){(core::int, [core::int?]) → core::List<dynamic>} in true) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#22.{core::List::[]}(#0#29.{core::num::-}(1){(core::num) → core::int}){(core::int) → dynamic}) && #0#24 && #0#26) {
+        {
+          self::expect(expectedRest, rest);
+          return 5;
+        }
+      }
+    }
   }
 }
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/patterns/rest_pattern_with_subpattern.dart.weak.expect b/pkg/front_end/testcases/patterns/rest_pattern_with_subpattern.dart.weak.expect
index 3c508583f6b..561929fcee7 100644
--- a/pkg/front_end/testcases/patterns/rest_pattern_with_subpattern.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/rest_pattern_with_subpattern.dart.weak.expect
@@ -5,10 +5,6 @@ import "dart:core" as core;
 static method test(dynamic o, [dynamic expectedRest = #C1]) → dynamic {
   #L1:
   {
-    core::List<dynamic> rest;
-    core::List<dynamic> rest#1;
-    core::List<dynamic> rest#2;
-    core::List<dynamic> rest#3;
     final synthesized dynamic #0#0 = o;
     late final synthesized core::int #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int};
     late final synthesized core::bool #0#4 = #0#2.{core::num::>=}(#C2){(core::num) → core::bool};
@@ -20,45 +16,56 @@ static method test(dynamic o, [dynamic expectedRest = #C1]) → dynamic {
     late final synthesized core::bool #0#24 = #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<dynamic>}.{core::List::[]}(#0#2.{core::num::-}(2){(core::num) → core::int}){(core::int) → dynamic};
     late final synthesized core::bool #0#26 = #C5 =={core::num::==}{(core::Object) → core::bool} #0#12;
     late final synthesized core::int #0#29 = #0#22.{core::List::length}{core::int};
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && #0#8 && #C6 =={core::num::==}{(core::Object) → core::bool} #0#9) {
-      {
-        return 0;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && #0#8 && #C6 =={core::num::==}{(core::Object) → core::bool} #0#9) {
+        {
+          return 0;
+        }
       }
     }
-    else
+    {
       if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && #0#8 && #C6 =={core::num::==}{(core::Object) → core::bool} #0#12) {
         {
           return 1;
         }
       }
-      else
-        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && #0#8 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#9 && (let final dynamic #t1 = rest = #0#0{core::List<dynamic>}.{core::List::sublist}(2){(core::int, [core::int?]) → core::List<dynamic>} in true)) {
-          {
-            self::expect(expectedRest, rest);
-            return 2;
-          }
+    }
+    {
+      core::List<dynamic> rest;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && #0#8 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#9 && (let final dynamic #t1 = rest = #0#0{core::List<dynamic>}.{core::List::sublist}(2){(core::int, [core::int?]) → core::List<dynamic>} in true)) {
+        {
+          self::expect(expectedRest, rest);
+          return 2;
         }
-        else
-          if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && #0#8 && (let final dynamic #t2 = rest#1 = #0#0{core::List<dynamic>}.{core::List::sublist}(1, #0#2.{core::num::-}(1){(core::num) → core::int}){(core::int, [core::int?]) → core::List<dynamic>} in true) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#12) {
-            {
-              self::expect(expectedRest, rest#1);
-              return 3;
-            }
-          }
-          else
-            if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#19 && #0#8 && #C4 =={core::num::==}{(core::Object) → core::bool} #0#9 && (let final dynamic #t3 = rest#2 = #0#22 in true) && #0#24 && #0#26) {
-              {
-                self::expect(expectedRest, rest#2);
-                return 4;
-              }
-            }
-            else
-              if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#19 && #0#8 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#9 && (#0#29.{core::num::>=}(#C2){(core::num) → core::bool} && #C6 =={core::num::==}{(core::Object) → core::bool} #0#22.{core::List::[]}(0){(core::int) → dynamic} && (let final dynamic #t4 = rest#3 = #0#22.{core::List::sublist}(1, #0#29.{core::num::-}(1){(core::num) → core::int}){(core::int, [core::int?]) → core::List<dynamic>} in true) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#22.{core::List::[]}(#0#29.{core::num::-}(1){(core::num) → core::int}){(core::int) → dynamic}) && #0#24 && #0#26) {
-                {
-                  self::expect(expectedRest, rest#3);
-                  return 5;
-                }
-              }
+      }
+    }
+    {
+      core::List<dynamic> rest;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && #0#8 && (let final dynamic #t2 = rest = #0#0{core::List<dynamic>}.{core::List::sublist}(1, #0#2.{core::num::-}(1){(core::num) → core::int}){(core::int, [core::int?]) → core::List<dynamic>} in true) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#12) {
+        {
+          self::expect(expectedRest, rest);
+          return 3;
+        }
+      }
+    }
+    {
+      core::List<dynamic> rest;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#19 && #0#8 && #C4 =={core::num::==}{(core::Object) → core::bool} #0#9 && (let final dynamic #t3 = rest = #0#22 in true) && #0#24 && #0#26) {
+        {
+          self::expect(expectedRest, rest);
+          return 4;
+        }
+      }
+    }
+    {
+      core::List<dynamic> rest;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#19 && #0#8 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#9 && (#0#29.{core::num::>=}(#C2){(core::num) → core::bool} && #C6 =={core::num::==}{(core::Object) → core::bool} #0#22.{core::List::[]}(0){(core::int) → dynamic} && (let final dynamic #t4 = rest = #0#22.{core::List::sublist}(1, #0#29.{core::num::-}(1){(core::num) → core::int}){(core::int, [core::int?]) → core::List<dynamic>} in true) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#22.{core::List::[]}(#0#29.{core::num::-}(1){(core::num) → core::int}){(core::int) → dynamic}) && #0#24 && #0#26) {
+        {
+          self::expect(expectedRest, rest);
+          return 5;
+        }
+      }
+    }
   }
 }
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/patterns/rest_pattern_with_subpattern.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/rest_pattern_with_subpattern.dart.weak.modular.expect
index 3c508583f6b..561929fcee7 100644
--- a/pkg/front_end/testcases/patterns/rest_pattern_with_subpattern.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/rest_pattern_with_subpattern.dart.weak.modular.expect
@@ -5,10 +5,6 @@ import "dart:core" as core;
 static method test(dynamic o, [dynamic expectedRest = #C1]) → dynamic {
   #L1:
   {
-    core::List<dynamic> rest;
-    core::List<dynamic> rest#1;
-    core::List<dynamic> rest#2;
-    core::List<dynamic> rest#3;
     final synthesized dynamic #0#0 = o;
     late final synthesized core::int #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int};
     late final synthesized core::bool #0#4 = #0#2.{core::num::>=}(#C2){(core::num) → core::bool};
@@ -20,45 +16,56 @@ static method test(dynamic o, [dynamic expectedRest = #C1]) → dynamic {
     late final synthesized core::bool #0#24 = #C2 =={core::num::==}{(core::Object) → core::bool} #0#0{core::List<dynamic>}.{core::List::[]}(#0#2.{core::num::-}(2){(core::num) → core::int}){(core::int) → dynamic};
     late final synthesized core::bool #0#26 = #C5 =={core::num::==}{(core::Object) → core::bool} #0#12;
     late final synthesized core::int #0#29 = #0#22.{core::List::length}{core::int};
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && #0#8 && #C6 =={core::num::==}{(core::Object) → core::bool} #0#9) {
-      {
-        return 0;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && #0#8 && #C6 =={core::num::==}{(core::Object) → core::bool} #0#9) {
+        {
+          return 0;
+        }
       }
     }
-    else
+    {
       if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && #0#8 && #C6 =={core::num::==}{(core::Object) → core::bool} #0#12) {
         {
           return 1;
         }
       }
-      else
-        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && #0#8 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#9 && (let final dynamic #t1 = rest = #0#0{core::List<dynamic>}.{core::List::sublist}(2){(core::int, [core::int?]) → core::List<dynamic>} in true)) {
-          {
-            self::expect(expectedRest, rest);
-            return 2;
-          }
+    }
+    {
+      core::List<dynamic> rest;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && #0#8 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#9 && (let final dynamic #t1 = rest = #0#0{core::List<dynamic>}.{core::List::sublist}(2){(core::int, [core::int?]) → core::List<dynamic>} in true)) {
+        {
+          self::expect(expectedRest, rest);
+          return 2;
         }
-        else
-          if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && #0#8 && (let final dynamic #t2 = rest#1 = #0#0{core::List<dynamic>}.{core::List::sublist}(1, #0#2.{core::num::-}(1){(core::num) → core::int}){(core::int, [core::int?]) → core::List<dynamic>} in true) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#12) {
-            {
-              self::expect(expectedRest, rest#1);
-              return 3;
-            }
-          }
-          else
-            if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#19 && #0#8 && #C4 =={core::num::==}{(core::Object) → core::bool} #0#9 && (let final dynamic #t3 = rest#2 = #0#22 in true) && #0#24 && #0#26) {
-              {
-                self::expect(expectedRest, rest#2);
-                return 4;
-              }
-            }
-            else
-              if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#19 && #0#8 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#9 && (#0#29.{core::num::>=}(#C2){(core::num) → core::bool} && #C6 =={core::num::==}{(core::Object) → core::bool} #0#22.{core::List::[]}(0){(core::int) → dynamic} && (let final dynamic #t4 = rest#3 = #0#22.{core::List::sublist}(1, #0#29.{core::num::-}(1){(core::num) → core::int}){(core::int, [core::int?]) → core::List<dynamic>} in true) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#22.{core::List::[]}(#0#29.{core::num::-}(1){(core::num) → core::int}){(core::int) → dynamic}) && #0#24 && #0#26) {
-                {
-                  self::expect(expectedRest, rest#3);
-                  return 5;
-                }
-              }
+      }
+    }
+    {
+      core::List<dynamic> rest;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && #0#8 && (let final dynamic #t2 = rest = #0#0{core::List<dynamic>}.{core::List::sublist}(1, #0#2.{core::num::-}(1){(core::num) → core::int}){(core::int, [core::int?]) → core::List<dynamic>} in true) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#12) {
+        {
+          self::expect(expectedRest, rest);
+          return 3;
+        }
+      }
+    }
+    {
+      core::List<dynamic> rest;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#19 && #0#8 && #C4 =={core::num::==}{(core::Object) → core::bool} #0#9 && (let final dynamic #t3 = rest = #0#22 in true) && #0#24 && #0#26) {
+        {
+          self::expect(expectedRest, rest);
+          return 4;
+        }
+      }
+    }
+    {
+      core::List<dynamic> rest;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#19 && #0#8 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#9 && (#0#29.{core::num::>=}(#C2){(core::num) → core::bool} && #C6 =={core::num::==}{(core::Object) → core::bool} #0#22.{core::List::[]}(0){(core::int) → dynamic} && (let final dynamic #t4 = rest = #0#22.{core::List::sublist}(1, #0#29.{core::num::-}(1){(core::num) → core::int}){(core::int, [core::int?]) → core::List<dynamic>} in true) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#22.{core::List::[]}(#0#29.{core::num::-}(1){(core::num) → core::int}){(core::int) → dynamic}) && #0#24 && #0#26) {
+        {
+          self::expect(expectedRest, rest);
+          return 5;
+        }
+      }
+    }
   }
 }
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/patterns/rest_pattern_with_subpattern.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/rest_pattern_with_subpattern.dart.weak.transformed.expect
index 5a86c0006f9..b1fbe2b8260 100644
--- a/pkg/front_end/testcases/patterns/rest_pattern_with_subpattern.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/rest_pattern_with_subpattern.dart.weak.transformed.expect
@@ -5,10 +5,6 @@ import "dart:core" as core;
 static method test(dynamic o, [dynamic expectedRest = #C1]) → dynamic {
   #L1:
   {
-    core::List<dynamic> rest;
-    core::List<dynamic> rest#1;
-    core::List<dynamic> rest#2;
-    core::List<dynamic> rest#3;
     final synthesized dynamic #0#0 = o;
     function ##0#2#initializer() → core::int
       return #0#0{core::List<dynamic>}.{core::List::length}{core::int};
@@ -40,45 +36,56 @@ static method test(dynamic o, [dynamic expectedRest = #C1]) → dynamic {
     function ##0#29#initializer() → core::int
       return #0#22.{core::List::length}{core::int};
     late final synthesized core::int #0#29 = ##0#29#initializer(){() → core::int};
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && #0#8 && #C6 =={core::num::==}{(core::Object) → core::bool} #0#9) {
-      {
-        return 0;
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && #0#8 && #C6 =={core::num::==}{(core::Object) → core::bool} #0#9) {
+        {
+          return 0;
+        }
       }
     }
-    else
+    {
       if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && #0#8 && #C6 =={core::num::==}{(core::Object) → core::bool} #0#12) {
         {
           return 1;
         }
       }
-      else
-        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && #0#8 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#9 && (let final core::List<dynamic> #t1 = rest = #0#0{core::List<dynamic>}.{core::List::sublist}(2){(core::int, [core::int?]) → core::List<dynamic>} in true)) {
-          {
-            self::expect(expectedRest, rest);
-            return 2;
-          }
+    }
+    {
+      core::List<dynamic> rest;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && #0#8 && #C2 =={core::num::==}{(core::Object) → core::bool} #0#9 && (let final core::List<dynamic> #t1 = rest = #0#0{core::List<dynamic>}.{core::List::sublist}(2){(core::int, [core::int?]) → core::List<dynamic>} in true)) {
+        {
+          self::expect(expectedRest, rest);
+          return 2;
         }
-        else
-          if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && #0#8 && (let final core::List<dynamic> #t2 = rest#1 = #0#0{core::List<dynamic>}.{core::List::sublist}(1, #0#2.{core::num::-}(1){(core::num) → core::int}){(core::int, [core::int?]) → core::List<dynamic>} in true) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#12) {
-            {
-              self::expect(expectedRest, rest#1);
-              return 3;
-            }
-          }
-          else
-            if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#19 && #0#8 && #C4 =={core::num::==}{(core::Object) → core::bool} #0#9 && (let final core::List<dynamic> #t3 = rest#2 = #0#22 in true) && #0#24 && #0#26) {
-              {
-                self::expect(expectedRest, rest#2);
-                return 4;
-              }
-            }
-            else
-              if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#19 && #0#8 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#9 && (#0#29.{core::num::>=}(#C2){(core::num) → core::bool} && #C6 =={core::num::==}{(core::Object) → core::bool} #0#22.{core::List::[]}(0){(core::int) → dynamic} && (let final core::List<dynamic> #t4 = rest#3 = #0#22.{core::List::sublist}(1, #0#29.{core::num::-}(1){(core::num) → core::int}){(core::int, [core::int?]) → core::List<dynamic>} in true) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#22.{core::List::[]}(#0#29.{core::num::-}(1){(core::num) → core::int}){(core::int) → dynamic}) && #0#24 && #0#26) {
-                {
-                  self::expect(expectedRest, rest#3);
-                  return 5;
-                }
-              }
+      }
+    }
+    {
+      core::List<dynamic> rest;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && #0#8 && (let final core::List<dynamic> #t2 = rest = #0#0{core::List<dynamic>}.{core::List::sublist}(1, #0#2.{core::num::-}(1){(core::num) → core::int}){(core::int, [core::int?]) → core::List<dynamic>} in true) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#12) {
+        {
+          self::expect(expectedRest, rest);
+          return 3;
+        }
+      }
+    }
+    {
+      core::List<dynamic> rest;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#19 && #0#8 && #C4 =={core::num::==}{(core::Object) → core::bool} #0#9 && (let final core::List<dynamic> #t3 = rest = #0#22 in true) && #0#24 && #0#26) {
+        {
+          self::expect(expectedRest, rest);
+          return 4;
+        }
+      }
+    }
+    {
+      core::List<dynamic> rest;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#19 && #0#8 && #C7 =={core::num::==}{(core::Object) → core::bool} #0#9 && (#0#29.{core::num::>=}(#C2){(core::num) → core::bool} && #C6 =={core::num::==}{(core::Object) → core::bool} #0#22.{core::List::[]}(0){(core::int) → dynamic} && (let final core::List<dynamic> #t4 = rest = #0#22.{core::List::sublist}(1, #0#29.{core::num::-}(1){(core::num) → core::int}){(core::int, [core::int?]) → core::List<dynamic>} in true) && #C2 =={core::num::==}{(core::Object) → core::bool} #0#22.{core::List::[]}(#0#29.{core::num::-}(1){(core::num) → core::int}){(core::int) → dynamic}) && #0#24 && #0#26) {
+        {
+          self::expect(expectedRest, rest);
+          return 5;
+        }
+      }
+    }
   }
 }
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/patterns/shared_errors.dart.strong.expect b/pkg/front_end/testcases/patterns/shared_errors.dart.strong.expect
index 63c00d8af1e..87363061862 100644
--- a/pkg/front_end/testcases/patterns/shared_errors.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/shared_errors.dart.strong.expect
@@ -104,23 +104,27 @@ class Class extends core::Object {
 }
 static method argumentTypeNotAssignable(self::Class cls) → dynamic {
   #L1:
-  if(invalid-expression "pkg/front_end/testcases/patterns/shared_errors.dart:13:13: Error: The argument type 'int' can't be assigned to the parameter type 'Class'.
+  {
+    if(invalid-expression "pkg/front_end/testcases/patterns/shared_errors.dart:13:13: Error: The argument type 'int' can't be assigned to the parameter type 'Class'.
  - 'Class' is from 'pkg/front_end/testcases/patterns/shared_errors.dart'.
     case >= 0: // Error
             ^") {
-    {
-      core::print(0);
+      {
+        core::print(0);
+      }
     }
   }
 }
 static method relationalPatternOperatorReturnTypeNotAssignableToBool(self::Class cls) → dynamic {
   #L2:
-  if(invalid-expression "pkg/front_end/testcases/patterns/shared_errors.dart:20:10: Error: A value of type 'Class' can't be assigned to a variable of type 'bool'.
+  {
+    if(invalid-expression "pkg/front_end/testcases/patterns/shared_errors.dart:20:10: Error: A value of type 'Class' can't be assigned to a variable of type 'bool'.
  - 'Class' is from 'pkg/front_end/testcases/patterns/shared_errors.dart'.
     case > 0: // Error
          ^") {
-    {
-      core::print(0);
+      {
+        core::print(0);
+      }
     }
   }
 }
@@ -149,15 +153,17 @@ static method duplicateRecordPatternField(dynamic o) → dynamic {
   {
     final synthesized dynamic #0#0 = o;
     late final synthesized core::int #0#2 = #0#0{self::Class}.{self::Class::field}{core::int};
-    if(invalid-expression "pkg/front_end/testcases/patterns/shared_errors.dart:36:28: Error: The field 'field' is already matched in this pattern.
+    {
+      if(invalid-expression "pkg/front_end/testcases/patterns/shared_errors.dart:36:28: Error: The field 'field' is already matched in this pattern.
 Try removing the duplicate field.
     case (field: 1, field: 2): // Error
                            ^" || #0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#2 && (let final dynamic #t3 = #0#2 in invalid-expression "pkg/front_end/testcases/patterns/shared_errors.dart:37:33: Error: The field 'field' is already matched in this pattern.
 Try removing the duplicate field.
     case Class(field: 1, field: 2): // Error
                                 ^")) {
-      {
-        core::print(0);
+        {
+          core::print(0);
+        }
       }
     }
   }
@@ -168,10 +174,12 @@ static method duplicateRestPattern(dynamic o) → dynamic {
     final synthesized dynamic #0#0 = o;
     synthesized core::int #0#2;
     synthesized core::bool #0#2#isSet = false;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t4 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}).{core::num::>=}(#C2){(core::num) → core::bool} && (let final dynamic #t5 = #0#0{core::List<dynamic>}.{core::List::[]}((#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t6 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}).{core::num::-}(1){(core::num) → core::int}){(core::int) → dynamic} in invalid-expression "pkg/front_end/testcases/patterns/shared_errors.dart:44:16: Error: At most one rest element is allowed in a list or map pattern.
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t4 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}).{core::num::>=}(#C2){(core::num) → core::bool} && (let final dynamic #t5 = #0#0{core::List<dynamic>}.{core::List::[]}((#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t6 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}).{core::num::-}(1){(core::num) → core::int}){(core::int) → dynamic} in invalid-expression "pkg/front_end/testcases/patterns/shared_errors.dart:44:16: Error: At most one rest element is allowed in a list or map pattern.
 Try removing the duplicate rest element.
     case [..., ...]: // Error
                ^") || #0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t7 = #0#2#isSet = true in #0#2 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C3){(core::num) → core::bool}) {
+      }
     }
   }
 }
diff --git a/pkg/front_end/testcases/patterns/shared_errors.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/shared_errors.dart.strong.transformed.expect
index 95fe00d990a..f98e74b2bc5 100644
--- a/pkg/front_end/testcases/patterns/shared_errors.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/shared_errors.dart.strong.transformed.expect
@@ -104,23 +104,27 @@ class Class extends core::Object {
 }
 static method argumentTypeNotAssignable(self::Class cls) → dynamic {
   #L1:
-  if(invalid-expression "pkg/front_end/testcases/patterns/shared_errors.dart:13:13: Error: The argument type 'int' can't be assigned to the parameter type 'Class'.
+  {
+    if(invalid-expression "pkg/front_end/testcases/patterns/shared_errors.dart:13:13: Error: The argument type 'int' can't be assigned to the parameter type 'Class'.
  - 'Class' is from 'pkg/front_end/testcases/patterns/shared_errors.dart'.
     case >= 0: // Error
             ^") {
-    {
-      core::print(0);
+      {
+        core::print(0);
+      }
     }
   }
 }
 static method relationalPatternOperatorReturnTypeNotAssignableToBool(self::Class cls) → dynamic {
   #L2:
-  if(invalid-expression "pkg/front_end/testcases/patterns/shared_errors.dart:20:10: Error: A value of type 'Class' can't be assigned to a variable of type 'bool'.
+  {
+    if(invalid-expression "pkg/front_end/testcases/patterns/shared_errors.dart:20:10: Error: A value of type 'Class' can't be assigned to a variable of type 'bool'.
  - 'Class' is from 'pkg/front_end/testcases/patterns/shared_errors.dart'.
     case > 0: // Error
          ^") {
-    {
-      core::print(0);
+      {
+        core::print(0);
+      }
     }
   }
 }
@@ -151,15 +155,17 @@ static method duplicateRecordPatternField(dynamic o) → dynamic {
     function ##0#2#initializer() → core::int
       return #0#0{self::Class}.{self::Class::field}{core::int};
     late final synthesized core::int #0#2 = ##0#2#initializer(){() → core::int};
-    if(invalid-expression "pkg/front_end/testcases/patterns/shared_errors.dart:36:28: Error: The field 'field' is already matched in this pattern.
+    {
+      if(invalid-expression "pkg/front_end/testcases/patterns/shared_errors.dart:36:28: Error: The field 'field' is already matched in this pattern.
 Try removing the duplicate field.
     case (field: 1, field: 2): // Error
                            ^" || #0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#2 && (let final core::int #t3 = #0#2 in invalid-expression "pkg/front_end/testcases/patterns/shared_errors.dart:37:33: Error: The field 'field' is already matched in this pattern.
 Try removing the duplicate field.
     case Class(field: 1, field: 2): // Error
                                 ^")) {
-      {
-        core::print(0);
+        {
+          core::print(0);
+        }
       }
     }
   }
@@ -170,10 +176,12 @@ static method duplicateRestPattern(dynamic o) → dynamic {
     final synthesized dynamic #0#0 = o;
     synthesized core::int #0#2;
     synthesized core::bool #0#2#isSet = false;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t4 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}).{core::num::>=}(#C2){(core::num) → core::bool} && (let final dynamic #t5 = #0#0{core::List<dynamic>}.{core::List::[]}((#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t6 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}).{core::num::-}(1){(core::num) → core::int}){(core::int) → dynamic} in invalid-expression "pkg/front_end/testcases/patterns/shared_errors.dart:44:16: Error: At most one rest element is allowed in a list or map pattern.
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t4 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}).{core::num::>=}(#C2){(core::num) → core::bool} && (let final dynamic #t5 = #0#0{core::List<dynamic>}.{core::List::[]}((#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t6 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}).{core::num::-}(1){(core::num) → core::int}){(core::int) → dynamic} in invalid-expression "pkg/front_end/testcases/patterns/shared_errors.dart:44:16: Error: At most one rest element is allowed in a list or map pattern.
 Try removing the duplicate rest element.
     case [..., ...]: // Error
                ^") || #0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t7 = #0#2#isSet = true in #0#2 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C3){(core::num) → core::bool}) {
+      }
     }
   }
 }
diff --git a/pkg/front_end/testcases/patterns/shared_errors.dart.weak.expect b/pkg/front_end/testcases/patterns/shared_errors.dart.weak.expect
index 63c00d8af1e..87363061862 100644
--- a/pkg/front_end/testcases/patterns/shared_errors.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/shared_errors.dart.weak.expect
@@ -104,23 +104,27 @@ class Class extends core::Object {
 }
 static method argumentTypeNotAssignable(self::Class cls) → dynamic {
   #L1:
-  if(invalid-expression "pkg/front_end/testcases/patterns/shared_errors.dart:13:13: Error: The argument type 'int' can't be assigned to the parameter type 'Class'.
+  {
+    if(invalid-expression "pkg/front_end/testcases/patterns/shared_errors.dart:13:13: Error: The argument type 'int' can't be assigned to the parameter type 'Class'.
  - 'Class' is from 'pkg/front_end/testcases/patterns/shared_errors.dart'.
     case >= 0: // Error
             ^") {
-    {
-      core::print(0);
+      {
+        core::print(0);
+      }
     }
   }
 }
 static method relationalPatternOperatorReturnTypeNotAssignableToBool(self::Class cls) → dynamic {
   #L2:
-  if(invalid-expression "pkg/front_end/testcases/patterns/shared_errors.dart:20:10: Error: A value of type 'Class' can't be assigned to a variable of type 'bool'.
+  {
+    if(invalid-expression "pkg/front_end/testcases/patterns/shared_errors.dart:20:10: Error: A value of type 'Class' can't be assigned to a variable of type 'bool'.
  - 'Class' is from 'pkg/front_end/testcases/patterns/shared_errors.dart'.
     case > 0: // Error
          ^") {
-    {
-      core::print(0);
+      {
+        core::print(0);
+      }
     }
   }
 }
@@ -149,15 +153,17 @@ static method duplicateRecordPatternField(dynamic o) → dynamic {
   {
     final synthesized dynamic #0#0 = o;
     late final synthesized core::int #0#2 = #0#0{self::Class}.{self::Class::field}{core::int};
-    if(invalid-expression "pkg/front_end/testcases/patterns/shared_errors.dart:36:28: Error: The field 'field' is already matched in this pattern.
+    {
+      if(invalid-expression "pkg/front_end/testcases/patterns/shared_errors.dart:36:28: Error: The field 'field' is already matched in this pattern.
 Try removing the duplicate field.
     case (field: 1, field: 2): // Error
                            ^" || #0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#2 && (let final dynamic #t3 = #0#2 in invalid-expression "pkg/front_end/testcases/patterns/shared_errors.dart:37:33: Error: The field 'field' is already matched in this pattern.
 Try removing the duplicate field.
     case Class(field: 1, field: 2): // Error
                                 ^")) {
-      {
-        core::print(0);
+        {
+          core::print(0);
+        }
       }
     }
   }
@@ -168,10 +174,12 @@ static method duplicateRestPattern(dynamic o) → dynamic {
     final synthesized dynamic #0#0 = o;
     synthesized core::int #0#2;
     synthesized core::bool #0#2#isSet = false;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t4 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}).{core::num::>=}(#C2){(core::num) → core::bool} && (let final dynamic #t5 = #0#0{core::List<dynamic>}.{core::List::[]}((#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t6 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}).{core::num::-}(1){(core::num) → core::int}){(core::int) → dynamic} in invalid-expression "pkg/front_end/testcases/patterns/shared_errors.dart:44:16: Error: At most one rest element is allowed in a list or map pattern.
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t4 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}).{core::num::>=}(#C2){(core::num) → core::bool} && (let final dynamic #t5 = #0#0{core::List<dynamic>}.{core::List::[]}((#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t6 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}).{core::num::-}(1){(core::num) → core::int}){(core::int) → dynamic} in invalid-expression "pkg/front_end/testcases/patterns/shared_errors.dart:44:16: Error: At most one rest element is allowed in a list or map pattern.
 Try removing the duplicate rest element.
     case [..., ...]: // Error
                ^") || #0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t7 = #0#2#isSet = true in #0#2 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C3){(core::num) → core::bool}) {
+      }
     }
   }
 }
diff --git a/pkg/front_end/testcases/patterns/shared_errors.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/shared_errors.dart.weak.modular.expect
index 63c00d8af1e..87363061862 100644
--- a/pkg/front_end/testcases/patterns/shared_errors.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/shared_errors.dart.weak.modular.expect
@@ -104,23 +104,27 @@ class Class extends core::Object {
 }
 static method argumentTypeNotAssignable(self::Class cls) → dynamic {
   #L1:
-  if(invalid-expression "pkg/front_end/testcases/patterns/shared_errors.dart:13:13: Error: The argument type 'int' can't be assigned to the parameter type 'Class'.
+  {
+    if(invalid-expression "pkg/front_end/testcases/patterns/shared_errors.dart:13:13: Error: The argument type 'int' can't be assigned to the parameter type 'Class'.
  - 'Class' is from 'pkg/front_end/testcases/patterns/shared_errors.dart'.
     case >= 0: // Error
             ^") {
-    {
-      core::print(0);
+      {
+        core::print(0);
+      }
     }
   }
 }
 static method relationalPatternOperatorReturnTypeNotAssignableToBool(self::Class cls) → dynamic {
   #L2:
-  if(invalid-expression "pkg/front_end/testcases/patterns/shared_errors.dart:20:10: Error: A value of type 'Class' can't be assigned to a variable of type 'bool'.
+  {
+    if(invalid-expression "pkg/front_end/testcases/patterns/shared_errors.dart:20:10: Error: A value of type 'Class' can't be assigned to a variable of type 'bool'.
  - 'Class' is from 'pkg/front_end/testcases/patterns/shared_errors.dart'.
     case > 0: // Error
          ^") {
-    {
-      core::print(0);
+      {
+        core::print(0);
+      }
     }
   }
 }
@@ -149,15 +153,17 @@ static method duplicateRecordPatternField(dynamic o) → dynamic {
   {
     final synthesized dynamic #0#0 = o;
     late final synthesized core::int #0#2 = #0#0{self::Class}.{self::Class::field}{core::int};
-    if(invalid-expression "pkg/front_end/testcases/patterns/shared_errors.dart:36:28: Error: The field 'field' is already matched in this pattern.
+    {
+      if(invalid-expression "pkg/front_end/testcases/patterns/shared_errors.dart:36:28: Error: The field 'field' is already matched in this pattern.
 Try removing the duplicate field.
     case (field: 1, field: 2): // Error
                            ^" || #0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#2 && (let final dynamic #t3 = #0#2 in invalid-expression "pkg/front_end/testcases/patterns/shared_errors.dart:37:33: Error: The field 'field' is already matched in this pattern.
 Try removing the duplicate field.
     case Class(field: 1, field: 2): // Error
                                 ^")) {
-      {
-        core::print(0);
+        {
+          core::print(0);
+        }
       }
     }
   }
@@ -168,10 +174,12 @@ static method duplicateRestPattern(dynamic o) → dynamic {
     final synthesized dynamic #0#0 = o;
     synthesized core::int #0#2;
     synthesized core::bool #0#2#isSet = false;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t4 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}).{core::num::>=}(#C2){(core::num) → core::bool} && (let final dynamic #t5 = #0#0{core::List<dynamic>}.{core::List::[]}((#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t6 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}).{core::num::-}(1){(core::num) → core::int}){(core::int) → dynamic} in invalid-expression "pkg/front_end/testcases/patterns/shared_errors.dart:44:16: Error: At most one rest element is allowed in a list or map pattern.
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t4 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}).{core::num::>=}(#C2){(core::num) → core::bool} && (let final dynamic #t5 = #0#0{core::List<dynamic>}.{core::List::[]}((#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t6 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}).{core::num::-}(1){(core::num) → core::int}){(core::int) → dynamic} in invalid-expression "pkg/front_end/testcases/patterns/shared_errors.dart:44:16: Error: At most one rest element is allowed in a list or map pattern.
 Try removing the duplicate rest element.
     case [..., ...]: // Error
                ^") || #0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t7 = #0#2#isSet = true in #0#2 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C3){(core::num) → core::bool}) {
+      }
     }
   }
 }
diff --git a/pkg/front_end/testcases/patterns/shared_errors.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/shared_errors.dart.weak.transformed.expect
index 95fe00d990a..f98e74b2bc5 100644
--- a/pkg/front_end/testcases/patterns/shared_errors.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/shared_errors.dart.weak.transformed.expect
@@ -104,23 +104,27 @@ class Class extends core::Object {
 }
 static method argumentTypeNotAssignable(self::Class cls) → dynamic {
   #L1:
-  if(invalid-expression "pkg/front_end/testcases/patterns/shared_errors.dart:13:13: Error: The argument type 'int' can't be assigned to the parameter type 'Class'.
+  {
+    if(invalid-expression "pkg/front_end/testcases/patterns/shared_errors.dart:13:13: Error: The argument type 'int' can't be assigned to the parameter type 'Class'.
  - 'Class' is from 'pkg/front_end/testcases/patterns/shared_errors.dart'.
     case >= 0: // Error
             ^") {
-    {
-      core::print(0);
+      {
+        core::print(0);
+      }
     }
   }
 }
 static method relationalPatternOperatorReturnTypeNotAssignableToBool(self::Class cls) → dynamic {
   #L2:
-  if(invalid-expression "pkg/front_end/testcases/patterns/shared_errors.dart:20:10: Error: A value of type 'Class' can't be assigned to a variable of type 'bool'.
+  {
+    if(invalid-expression "pkg/front_end/testcases/patterns/shared_errors.dart:20:10: Error: A value of type 'Class' can't be assigned to a variable of type 'bool'.
  - 'Class' is from 'pkg/front_end/testcases/patterns/shared_errors.dart'.
     case > 0: // Error
          ^") {
-    {
-      core::print(0);
+      {
+        core::print(0);
+      }
     }
   }
 }
@@ -151,15 +155,17 @@ static method duplicateRecordPatternField(dynamic o) → dynamic {
     function ##0#2#initializer() → core::int
       return #0#0{self::Class}.{self::Class::field}{core::int};
     late final synthesized core::int #0#2 = ##0#2#initializer(){() → core::int};
-    if(invalid-expression "pkg/front_end/testcases/patterns/shared_errors.dart:36:28: Error: The field 'field' is already matched in this pattern.
+    {
+      if(invalid-expression "pkg/front_end/testcases/patterns/shared_errors.dart:36:28: Error: The field 'field' is already matched in this pattern.
 Try removing the duplicate field.
     case (field: 1, field: 2): // Error
                            ^" || #0#0 is{ForNonNullableByDefault} self::Class && #C2 =={core::num::==}{(core::Object) → core::bool} #0#2 && (let final core::int #t3 = #0#2 in invalid-expression "pkg/front_end/testcases/patterns/shared_errors.dart:37:33: Error: The field 'field' is already matched in this pattern.
 Try removing the duplicate field.
     case Class(field: 1, field: 2): // Error
                                 ^")) {
-      {
-        core::print(0);
+        {
+          core::print(0);
+        }
       }
     }
   }
@@ -170,10 +176,12 @@ static method duplicateRestPattern(dynamic o) → dynamic {
     final synthesized dynamic #0#0 = o;
     synthesized core::int #0#2;
     synthesized core::bool #0#2#isSet = false;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t4 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}).{core::num::>=}(#C2){(core::num) → core::bool} && (let final dynamic #t5 = #0#0{core::List<dynamic>}.{core::List::[]}((#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t6 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}).{core::num::-}(1){(core::num) → core::int}){(core::int) → dynamic} in invalid-expression "pkg/front_end/testcases/patterns/shared_errors.dart:44:16: Error: At most one rest element is allowed in a list or map pattern.
+    {
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t4 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}).{core::num::>=}(#C2){(core::num) → core::bool} && (let final dynamic #t5 = #0#0{core::List<dynamic>}.{core::List::[]}((#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t6 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}).{core::num::-}(1){(core::num) → core::int}){(core::int) → dynamic} in invalid-expression "pkg/front_end/testcases/patterns/shared_errors.dart:44:16: Error: At most one rest element is allowed in a list or map pattern.
 Try removing the duplicate rest element.
     case [..., ...]: // Error
                ^") || #0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t7 = #0#2#isSet = true in #0#2 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}).{core::num::>=}(#C3){(core::num) → core::bool}) {
+      }
     }
   }
 }
diff --git a/pkg/front_end/testcases/patterns/simple_switch.dart.strong.expect b/pkg/front_end/testcases/patterns/simple_switch.dart.strong.expect
index 54e3a600c8d..d8413bd371a 100644
--- a/pkg/front_end/testcases/patterns/simple_switch.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/simple_switch.dart.strong.expect
@@ -5,26 +5,31 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int y;
-    core::double z;
     final synthesized dynamic #0#0 = x;
     late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = y = #0#0{core::int} in true)) {
-      {
-        return y;
+    {
+      core::int y;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = y = #0#0{core::int} in true)) {
+        {
+          return y;
+        }
       }
     }
-    else
+    {
+      core::double z;
       if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (#0#6 is{ForNonNullableByDefault} core::double && (let final dynamic #t2 = z = #0#6{core::double} in true))) {
         {
           return z;
         }
       }
-      else {
+    }
+    {
+      {
         {
           return null;
         }
       }
+    }
   }
 }
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/patterns/simple_switch.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/simple_switch.dart.strong.transformed.expect
index f13ecad5bd0..bfd2505df30 100644
--- a/pkg/front_end/testcases/patterns/simple_switch.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/simple_switch.dart.strong.transformed.expect
@@ -5,28 +5,33 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int y;
-    core::double z;
     final synthesized dynamic #0#0 = x;
     function ##0#6#initializer() → dynamic
       return #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
     late final synthesized dynamic #0#6 = ##0#6#initializer(){() → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = y = #0#0{core::int} in true)) {
-      {
-        return y;
+    {
+      core::int y;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = y = #0#0{core::int} in true)) {
+        {
+          return y;
+        }
       }
     }
-    else
+    {
+      core::double z;
       if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (#0#6 is{ForNonNullableByDefault} core::double && (let final core::double #t2 = z = #0#6{core::double} in true))) {
         {
           return z;
         }
       }
-      else {
+    }
+    {
+      {
         {
           return null;
         }
       }
+    }
   }
 }
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/patterns/simple_switch.dart.weak.expect b/pkg/front_end/testcases/patterns/simple_switch.dart.weak.expect
index 54e3a600c8d..d8413bd371a 100644
--- a/pkg/front_end/testcases/patterns/simple_switch.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/simple_switch.dart.weak.expect
@@ -5,26 +5,31 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int y;
-    core::double z;
     final synthesized dynamic #0#0 = x;
     late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = y = #0#0{core::int} in true)) {
-      {
-        return y;
+    {
+      core::int y;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = y = #0#0{core::int} in true)) {
+        {
+          return y;
+        }
       }
     }
-    else
+    {
+      core::double z;
       if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (#0#6 is{ForNonNullableByDefault} core::double && (let final dynamic #t2 = z = #0#6{core::double} in true))) {
         {
           return z;
         }
       }
-      else {
+    }
+    {
+      {
         {
           return null;
         }
       }
+    }
   }
 }
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/patterns/simple_switch.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/simple_switch.dart.weak.modular.expect
index 54e3a600c8d..d8413bd371a 100644
--- a/pkg/front_end/testcases/patterns/simple_switch.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/simple_switch.dart.weak.modular.expect
@@ -5,26 +5,31 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int y;
-    core::double z;
     final synthesized dynamic #0#0 = x;
     late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = y = #0#0{core::int} in true)) {
-      {
-        return y;
+    {
+      core::int y;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = y = #0#0{core::int} in true)) {
+        {
+          return y;
+        }
       }
     }
-    else
+    {
+      core::double z;
       if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (#0#6 is{ForNonNullableByDefault} core::double && (let final dynamic #t2 = z = #0#6{core::double} in true))) {
         {
           return z;
         }
       }
-      else {
+    }
+    {
+      {
         {
           return null;
         }
       }
+    }
   }
 }
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/patterns/simple_switch.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/simple_switch.dart.weak.transformed.expect
index f13ecad5bd0..bfd2505df30 100644
--- a/pkg/front_end/testcases/patterns/simple_switch.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/simple_switch.dart.weak.transformed.expect
@@ -5,28 +5,33 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int y;
-    core::double z;
     final synthesized dynamic #0#0 = x;
     function ##0#6#initializer() → dynamic
       return #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
     late final synthesized dynamic #0#6 = ##0#6#initializer(){() → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = y = #0#0{core::int} in true)) {
-      {
-        return y;
+    {
+      core::int y;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = y = #0#0{core::int} in true)) {
+        {
+          return y;
+        }
       }
     }
-    else
+    {
+      core::double z;
       if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (#0#6 is{ForNonNullableByDefault} core::double && (let final core::double #t2 = z = #0#6{core::double} in true))) {
         {
           return z;
         }
       }
-      else {
+    }
+    {
+      {
         {
           return null;
         }
       }
+    }
   }
 }
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/patterns/simple_switch_expressions.dart.strong.expect b/pkg/front_end/testcases/patterns/simple_switch_expressions.dart.strong.expect
index 3afec27b1e7..77628ed3fbf 100644
--- a/pkg/front_end/testcases/patterns/simple_switch_expressions.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/simple_switch_expressions.dart.strong.expect
@@ -6,22 +6,42 @@ static method test1(dynamic x) → dynamic {
   return block {
     core::String #t1;
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0)
-      #t1 = "zero";
-    else
-      if(true)
-        #t1 = "other";
+    #L1:
+    {
+      {
+        if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+          #t1 = "zero";
+          break #L1;
+        }
+      }
+      {
+        if(true) {
+          #t1 = "other";
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
 }
 static method test2(core::String x) → dynamic {
   return block {
     core::int #t2;
     final synthesized core::String #0#0 = x;
-    if(#C2 =={core::String::==}{(core::Object) → core::bool} #0#0)
-      #t2 = 0;
-    else
-      if(true)
-        #t2 = 1;
+    #L2:
+    {
+      {
+        if(#C2 =={core::String::==}{(core::Object) → core::bool} #0#0) {
+          #t2 = 0;
+          break #L2;
+        }
+      }
+      {
+        if(true) {
+          #t2 = 1;
+          break #L2;
+        }
+      }
+    }
   } =>#t2;
 }
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/patterns/simple_switch_expressions.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/simple_switch_expressions.dart.strong.transformed.expect
index fe15dca4131..0883816f205 100644
--- a/pkg/front_end/testcases/patterns/simple_switch_expressions.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/simple_switch_expressions.dart.strong.transformed.expect
@@ -6,22 +6,42 @@ static method test1(dynamic x) → dynamic {
   return block {
     core::String #t1;
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0)
-      #t1 = "zero";
-    else
-      if(true)
-        #t1 = "other";
+    #L1:
+    {
+      {
+        if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+          #t1 = "zero";
+          break #L1;
+        }
+      }
+      {
+        if(true) {
+          #t1 = "other";
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
 }
 static method test2(core::String x) → dynamic {
   return block {
     core::int #t2;
     final synthesized core::String #0#0 = x;
-    if(#C2 =={core::String::==}{(core::Object) → core::bool} #0#0)
-      #t2 = 0;
-    else
-      if(true)
-        #t2 = 1;
+    #L2:
+    {
+      {
+        if(#C2 =={core::String::==}{(core::Object) → core::bool} #0#0) {
+          #t2 = 0;
+          break #L2;
+        }
+      }
+      {
+        if(true) {
+          #t2 = 1;
+          break #L2;
+        }
+      }
+    }
   } =>#t2;
 }
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/patterns/simple_switch_expressions.dart.weak.expect b/pkg/front_end/testcases/patterns/simple_switch_expressions.dart.weak.expect
index 3afec27b1e7..77628ed3fbf 100644
--- a/pkg/front_end/testcases/patterns/simple_switch_expressions.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/simple_switch_expressions.dart.weak.expect
@@ -6,22 +6,42 @@ static method test1(dynamic x) → dynamic {
   return block {
     core::String #t1;
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0)
-      #t1 = "zero";
-    else
-      if(true)
-        #t1 = "other";
+    #L1:
+    {
+      {
+        if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+          #t1 = "zero";
+          break #L1;
+        }
+      }
+      {
+        if(true) {
+          #t1 = "other";
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
 }
 static method test2(core::String x) → dynamic {
   return block {
     core::int #t2;
     final synthesized core::String #0#0 = x;
-    if(#C2 =={core::String::==}{(core::Object) → core::bool} #0#0)
-      #t2 = 0;
-    else
-      if(true)
-        #t2 = 1;
+    #L2:
+    {
+      {
+        if(#C2 =={core::String::==}{(core::Object) → core::bool} #0#0) {
+          #t2 = 0;
+          break #L2;
+        }
+      }
+      {
+        if(true) {
+          #t2 = 1;
+          break #L2;
+        }
+      }
+    }
   } =>#t2;
 }
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/patterns/simple_switch_expressions.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/simple_switch_expressions.dart.weak.modular.expect
index 3afec27b1e7..77628ed3fbf 100644
--- a/pkg/front_end/testcases/patterns/simple_switch_expressions.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/simple_switch_expressions.dart.weak.modular.expect
@@ -6,22 +6,42 @@ static method test1(dynamic x) → dynamic {
   return block {
     core::String #t1;
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0)
-      #t1 = "zero";
-    else
-      if(true)
-        #t1 = "other";
+    #L1:
+    {
+      {
+        if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+          #t1 = "zero";
+          break #L1;
+        }
+      }
+      {
+        if(true) {
+          #t1 = "other";
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
 }
 static method test2(core::String x) → dynamic {
   return block {
     core::int #t2;
     final synthesized core::String #0#0 = x;
-    if(#C2 =={core::String::==}{(core::Object) → core::bool} #0#0)
-      #t2 = 0;
-    else
-      if(true)
-        #t2 = 1;
+    #L2:
+    {
+      {
+        if(#C2 =={core::String::==}{(core::Object) → core::bool} #0#0) {
+          #t2 = 0;
+          break #L2;
+        }
+      }
+      {
+        if(true) {
+          #t2 = 1;
+          break #L2;
+        }
+      }
+    }
   } =>#t2;
 }
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/patterns/simple_switch_expressions.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/simple_switch_expressions.dart.weak.transformed.expect
index fe15dca4131..0883816f205 100644
--- a/pkg/front_end/testcases/patterns/simple_switch_expressions.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/simple_switch_expressions.dart.weak.transformed.expect
@@ -6,22 +6,42 @@ static method test1(dynamic x) → dynamic {
   return block {
     core::String #t1;
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0)
-      #t1 = "zero";
-    else
-      if(true)
-        #t1 = "other";
+    #L1:
+    {
+      {
+        if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+          #t1 = "zero";
+          break #L1;
+        }
+      }
+      {
+        if(true) {
+          #t1 = "other";
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
 }
 static method test2(core::String x) → dynamic {
   return block {
     core::int #t2;
     final synthesized core::String #0#0 = x;
-    if(#C2 =={core::String::==}{(core::Object) → core::bool} #0#0)
-      #t2 = 0;
-    else
-      if(true)
-        #t2 = 1;
+    #L2:
+    {
+      {
+        if(#C2 =={core::String::==}{(core::Object) → core::bool} #0#0) {
+          #t2 = 0;
+          break #L2;
+        }
+      }
+      {
+        if(true) {
+          #t2 = 1;
+          break #L2;
+        }
+      }
+    }
   } =>#t2;
 }
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/patterns/simple_switch_with_guards_error.dart.strong.expect b/pkg/front_end/testcases/patterns/simple_switch_with_guards_error.dart.strong.expect
index aa11f3a612f..673d32b8dd2 100644
--- a/pkg/front_end/testcases/patterns/simple_switch_with_guards_error.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/simple_switch_with_guards_error.dart.strong.expect
@@ -12,24 +12,28 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int a;
-    core::double a#1;
     final synthesized dynamic #0#0 = x;
     late final synthesized core::bool #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1;
     late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
     late final synthesized dynamic #0#7 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic};
     dynamic #t1;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = a = #0#6{core::int} in true)) && (let final dynamic #t3 = #0#7 in true) && a.{core::int::isEven}{core::bool} && (let final dynamic #t4 = #t1 = a in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (let final dynamic #t5 = #0#6 in true) && (#0#7 is{ForNonNullableByDefault} core::double && (let final dynamic #t6 = a#1 = #0#7{core::double} in true)) && a#1.{core::double::ceil}(){() → core::int}.{core::int::isOdd}{core::bool} && (let final dynamic #t7 = #t1 = a#1 in true)) {
-      core::int a = invalid-expression "pkg/front_end/testcases/patterns/simple_switch_with_guards_error.dart:7:15: Error: Variable pattern 'a' doesn't have the same type in all cases.
+    {
+      lowered core::int a#case#0;
+      lowered core::double a#case#1;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = a#case#0 = #0#6{core::int} in true)) && (let final dynamic #t3 = #0#7 in true) && a#case#0.{core::int::isEven}{core::bool} && (let final dynamic #t4 = #t1 = a#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (let final dynamic #t5 = #0#6 in true) && (#0#7 is{ForNonNullableByDefault} core::double && (let final dynamic #t6 = a#case#1 = #0#7{core::double} in true)) && a#case#1.{core::double::ceil}(){() → core::int}.{core::int::isOdd}{core::bool} && (let final dynamic #t7 = #t1 = a#case#1 in true)) {
+        core::int a = invalid-expression "pkg/front_end/testcases/patterns/simple_switch_with_guards_error.dart:7:15: Error: Variable pattern 'a' doesn't have the same type in all cases.
     case [int a, _] when a.isEven: // Error: type of 'a' mismatch.
               ^";
-      {
-        return a;
+        {
+          return a;
+        }
       }
     }
-    else {
+    {
       {
-        return null;
+        {
+          return null;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/simple_switch_with_guards_error.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/simple_switch_with_guards_error.dart.strong.transformed.expect
index 7ddc57850b2..9f136660b02 100644
--- a/pkg/front_end/testcases/patterns/simple_switch_with_guards_error.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/simple_switch_with_guards_error.dart.strong.transformed.expect
@@ -12,8 +12,6 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int a;
-    core::double a#1;
     final synthesized dynamic #0#0 = x;
     function ##0#4#initializer() → core::bool
       return #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1;
@@ -25,17 +23,23 @@ static method test(dynamic x) → dynamic {
       return #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic};
     late final synthesized dynamic #0#7 = ##0#7#initializer(){() → dynamic};
     dynamic #t1;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final core::int #t2 = a = #0#6{core::int} in true)) && (let final dynamic #t3 = #0#7 in true) && a.{core::int::isEven}{core::bool} && (let final core::int #t4 = #t1 = a in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (let final dynamic #t5 = #0#6 in true) && (#0#7 is{ForNonNullableByDefault} core::double && (let final core::double #t6 = a#1 = #0#7{core::double} in true)) && a#1.{core::double::ceil}(){() → core::int}.{core::int::isOdd}{core::bool} && (let final core::double #t7 = #t1 = a#1 in true)) {
-      core::int a = invalid-expression "pkg/front_end/testcases/patterns/simple_switch_with_guards_error.dart:7:15: Error: Variable pattern 'a' doesn't have the same type in all cases.
+    {
+      lowered core::int a#case#0;
+      lowered core::double a#case#1;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final core::int #t2 = a#case#0 = #0#6{core::int} in true)) && (let final dynamic #t3 = #0#7 in true) && a#case#0.{core::int::isEven}{core::bool} && (let final core::int #t4 = #t1 = a#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (let final dynamic #t5 = #0#6 in true) && (#0#7 is{ForNonNullableByDefault} core::double && (let final core::double #t6 = a#case#1 = #0#7{core::double} in true)) && a#case#1.{core::double::ceil}(){() → core::int}.{core::int::isOdd}{core::bool} && (let final core::double #t7 = #t1 = a#case#1 in true)) {
+        core::int a = invalid-expression "pkg/front_end/testcases/patterns/simple_switch_with_guards_error.dart:7:15: Error: Variable pattern 'a' doesn't have the same type in all cases.
     case [int a, _] when a.isEven: // Error: type of 'a' mismatch.
               ^";
-      {
-        return a;
+        {
+          return a;
+        }
       }
     }
-    else {
+    {
       {
-        return null;
+        {
+          return null;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/simple_switch_with_guards_error.dart.weak.expect b/pkg/front_end/testcases/patterns/simple_switch_with_guards_error.dart.weak.expect
index aa11f3a612f..673d32b8dd2 100644
--- a/pkg/front_end/testcases/patterns/simple_switch_with_guards_error.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/simple_switch_with_guards_error.dart.weak.expect
@@ -12,24 +12,28 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int a;
-    core::double a#1;
     final synthesized dynamic #0#0 = x;
     late final synthesized core::bool #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1;
     late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
     late final synthesized dynamic #0#7 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic};
     dynamic #t1;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = a = #0#6{core::int} in true)) && (let final dynamic #t3 = #0#7 in true) && a.{core::int::isEven}{core::bool} && (let final dynamic #t4 = #t1 = a in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (let final dynamic #t5 = #0#6 in true) && (#0#7 is{ForNonNullableByDefault} core::double && (let final dynamic #t6 = a#1 = #0#7{core::double} in true)) && a#1.{core::double::ceil}(){() → core::int}.{core::int::isOdd}{core::bool} && (let final dynamic #t7 = #t1 = a#1 in true)) {
-      core::int a = invalid-expression "pkg/front_end/testcases/patterns/simple_switch_with_guards_error.dart:7:15: Error: Variable pattern 'a' doesn't have the same type in all cases.
+    {
+      lowered core::int a#case#0;
+      lowered core::double a#case#1;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = a#case#0 = #0#6{core::int} in true)) && (let final dynamic #t3 = #0#7 in true) && a#case#0.{core::int::isEven}{core::bool} && (let final dynamic #t4 = #t1 = a#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (let final dynamic #t5 = #0#6 in true) && (#0#7 is{ForNonNullableByDefault} core::double && (let final dynamic #t6 = a#case#1 = #0#7{core::double} in true)) && a#case#1.{core::double::ceil}(){() → core::int}.{core::int::isOdd}{core::bool} && (let final dynamic #t7 = #t1 = a#case#1 in true)) {
+        core::int a = invalid-expression "pkg/front_end/testcases/patterns/simple_switch_with_guards_error.dart:7:15: Error: Variable pattern 'a' doesn't have the same type in all cases.
     case [int a, _] when a.isEven: // Error: type of 'a' mismatch.
               ^";
-      {
-        return a;
+        {
+          return a;
+        }
       }
     }
-    else {
+    {
       {
-        return null;
+        {
+          return null;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/simple_switch_with_guards_error.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/simple_switch_with_guards_error.dart.weak.modular.expect
index aa11f3a612f..673d32b8dd2 100644
--- a/pkg/front_end/testcases/patterns/simple_switch_with_guards_error.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/simple_switch_with_guards_error.dart.weak.modular.expect
@@ -12,24 +12,28 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int a;
-    core::double a#1;
     final synthesized dynamic #0#0 = x;
     late final synthesized core::bool #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1;
     late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
     late final synthesized dynamic #0#7 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic};
     dynamic #t1;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = a = #0#6{core::int} in true)) && (let final dynamic #t3 = #0#7 in true) && a.{core::int::isEven}{core::bool} && (let final dynamic #t4 = #t1 = a in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (let final dynamic #t5 = #0#6 in true) && (#0#7 is{ForNonNullableByDefault} core::double && (let final dynamic #t6 = a#1 = #0#7{core::double} in true)) && a#1.{core::double::ceil}(){() → core::int}.{core::int::isOdd}{core::bool} && (let final dynamic #t7 = #t1 = a#1 in true)) {
-      core::int a = invalid-expression "pkg/front_end/testcases/patterns/simple_switch_with_guards_error.dart:7:15: Error: Variable pattern 'a' doesn't have the same type in all cases.
+    {
+      lowered core::int a#case#0;
+      lowered core::double a#case#1;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = a#case#0 = #0#6{core::int} in true)) && (let final dynamic #t3 = #0#7 in true) && a#case#0.{core::int::isEven}{core::bool} && (let final dynamic #t4 = #t1 = a#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (let final dynamic #t5 = #0#6 in true) && (#0#7 is{ForNonNullableByDefault} core::double && (let final dynamic #t6 = a#case#1 = #0#7{core::double} in true)) && a#case#1.{core::double::ceil}(){() → core::int}.{core::int::isOdd}{core::bool} && (let final dynamic #t7 = #t1 = a#case#1 in true)) {
+        core::int a = invalid-expression "pkg/front_end/testcases/patterns/simple_switch_with_guards_error.dart:7:15: Error: Variable pattern 'a' doesn't have the same type in all cases.
     case [int a, _] when a.isEven: // Error: type of 'a' mismatch.
               ^";
-      {
-        return a;
+        {
+          return a;
+        }
       }
     }
-    else {
+    {
       {
-        return null;
+        {
+          return null;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/simple_switch_with_guards_error.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/simple_switch_with_guards_error.dart.weak.transformed.expect
index 7ddc57850b2..9f136660b02 100644
--- a/pkg/front_end/testcases/patterns/simple_switch_with_guards_error.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/simple_switch_with_guards_error.dart.weak.transformed.expect
@@ -12,8 +12,6 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int a;
-    core::double a#1;
     final synthesized dynamic #0#0 = x;
     function ##0#4#initializer() → core::bool
       return #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1;
@@ -25,17 +23,23 @@ static method test(dynamic x) → dynamic {
       return #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic};
     late final synthesized dynamic #0#7 = ##0#7#initializer(){() → dynamic};
     dynamic #t1;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final core::int #t2 = a = #0#6{core::int} in true)) && (let final dynamic #t3 = #0#7 in true) && a.{core::int::isEven}{core::bool} && (let final core::int #t4 = #t1 = a in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (let final dynamic #t5 = #0#6 in true) && (#0#7 is{ForNonNullableByDefault} core::double && (let final core::double #t6 = a#1 = #0#7{core::double} in true)) && a#1.{core::double::ceil}(){() → core::int}.{core::int::isOdd}{core::bool} && (let final core::double #t7 = #t1 = a#1 in true)) {
-      core::int a = invalid-expression "pkg/front_end/testcases/patterns/simple_switch_with_guards_error.dart:7:15: Error: Variable pattern 'a' doesn't have the same type in all cases.
+    {
+      lowered core::int a#case#0;
+      lowered core::double a#case#1;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final core::int #t2 = a#case#0 = #0#6{core::int} in true)) && (let final dynamic #t3 = #0#7 in true) && a#case#0.{core::int::isEven}{core::bool} && (let final core::int #t4 = #t1 = a#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (let final dynamic #t5 = #0#6 in true) && (#0#7 is{ForNonNullableByDefault} core::double && (let final core::double #t6 = a#case#1 = #0#7{core::double} in true)) && a#case#1.{core::double::ceil}(){() → core::int}.{core::int::isOdd}{core::bool} && (let final core::double #t7 = #t1 = a#case#1 in true)) {
+        core::int a = invalid-expression "pkg/front_end/testcases/patterns/simple_switch_with_guards_error.dart:7:15: Error: Variable pattern 'a' doesn't have the same type in all cases.
     case [int a, _] when a.isEven: // Error: type of 'a' mismatch.
               ^";
-      {
-        return a;
+        {
+          return a;
+        }
       }
     }
-    else {
+    {
       {
-        return null;
+        {
+          return null;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/simple_switch_with_guards_runtime.dart.strong.expect b/pkg/front_end/testcases/patterns/simple_switch_with_guards_runtime.dart.strong.expect
index e7ccfc451d8..6f5de608abb 100644
--- a/pkg/front_end/testcases/patterns/simple_switch_with_guards_runtime.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/simple_switch_with_guards_runtime.dart.strong.expect
@@ -5,17 +5,21 @@ import "dart:core" as core;
 static method test1(dynamic x) → dynamic {
   #L1:
   {
-    core::int a;
     final synthesized dynamic #0#0 = x;
     late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = a = #0#6{core::int} in true)) && a.{core::num::>}(0){(core::num) → core::bool}) {
-      {
-        return a;
+    {
+      core::int a;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = a = #0#6{core::int} in true)) && a.{core::num::>}(0){(core::num) → core::bool}) {
+        {
+          return a;
+        }
       }
     }
-    else {
+    {
       {
-        return null;
+        {
+          return null;
+        }
       }
     }
   }
@@ -23,22 +27,26 @@ static method test1(dynamic x) → dynamic {
 static method test2(dynamic x) → dynamic {
   #L2:
   {
-    core::num a;
-    core::num a#1;
     final synthesized dynamic #0#0 = x;
     late final synthesized core::bool #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2;
     late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
     late final synthesized dynamic #0#7 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic};
     dynamic #t2;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::num && (let final dynamic #t3 = a = #0#6{core::num} in true)) && (let final dynamic #t4 = #0#7 in true) && (a is{ForNonNullableByDefault} core::int && a{core::int}.{core::int::isEven}{core::bool}) && (let final dynamic #t5 = #t2 = a in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (let final dynamic #t6 = #0#6 in true) && (#0#7 is{ForNonNullableByDefault} core::num && (let final dynamic #t7 = a#1 = #0#7{core::num} in true)) && (a#1 is{ForNonNullableByDefault} core::double && a#1{core::double}.{core::double::ceil}(){() → core::int}.{core::int::isOdd}{core::bool}) && (let final dynamic #t8 = #t2 = a#1 in true)) {
-      core::num a = #t2{core::num};
-      {
-        return a;
+    {
+      lowered core::num a#case#0;
+      lowered core::num a#case#1;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::num && (let final dynamic #t3 = a#case#0 = #0#6{core::num} in true)) && (let final dynamic #t4 = #0#7 in true) && (a#case#0 is{ForNonNullableByDefault} core::int && a#case#0{core::int}.{core::int::isEven}{core::bool}) && (let final dynamic #t5 = #t2 = a#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (let final dynamic #t6 = #0#6 in true) && (#0#7 is{ForNonNullableByDefault} core::num && (let final dynamic #t7 = a#case#1 = #0#7{core::num} in true)) && (a#case#1 is{ForNonNullableByDefault} core::double && a#case#1{core::double}.{core::double::ceil}(){() → core::int}.{core::int::isOdd}{core::bool}) && (let final dynamic #t8 = #t2 = a#case#1 in true)) {
+        core::num a = #t2{core::num};
+        {
+          return a;
+        }
       }
     }
-    else {
+    {
       {
-        return null;
+        {
+          return null;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/simple_switch_with_guards_runtime.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/simple_switch_with_guards_runtime.dart.strong.transformed.expect
index 7940e33c376..f5a2fcd963b 100644
--- a/pkg/front_end/testcases/patterns/simple_switch_with_guards_runtime.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/simple_switch_with_guards_runtime.dart.strong.transformed.expect
@@ -5,19 +5,23 @@ import "dart:core" as core;
 static method test1(dynamic x) → dynamic {
   #L1:
   {
-    core::int a;
     final synthesized dynamic #0#0 = x;
     function ##0#6#initializer() → dynamic
       return #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
     late final synthesized dynamic #0#6 = ##0#6#initializer(){() → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (#0#6 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = a = #0#6{core::int} in true)) && a.{core::num::>}(0){(core::num) → core::bool}) {
-      {
-        return a;
+    {
+      core::int a;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (#0#6 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = a = #0#6{core::int} in true)) && a.{core::num::>}(0){(core::num) → core::bool}) {
+        {
+          return a;
+        }
       }
     }
-    else {
+    {
       {
-        return null;
+        {
+          return null;
+        }
       }
     }
   }
@@ -25,8 +29,6 @@ static method test1(dynamic x) → dynamic {
 static method test2(dynamic x) → dynamic {
   #L2:
   {
-    core::num a;
-    core::num a#1;
     final synthesized dynamic #0#0 = x;
     function ##0#4#initializer() → core::bool
       return #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2;
@@ -38,15 +40,21 @@ static method test2(dynamic x) → dynamic {
       return #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic};
     late final synthesized dynamic #0#7 = ##0#7#initializer(){() → dynamic};
     dynamic #t2;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::num && (let final core::num #t3 = a = #0#6{core::num} in true)) && (let final dynamic #t4 = #0#7 in true) && (a is{ForNonNullableByDefault} core::int && a{core::int}.{core::int::isEven}{core::bool}) && (let final core::num #t5 = #t2 = a in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (let final dynamic #t6 = #0#6 in true) && (#0#7 is{ForNonNullableByDefault} core::num && (let final core::num #t7 = a#1 = #0#7{core::num} in true)) && (a#1 is{ForNonNullableByDefault} core::double && a#1{core::double}.{core::double::ceil}(){() → core::int}.{core::int::isOdd}{core::bool}) && (let final core::num #t8 = #t2 = a#1 in true)) {
-      core::num a = #t2{core::num};
-      {
-        return a;
+    {
+      lowered core::num a#case#0;
+      lowered core::num a#case#1;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::num && (let final core::num #t3 = a#case#0 = #0#6{core::num} in true)) && (let final dynamic #t4 = #0#7 in true) && (a#case#0 is{ForNonNullableByDefault} core::int && a#case#0{core::int}.{core::int::isEven}{core::bool}) && (let final core::num #t5 = #t2 = a#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (let final dynamic #t6 = #0#6 in true) && (#0#7 is{ForNonNullableByDefault} core::num && (let final core::num #t7 = a#case#1 = #0#7{core::num} in true)) && (a#case#1 is{ForNonNullableByDefault} core::double && a#case#1{core::double}.{core::double::ceil}(){() → core::int}.{core::int::isOdd}{core::bool}) && (let final core::num #t8 = #t2 = a#case#1 in true)) {
+        core::num a = #t2{core::num};
+        {
+          return a;
+        }
       }
     }
-    else {
+    {
       {
-        return null;
+        {
+          return null;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/simple_switch_with_guards_runtime.dart.weak.expect b/pkg/front_end/testcases/patterns/simple_switch_with_guards_runtime.dart.weak.expect
index e7ccfc451d8..6f5de608abb 100644
--- a/pkg/front_end/testcases/patterns/simple_switch_with_guards_runtime.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/simple_switch_with_guards_runtime.dart.weak.expect
@@ -5,17 +5,21 @@ import "dart:core" as core;
 static method test1(dynamic x) → dynamic {
   #L1:
   {
-    core::int a;
     final synthesized dynamic #0#0 = x;
     late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = a = #0#6{core::int} in true)) && a.{core::num::>}(0){(core::num) → core::bool}) {
-      {
-        return a;
+    {
+      core::int a;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = a = #0#6{core::int} in true)) && a.{core::num::>}(0){(core::num) → core::bool}) {
+        {
+          return a;
+        }
       }
     }
-    else {
+    {
       {
-        return null;
+        {
+          return null;
+        }
       }
     }
   }
@@ -23,22 +27,26 @@ static method test1(dynamic x) → dynamic {
 static method test2(dynamic x) → dynamic {
   #L2:
   {
-    core::num a;
-    core::num a#1;
     final synthesized dynamic #0#0 = x;
     late final synthesized core::bool #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2;
     late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
     late final synthesized dynamic #0#7 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic};
     dynamic #t2;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::num && (let final dynamic #t3 = a = #0#6{core::num} in true)) && (let final dynamic #t4 = #0#7 in true) && (a is{ForNonNullableByDefault} core::int && a{core::int}.{core::int::isEven}{core::bool}) && (let final dynamic #t5 = #t2 = a in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (let final dynamic #t6 = #0#6 in true) && (#0#7 is{ForNonNullableByDefault} core::num && (let final dynamic #t7 = a#1 = #0#7{core::num} in true)) && (a#1 is{ForNonNullableByDefault} core::double && a#1{core::double}.{core::double::ceil}(){() → core::int}.{core::int::isOdd}{core::bool}) && (let final dynamic #t8 = #t2 = a#1 in true)) {
-      core::num a = #t2{core::num};
-      {
-        return a;
+    {
+      lowered core::num a#case#0;
+      lowered core::num a#case#1;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::num && (let final dynamic #t3 = a#case#0 = #0#6{core::num} in true)) && (let final dynamic #t4 = #0#7 in true) && (a#case#0 is{ForNonNullableByDefault} core::int && a#case#0{core::int}.{core::int::isEven}{core::bool}) && (let final dynamic #t5 = #t2 = a#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (let final dynamic #t6 = #0#6 in true) && (#0#7 is{ForNonNullableByDefault} core::num && (let final dynamic #t7 = a#case#1 = #0#7{core::num} in true)) && (a#case#1 is{ForNonNullableByDefault} core::double && a#case#1{core::double}.{core::double::ceil}(){() → core::int}.{core::int::isOdd}{core::bool}) && (let final dynamic #t8 = #t2 = a#case#1 in true)) {
+        core::num a = #t2{core::num};
+        {
+          return a;
+        }
       }
     }
-    else {
+    {
       {
-        return null;
+        {
+          return null;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/simple_switch_with_guards_runtime.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/simple_switch_with_guards_runtime.dart.weak.modular.expect
index e7ccfc451d8..6f5de608abb 100644
--- a/pkg/front_end/testcases/patterns/simple_switch_with_guards_runtime.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/simple_switch_with_guards_runtime.dart.weak.modular.expect
@@ -5,17 +5,21 @@ import "dart:core" as core;
 static method test1(dynamic x) → dynamic {
   #L1:
   {
-    core::int a;
     final synthesized dynamic #0#0 = x;
     late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = a = #0#6{core::int} in true)) && a.{core::num::>}(0){(core::num) → core::bool}) {
-      {
-        return a;
+    {
+      core::int a;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = a = #0#6{core::int} in true)) && a.{core::num::>}(0){(core::num) → core::bool}) {
+        {
+          return a;
+        }
       }
     }
-    else {
+    {
       {
-        return null;
+        {
+          return null;
+        }
       }
     }
   }
@@ -23,22 +27,26 @@ static method test1(dynamic x) → dynamic {
 static method test2(dynamic x) → dynamic {
   #L2:
   {
-    core::num a;
-    core::num a#1;
     final synthesized dynamic #0#0 = x;
     late final synthesized core::bool #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2;
     late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
     late final synthesized dynamic #0#7 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic};
     dynamic #t2;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::num && (let final dynamic #t3 = a = #0#6{core::num} in true)) && (let final dynamic #t4 = #0#7 in true) && (a is{ForNonNullableByDefault} core::int && a{core::int}.{core::int::isEven}{core::bool}) && (let final dynamic #t5 = #t2 = a in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (let final dynamic #t6 = #0#6 in true) && (#0#7 is{ForNonNullableByDefault} core::num && (let final dynamic #t7 = a#1 = #0#7{core::num} in true)) && (a#1 is{ForNonNullableByDefault} core::double && a#1{core::double}.{core::double::ceil}(){() → core::int}.{core::int::isOdd}{core::bool}) && (let final dynamic #t8 = #t2 = a#1 in true)) {
-      core::num a = #t2{core::num};
-      {
-        return a;
+    {
+      lowered core::num a#case#0;
+      lowered core::num a#case#1;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::num && (let final dynamic #t3 = a#case#0 = #0#6{core::num} in true)) && (let final dynamic #t4 = #0#7 in true) && (a#case#0 is{ForNonNullableByDefault} core::int && a#case#0{core::int}.{core::int::isEven}{core::bool}) && (let final dynamic #t5 = #t2 = a#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (let final dynamic #t6 = #0#6 in true) && (#0#7 is{ForNonNullableByDefault} core::num && (let final dynamic #t7 = a#case#1 = #0#7{core::num} in true)) && (a#case#1 is{ForNonNullableByDefault} core::double && a#case#1{core::double}.{core::double::ceil}(){() → core::int}.{core::int::isOdd}{core::bool}) && (let final dynamic #t8 = #t2 = a#case#1 in true)) {
+        core::num a = #t2{core::num};
+        {
+          return a;
+        }
       }
     }
-    else {
+    {
       {
-        return null;
+        {
+          return null;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/simple_switch_with_guards_runtime.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/simple_switch_with_guards_runtime.dart.weak.transformed.expect
index 7940e33c376..f5a2fcd963b 100644
--- a/pkg/front_end/testcases/patterns/simple_switch_with_guards_runtime.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/simple_switch_with_guards_runtime.dart.weak.transformed.expect
@@ -5,19 +5,23 @@ import "dart:core" as core;
 static method test1(dynamic x) → dynamic {
   #L1:
   {
-    core::int a;
     final synthesized dynamic #0#0 = x;
     function ##0#6#initializer() → dynamic
       return #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
     late final synthesized dynamic #0#6 = ##0#6#initializer(){() → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (#0#6 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = a = #0#6{core::int} in true)) && a.{core::num::>}(0){(core::num) → core::bool}) {
-      {
-        return a;
+    {
+      core::int a;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (#0#6 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = a = #0#6{core::int} in true)) && a.{core::num::>}(0){(core::num) → core::bool}) {
+        {
+          return a;
+        }
       }
     }
-    else {
+    {
       {
-        return null;
+        {
+          return null;
+        }
       }
     }
   }
@@ -25,8 +29,6 @@ static method test1(dynamic x) → dynamic {
 static method test2(dynamic x) → dynamic {
   #L2:
   {
-    core::num a;
-    core::num a#1;
     final synthesized dynamic #0#0 = x;
     function ##0#4#initializer() → core::bool
       return #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2;
@@ -38,15 +40,21 @@ static method test2(dynamic x) → dynamic {
       return #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic};
     late final synthesized dynamic #0#7 = ##0#7#initializer(){() → dynamic};
     dynamic #t2;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::num && (let final core::num #t3 = a = #0#6{core::num} in true)) && (let final dynamic #t4 = #0#7 in true) && (a is{ForNonNullableByDefault} core::int && a{core::int}.{core::int::isEven}{core::bool}) && (let final core::num #t5 = #t2 = a in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (let final dynamic #t6 = #0#6 in true) && (#0#7 is{ForNonNullableByDefault} core::num && (let final core::num #t7 = a#1 = #0#7{core::num} in true)) && (a#1 is{ForNonNullableByDefault} core::double && a#1{core::double}.{core::double::ceil}(){() → core::int}.{core::int::isOdd}{core::bool}) && (let final core::num #t8 = #t2 = a#1 in true)) {
-      core::num a = #t2{core::num};
-      {
-        return a;
+    {
+      lowered core::num a#case#0;
+      lowered core::num a#case#1;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::num && (let final core::num #t3 = a#case#0 = #0#6{core::num} in true)) && (let final dynamic #t4 = #0#7 in true) && (a#case#0 is{ForNonNullableByDefault} core::int && a#case#0{core::int}.{core::int::isEven}{core::bool}) && (let final core::num #t5 = #t2 = a#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (let final dynamic #t6 = #0#6 in true) && (#0#7 is{ForNonNullableByDefault} core::num && (let final core::num #t7 = a#case#1 = #0#7{core::num} in true)) && (a#case#1 is{ForNonNullableByDefault} core::double && a#case#1{core::double}.{core::double::ceil}(){() → core::int}.{core::int::isOdd}{core::bool}) && (let final core::num #t8 = #t2 = a#case#1 in true)) {
+        core::num a = #t2{core::num};
+        {
+          return a;
+        }
       }
     }
-    else {
+    {
       {
-        return null;
+        {
+          return null;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/string_literal_inside_case.dart.strong.expect b/pkg/front_end/testcases/patterns/string_literal_inside_case.dart.strong.expect
index 32410dd3f6d..3868fdb6526 100644
--- a/pkg/front_end/testcases/patterns/string_literal_inside_case.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/string_literal_inside_case.dart.strong.expect
@@ -4,13 +4,12 @@ import "dart:core" as core;
 
 static method test(dynamic x) → dynamic {
   #L1:
-  {
-    final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::String::==}{(core::Object) → core::bool} #0#0) {
+  switch(x) {
+    #L2:
+    case #C1:
       {
         break #L1;
       }
-    }
   }
 }
 
diff --git a/pkg/front_end/testcases/patterns/string_literal_inside_case.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/string_literal_inside_case.dart.strong.transformed.expect
index 32410dd3f6d..3868fdb6526 100644
--- a/pkg/front_end/testcases/patterns/string_literal_inside_case.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/string_literal_inside_case.dart.strong.transformed.expect
@@ -4,13 +4,12 @@ import "dart:core" as core;
 
 static method test(dynamic x) → dynamic {
   #L1:
-  {
-    final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::String::==}{(core::Object) → core::bool} #0#0) {
+  switch(x) {
+    #L2:
+    case #C1:
       {
         break #L1;
       }
-    }
   }
 }
 
diff --git a/pkg/front_end/testcases/patterns/string_literal_inside_case.dart.weak.expect b/pkg/front_end/testcases/patterns/string_literal_inside_case.dart.weak.expect
index 32410dd3f6d..3868fdb6526 100644
--- a/pkg/front_end/testcases/patterns/string_literal_inside_case.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/string_literal_inside_case.dart.weak.expect
@@ -4,13 +4,12 @@ import "dart:core" as core;
 
 static method test(dynamic x) → dynamic {
   #L1:
-  {
-    final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::String::==}{(core::Object) → core::bool} #0#0) {
+  switch(x) {
+    #L2:
+    case #C1:
       {
         break #L1;
       }
-    }
   }
 }
 
diff --git a/pkg/front_end/testcases/patterns/string_literal_inside_case.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/string_literal_inside_case.dart.weak.modular.expect
index 32410dd3f6d..3868fdb6526 100644
--- a/pkg/front_end/testcases/patterns/string_literal_inside_case.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/string_literal_inside_case.dart.weak.modular.expect
@@ -4,13 +4,12 @@ import "dart:core" as core;
 
 static method test(dynamic x) → dynamic {
   #L1:
-  {
-    final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::String::==}{(core::Object) → core::bool} #0#0) {
+  switch(x) {
+    #L2:
+    case #C1:
       {
         break #L1;
       }
-    }
   }
 }
 
diff --git a/pkg/front_end/testcases/patterns/string_literal_inside_case.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/string_literal_inside_case.dart.weak.transformed.expect
index 32410dd3f6d..3868fdb6526 100644
--- a/pkg/front_end/testcases/patterns/string_literal_inside_case.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/string_literal_inside_case.dart.weak.transformed.expect
@@ -4,13 +4,12 @@ import "dart:core" as core;
 
 static method test(dynamic x) → dynamic {
   #L1:
-  {
-    final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::String::==}{(core::Object) → core::bool} #0#0) {
+  switch(x) {
+    #L2:
+    case #C1:
       {
         break #L1;
       }
-    }
   }
 }
 
diff --git a/pkg/front_end/testcases/patterns/string_literal_inside_cast.dart.strong.expect b/pkg/front_end/testcases/patterns/string_literal_inside_cast.dart.strong.expect
index 6a8c856bbf4..7c18d123c37 100644
--- a/pkg/front_end/testcases/patterns/string_literal_inside_cast.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/string_literal_inside_cast.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in #C1 =={core::String::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::Object) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in #C1 =={core::String::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::Object) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/string_literal_inside_cast.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/string_literal_inside_cast.dart.strong.transformed.expect
index 936e13ec633..a8c9cf24dba 100644
--- a/pkg/front_end/testcases/patterns/string_literal_inside_cast.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/string_literal_inside_cast.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final core::Object #t1 = let dynamic #t2 = #0#0 in #t2 == null ?{core::Object} #t2 as{ForNonNullableByDefault} core::Object : #t2{core::Object} in #C1 =={core::String::==}{(core::Object) → core::bool} (let dynamic #t3 = #0#0 in #t3 == null ?{core::Object} #t3 as{ForNonNullableByDefault} core::Object : #t3{core::Object})) {
-      {
-        break #L1;
+    {
+      if(let final core::Object #t1 = let dynamic #t2 = #0#0 in #t2 == null ?{core::Object} #t2 as{ForNonNullableByDefault} core::Object : #t2{core::Object} in #C1 =={core::String::==}{(core::Object) → core::bool} (let dynamic #t3 = #0#0 in #t3 == null ?{core::Object} #t3 as{ForNonNullableByDefault} core::Object : #t3{core::Object})) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/string_literal_inside_cast.dart.weak.expect b/pkg/front_end/testcases/patterns/string_literal_inside_cast.dart.weak.expect
index 6a8c856bbf4..7c18d123c37 100644
--- a/pkg/front_end/testcases/patterns/string_literal_inside_cast.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/string_literal_inside_cast.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in #C1 =={core::String::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::Object) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in #C1 =={core::String::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::Object) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/string_literal_inside_cast.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/string_literal_inside_cast.dart.weak.modular.expect
index 6a8c856bbf4..7c18d123c37 100644
--- a/pkg/front_end/testcases/patterns/string_literal_inside_cast.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/string_literal_inside_cast.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in #C1 =={core::String::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::Object) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in #C1 =={core::String::==}{(core::Object) → core::bool} #0#0 as{ForNonNullableByDefault} core::Object) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/string_literal_inside_cast.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/string_literal_inside_cast.dart.weak.transformed.expect
index 941c593d330..72b452264fa 100644
--- a/pkg/front_end/testcases/patterns/string_literal_inside_cast.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/string_literal_inside_cast.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final core::Object #t1 = #0#0 in #C1 =={core::String::==}{(core::Object) → core::bool} #0#0) {
-      {
-        break #L1;
+    {
+      if(let final core::Object #t1 = #0#0 in #C1 =={core::String::==}{(core::Object) → core::bool} #0#0) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/string_literal_inside_null_assert.dart.strong.expect b/pkg/front_end/testcases/patterns/string_literal_inside_null_assert.dart.strong.expect
index de3a6cbbab1..314c0669b61 100644
--- a/pkg/front_end/testcases/patterns/string_literal_inside_null_assert.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/string_literal_inside_null_assert.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #C1 =={core::String::==}{(core::Object) → core::bool} #0#0!) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #C1 =={core::String::==}{(core::Object) → core::bool} #0#0!) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/string_literal_inside_null_assert.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/string_literal_inside_null_assert.dart.strong.transformed.expect
index de3a6cbbab1..314c0669b61 100644
--- a/pkg/front_end/testcases/patterns/string_literal_inside_null_assert.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/string_literal_inside_null_assert.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #C1 =={core::String::==}{(core::Object) → core::bool} #0#0!) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #C1 =={core::String::==}{(core::Object) → core::bool} #0#0!) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/string_literal_inside_null_assert.dart.weak.expect b/pkg/front_end/testcases/patterns/string_literal_inside_null_assert.dart.weak.expect
index de3a6cbbab1..314c0669b61 100644
--- a/pkg/front_end/testcases/patterns/string_literal_inside_null_assert.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/string_literal_inside_null_assert.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #C1 =={core::String::==}{(core::Object) → core::bool} #0#0!) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #C1 =={core::String::==}{(core::Object) → core::bool} #0#0!) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/string_literal_inside_null_assert.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/string_literal_inside_null_assert.dart.weak.modular.expect
index de3a6cbbab1..314c0669b61 100644
--- a/pkg/front_end/testcases/patterns/string_literal_inside_null_assert.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/string_literal_inside_null_assert.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #C1 =={core::String::==}{(core::Object) → core::bool} #0#0!) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #C1 =={core::String::==}{(core::Object) → core::bool} #0#0!) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/string_literal_inside_null_assert.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/string_literal_inside_null_assert.dart.weak.transformed.expect
index de3a6cbbab1..314c0669b61 100644
--- a/pkg/front_end/testcases/patterns/string_literal_inside_null_assert.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/string_literal_inside_null_assert.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #C1 =={core::String::==}{(core::Object) → core::bool} #0#0!) {
-      {
-        break #L1;
+    {
+      if(let final dynamic #t1 = #0#0! in #C1 =={core::String::==}{(core::Object) → core::bool} #0#0!) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/string_literal_inside_null_check.dart.strong.expect b/pkg/front_end/testcases/patterns/string_literal_inside_null_check.dart.strong.expect
index 9a758221c1c..922249e25d5 100644
--- a/pkg/front_end/testcases/patterns/string_literal_inside_null_check.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/string_literal_inside_null_check.dart.strong.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #C1 =={core::String::==}{(core::Object) → core::bool} #0#0 : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #C1 =={core::String::==}{(core::Object) → core::bool} #0#0 : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/string_literal_inside_null_check.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/string_literal_inside_null_check.dart.strong.transformed.expect
index 9a758221c1c..922249e25d5 100644
--- a/pkg/front_end/testcases/patterns/string_literal_inside_null_check.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/string_literal_inside_null_check.dart.strong.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #C1 =={core::String::==}{(core::Object) → core::bool} #0#0 : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #C1 =={core::String::==}{(core::Object) → core::bool} #0#0 : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/string_literal_inside_null_check.dart.weak.expect b/pkg/front_end/testcases/patterns/string_literal_inside_null_check.dart.weak.expect
index 9a758221c1c..922249e25d5 100644
--- a/pkg/front_end/testcases/patterns/string_literal_inside_null_check.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/string_literal_inside_null_check.dart.weak.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #C1 =={core::String::==}{(core::Object) → core::bool} #0#0 : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #C1 =={core::String::==}{(core::Object) → core::bool} #0#0 : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/string_literal_inside_null_check.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/string_literal_inside_null_check.dart.weak.modular.expect
index 9a758221c1c..922249e25d5 100644
--- a/pkg/front_end/testcases/patterns/string_literal_inside_null_check.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/string_literal_inside_null_check.dart.weak.modular.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #C1 =={core::String::==}{(core::Object) → core::bool} #0#0 : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #C1 =={core::String::==}{(core::Object) → core::bool} #0#0 : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/string_literal_inside_null_check.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/string_literal_inside_null_check.dart.weak.transformed.expect
index 9a758221c1c..922249e25d5 100644
--- a/pkg/front_end/testcases/patterns/string_literal_inside_null_check.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/string_literal_inside_null_check.dart.weak.transformed.expect
@@ -6,9 +6,11 @@ static method test(dynamic x) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #C1 =={core::String::==}{(core::Object) → core::bool} #0#0 : false) {
-      {
-        break #L1;
+    {
+      if(!(#0#0 == null) ?{core::bool} #C1 =={core::String::==}{(core::Object) → core::bool} #0#0 : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/switchExpression_onePattern_guarded.dart.strong.expect b/pkg/front_end/testcases/patterns/switchExpression_onePattern_guarded.dart.strong.expect
index 8f7c3a56c18..54f22a5c403 100644
--- a/pkg/front_end/testcases/patterns/switchExpression_onePattern_guarded.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/switchExpression_onePattern_guarded.dart.strong.expect
@@ -13,6 +13,13 @@ import "dart:core" as core;
 static method f(dynamic x) → dynamic
   return block {
     core::int #t1;
-    if(true && true)
-      #t1 = 0;
+    #L1:
+    {
+      {
+        if(true && true) {
+          #t1 = 0;
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
diff --git a/pkg/front_end/testcases/patterns/switchExpression_onePattern_guarded.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/switchExpression_onePattern_guarded.dart.strong.transformed.expect
index 0bbfc21439c..98160125cad 100644
--- a/pkg/front_end/testcases/patterns/switchExpression_onePattern_guarded.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/switchExpression_onePattern_guarded.dart.strong.transformed.expect
@@ -13,8 +13,15 @@ import "dart:core" as core;
 static method f(dynamic x) → dynamic
   return block {
     core::int #t1;
-    if(true && true)
-      #t1 = 0;
+    #L1:
+    {
+      {
+        if(true && true) {
+          #t1 = 0;
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
 
 
diff --git a/pkg/front_end/testcases/patterns/switchExpression_onePattern_guarded.dart.weak.expect b/pkg/front_end/testcases/patterns/switchExpression_onePattern_guarded.dart.weak.expect
index 8f7c3a56c18..54f22a5c403 100644
--- a/pkg/front_end/testcases/patterns/switchExpression_onePattern_guarded.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/switchExpression_onePattern_guarded.dart.weak.expect
@@ -13,6 +13,13 @@ import "dart:core" as core;
 static method f(dynamic x) → dynamic
   return block {
     core::int #t1;
-    if(true && true)
-      #t1 = 0;
+    #L1:
+    {
+      {
+        if(true && true) {
+          #t1 = 0;
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
diff --git a/pkg/front_end/testcases/patterns/switchExpression_onePattern_guarded.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/switchExpression_onePattern_guarded.dart.weak.modular.expect
index 8f7c3a56c18..54f22a5c403 100644
--- a/pkg/front_end/testcases/patterns/switchExpression_onePattern_guarded.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/switchExpression_onePattern_guarded.dart.weak.modular.expect
@@ -13,6 +13,13 @@ import "dart:core" as core;
 static method f(dynamic x) → dynamic
   return block {
     core::int #t1;
-    if(true && true)
-      #t1 = 0;
+    #L1:
+    {
+      {
+        if(true && true) {
+          #t1 = 0;
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
diff --git a/pkg/front_end/testcases/patterns/switchExpression_onePattern_guarded.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/switchExpression_onePattern_guarded.dart.weak.transformed.expect
index 0bbfc21439c..98160125cad 100644
--- a/pkg/front_end/testcases/patterns/switchExpression_onePattern_guarded.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/switchExpression_onePattern_guarded.dart.weak.transformed.expect
@@ -13,8 +13,15 @@ import "dart:core" as core;
 static method f(dynamic x) → dynamic
   return block {
     core::int #t1;
-    if(true && true)
-      #t1 = 0;
+    #L1:
+    {
+      {
+        if(true && true) {
+          #t1 = 0;
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
 
 
diff --git a/pkg/front_end/testcases/patterns/switchExpression_onePattern_noTrailingComma.dart.strong.expect b/pkg/front_end/testcases/patterns/switchExpression_onePattern_noTrailingComma.dart.strong.expect
index dedc466f6d4..b7a976419a3 100644
--- a/pkg/front_end/testcases/patterns/switchExpression_onePattern_noTrailingComma.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/switchExpression_onePattern_noTrailingComma.dart.strong.expect
@@ -5,6 +5,13 @@ import "dart:core" as core;
 static method f(dynamic x) → dynamic
   return block {
     core::int #t1;
-    if(true)
-      #t1 = 0;
+    #L1:
+    {
+      {
+        if(true) {
+          #t1 = 0;
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
diff --git a/pkg/front_end/testcases/patterns/switchExpression_onePattern_noTrailingComma.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/switchExpression_onePattern_noTrailingComma.dart.strong.transformed.expect
index dedc466f6d4..b7a976419a3 100644
--- a/pkg/front_end/testcases/patterns/switchExpression_onePattern_noTrailingComma.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/switchExpression_onePattern_noTrailingComma.dart.strong.transformed.expect
@@ -5,6 +5,13 @@ import "dart:core" as core;
 static method f(dynamic x) → dynamic
   return block {
     core::int #t1;
-    if(true)
-      #t1 = 0;
+    #L1:
+    {
+      {
+        if(true) {
+          #t1 = 0;
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
diff --git a/pkg/front_end/testcases/patterns/switchExpression_onePattern_noTrailingComma.dart.weak.expect b/pkg/front_end/testcases/patterns/switchExpression_onePattern_noTrailingComma.dart.weak.expect
index dedc466f6d4..b7a976419a3 100644
--- a/pkg/front_end/testcases/patterns/switchExpression_onePattern_noTrailingComma.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/switchExpression_onePattern_noTrailingComma.dart.weak.expect
@@ -5,6 +5,13 @@ import "dart:core" as core;
 static method f(dynamic x) → dynamic
   return block {
     core::int #t1;
-    if(true)
-      #t1 = 0;
+    #L1:
+    {
+      {
+        if(true) {
+          #t1 = 0;
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
diff --git a/pkg/front_end/testcases/patterns/switchExpression_onePattern_noTrailingComma.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/switchExpression_onePattern_noTrailingComma.dart.weak.modular.expect
index dedc466f6d4..b7a976419a3 100644
--- a/pkg/front_end/testcases/patterns/switchExpression_onePattern_noTrailingComma.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/switchExpression_onePattern_noTrailingComma.dart.weak.modular.expect
@@ -5,6 +5,13 @@ import "dart:core" as core;
 static method f(dynamic x) → dynamic
   return block {
     core::int #t1;
-    if(true)
-      #t1 = 0;
+    #L1:
+    {
+      {
+        if(true) {
+          #t1 = 0;
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
diff --git a/pkg/front_end/testcases/patterns/switchExpression_onePattern_noTrailingComma.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/switchExpression_onePattern_noTrailingComma.dart.weak.transformed.expect
index dedc466f6d4..b7a976419a3 100644
--- a/pkg/front_end/testcases/patterns/switchExpression_onePattern_noTrailingComma.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/switchExpression_onePattern_noTrailingComma.dart.weak.transformed.expect
@@ -5,6 +5,13 @@ import "dart:core" as core;
 static method f(dynamic x) → dynamic
   return block {
     core::int #t1;
-    if(true)
-      #t1 = 0;
+    #L1:
+    {
+      {
+        if(true) {
+          #t1 = 0;
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
diff --git a/pkg/front_end/testcases/patterns/switchExpression_onePattern_trailingComma.dart.strong.expect b/pkg/front_end/testcases/patterns/switchExpression_onePattern_trailingComma.dart.strong.expect
index dedc466f6d4..b7a976419a3 100644
--- a/pkg/front_end/testcases/patterns/switchExpression_onePattern_trailingComma.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/switchExpression_onePattern_trailingComma.dart.strong.expect
@@ -5,6 +5,13 @@ import "dart:core" as core;
 static method f(dynamic x) → dynamic
   return block {
     core::int #t1;
-    if(true)
-      #t1 = 0;
+    #L1:
+    {
+      {
+        if(true) {
+          #t1 = 0;
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
diff --git a/pkg/front_end/testcases/patterns/switchExpression_onePattern_trailingComma.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/switchExpression_onePattern_trailingComma.dart.strong.transformed.expect
index dedc466f6d4..b7a976419a3 100644
--- a/pkg/front_end/testcases/patterns/switchExpression_onePattern_trailingComma.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/switchExpression_onePattern_trailingComma.dart.strong.transformed.expect
@@ -5,6 +5,13 @@ import "dart:core" as core;
 static method f(dynamic x) → dynamic
   return block {
     core::int #t1;
-    if(true)
-      #t1 = 0;
+    #L1:
+    {
+      {
+        if(true) {
+          #t1 = 0;
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
diff --git a/pkg/front_end/testcases/patterns/switchExpression_onePattern_trailingComma.dart.weak.expect b/pkg/front_end/testcases/patterns/switchExpression_onePattern_trailingComma.dart.weak.expect
index dedc466f6d4..b7a976419a3 100644
--- a/pkg/front_end/testcases/patterns/switchExpression_onePattern_trailingComma.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/switchExpression_onePattern_trailingComma.dart.weak.expect
@@ -5,6 +5,13 @@ import "dart:core" as core;
 static method f(dynamic x) → dynamic
   return block {
     core::int #t1;
-    if(true)
-      #t1 = 0;
+    #L1:
+    {
+      {
+        if(true) {
+          #t1 = 0;
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
diff --git a/pkg/front_end/testcases/patterns/switchExpression_onePattern_trailingComma.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/switchExpression_onePattern_trailingComma.dart.weak.modular.expect
index dedc466f6d4..b7a976419a3 100644
--- a/pkg/front_end/testcases/patterns/switchExpression_onePattern_trailingComma.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/switchExpression_onePattern_trailingComma.dart.weak.modular.expect
@@ -5,6 +5,13 @@ import "dart:core" as core;
 static method f(dynamic x) → dynamic
   return block {
     core::int #t1;
-    if(true)
-      #t1 = 0;
+    #L1:
+    {
+      {
+        if(true) {
+          #t1 = 0;
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
diff --git a/pkg/front_end/testcases/patterns/switchExpression_onePattern_trailingComma.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/switchExpression_onePattern_trailingComma.dart.weak.transformed.expect
index dedc466f6d4..b7a976419a3 100644
--- a/pkg/front_end/testcases/patterns/switchExpression_onePattern_trailingComma.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/switchExpression_onePattern_trailingComma.dart.weak.transformed.expect
@@ -5,6 +5,13 @@ import "dart:core" as core;
 static method f(dynamic x) → dynamic
   return block {
     core::int #t1;
-    if(true)
-      #t1 = 0;
+    #L1:
+    {
+      {
+        if(true) {
+          #t1 = 0;
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
diff --git a/pkg/front_end/testcases/patterns/switchExpression_twoPatterns.dart.strong.expect b/pkg/front_end/testcases/patterns/switchExpression_twoPatterns.dart.strong.expect
index a02dd8454ca..a7653c3ff72 100644
--- a/pkg/front_end/testcases/patterns/switchExpression_twoPatterns.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/switchExpression_twoPatterns.dart.strong.expect
@@ -6,9 +6,19 @@ static method f(dynamic x) → dynamic
   return block {
     core::int #t1;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int)
-      #t1 = 0;
-    else
-      if(true)
-        #t1 = 1;
+    #L1:
+    {
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::int) {
+          #t1 = 0;
+          break #L1;
+        }
+      }
+      {
+        if(true) {
+          #t1 = 1;
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
diff --git a/pkg/front_end/testcases/patterns/switchExpression_twoPatterns.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/switchExpression_twoPatterns.dart.strong.transformed.expect
index a02dd8454ca..a7653c3ff72 100644
--- a/pkg/front_end/testcases/patterns/switchExpression_twoPatterns.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/switchExpression_twoPatterns.dart.strong.transformed.expect
@@ -6,9 +6,19 @@ static method f(dynamic x) → dynamic
   return block {
     core::int #t1;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int)
-      #t1 = 0;
-    else
-      if(true)
-        #t1 = 1;
+    #L1:
+    {
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::int) {
+          #t1 = 0;
+          break #L1;
+        }
+      }
+      {
+        if(true) {
+          #t1 = 1;
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
diff --git a/pkg/front_end/testcases/patterns/switchExpression_twoPatterns.dart.weak.expect b/pkg/front_end/testcases/patterns/switchExpression_twoPatterns.dart.weak.expect
index a02dd8454ca..a7653c3ff72 100644
--- a/pkg/front_end/testcases/patterns/switchExpression_twoPatterns.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/switchExpression_twoPatterns.dart.weak.expect
@@ -6,9 +6,19 @@ static method f(dynamic x) → dynamic
   return block {
     core::int #t1;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int)
-      #t1 = 0;
-    else
-      if(true)
-        #t1 = 1;
+    #L1:
+    {
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::int) {
+          #t1 = 0;
+          break #L1;
+        }
+      }
+      {
+        if(true) {
+          #t1 = 1;
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
diff --git a/pkg/front_end/testcases/patterns/switchExpression_twoPatterns.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/switchExpression_twoPatterns.dart.weak.modular.expect
index a02dd8454ca..a7653c3ff72 100644
--- a/pkg/front_end/testcases/patterns/switchExpression_twoPatterns.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/switchExpression_twoPatterns.dart.weak.modular.expect
@@ -6,9 +6,19 @@ static method f(dynamic x) → dynamic
   return block {
     core::int #t1;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int)
-      #t1 = 0;
-    else
-      if(true)
-        #t1 = 1;
+    #L1:
+    {
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::int) {
+          #t1 = 0;
+          break #L1;
+        }
+      }
+      {
+        if(true) {
+          #t1 = 1;
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
diff --git a/pkg/front_end/testcases/patterns/switchExpression_twoPatterns.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/switchExpression_twoPatterns.dart.weak.transformed.expect
index a02dd8454ca..a7653c3ff72 100644
--- a/pkg/front_end/testcases/patterns/switchExpression_twoPatterns.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/switchExpression_twoPatterns.dart.weak.transformed.expect
@@ -6,9 +6,19 @@ static method f(dynamic x) → dynamic
   return block {
     core::int #t1;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int)
-      #t1 = 0;
-    else
-      if(true)
-        #t1 = 1;
+    #L1:
+    {
+      {
+        if(#0#0 is{ForNonNullableByDefault} core::int) {
+          #t1 = 0;
+          break #L1;
+        }
+      }
+      {
+        if(true) {
+          #t1 = 1;
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
diff --git a/pkg/front_end/testcases/patterns/switch_encoding.dart b/pkg/front_end/testcases/patterns/switch_encoding.dart
new file mode 100644
index 00000000000..db4381fdd37
--- /dev/null
+++ b/pkg/front_end/testcases/patterns/switch_encoding.dart
@@ -0,0 +1,248 @@
+// 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.
+
+enum E { a, b, c }
+
+class PrimitiveEquals {
+  final int field;
+
+  const PrimitiveEquals(this.field);
+}
+
+class NonPrimitiveEquals {
+  final int field;
+
+  const NonPrimitiveEquals(this.field);
+
+  int get hashCode => field.hashCode;
+
+  bool operator ==(Object other) {
+    if (identical(this, other)) return true;
+    return other is NonPrimitiveEquals && field == other.field;
+  }
+}
+
+switchStatement(o) {
+  switch (o) {
+    case [var a] when a > 5:
+    case [_, var a] when a < 5:
+      print(a);
+    case {1: var a}:
+      print(a);
+  }
+}
+
+switchStatementWithLabel(o) {
+  switch (o) {
+    case [var a] when a > 5:
+    case [_, var a] when a < 5:
+      print(a);
+    case {1: var a}:
+      print(a);
+    label:
+    case 1:
+      print(1);
+  }
+}
+
+switchStatementWithContinue(o) {
+  switch (o) {
+    case [var a] when a > 5:
+    case [_, var a] when a < 5:
+      print(a);
+    case {1: var a}:
+      print(a);
+      continue label1;
+    case 0:
+      print(o);
+    label1:
+    case 1:
+      print(1);
+      continue label2;
+    label2:
+    case 2:
+      print(2);
+  }
+}
+
+switchStatementWithContinueNested(o1, o2) {
+  switch (o1) {
+    case [var a]:
+      print(a);
+    case {1: var a}:
+      print(a);
+      switch (o2) {
+        case [var a] when a > 5:
+        case [_, var a] when a < 5:
+          print(a);
+        case {1: var a}:
+          print(a);
+          continue label2a;
+        case 0:
+          print(o2);
+          continue label1b;
+        label1b:
+        case 1:
+          print(1);
+          continue label2b;
+        label2b:
+        case 2:
+          print(2);
+          continue label1a;
+      }
+    case 0:
+      print(o1);
+    label1a:
+    case 1:
+      print(1);
+      continue label2a;
+    label2a:
+    case 2:
+      print(2);
+      switch (o2) {
+        case [var a] when a > 5:
+        case [_, var a] when a < 5:
+          print(a);
+        case {1: var a}:
+          print(a);
+          continue label2a;
+        case 0:
+          print(o2);
+          continue label1b;
+        label1b:
+        case 1:
+          print(1);
+          continue label2b;
+        label2b:
+        case 2:
+          print(2);
+          continue label1a;
+      }
+  }
+}
+
+switchStatementEnum(E o) {
+  switch (o) {
+    case E.a:
+      print('a');
+    case E.b:
+      print('b');
+    case E.c:
+      print('c');
+  }
+}
+
+switchStatementEnumWithGuard(E o) {
+  switch (o) {
+    case E.a when true:
+      print('a');
+    case E.b:
+      print('b');
+    case _:
+  }
+}
+
+switchStatementEnumWithLabel(E o) {
+  switch (o) {
+    case E.a:
+      print('a');
+    label:
+    case E.b:
+      print('b');
+    case E.c:
+      print('c');
+  }
+}
+
+switchStatementEnumWithContinue(E o) {
+  switch (o) {
+    case E.a:
+      print('a');
+      continue label1;
+    label1:
+    case E.b:
+      print('b');
+      continue label2;
+    label2:
+    case E.c:
+      print('c');
+  }
+}
+
+switchStatementPrimitiveEquals(o) {
+  switch (o) {
+    case const PrimitiveEquals(0):
+      print('a');
+    case const PrimitiveEquals(1):
+      print('b');
+  }
+}
+
+switchStatementNonPrimitiveEquals(o) {
+  switch (o) {
+    case const NonPrimitiveEquals(0):
+      print('a');
+    case const NonPrimitiveEquals(1):
+      print('b');
+  }
+}
+
+switchExpression(o) {
+  return switch (o) {
+    [var a] => a,
+    {1: var a} => a,
+    _ => null,
+  };
+}
+
+switchExpressionEnum(E o) {
+  return switch (o) {
+    E.a => 0,
+    E.b => 1,
+    E.c => 2,
+  };
+}
+
+switchExpressionEnumWithGuard(E o) {
+  return switch (o) {
+    E.a when true => 0,
+    E.b => 1,
+    _ => 2,
+  };
+}
+
+switchExpressionPrimitiveEquals(o) {
+  return switch (o) {
+    const PrimitiveEquals(0) => 0,
+    const PrimitiveEquals(1) => 1,
+    _ => 2,
+  };
+}
+
+switchExpressionNonPrimitiveEquals(o) {
+  return switch (o) {
+    const NonPrimitiveEquals(0) => 0,
+    const NonPrimitiveEquals(1) => 1,
+    _ => 2,
+  };
+}
+
+switchStatementSymbol(Symbol s) {
+  switch (s) {
+    case #a:
+      return 0;
+    case const Symbol('b'):
+      return 1;
+    default:
+      return 2;
+  }
+}
+
+switchExpressionSymbol(Symbol s) {
+  return switch (s) {
+    #a => 0,
+    const Symbol('b') => 1,
+    _ => 2,
+  };
+}
diff --git a/pkg/front_end/testcases/patterns/switch_encoding.dart.strong.expect b/pkg/front_end/testcases/patterns/switch_encoding.dart.strong.expect
new file mode 100644
index 00000000000..b5af432adb7
--- /dev/null
+++ b/pkg/front_end/testcases/patterns/switch_encoding.dart.strong.expect
@@ -0,0 +1,742 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+class E extends core::_Enum /*isEnum*/  {
+  static const field core::List<self::E> values = #C10;
+  enum-element static const field self::E a = #C3;
+  enum-element static const field self::E b = #C6;
+  enum-element static const field self::E c = #C9;
+  const constructor •(core::int #index, core::String #name) → self::E
+    : super core::_Enum::•(#index, #name)
+    ;
+  method _enumToString() → core::String
+    return "E.${this.{core::_Enum::_name}{core::String}}";
+}
+class PrimitiveEquals extends core::Object /*hasConstConstructor*/  {
+  final field core::int field;
+  const constructor •(core::int field) → self::PrimitiveEquals
+    : self::PrimitiveEquals::field = field, super core::Object::•()
+    ;
+}
+class NonPrimitiveEquals extends core::Object /*hasConstConstructor*/  {
+  final field core::int field;
+  const constructor •(core::int field) → self::NonPrimitiveEquals
+    : self::NonPrimitiveEquals::field = field, super core::Object::•()
+    ;
+  get hashCode() → core::int
+    return this.{self::NonPrimitiveEquals::field}{core::int}.{core::num::hashCode}{core::int};
+  operator ==(core::Object other) → core::bool {
+    if(core::identical(this, other))
+      return true;
+    return other is{ForNonNullableByDefault} self::NonPrimitiveEquals && this.{self::NonPrimitiveEquals::field}{core::int} =={core::num::==}{(core::Object) → core::bool} other{self::NonPrimitiveEquals}.{self::NonPrimitiveEquals::field}{core::int};
+  }
+}
+static method switchStatement(dynamic o) → dynamic {
+  #L1:
+  {
+    final synthesized dynamic #0#0 = o;
+    synthesized core::bool #0#4;
+    synthesized core::bool #0#4#isSet = false;
+    synthesized core::int #0#2;
+    synthesized core::bool #0#2#isSet = false;
+    late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
+    dynamic #t1;
+    {
+      lowered dynamic a#case#0;
+      lowered dynamic a#case#1;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t2 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t3 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && (let final dynamic #t4 = a#case#0 = #0#6 in true) && a#case#0{dynamic}.>(5) && (let final dynamic #t5 = #t1 = a#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t6 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t7 = #0#6 in true) && (let final dynamic #t8 = a#case#1 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic} in true) && a#case#1{dynamic}.<(5) && (let final dynamic #t9 = #t1 = a#case#1 in true)) {
+        dynamic a = #t1{dynamic};
+        {
+          core::print(a);
+          break #L1;
+        }
+      }
+    }
+    {
+      dynamic a;
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t10 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t11 = #0#2#isSet = true in #0#2 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && (let final dynamic #t12 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C4){(core::Object?) → dynamic} in true)) {
+        {
+          core::print(a);
+        }
+      }
+    }
+  }
+}
+static method switchStatementWithLabel(dynamic o) → dynamic {
+  #L2:
+  {
+    final synthesized dynamic #0#0 = o;
+    synthesized core::bool #0#4;
+    synthesized core::bool #0#4#isSet = false;
+    synthesized core::int #0#2;
+    synthesized core::bool #0#2#isSet = false;
+    late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
+    dynamic #t13;
+    {
+      lowered dynamic a#case#0;
+      lowered dynamic a#case#1;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t14 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t15 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && (let final dynamic #t16 = a#case#0 = #0#6 in true) && a#case#0{dynamic}.>(5) && (let final dynamic #t17 = #t13 = a#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t18 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t19 = #0#6 in true) && (let final dynamic #t20 = a#case#1 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic} in true) && a#case#1{dynamic}.<(5) && (let final dynamic #t21 = #t13 = a#case#1 in true)) {
+        dynamic a = #t13{dynamic};
+        {
+          core::print(a);
+          break #L2;
+        }
+      }
+    }
+    {
+      dynamic a;
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t22 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t23 = #0#2#isSet = true in #0#2 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && (let final dynamic #t24 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C4){(core::Object?) → dynamic} in true)) {
+        {
+          core::print(a);
+          break #L2;
+        }
+      }
+    }
+    {
+      if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          core::print(1);
+        }
+      }
+    }
+  }
+}
+static method switchStatementWithContinue(dynamic o) → dynamic {
+  #L3:
+  {
+    core::int #t25 = -1;
+    final synthesized dynamic #0#0 = o;
+    synthesized core::bool #0#4;
+    synthesized core::bool #0#4#isSet = false;
+    synthesized core::int #0#2;
+    synthesized core::bool #0#2#isSet = false;
+    late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
+    dynamic #t26;
+    #L4:
+    {
+      {
+        lowered dynamic a#case#0;
+        lowered dynamic a#case#1;
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t27 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t28 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && (let final dynamic #t29 = a#case#0 = #0#6 in true) && a#case#0{dynamic}.>(5) && (let final dynamic #t30 = #t26 = a#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t31 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t32 = #0#6 in true) && (let final dynamic #t33 = a#case#1 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic} in true) && a#case#1{dynamic}.<(5) && (let final dynamic #t34 = #t26 = a#case#1 in true)) {
+          dynamic a = #t26{dynamic};
+          {
+            core::print(a);
+            break #L3;
+          }
+        }
+      }
+      {
+        dynamic a;
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t35 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t36 = #0#2#isSet = true in #0#2 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && (let final dynamic #t37 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C4){(core::Object?) → dynamic} in true)) {
+          {
+            core::print(a);
+            #t25 = 0;
+            break #L4;
+          }
+        }
+      }
+      {
+        if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+          {
+            core::print(o);
+            break #L3;
+          }
+        }
+      }
+      {
+        if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+          #t25 = 0;
+          break #L4;
+        }
+      }
+      {
+        if(#C7 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+          #t25 = 1;
+          break #L4;
+        }
+      }
+    }
+    switch(#t25) {
+      #L5:
+      case #C1:
+        {
+          {
+            core::print(1);
+            continue #L6;
+          }
+        }
+      #L6:
+      case #C4:
+        {
+          {
+            core::print(2);
+          }
+        }
+    }
+  }
+}
+static method switchStatementWithContinueNested(dynamic o1, dynamic o2) → dynamic {
+  #L7:
+  {
+    core::int #t38 = -1;
+    final synthesized dynamic #2#0 = o1;
+    synthesized core::bool #2#4;
+    synthesized core::bool #2#4#isSet = false;
+    #L8:
+    {
+      {
+        dynamic a;
+        if(#2#0 is{ForNonNullableByDefault} core::List<dynamic> && (#2#4#isSet ?{core::bool} #2#4{core::bool} : let final dynamic #t39 = #2#4#isSet = true in #2#4 = #2#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C4) && (let final dynamic #t40 = a = #2#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} in true)) {
+          {
+            core::print(a);
+            break #L7;
+          }
+        }
+      }
+      {
+        dynamic a;
+        if(#2#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#2#4#isSet ?{core::bool} #2#4{core::bool} : let final dynamic #t41 = #2#4#isSet = true in #2#4 = #2#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C4) && #2#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && (let final dynamic #t42 = a = #2#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C4){(core::Object?) → dynamic} in true)) {
+          {
+            core::print(a);
+            #L9:
+            {
+              core::int #t43 = -1;
+              final synthesized dynamic #0#0 = o2;
+              synthesized core::bool #0#4;
+              synthesized core::bool #0#4#isSet = false;
+              synthesized core::int #0#2;
+              synthesized core::bool #0#2#isSet = false;
+              late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
+              dynamic #t44;
+              #L10:
+              {
+                {
+                  lowered dynamic a#case#0;
+                  lowered dynamic a#case#1;
+                  if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t45 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t46 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && (let final dynamic #t47 = a#case#0 = #0#6 in true) && a#case#0{dynamic}.>(5) && (let final dynamic #t48 = #t44 = a#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t49 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t50 = #0#6 in true) && (let final dynamic #t51 = a#case#1 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic} in true) && a#case#1{dynamic}.<(5) && (let final dynamic #t52 = #t44 = a#case#1 in true)) {
+                    dynamic a = #t44{dynamic};
+                    {
+                      core::print(a);
+                      break #L9;
+                    }
+                  }
+                }
+                {
+                  dynamic a;
+                  if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t53 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t54 = #0#2#isSet = true in #0#2 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && (let final dynamic #t55 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C4){(core::Object?) → dynamic} in true)) {
+                    {
+                      core::print(a);
+                      #t38 = 1;
+                      break #L8;
+                    }
+                  }
+                }
+                {
+                  if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+                    {
+                      core::print(o2);
+                      #t43 = 0;
+                      break #L10;
+                    }
+                  }
+                }
+                {
+                  if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+                    #t43 = 0;
+                    break #L10;
+                  }
+                }
+                {
+                  if(#C7 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+                    #t43 = 1;
+                    break #L10;
+                  }
+                }
+              }
+              switch(#t43) {
+                #L11:
+                case #C1:
+                  {
+                    {
+                      core::print(1);
+                      continue #L12;
+                    }
+                  }
+                #L12:
+                case #C4:
+                  {
+                    {
+                      core::print(2);
+                      #t38 = 0;
+                      break #L8;
+                    }
+                  }
+              }
+            }
+            break #L7;
+          }
+        }
+      }
+      {
+        if(#C1 =={core::num::==}{(core::Object) → core::bool} #2#0) {
+          {
+            core::print(o1);
+            break #L7;
+          }
+        }
+      }
+      {
+        if(#C4 =={core::num::==}{(core::Object) → core::bool} #2#0) {
+          #t38 = 0;
+          break #L8;
+        }
+      }
+      {
+        if(#C7 =={core::num::==}{(core::Object) → core::bool} #2#0) {
+          #t38 = 1;
+          break #L8;
+        }
+      }
+    }
+    switch(#t38) {
+      #L13:
+      case #C1:
+        {
+          {
+            core::print(1);
+            continue #L14;
+          }
+        }
+      #L14:
+      case #C4:
+        {
+          {
+            core::print(2);
+            #L15:
+            {
+              core::int #t56 = -1;
+              final synthesized dynamic #1#0 = o2;
+              synthesized core::bool #1#4;
+              synthesized core::bool #1#4#isSet = false;
+              synthesized core::int #1#2;
+              synthesized core::bool #1#2#isSet = false;
+              late final synthesized dynamic #1#6 = #1#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
+              dynamic #t57;
+              #L16:
+              {
+                {
+                  lowered dynamic a#case#0;
+                  lowered dynamic a#case#1;
+                  if(#1#0 is{ForNonNullableByDefault} core::List<dynamic> && (#1#4#isSet ?{core::bool} #1#4{core::bool} : let final dynamic #t58 = #1#4#isSet = true in #1#4 = (#1#2#isSet ?{core::int} #1#2{core::int} : let final dynamic #t59 = #1#2#isSet = true in #1#2 = #1#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && (let final dynamic #t60 = a#case#0 = #1#6 in true) && a#case#0{dynamic}.>(5) && (let final dynamic #t61 = #t57 = a#case#0 in true) || #1#0 is{ForNonNullableByDefault} core::List<dynamic> && (#1#2#isSet ?{core::int} #1#2{core::int} : let final dynamic #t62 = #1#2#isSet = true in #1#2 = #1#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t63 = #1#6 in true) && (let final dynamic #t64 = a#case#1 = #1#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic} in true) && a#case#1{dynamic}.<(5) && (let final dynamic #t65 = #t57 = a#case#1 in true)) {
+                    dynamic a = #t57{dynamic};
+                    {
+                      core::print(a);
+                      break #L15;
+                    }
+                  }
+                }
+                {
+                  dynamic a;
+                  if(#1#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#1#4#isSet ?{core::bool} #1#4{core::bool} : let final dynamic #t66 = #1#4#isSet = true in #1#4 = (#1#2#isSet ?{core::int} #1#2{core::int} : let final dynamic #t67 = #1#2#isSet = true in #1#2 = #1#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && #1#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && (let final dynamic #t68 = a = #1#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C4){(core::Object?) → dynamic} in true)) {
+                    {
+                      core::print(a);
+                      continue #L14;
+                    }
+                  }
+                }
+                {
+                  if(#C1 =={core::num::==}{(core::Object) → core::bool} #1#0) {
+                    {
+                      core::print(o2);
+                      #t56 = 0;
+                      break #L16;
+                    }
+                  }
+                }
+                {
+                  if(#C4 =={core::num::==}{(core::Object) → core::bool} #1#0) {
+                    #t56 = 0;
+                    break #L16;
+                  }
+                }
+                {
+                  if(#C7 =={core::num::==}{(core::Object) → core::bool} #1#0) {
+                    #t56 = 1;
+                    break #L16;
+                  }
+                }
+              }
+              switch(#t56) {
+                #L17:
+                case #C1:
+                  {
+                    {
+                      core::print(1);
+                      continue #L18;
+                    }
+                  }
+                #L18:
+                case #C4:
+                  {
+                    {
+                      core::print(2);
+                      continue #L13;
+                    }
+                  }
+              }
+            }
+          }
+        }
+    }
+  }
+}
+static method switchStatementEnum(self::E o) → dynamic {
+  #L19:
+  switch(o) /*isExplicitlyExhaustive*/ {
+    #L20:
+    case #C3:
+      {
+        core::print("a");
+        break #L19;
+      }
+    #L21:
+    case #C6:
+      {
+        core::print("b");
+        break #L19;
+      }
+    #L22:
+    case #C9:
+      {
+        core::print("c");
+      }
+  }
+}
+static method switchStatementEnumWithGuard(self::E o) → dynamic {
+  #L23:
+  {
+    final synthesized self::E #0#0 = o;
+    {
+      if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0 && true) {
+        {
+          core::print("a");
+          break #L23;
+        }
+      }
+    }
+    {
+      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+        {
+          core::print("b");
+          break #L23;
+        }
+      }
+    }
+    {
+      if(true) {
+      }
+    }
+  }
+}
+static method switchStatementEnumWithLabel(self::E o) → dynamic {
+  #L24:
+  switch(o) /*isExplicitlyExhaustive*/ {
+    #L25:
+    case #C3:
+      {
+        core::print("a");
+        break #L24;
+      }
+    #L26:
+    case #C6:
+      {
+        core::print("b");
+        break #L24;
+      }
+    #L27:
+    case #C9:
+      {
+        core::print("c");
+      }
+  }
+}
+static method switchStatementEnumWithContinue(self::E o) → dynamic {
+  #L28:
+  switch(o) /*isExplicitlyExhaustive*/ {
+    #L29:
+    case #C3:
+      {
+        core::print("a");
+        continue #L30;
+      }
+    #L30:
+    case #C6:
+      {
+        core::print("b");
+        continue #L31;
+      }
+    #L31:
+    case #C9:
+      {
+        core::print("c");
+      }
+  }
+}
+static method switchStatementPrimitiveEquals(dynamic o) → dynamic {
+  #L32:
+  switch(o) {
+    #L33:
+    case #C11:
+      {
+        core::print("a");
+        break #L32;
+      }
+    #L34:
+    case #C12:
+      {
+        core::print("b");
+      }
+  }
+}
+static method switchStatementNonPrimitiveEquals(dynamic o) → dynamic {
+  #L35:
+  {
+    final synthesized dynamic #0#0 = o;
+    {
+      if(#C13 =={self::NonPrimitiveEquals::==}{(core::Object) → core::bool} #0#0) {
+        {
+          core::print("a");
+          break #L35;
+        }
+      }
+    }
+    {
+      if(#C14 =={self::NonPrimitiveEquals::==}{(core::Object) → core::bool} #0#0) {
+        {
+          core::print("b");
+        }
+      }
+    }
+  }
+}
+static method switchExpression(dynamic o) → dynamic {
+  return block {
+    dynamic #t69;
+    final synthesized dynamic #0#0 = o;
+    synthesized core::bool #0#4;
+    synthesized core::bool #0#4#isSet = false;
+    #L36:
+    {
+      {
+        dynamic a;
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t70 = #0#4#isSet = true in #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C4) && (let final dynamic #t71 = a = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} in true)) {
+          #t69 = a;
+          break #L36;
+        }
+      }
+      {
+        dynamic a;
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t72 = #0#4#isSet = true in #0#4 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C4) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && (let final dynamic #t73 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C4){(core::Object?) → dynamic} in true)) {
+          #t69 = a;
+          break #L36;
+        }
+      }
+      {
+        if(true) {
+          #t69 = null;
+          break #L36;
+        }
+      }
+    }
+  } =>#t69;
+}
+static method switchExpressionEnum(self::E o) → dynamic {
+  return block {
+    core::int #t74;
+    #L37:
+    switch(o) /*isExplicitlyExhaustive*/ {
+      #L38:
+      case #C3:
+        {
+          #t74 = 0;
+          break #L37;
+        }
+      #L39:
+      case #C6:
+        {
+          #t74 = 1;
+          break #L37;
+        }
+      #L40:
+      case #C9:
+        {
+          #t74 = 2;
+          break #L37;
+        }
+    }
+  } =>#t74;
+}
+static method switchExpressionEnumWithGuard(self::E o) → dynamic {
+  return block {
+    core::int #t75;
+    final synthesized self::E #0#0 = o;
+    #L41:
+    {
+      {
+        if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0 && true) {
+          #t75 = 0;
+          break #L41;
+        }
+      }
+      {
+        if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+          #t75 = 1;
+          break #L41;
+        }
+      }
+      {
+        if(true) {
+          #t75 = 2;
+          break #L41;
+        }
+      }
+    }
+  } =>#t75;
+}
+static method switchExpressionPrimitiveEquals(dynamic o) → dynamic {
+  return block {
+    core::int #t76;
+    final synthesized dynamic #0#0 = o;
+    #L42:
+    {
+      {
+        if(#C11 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+          #t76 = 0;
+          break #L42;
+        }
+      }
+      {
+        if(#C12 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+          #t76 = 1;
+          break #L42;
+        }
+      }
+      {
+        if(true) {
+          #t76 = 2;
+          break #L42;
+        }
+      }
+    }
+  } =>#t76;
+}
+static method switchExpressionNonPrimitiveEquals(dynamic o) → dynamic {
+  return block {
+    core::int #t77;
+    final synthesized dynamic #0#0 = o;
+    #L43:
+    {
+      {
+        if(#C13 =={self::NonPrimitiveEquals::==}{(core::Object) → core::bool} #0#0) {
+          #t77 = 0;
+          break #L43;
+        }
+      }
+      {
+        if(#C14 =={self::NonPrimitiveEquals::==}{(core::Object) → core::bool} #0#0) {
+          #t77 = 1;
+          break #L43;
+        }
+      }
+      {
+        if(true) {
+          #t77 = 2;
+          break #L43;
+        }
+      }
+    }
+  } =>#t77;
+}
+static method switchStatementSymbol(core::Symbol s) → dynamic {
+  #L44:
+  {
+    final synthesized core::Symbol #0#0 = s;
+    {
+      if(#C15 =={core::Symbol::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return 0;
+        }
+      }
+    }
+    {
+      if(#C16 =={core::Symbol::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return 1;
+        }
+      }
+    }
+    {
+      {
+        {
+          return 2;
+        }
+      }
+    }
+  }
+}
+static method switchExpressionSymbol(core::Symbol s) → dynamic {
+  return block {
+    core::int #t78;
+    final synthesized core::Symbol #0#0 = s;
+    #L45:
+    {
+      {
+        if(#C15 =={core::Symbol::==}{(core::Object) → core::bool} #0#0) {
+          #t78 = 0;
+          break #L45;
+        }
+      }
+      {
+        if(#C16 =={core::Symbol::==}{(core::Object) → core::bool} #0#0) {
+          #t78 = 1;
+          break #L45;
+        }
+      }
+      {
+        if(true) {
+          #t78 = 2;
+          break #L45;
+        }
+      }
+    }
+  } =>#t78;
+}
+
+constants  {
+  #C1 = 0
+  #C2 = "a"
+  #C3 = self::E {index:#C1, _name:#C2}
+  #C4 = 1
+  #C5 = "b"
+  #C6 = self::E {index:#C4, _name:#C5}
+  #C7 = 2
+  #C8 = "c"
+  #C9 = self::E {index:#C7, _name:#C8}
+  #C10 = <self::E>[#C3, #C6, #C9]
+  #C11 = self::PrimitiveEquals {field:#C1}
+  #C12 = self::PrimitiveEquals {field:#C4}
+  #C13 = self::NonPrimitiveEquals {field:#C1}
+  #C14 = self::NonPrimitiveEquals {field:#C4}
+  #C15 = #a
+  #C16 = #b
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///switch_encoding.dart:
+- E. (from org-dartlang-testcase:///switch_encoding.dart:5:6)
+- _Enum. (from org-dartlang-sdk:///sdk/lib/core/enum.dart)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart)
+- PrimitiveEquals. (from org-dartlang-testcase:///switch_encoding.dart:10:9)
+- NonPrimitiveEquals. (from org-dartlang-testcase:///switch_encoding.dart:16:9)
diff --git a/pkg/front_end/testcases/patterns/switch_encoding.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/switch_encoding.dart.strong.transformed.expect
new file mode 100644
index 00000000000..84b34d38a40
--- /dev/null
+++ b/pkg/front_end/testcases/patterns/switch_encoding.dart.strong.transformed.expect
@@ -0,0 +1,752 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+class E extends core::_Enum /*isEnum*/  {
+  static const field core::List<self::E> values = #C10;
+  enum-element static const field self::E a = #C3;
+  enum-element static const field self::E b = #C6;
+  enum-element static const field self::E c = #C9;
+  const constructor •(core::int #index, core::String #name) → self::E
+    : super core::_Enum::•(#index, #name)
+    ;
+  method _enumToString() → core::String
+    return "E.${this.{core::_Enum::_name}{core::String}}";
+}
+class PrimitiveEquals extends core::Object /*hasConstConstructor*/  {
+  final field core::int field;
+  const constructor •(core::int field) → self::PrimitiveEquals
+    : self::PrimitiveEquals::field = field, super core::Object::•()
+    ;
+}
+class NonPrimitiveEquals extends core::Object /*hasConstConstructor*/  {
+  final field core::int field;
+  const constructor •(core::int field) → self::NonPrimitiveEquals
+    : self::NonPrimitiveEquals::field = field, super core::Object::•()
+    ;
+  get hashCode() → core::int
+    return this.{self::NonPrimitiveEquals::field}{core::int}.{core::num::hashCode}{core::int};
+  operator ==(core::Object other) → core::bool {
+    if(core::identical(this, other))
+      return true;
+    return other is{ForNonNullableByDefault} self::NonPrimitiveEquals && this.{self::NonPrimitiveEquals::field}{core::int} =={core::num::==}{(core::Object) → core::bool} other{self::NonPrimitiveEquals}.{self::NonPrimitiveEquals::field}{core::int};
+  }
+}
+static method switchStatement(dynamic o) → dynamic {
+  #L1:
+  {
+    final synthesized dynamic #0#0 = o;
+    synthesized core::bool #0#4;
+    synthesized core::bool #0#4#isSet = false;
+    synthesized core::int #0#2;
+    synthesized core::bool #0#2#isSet = false;
+    function ##0#6#initializer() → dynamic
+      return #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
+    late final synthesized dynamic #0#6 = ##0#6#initializer(){() → dynamic};
+    dynamic #t1;
+    {
+      lowered dynamic a#case#0;
+      lowered dynamic a#case#1;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t2 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t3 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && (let final dynamic #t4 = a#case#0 = #0#6 in true) && a#case#0{dynamic}.>(5) && (let final dynamic #t5 = #t1 = a#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t6 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t7 = #0#6 in true) && (let final dynamic #t8 = a#case#1 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic} in true) && a#case#1{dynamic}.<(5) && (let final dynamic #t9 = #t1 = a#case#1 in true)) {
+        dynamic a = #t1{dynamic};
+        {
+          core::print(a);
+          break #L1;
+        }
+      }
+    }
+    {
+      dynamic a;
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t10 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t11 = #0#2#isSet = true in #0#2 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && (let final dynamic #t12 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C4){(core::Object?) → dynamic} in true)) {
+        {
+          core::print(a);
+        }
+      }
+    }
+  }
+}
+static method switchStatementWithLabel(dynamic o) → dynamic {
+  #L2:
+  {
+    final synthesized dynamic #0#0 = o;
+    synthesized core::bool #0#4;
+    synthesized core::bool #0#4#isSet = false;
+    synthesized core::int #0#2;
+    synthesized core::bool #0#2#isSet = false;
+    function ##0#6#initializer() → dynamic
+      return #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
+    late final synthesized dynamic #0#6 = ##0#6#initializer(){() → dynamic};
+    dynamic #t13;
+    {
+      lowered dynamic a#case#0;
+      lowered dynamic a#case#1;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t14 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t15 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && (let final dynamic #t16 = a#case#0 = #0#6 in true) && a#case#0{dynamic}.>(5) && (let final dynamic #t17 = #t13 = a#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t18 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t19 = #0#6 in true) && (let final dynamic #t20 = a#case#1 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic} in true) && a#case#1{dynamic}.<(5) && (let final dynamic #t21 = #t13 = a#case#1 in true)) {
+        dynamic a = #t13{dynamic};
+        {
+          core::print(a);
+          break #L2;
+        }
+      }
+    }
+    {
+      dynamic a;
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t22 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t23 = #0#2#isSet = true in #0#2 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && (let final dynamic #t24 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C4){(core::Object?) → dynamic} in true)) {
+        {
+          core::print(a);
+          break #L2;
+        }
+      }
+    }
+    {
+      if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          core::print(1);
+        }
+      }
+    }
+  }
+}
+static method switchStatementWithContinue(dynamic o) → dynamic {
+  #L3:
+  {
+    core::int #t25 = -1;
+    final synthesized dynamic #0#0 = o;
+    synthesized core::bool #0#4;
+    synthesized core::bool #0#4#isSet = false;
+    synthesized core::int #0#2;
+    synthesized core::bool #0#2#isSet = false;
+    function ##0#6#initializer() → dynamic
+      return #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
+    late final synthesized dynamic #0#6 = ##0#6#initializer(){() → dynamic};
+    dynamic #t26;
+    #L4:
+    {
+      {
+        lowered dynamic a#case#0;
+        lowered dynamic a#case#1;
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t27 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t28 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && (let final dynamic #t29 = a#case#0 = #0#6 in true) && a#case#0{dynamic}.>(5) && (let final dynamic #t30 = #t26 = a#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t31 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t32 = #0#6 in true) && (let final dynamic #t33 = a#case#1 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic} in true) && a#case#1{dynamic}.<(5) && (let final dynamic #t34 = #t26 = a#case#1 in true)) {
+          dynamic a = #t26{dynamic};
+          {
+            core::print(a);
+            break #L3;
+          }
+        }
+      }
+      {
+        dynamic a;
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t35 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t36 = #0#2#isSet = true in #0#2 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && (let final dynamic #t37 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C4){(core::Object?) → dynamic} in true)) {
+          {
+            core::print(a);
+            #t25 = 0;
+            break #L4;
+          }
+        }
+      }
+      {
+        if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+          {
+            core::print(o);
+            break #L3;
+          }
+        }
+      }
+      {
+        if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+          #t25 = 0;
+          break #L4;
+        }
+      }
+      {
+        if(#C7 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+          #t25 = 1;
+          break #L4;
+        }
+      }
+    }
+    switch(#t25) {
+      #L5:
+      case #C1:
+        {
+          {
+            core::print(1);
+            continue #L6;
+          }
+        }
+      #L6:
+      case #C4:
+        {
+          {
+            core::print(2);
+          }
+        }
+    }
+  }
+}
+static method switchStatementWithContinueNested(dynamic o1, dynamic o2) → dynamic {
+  #L7:
+  {
+    core::int #t38 = -1;
+    final synthesized dynamic #2#0 = o1;
+    synthesized core::bool #2#4;
+    synthesized core::bool #2#4#isSet = false;
+    #L8:
+    {
+      {
+        dynamic a;
+        if(#2#0 is{ForNonNullableByDefault} core::List<dynamic> && (#2#4#isSet ?{core::bool} #2#4{core::bool} : let final core::bool* #t39 = #2#4#isSet = true in #2#4 = #2#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C4) && (let final dynamic #t40 = a = #2#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} in true)) {
+          {
+            core::print(a);
+            break #L7;
+          }
+        }
+      }
+      {
+        dynamic a;
+        if(#2#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#2#4#isSet ?{core::bool} #2#4{core::bool} : let final core::bool* #t41 = #2#4#isSet = true in #2#4 = #2#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C4) && #2#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && (let final dynamic #t42 = a = #2#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C4){(core::Object?) → dynamic} in true)) {
+          {
+            core::print(a);
+            #L9:
+            {
+              core::int #t43 = -1;
+              final synthesized dynamic #0#0 = o2;
+              synthesized core::bool #0#4;
+              synthesized core::bool #0#4#isSet = false;
+              synthesized core::int #0#2;
+              synthesized core::bool #0#2#isSet = false;
+              function ##0#6#initializer() → dynamic
+                return #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
+              late final synthesized dynamic #0#6 = ##0#6#initializer(){() → dynamic};
+              dynamic #t44;
+              #L10:
+              {
+                {
+                  lowered dynamic a#case#0;
+                  lowered dynamic a#case#1;
+                  if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t45 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t46 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && (let final dynamic #t47 = a#case#0 = #0#6 in true) && a#case#0{dynamic}.>(5) && (let final dynamic #t48 = #t44 = a#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t49 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t50 = #0#6 in true) && (let final dynamic #t51 = a#case#1 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic} in true) && a#case#1{dynamic}.<(5) && (let final dynamic #t52 = #t44 = a#case#1 in true)) {
+                    dynamic a = #t44{dynamic};
+                    {
+                      core::print(a);
+                      break #L9;
+                    }
+                  }
+                }
+                {
+                  dynamic a;
+                  if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t53 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t54 = #0#2#isSet = true in #0#2 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && (let final dynamic #t55 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C4){(core::Object?) → dynamic} in true)) {
+                    {
+                      core::print(a);
+                      #t38 = 1;
+                      break #L8;
+                    }
+                  }
+                }
+                {
+                  if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+                    {
+                      core::print(o2);
+                      #t43 = 0;
+                      break #L10;
+                    }
+                  }
+                }
+                {
+                  if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+                    #t43 = 0;
+                    break #L10;
+                  }
+                }
+                {
+                  if(#C7 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+                    #t43 = 1;
+                    break #L10;
+                  }
+                }
+              }
+              switch(#t43) {
+                #L11:
+                case #C1:
+                  {
+                    {
+                      core::print(1);
+                      continue #L12;
+                    }
+                  }
+                #L12:
+                case #C4:
+                  {
+                    {
+                      core::print(2);
+                      #t38 = 0;
+                      break #L8;
+                    }
+                  }
+              }
+            }
+            break #L7;
+          }
+        }
+      }
+      {
+        if(#C1 =={core::num::==}{(core::Object) → core::bool} #2#0) {
+          {
+            core::print(o1);
+            break #L7;
+          }
+        }
+      }
+      {
+        if(#C4 =={core::num::==}{(core::Object) → core::bool} #2#0) {
+          #t38 = 0;
+          break #L8;
+        }
+      }
+      {
+        if(#C7 =={core::num::==}{(core::Object) → core::bool} #2#0) {
+          #t38 = 1;
+          break #L8;
+        }
+      }
+    }
+    switch(#t38) {
+      #L13:
+      case #C1:
+        {
+          {
+            core::print(1);
+            continue #L14;
+          }
+        }
+      #L14:
+      case #C4:
+        {
+          {
+            core::print(2);
+            #L15:
+            {
+              core::int #t56 = -1;
+              final synthesized dynamic #1#0 = o2;
+              synthesized core::bool #1#4;
+              synthesized core::bool #1#4#isSet = false;
+              synthesized core::int #1#2;
+              synthesized core::bool #1#2#isSet = false;
+              function ##1#6#initializer() → dynamic
+                return #1#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
+              late final synthesized dynamic #1#6 = ##1#6#initializer(){() → dynamic};
+              dynamic #t57;
+              #L16:
+              {
+                {
+                  lowered dynamic a#case#0;
+                  lowered dynamic a#case#1;
+                  if(#1#0 is{ForNonNullableByDefault} core::List<dynamic> && (#1#4#isSet ?{core::bool} #1#4{core::bool} : let final core::bool* #t58 = #1#4#isSet = true in #1#4 = (#1#2#isSet ?{core::int} #1#2{core::int} : let final core::bool* #t59 = #1#2#isSet = true in #1#2 = #1#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && (let final dynamic #t60 = a#case#0 = #1#6 in true) && a#case#0{dynamic}.>(5) && (let final dynamic #t61 = #t57 = a#case#0 in true) || #1#0 is{ForNonNullableByDefault} core::List<dynamic> && (#1#2#isSet ?{core::int} #1#2{core::int} : let final core::bool* #t62 = #1#2#isSet = true in #1#2 = #1#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t63 = #1#6 in true) && (let final dynamic #t64 = a#case#1 = #1#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic} in true) && a#case#1{dynamic}.<(5) && (let final dynamic #t65 = #t57 = a#case#1 in true)) {
+                    dynamic a = #t57{dynamic};
+                    {
+                      core::print(a);
+                      break #L15;
+                    }
+                  }
+                }
+                {
+                  dynamic a;
+                  if(#1#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#1#4#isSet ?{core::bool} #1#4{core::bool} : let final core::bool* #t66 = #1#4#isSet = true in #1#4 = (#1#2#isSet ?{core::int} #1#2{core::int} : let final core::bool* #t67 = #1#2#isSet = true in #1#2 = #1#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && #1#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && (let final dynamic #t68 = a = #1#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C4){(core::Object?) → dynamic} in true)) {
+                    {
+                      core::print(a);
+                      continue #L14;
+                    }
+                  }
+                }
+                {
+                  if(#C1 =={core::num::==}{(core::Object) → core::bool} #1#0) {
+                    {
+                      core::print(o2);
+                      #t56 = 0;
+                      break #L16;
+                    }
+                  }
+                }
+                {
+                  if(#C4 =={core::num::==}{(core::Object) → core::bool} #1#0) {
+                    #t56 = 0;
+                    break #L16;
+                  }
+                }
+                {
+                  if(#C7 =={core::num::==}{(core::Object) → core::bool} #1#0) {
+                    #t56 = 1;
+                    break #L16;
+                  }
+                }
+              }
+              switch(#t56) {
+                #L17:
+                case #C1:
+                  {
+                    {
+                      core::print(1);
+                      continue #L18;
+                    }
+                  }
+                #L18:
+                case #C4:
+                  {
+                    {
+                      core::print(2);
+                      continue #L13;
+                    }
+                  }
+              }
+            }
+          }
+        }
+    }
+  }
+}
+static method switchStatementEnum(self::E o) → dynamic {
+  #L19:
+  switch(o) /*isExplicitlyExhaustive*/ {
+    #L20:
+    case #C3:
+      {
+        core::print("a");
+        break #L19;
+      }
+    #L21:
+    case #C6:
+      {
+        core::print("b");
+        break #L19;
+      }
+    #L22:
+    case #C9:
+      {
+        core::print("c");
+      }
+  }
+}
+static method switchStatementEnumWithGuard(self::E o) → dynamic {
+  #L23:
+  {
+    final synthesized self::E #0#0 = o;
+    {
+      if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0 && true) {
+        {
+          core::print("a");
+          break #L23;
+        }
+      }
+    }
+    {
+      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+        {
+          core::print("b");
+          break #L23;
+        }
+      }
+    }
+    {
+      if(true) {
+      }
+    }
+  }
+}
+static method switchStatementEnumWithLabel(self::E o) → dynamic {
+  #L24:
+  switch(o) /*isExplicitlyExhaustive*/ {
+    #L25:
+    case #C3:
+      {
+        core::print("a");
+        break #L24;
+      }
+    #L26:
+    case #C6:
+      {
+        core::print("b");
+        break #L24;
+      }
+    #L27:
+    case #C9:
+      {
+        core::print("c");
+      }
+  }
+}
+static method switchStatementEnumWithContinue(self::E o) → dynamic {
+  #L28:
+  switch(o) /*isExplicitlyExhaustive*/ {
+    #L29:
+    case #C3:
+      {
+        core::print("a");
+        continue #L30;
+      }
+    #L30:
+    case #C6:
+      {
+        core::print("b");
+        continue #L31;
+      }
+    #L31:
+    case #C9:
+      {
+        core::print("c");
+      }
+  }
+}
+static method switchStatementPrimitiveEquals(dynamic o) → dynamic {
+  #L32:
+  switch(o) {
+    #L33:
+    case #C11:
+      {
+        core::print("a");
+        break #L32;
+      }
+    #L34:
+    case #C12:
+      {
+        core::print("b");
+      }
+  }
+}
+static method switchStatementNonPrimitiveEquals(dynamic o) → dynamic {
+  #L35:
+  {
+    final synthesized dynamic #0#0 = o;
+    {
+      if(#C13 =={self::NonPrimitiveEquals::==}{(core::Object) → core::bool} #0#0) {
+        {
+          core::print("a");
+          break #L35;
+        }
+      }
+    }
+    {
+      if(#C14 =={self::NonPrimitiveEquals::==}{(core::Object) → core::bool} #0#0) {
+        {
+          core::print("b");
+        }
+      }
+    }
+  }
+}
+static method switchExpression(dynamic o) → dynamic {
+  return block {
+    dynamic #t69;
+    final synthesized dynamic #0#0 = o;
+    synthesized core::bool #0#4;
+    synthesized core::bool #0#4#isSet = false;
+    #L36:
+    {
+      {
+        dynamic a;
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t70 = #0#4#isSet = true in #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C4) && (let final dynamic #t71 = a = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} in true)) {
+          #t69 = a;
+          break #L36;
+        }
+      }
+      {
+        dynamic a;
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t72 = #0#4#isSet = true in #0#4 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C4) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && (let final dynamic #t73 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C4){(core::Object?) → dynamic} in true)) {
+          #t69 = a;
+          break #L36;
+        }
+      }
+      {
+        if(true) {
+          #t69 = null;
+          break #L36;
+        }
+      }
+    }
+  } =>#t69;
+}
+static method switchExpressionEnum(self::E o) → dynamic {
+  return block {
+    core::int #t74;
+    #L37:
+    switch(o) /*isExplicitlyExhaustive*/ {
+      #L38:
+      case #C3:
+        {
+          #t74 = 0;
+          break #L37;
+        }
+      #L39:
+      case #C6:
+        {
+          #t74 = 1;
+          break #L37;
+        }
+      #L40:
+      case #C9:
+        {
+          #t74 = 2;
+          break #L37;
+        }
+    }
+  } =>#t74;
+}
+static method switchExpressionEnumWithGuard(self::E o) → dynamic {
+  return block {
+    core::int #t75;
+    final synthesized self::E #0#0 = o;
+    #L41:
+    {
+      {
+        if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0 && true) {
+          #t75 = 0;
+          break #L41;
+        }
+      }
+      {
+        if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+          #t75 = 1;
+          break #L41;
+        }
+      }
+      {
+        if(true) {
+          #t75 = 2;
+          break #L41;
+        }
+      }
+    }
+  } =>#t75;
+}
+static method switchExpressionPrimitiveEquals(dynamic o) → dynamic {
+  return block {
+    core::int #t76;
+    final synthesized dynamic #0#0 = o;
+    #L42:
+    {
+      {
+        if(#C11 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+          #t76 = 0;
+          break #L42;
+        }
+      }
+      {
+        if(#C12 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+          #t76 = 1;
+          break #L42;
+        }
+      }
+      {
+        if(true) {
+          #t76 = 2;
+          break #L42;
+        }
+      }
+    }
+  } =>#t76;
+}
+static method switchExpressionNonPrimitiveEquals(dynamic o) → dynamic {
+  return block {
+    core::int #t77;
+    final synthesized dynamic #0#0 = o;
+    #L43:
+    {
+      {
+        if(#C13 =={self::NonPrimitiveEquals::==}{(core::Object) → core::bool} #0#0) {
+          #t77 = 0;
+          break #L43;
+        }
+      }
+      {
+        if(#C14 =={self::NonPrimitiveEquals::==}{(core::Object) → core::bool} #0#0) {
+          #t77 = 1;
+          break #L43;
+        }
+      }
+      {
+        if(true) {
+          #t77 = 2;
+          break #L43;
+        }
+      }
+    }
+  } =>#t77;
+}
+static method switchStatementSymbol(core::Symbol s) → dynamic {
+  #L44:
+  {
+    final synthesized core::Symbol #0#0 = s;
+    {
+      if(#C15 =={core::Symbol::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return 0;
+        }
+      }
+    }
+    {
+      if(#C16 =={core::Symbol::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return 1;
+        }
+      }
+    }
+    {
+      {
+        {
+          return 2;
+        }
+      }
+    }
+  }
+}
+static method switchExpressionSymbol(core::Symbol s) → dynamic {
+  return block {
+    core::int #t78;
+    final synthesized core::Symbol #0#0 = s;
+    #L45:
+    {
+      {
+        if(#C15 =={core::Symbol::==}{(core::Object) → core::bool} #0#0) {
+          #t78 = 0;
+          break #L45;
+        }
+      }
+      {
+        if(#C16 =={core::Symbol::==}{(core::Object) → core::bool} #0#0) {
+          #t78 = 1;
+          break #L45;
+        }
+      }
+      {
+        if(true) {
+          #t78 = 2;
+          break #L45;
+        }
+      }
+    }
+  } =>#t78;
+}
+
+constants  {
+  #C1 = 0
+  #C2 = "a"
+  #C3 = self::E {index:#C1, _name:#C2}
+  #C4 = 1
+  #C5 = "b"
+  #C6 = self::E {index:#C4, _name:#C5}
+  #C7 = 2
+  #C8 = "c"
+  #C9 = self::E {index:#C7, _name:#C8}
+  #C10 = <self::E>[#C3, #C6, #C9]
+  #C11 = self::PrimitiveEquals {field:#C1}
+  #C12 = self::PrimitiveEquals {field:#C4}
+  #C13 = self::NonPrimitiveEquals {field:#C1}
+  #C14 = self::NonPrimitiveEquals {field:#C4}
+  #C15 = #a
+  #C16 = #b
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///switch_encoding.dart:
+- E. (from org-dartlang-testcase:///switch_encoding.dart:5:6)
+- _Enum. (from org-dartlang-sdk:///sdk/lib/core/enum.dart)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart)
+- PrimitiveEquals. (from org-dartlang-testcase:///switch_encoding.dart:10:9)
+- NonPrimitiveEquals. (from org-dartlang-testcase:///switch_encoding.dart:16:9)
diff --git a/pkg/front_end/testcases/patterns/switch_encoding.dart.textual_outline.expect b/pkg/front_end/testcases/patterns/switch_encoding.dart.textual_outline.expect
new file mode 100644
index 00000000000..2b3f2e2cd70
--- /dev/null
+++ b/pkg/front_end/testcases/patterns/switch_encoding.dart.textual_outline.expect
@@ -0,0 +1,31 @@
+enum E { a, b, c }
+
+class PrimitiveEquals {
+  final int field;
+  const PrimitiveEquals(this.field);
+}
+
+class NonPrimitiveEquals {
+  final int field;
+  const NonPrimitiveEquals(this.field);
+  int get hashCode => field.hashCode;
+  bool operator ==(Object other) {}
+}
+
+switchStatement(o) {}
+switchStatementWithLabel(o) {}
+switchStatementWithContinue(o) {}
+switchStatementWithContinueNested(o1, o2) {}
+switchStatementEnum(E o) {}
+switchStatementEnumWithGuard(E o) {}
+switchStatementEnumWithLabel(E o) {}
+switchStatementEnumWithContinue(E o) {}
+switchStatementPrimitiveEquals(o) {}
+switchStatementNonPrimitiveEquals(o) {}
+switchExpression(o) {}
+switchExpressionEnum(E o) {}
+switchExpressionEnumWithGuard(E o) {}
+switchExpressionPrimitiveEquals(o) {}
+switchExpressionNonPrimitiveEquals(o) {}
+switchStatementSymbol(Symbol s) {}
+switchExpressionSymbol(Symbol s) {}
diff --git a/pkg/front_end/testcases/patterns/switch_encoding.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/patterns/switch_encoding.dart.textual_outline_modelled.expect
new file mode 100644
index 00000000000..2457dafef09
--- /dev/null
+++ b/pkg/front_end/testcases/patterns/switch_encoding.dart.textual_outline_modelled.expect
@@ -0,0 +1,31 @@
+class NonPrimitiveEquals {
+  bool operator ==(Object other) {}
+  const NonPrimitiveEquals(this.field);
+  final int field;
+  int get hashCode => field.hashCode;
+}
+
+class PrimitiveEquals {
+  const PrimitiveEquals(this.field);
+  final int field;
+}
+
+enum E { a, b, c }
+
+switchExpression(o) {}
+switchExpressionEnum(E o) {}
+switchExpressionEnumWithGuard(E o) {}
+switchExpressionNonPrimitiveEquals(o) {}
+switchExpressionPrimitiveEquals(o) {}
+switchExpressionSymbol(Symbol s) {}
+switchStatement(o) {}
+switchStatementEnum(E o) {}
+switchStatementEnumWithContinue(E o) {}
+switchStatementEnumWithGuard(E o) {}
+switchStatementEnumWithLabel(E o) {}
+switchStatementNonPrimitiveEquals(o) {}
+switchStatementPrimitiveEquals(o) {}
+switchStatementSymbol(Symbol s) {}
+switchStatementWithContinue(o) {}
+switchStatementWithContinueNested(o1, o2) {}
+switchStatementWithLabel(o) {}
diff --git a/pkg/front_end/testcases/patterns/switch_encoding.dart.weak.expect b/pkg/front_end/testcases/patterns/switch_encoding.dart.weak.expect
new file mode 100644
index 00000000000..0a0c748935f
--- /dev/null
+++ b/pkg/front_end/testcases/patterns/switch_encoding.dart.weak.expect
@@ -0,0 +1,742 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+class E extends core::_Enum /*isEnum*/  {
+  static const field core::List<self::E> values = #C10;
+  enum-element static const field self::E a = #C3;
+  enum-element static const field self::E b = #C6;
+  enum-element static const field self::E c = #C9;
+  const constructor •(core::int #index, core::String #name) → self::E
+    : super core::_Enum::•(#index, #name)
+    ;
+  method _enumToString() → core::String
+    return "E.${this.{core::_Enum::_name}{core::String}}";
+}
+class PrimitiveEquals extends core::Object /*hasConstConstructor*/  {
+  final field core::int field;
+  const constructor •(core::int field) → self::PrimitiveEquals
+    : self::PrimitiveEquals::field = field, super core::Object::•()
+    ;
+}
+class NonPrimitiveEquals extends core::Object /*hasConstConstructor*/  {
+  final field core::int field;
+  const constructor •(core::int field) → self::NonPrimitiveEquals
+    : self::NonPrimitiveEquals::field = field, super core::Object::•()
+    ;
+  get hashCode() → core::int
+    return this.{self::NonPrimitiveEquals::field}{core::int}.{core::num::hashCode}{core::int};
+  operator ==(core::Object other) → core::bool {
+    if(core::identical(this, other))
+      return true;
+    return other is{ForNonNullableByDefault} self::NonPrimitiveEquals && this.{self::NonPrimitiveEquals::field}{core::int} =={core::num::==}{(core::Object) → core::bool} other{self::NonPrimitiveEquals}.{self::NonPrimitiveEquals::field}{core::int};
+  }
+}
+static method switchStatement(dynamic o) → dynamic {
+  #L1:
+  {
+    final synthesized dynamic #0#0 = o;
+    synthesized core::bool #0#4;
+    synthesized core::bool #0#4#isSet = false;
+    synthesized core::int #0#2;
+    synthesized core::bool #0#2#isSet = false;
+    late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
+    dynamic #t1;
+    {
+      lowered dynamic a#case#0;
+      lowered dynamic a#case#1;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t2 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t3 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && (let final dynamic #t4 = a#case#0 = #0#6 in true) && a#case#0{dynamic}.>(5) && (let final dynamic #t5 = #t1 = a#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t6 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t7 = #0#6 in true) && (let final dynamic #t8 = a#case#1 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic} in true) && a#case#1{dynamic}.<(5) && (let final dynamic #t9 = #t1 = a#case#1 in true)) {
+        dynamic a = #t1{dynamic};
+        {
+          core::print(a);
+          break #L1;
+        }
+      }
+    }
+    {
+      dynamic a;
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t10 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t11 = #0#2#isSet = true in #0#2 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && (let final dynamic #t12 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C4){(core::Object?) → dynamic} in true)) {
+        {
+          core::print(a);
+        }
+      }
+    }
+  }
+}
+static method switchStatementWithLabel(dynamic o) → dynamic {
+  #L2:
+  {
+    final synthesized dynamic #0#0 = o;
+    synthesized core::bool #0#4;
+    synthesized core::bool #0#4#isSet = false;
+    synthesized core::int #0#2;
+    synthesized core::bool #0#2#isSet = false;
+    late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
+    dynamic #t13;
+    {
+      lowered dynamic a#case#0;
+      lowered dynamic a#case#1;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t14 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t15 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && (let final dynamic #t16 = a#case#0 = #0#6 in true) && a#case#0{dynamic}.>(5) && (let final dynamic #t17 = #t13 = a#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t18 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t19 = #0#6 in true) && (let final dynamic #t20 = a#case#1 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic} in true) && a#case#1{dynamic}.<(5) && (let final dynamic #t21 = #t13 = a#case#1 in true)) {
+        dynamic a = #t13{dynamic};
+        {
+          core::print(a);
+          break #L2;
+        }
+      }
+    }
+    {
+      dynamic a;
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t22 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t23 = #0#2#isSet = true in #0#2 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && (let final dynamic #t24 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C4){(core::Object?) → dynamic} in true)) {
+        {
+          core::print(a);
+          break #L2;
+        }
+      }
+    }
+    {
+      if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          core::print(1);
+        }
+      }
+    }
+  }
+}
+static method switchStatementWithContinue(dynamic o) → dynamic {
+  #L3:
+  {
+    core::int #t25 = -1;
+    final synthesized dynamic #0#0 = o;
+    synthesized core::bool #0#4;
+    synthesized core::bool #0#4#isSet = false;
+    synthesized core::int #0#2;
+    synthesized core::bool #0#2#isSet = false;
+    late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
+    dynamic #t26;
+    #L4:
+    {
+      {
+        lowered dynamic a#case#0;
+        lowered dynamic a#case#1;
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t27 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t28 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && (let final dynamic #t29 = a#case#0 = #0#6 in true) && a#case#0{dynamic}.>(5) && (let final dynamic #t30 = #t26 = a#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t31 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t32 = #0#6 in true) && (let final dynamic #t33 = a#case#1 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic} in true) && a#case#1{dynamic}.<(5) && (let final dynamic #t34 = #t26 = a#case#1 in true)) {
+          dynamic a = #t26{dynamic};
+          {
+            core::print(a);
+            break #L3;
+          }
+        }
+      }
+      {
+        dynamic a;
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t35 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t36 = #0#2#isSet = true in #0#2 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && (let final dynamic #t37 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C4){(core::Object?) → dynamic} in true)) {
+          {
+            core::print(a);
+            #t25 = 0;
+            break #L4;
+          }
+        }
+      }
+      {
+        if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+          {
+            core::print(o);
+            break #L3;
+          }
+        }
+      }
+      {
+        if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+          #t25 = 0;
+          break #L4;
+        }
+      }
+      {
+        if(#C7 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+          #t25 = 1;
+          break #L4;
+        }
+      }
+    }
+    switch(#t25) {
+      #L5:
+      case #C1:
+        {
+          {
+            core::print(1);
+            continue #L6;
+          }
+        }
+      #L6:
+      case #C4:
+        {
+          {
+            core::print(2);
+          }
+        }
+    }
+  }
+}
+static method switchStatementWithContinueNested(dynamic o1, dynamic o2) → dynamic {
+  #L7:
+  {
+    core::int #t38 = -1;
+    final synthesized dynamic #2#0 = o1;
+    synthesized core::bool #2#4;
+    synthesized core::bool #2#4#isSet = false;
+    #L8:
+    {
+      {
+        dynamic a;
+        if(#2#0 is{ForNonNullableByDefault} core::List<dynamic> && (#2#4#isSet ?{core::bool} #2#4{core::bool} : let final dynamic #t39 = #2#4#isSet = true in #2#4 = #2#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C4) && (let final dynamic #t40 = a = #2#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} in true)) {
+          {
+            core::print(a);
+            break #L7;
+          }
+        }
+      }
+      {
+        dynamic a;
+        if(#2#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#2#4#isSet ?{core::bool} #2#4{core::bool} : let final dynamic #t41 = #2#4#isSet = true in #2#4 = #2#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C4) && #2#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && (let final dynamic #t42 = a = #2#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C4){(core::Object?) → dynamic} in true)) {
+          {
+            core::print(a);
+            #L9:
+            {
+              core::int #t43 = -1;
+              final synthesized dynamic #0#0 = o2;
+              synthesized core::bool #0#4;
+              synthesized core::bool #0#4#isSet = false;
+              synthesized core::int #0#2;
+              synthesized core::bool #0#2#isSet = false;
+              late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
+              dynamic #t44;
+              #L10:
+              {
+                {
+                  lowered dynamic a#case#0;
+                  lowered dynamic a#case#1;
+                  if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t45 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t46 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && (let final dynamic #t47 = a#case#0 = #0#6 in true) && a#case#0{dynamic}.>(5) && (let final dynamic #t48 = #t44 = a#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t49 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t50 = #0#6 in true) && (let final dynamic #t51 = a#case#1 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic} in true) && a#case#1{dynamic}.<(5) && (let final dynamic #t52 = #t44 = a#case#1 in true)) {
+                    dynamic a = #t44{dynamic};
+                    {
+                      core::print(a);
+                      break #L9;
+                    }
+                  }
+                }
+                {
+                  dynamic a;
+                  if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t53 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t54 = #0#2#isSet = true in #0#2 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && (let final dynamic #t55 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C4){(core::Object?) → dynamic} in true)) {
+                    {
+                      core::print(a);
+                      #t38 = 1;
+                      break #L8;
+                    }
+                  }
+                }
+                {
+                  if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+                    {
+                      core::print(o2);
+                      #t43 = 0;
+                      break #L10;
+                    }
+                  }
+                }
+                {
+                  if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+                    #t43 = 0;
+                    break #L10;
+                  }
+                }
+                {
+                  if(#C7 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+                    #t43 = 1;
+                    break #L10;
+                  }
+                }
+              }
+              switch(#t43) {
+                #L11:
+                case #C1:
+                  {
+                    {
+                      core::print(1);
+                      continue #L12;
+                    }
+                  }
+                #L12:
+                case #C4:
+                  {
+                    {
+                      core::print(2);
+                      #t38 = 0;
+                      break #L8;
+                    }
+                  }
+              }
+            }
+            break #L7;
+          }
+        }
+      }
+      {
+        if(#C1 =={core::num::==}{(core::Object) → core::bool} #2#0) {
+          {
+            core::print(o1);
+            break #L7;
+          }
+        }
+      }
+      {
+        if(#C4 =={core::num::==}{(core::Object) → core::bool} #2#0) {
+          #t38 = 0;
+          break #L8;
+        }
+      }
+      {
+        if(#C7 =={core::num::==}{(core::Object) → core::bool} #2#0) {
+          #t38 = 1;
+          break #L8;
+        }
+      }
+    }
+    switch(#t38) {
+      #L13:
+      case #C1:
+        {
+          {
+            core::print(1);
+            continue #L14;
+          }
+        }
+      #L14:
+      case #C4:
+        {
+          {
+            core::print(2);
+            #L15:
+            {
+              core::int #t56 = -1;
+              final synthesized dynamic #1#0 = o2;
+              synthesized core::bool #1#4;
+              synthesized core::bool #1#4#isSet = false;
+              synthesized core::int #1#2;
+              synthesized core::bool #1#2#isSet = false;
+              late final synthesized dynamic #1#6 = #1#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
+              dynamic #t57;
+              #L16:
+              {
+                {
+                  lowered dynamic a#case#0;
+                  lowered dynamic a#case#1;
+                  if(#1#0 is{ForNonNullableByDefault} core::List<dynamic> && (#1#4#isSet ?{core::bool} #1#4{core::bool} : let final dynamic #t58 = #1#4#isSet = true in #1#4 = (#1#2#isSet ?{core::int} #1#2{core::int} : let final dynamic #t59 = #1#2#isSet = true in #1#2 = #1#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && (let final dynamic #t60 = a#case#0 = #1#6 in true) && a#case#0{dynamic}.>(5) && (let final dynamic #t61 = #t57 = a#case#0 in true) || #1#0 is{ForNonNullableByDefault} core::List<dynamic> && (#1#2#isSet ?{core::int} #1#2{core::int} : let final dynamic #t62 = #1#2#isSet = true in #1#2 = #1#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t63 = #1#6 in true) && (let final dynamic #t64 = a#case#1 = #1#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic} in true) && a#case#1{dynamic}.<(5) && (let final dynamic #t65 = #t57 = a#case#1 in true)) {
+                    dynamic a = #t57{dynamic};
+                    {
+                      core::print(a);
+                      break #L15;
+                    }
+                  }
+                }
+                {
+                  dynamic a;
+                  if(#1#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#1#4#isSet ?{core::bool} #1#4{core::bool} : let final dynamic #t66 = #1#4#isSet = true in #1#4 = (#1#2#isSet ?{core::int} #1#2{core::int} : let final dynamic #t67 = #1#2#isSet = true in #1#2 = #1#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && #1#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && (let final dynamic #t68 = a = #1#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C4){(core::Object?) → dynamic} in true)) {
+                    {
+                      core::print(a);
+                      continue #L14;
+                    }
+                  }
+                }
+                {
+                  if(#C1 =={core::num::==}{(core::Object) → core::bool} #1#0) {
+                    {
+                      core::print(o2);
+                      #t56 = 0;
+                      break #L16;
+                    }
+                  }
+                }
+                {
+                  if(#C4 =={core::num::==}{(core::Object) → core::bool} #1#0) {
+                    #t56 = 0;
+                    break #L16;
+                  }
+                }
+                {
+                  if(#C7 =={core::num::==}{(core::Object) → core::bool} #1#0) {
+                    #t56 = 1;
+                    break #L16;
+                  }
+                }
+              }
+              switch(#t56) {
+                #L17:
+                case #C1:
+                  {
+                    {
+                      core::print(1);
+                      continue #L18;
+                    }
+                  }
+                #L18:
+                case #C4:
+                  {
+                    {
+                      core::print(2);
+                      continue #L13;
+                    }
+                  }
+              }
+            }
+          }
+        }
+    }
+  }
+}
+static method switchStatementEnum(self::E o) → dynamic {
+  #L19:
+  switch(o) /*isExplicitlyExhaustive*/ {
+    #L20:
+    case #C3:
+      {
+        core::print("a");
+        break #L19;
+      }
+    #L21:
+    case #C6:
+      {
+        core::print("b");
+        break #L19;
+      }
+    #L22:
+    case #C9:
+      {
+        core::print("c");
+      }
+  }
+}
+static method switchStatementEnumWithGuard(self::E o) → dynamic {
+  #L23:
+  {
+    final synthesized self::E #0#0 = o;
+    {
+      if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0 && true) {
+        {
+          core::print("a");
+          break #L23;
+        }
+      }
+    }
+    {
+      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+        {
+          core::print("b");
+          break #L23;
+        }
+      }
+    }
+    {
+      if(true) {
+      }
+    }
+  }
+}
+static method switchStatementEnumWithLabel(self::E o) → dynamic {
+  #L24:
+  switch(o) /*isExplicitlyExhaustive*/ {
+    #L25:
+    case #C3:
+      {
+        core::print("a");
+        break #L24;
+      }
+    #L26:
+    case #C6:
+      {
+        core::print("b");
+        break #L24;
+      }
+    #L27:
+    case #C9:
+      {
+        core::print("c");
+      }
+  }
+}
+static method switchStatementEnumWithContinue(self::E o) → dynamic {
+  #L28:
+  switch(o) /*isExplicitlyExhaustive*/ {
+    #L29:
+    case #C3:
+      {
+        core::print("a");
+        continue #L30;
+      }
+    #L30:
+    case #C6:
+      {
+        core::print("b");
+        continue #L31;
+      }
+    #L31:
+    case #C9:
+      {
+        core::print("c");
+      }
+  }
+}
+static method switchStatementPrimitiveEquals(dynamic o) → dynamic {
+  #L32:
+  switch(o) {
+    #L33:
+    case #C11:
+      {
+        core::print("a");
+        break #L32;
+      }
+    #L34:
+    case #C12:
+      {
+        core::print("b");
+      }
+  }
+}
+static method switchStatementNonPrimitiveEquals(dynamic o) → dynamic {
+  #L35:
+  {
+    final synthesized dynamic #0#0 = o;
+    {
+      if(#C13 =={self::NonPrimitiveEquals::==}{(core::Object) → core::bool} #0#0) {
+        {
+          core::print("a");
+          break #L35;
+        }
+      }
+    }
+    {
+      if(#C14 =={self::NonPrimitiveEquals::==}{(core::Object) → core::bool} #0#0) {
+        {
+          core::print("b");
+        }
+      }
+    }
+  }
+}
+static method switchExpression(dynamic o) → dynamic {
+  return block {
+    dynamic #t69;
+    final synthesized dynamic #0#0 = o;
+    synthesized core::bool #0#4;
+    synthesized core::bool #0#4#isSet = false;
+    #L36:
+    {
+      {
+        dynamic a;
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t70 = #0#4#isSet = true in #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C4) && (let final dynamic #t71 = a = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} in true)) {
+          #t69 = a;
+          break #L36;
+        }
+      }
+      {
+        dynamic a;
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t72 = #0#4#isSet = true in #0#4 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C4) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && (let final dynamic #t73 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C4){(core::Object?) → dynamic} in true)) {
+          #t69 = a;
+          break #L36;
+        }
+      }
+      {
+        if(true) {
+          #t69 = null;
+          break #L36;
+        }
+      }
+    }
+  } =>#t69;
+}
+static method switchExpressionEnum(self::E o) → dynamic {
+  return block {
+    core::int #t74;
+    #L37:
+    switch(o) /*isExplicitlyExhaustive*/ {
+      #L38:
+      case #C3:
+        {
+          #t74 = 0;
+          break #L37;
+        }
+      #L39:
+      case #C6:
+        {
+          #t74 = 1;
+          break #L37;
+        }
+      #L40:
+      case #C9:
+        {
+          #t74 = 2;
+          break #L37;
+        }
+    }
+  } =>#t74;
+}
+static method switchExpressionEnumWithGuard(self::E o) → dynamic {
+  return block {
+    core::int #t75;
+    final synthesized self::E #0#0 = o;
+    #L41:
+    {
+      {
+        if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0 && true) {
+          #t75 = 0;
+          break #L41;
+        }
+      }
+      {
+        if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+          #t75 = 1;
+          break #L41;
+        }
+      }
+      {
+        if(true) {
+          #t75 = 2;
+          break #L41;
+        }
+      }
+    }
+  } =>#t75;
+}
+static method switchExpressionPrimitiveEquals(dynamic o) → dynamic {
+  return block {
+    core::int #t76;
+    final synthesized dynamic #0#0 = o;
+    #L42:
+    {
+      {
+        if(#C11 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+          #t76 = 0;
+          break #L42;
+        }
+      }
+      {
+        if(#C12 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+          #t76 = 1;
+          break #L42;
+        }
+      }
+      {
+        if(true) {
+          #t76 = 2;
+          break #L42;
+        }
+      }
+    }
+  } =>#t76;
+}
+static method switchExpressionNonPrimitiveEquals(dynamic o) → dynamic {
+  return block {
+    core::int #t77;
+    final synthesized dynamic #0#0 = o;
+    #L43:
+    {
+      {
+        if(#C13 =={self::NonPrimitiveEquals::==}{(core::Object) → core::bool} #0#0) {
+          #t77 = 0;
+          break #L43;
+        }
+      }
+      {
+        if(#C14 =={self::NonPrimitiveEquals::==}{(core::Object) → core::bool} #0#0) {
+          #t77 = 1;
+          break #L43;
+        }
+      }
+      {
+        if(true) {
+          #t77 = 2;
+          break #L43;
+        }
+      }
+    }
+  } =>#t77;
+}
+static method switchStatementSymbol(core::Symbol s) → dynamic {
+  #L44:
+  {
+    final synthesized core::Symbol #0#0 = s;
+    {
+      if(#C15 =={core::Symbol::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return 0;
+        }
+      }
+    }
+    {
+      if(#C16 =={core::Symbol::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return 1;
+        }
+      }
+    }
+    {
+      {
+        {
+          return 2;
+        }
+      }
+    }
+  }
+}
+static method switchExpressionSymbol(core::Symbol s) → dynamic {
+  return block {
+    core::int #t78;
+    final synthesized core::Symbol #0#0 = s;
+    #L45:
+    {
+      {
+        if(#C15 =={core::Symbol::==}{(core::Object) → core::bool} #0#0) {
+          #t78 = 0;
+          break #L45;
+        }
+      }
+      {
+        if(#C16 =={core::Symbol::==}{(core::Object) → core::bool} #0#0) {
+          #t78 = 1;
+          break #L45;
+        }
+      }
+      {
+        if(true) {
+          #t78 = 2;
+          break #L45;
+        }
+      }
+    }
+  } =>#t78;
+}
+
+constants  {
+  #C1 = 0
+  #C2 = "a"
+  #C3 = self::E {index:#C1, _name:#C2}
+  #C4 = 1
+  #C5 = "b"
+  #C6 = self::E {index:#C4, _name:#C5}
+  #C7 = 2
+  #C8 = "c"
+  #C9 = self::E {index:#C7, _name:#C8}
+  #C10 = <self::E*>[#C3, #C6, #C9]
+  #C11 = self::PrimitiveEquals {field:#C1}
+  #C12 = self::PrimitiveEquals {field:#C4}
+  #C13 = self::NonPrimitiveEquals {field:#C1}
+  #C14 = self::NonPrimitiveEquals {field:#C4}
+  #C15 = #a
+  #C16 = #b
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///switch_encoding.dart:
+- E. (from org-dartlang-testcase:///switch_encoding.dart:5:6)
+- _Enum. (from org-dartlang-sdk:///sdk/lib/core/enum.dart)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart)
+- PrimitiveEquals. (from org-dartlang-testcase:///switch_encoding.dart:10:9)
+- NonPrimitiveEquals. (from org-dartlang-testcase:///switch_encoding.dart:16:9)
diff --git a/pkg/front_end/testcases/patterns/switch_encoding.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/switch_encoding.dart.weak.modular.expect
new file mode 100644
index 00000000000..0a0c748935f
--- /dev/null
+++ b/pkg/front_end/testcases/patterns/switch_encoding.dart.weak.modular.expect
@@ -0,0 +1,742 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+class E extends core::_Enum /*isEnum*/  {
+  static const field core::List<self::E> values = #C10;
+  enum-element static const field self::E a = #C3;
+  enum-element static const field self::E b = #C6;
+  enum-element static const field self::E c = #C9;
+  const constructor •(core::int #index, core::String #name) → self::E
+    : super core::_Enum::•(#index, #name)
+    ;
+  method _enumToString() → core::String
+    return "E.${this.{core::_Enum::_name}{core::String}}";
+}
+class PrimitiveEquals extends core::Object /*hasConstConstructor*/  {
+  final field core::int field;
+  const constructor •(core::int field) → self::PrimitiveEquals
+    : self::PrimitiveEquals::field = field, super core::Object::•()
+    ;
+}
+class NonPrimitiveEquals extends core::Object /*hasConstConstructor*/  {
+  final field core::int field;
+  const constructor •(core::int field) → self::NonPrimitiveEquals
+    : self::NonPrimitiveEquals::field = field, super core::Object::•()
+    ;
+  get hashCode() → core::int
+    return this.{self::NonPrimitiveEquals::field}{core::int}.{core::num::hashCode}{core::int};
+  operator ==(core::Object other) → core::bool {
+    if(core::identical(this, other))
+      return true;
+    return other is{ForNonNullableByDefault} self::NonPrimitiveEquals && this.{self::NonPrimitiveEquals::field}{core::int} =={core::num::==}{(core::Object) → core::bool} other{self::NonPrimitiveEquals}.{self::NonPrimitiveEquals::field}{core::int};
+  }
+}
+static method switchStatement(dynamic o) → dynamic {
+  #L1:
+  {
+    final synthesized dynamic #0#0 = o;
+    synthesized core::bool #0#4;
+    synthesized core::bool #0#4#isSet = false;
+    synthesized core::int #0#2;
+    synthesized core::bool #0#2#isSet = false;
+    late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
+    dynamic #t1;
+    {
+      lowered dynamic a#case#0;
+      lowered dynamic a#case#1;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t2 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t3 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && (let final dynamic #t4 = a#case#0 = #0#6 in true) && a#case#0{dynamic}.>(5) && (let final dynamic #t5 = #t1 = a#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t6 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t7 = #0#6 in true) && (let final dynamic #t8 = a#case#1 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic} in true) && a#case#1{dynamic}.<(5) && (let final dynamic #t9 = #t1 = a#case#1 in true)) {
+        dynamic a = #t1{dynamic};
+        {
+          core::print(a);
+          break #L1;
+        }
+      }
+    }
+    {
+      dynamic a;
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t10 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t11 = #0#2#isSet = true in #0#2 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && (let final dynamic #t12 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C4){(core::Object?) → dynamic} in true)) {
+        {
+          core::print(a);
+        }
+      }
+    }
+  }
+}
+static method switchStatementWithLabel(dynamic o) → dynamic {
+  #L2:
+  {
+    final synthesized dynamic #0#0 = o;
+    synthesized core::bool #0#4;
+    synthesized core::bool #0#4#isSet = false;
+    synthesized core::int #0#2;
+    synthesized core::bool #0#2#isSet = false;
+    late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
+    dynamic #t13;
+    {
+      lowered dynamic a#case#0;
+      lowered dynamic a#case#1;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t14 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t15 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && (let final dynamic #t16 = a#case#0 = #0#6 in true) && a#case#0{dynamic}.>(5) && (let final dynamic #t17 = #t13 = a#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t18 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t19 = #0#6 in true) && (let final dynamic #t20 = a#case#1 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic} in true) && a#case#1{dynamic}.<(5) && (let final dynamic #t21 = #t13 = a#case#1 in true)) {
+        dynamic a = #t13{dynamic};
+        {
+          core::print(a);
+          break #L2;
+        }
+      }
+    }
+    {
+      dynamic a;
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t22 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t23 = #0#2#isSet = true in #0#2 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && (let final dynamic #t24 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C4){(core::Object?) → dynamic} in true)) {
+        {
+          core::print(a);
+          break #L2;
+        }
+      }
+    }
+    {
+      if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          core::print(1);
+        }
+      }
+    }
+  }
+}
+static method switchStatementWithContinue(dynamic o) → dynamic {
+  #L3:
+  {
+    core::int #t25 = -1;
+    final synthesized dynamic #0#0 = o;
+    synthesized core::bool #0#4;
+    synthesized core::bool #0#4#isSet = false;
+    synthesized core::int #0#2;
+    synthesized core::bool #0#2#isSet = false;
+    late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
+    dynamic #t26;
+    #L4:
+    {
+      {
+        lowered dynamic a#case#0;
+        lowered dynamic a#case#1;
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t27 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t28 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && (let final dynamic #t29 = a#case#0 = #0#6 in true) && a#case#0{dynamic}.>(5) && (let final dynamic #t30 = #t26 = a#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t31 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t32 = #0#6 in true) && (let final dynamic #t33 = a#case#1 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic} in true) && a#case#1{dynamic}.<(5) && (let final dynamic #t34 = #t26 = a#case#1 in true)) {
+          dynamic a = #t26{dynamic};
+          {
+            core::print(a);
+            break #L3;
+          }
+        }
+      }
+      {
+        dynamic a;
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t35 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t36 = #0#2#isSet = true in #0#2 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && (let final dynamic #t37 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C4){(core::Object?) → dynamic} in true)) {
+          {
+            core::print(a);
+            #t25 = 0;
+            break #L4;
+          }
+        }
+      }
+      {
+        if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+          {
+            core::print(o);
+            break #L3;
+          }
+        }
+      }
+      {
+        if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+          #t25 = 0;
+          break #L4;
+        }
+      }
+      {
+        if(#C7 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+          #t25 = 1;
+          break #L4;
+        }
+      }
+    }
+    switch(#t25) {
+      #L5:
+      case #C1:
+        {
+          {
+            core::print(1);
+            continue #L6;
+          }
+        }
+      #L6:
+      case #C4:
+        {
+          {
+            core::print(2);
+          }
+        }
+    }
+  }
+}
+static method switchStatementWithContinueNested(dynamic o1, dynamic o2) → dynamic {
+  #L7:
+  {
+    core::int #t38 = -1;
+    final synthesized dynamic #2#0 = o1;
+    synthesized core::bool #2#4;
+    synthesized core::bool #2#4#isSet = false;
+    #L8:
+    {
+      {
+        dynamic a;
+        if(#2#0 is{ForNonNullableByDefault} core::List<dynamic> && (#2#4#isSet ?{core::bool} #2#4{core::bool} : let final dynamic #t39 = #2#4#isSet = true in #2#4 = #2#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C4) && (let final dynamic #t40 = a = #2#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} in true)) {
+          {
+            core::print(a);
+            break #L7;
+          }
+        }
+      }
+      {
+        dynamic a;
+        if(#2#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#2#4#isSet ?{core::bool} #2#4{core::bool} : let final dynamic #t41 = #2#4#isSet = true in #2#4 = #2#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C4) && #2#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && (let final dynamic #t42 = a = #2#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C4){(core::Object?) → dynamic} in true)) {
+          {
+            core::print(a);
+            #L9:
+            {
+              core::int #t43 = -1;
+              final synthesized dynamic #0#0 = o2;
+              synthesized core::bool #0#4;
+              synthesized core::bool #0#4#isSet = false;
+              synthesized core::int #0#2;
+              synthesized core::bool #0#2#isSet = false;
+              late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
+              dynamic #t44;
+              #L10:
+              {
+                {
+                  lowered dynamic a#case#0;
+                  lowered dynamic a#case#1;
+                  if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t45 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t46 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && (let final dynamic #t47 = a#case#0 = #0#6 in true) && a#case#0{dynamic}.>(5) && (let final dynamic #t48 = #t44 = a#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t49 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t50 = #0#6 in true) && (let final dynamic #t51 = a#case#1 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic} in true) && a#case#1{dynamic}.<(5) && (let final dynamic #t52 = #t44 = a#case#1 in true)) {
+                    dynamic a = #t44{dynamic};
+                    {
+                      core::print(a);
+                      break #L9;
+                    }
+                  }
+                }
+                {
+                  dynamic a;
+                  if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t53 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final dynamic #t54 = #0#2#isSet = true in #0#2 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && (let final dynamic #t55 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C4){(core::Object?) → dynamic} in true)) {
+                    {
+                      core::print(a);
+                      #t38 = 1;
+                      break #L8;
+                    }
+                  }
+                }
+                {
+                  if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+                    {
+                      core::print(o2);
+                      #t43 = 0;
+                      break #L10;
+                    }
+                  }
+                }
+                {
+                  if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+                    #t43 = 0;
+                    break #L10;
+                  }
+                }
+                {
+                  if(#C7 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+                    #t43 = 1;
+                    break #L10;
+                  }
+                }
+              }
+              switch(#t43) {
+                #L11:
+                case #C1:
+                  {
+                    {
+                      core::print(1);
+                      continue #L12;
+                    }
+                  }
+                #L12:
+                case #C4:
+                  {
+                    {
+                      core::print(2);
+                      #t38 = 0;
+                      break #L8;
+                    }
+                  }
+              }
+            }
+            break #L7;
+          }
+        }
+      }
+      {
+        if(#C1 =={core::num::==}{(core::Object) → core::bool} #2#0) {
+          {
+            core::print(o1);
+            break #L7;
+          }
+        }
+      }
+      {
+        if(#C4 =={core::num::==}{(core::Object) → core::bool} #2#0) {
+          #t38 = 0;
+          break #L8;
+        }
+      }
+      {
+        if(#C7 =={core::num::==}{(core::Object) → core::bool} #2#0) {
+          #t38 = 1;
+          break #L8;
+        }
+      }
+    }
+    switch(#t38) {
+      #L13:
+      case #C1:
+        {
+          {
+            core::print(1);
+            continue #L14;
+          }
+        }
+      #L14:
+      case #C4:
+        {
+          {
+            core::print(2);
+            #L15:
+            {
+              core::int #t56 = -1;
+              final synthesized dynamic #1#0 = o2;
+              synthesized core::bool #1#4;
+              synthesized core::bool #1#4#isSet = false;
+              synthesized core::int #1#2;
+              synthesized core::bool #1#2#isSet = false;
+              late final synthesized dynamic #1#6 = #1#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
+              dynamic #t57;
+              #L16:
+              {
+                {
+                  lowered dynamic a#case#0;
+                  lowered dynamic a#case#1;
+                  if(#1#0 is{ForNonNullableByDefault} core::List<dynamic> && (#1#4#isSet ?{core::bool} #1#4{core::bool} : let final dynamic #t58 = #1#4#isSet = true in #1#4 = (#1#2#isSet ?{core::int} #1#2{core::int} : let final dynamic #t59 = #1#2#isSet = true in #1#2 = #1#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && (let final dynamic #t60 = a#case#0 = #1#6 in true) && a#case#0{dynamic}.>(5) && (let final dynamic #t61 = #t57 = a#case#0 in true) || #1#0 is{ForNonNullableByDefault} core::List<dynamic> && (#1#2#isSet ?{core::int} #1#2{core::int} : let final dynamic #t62 = #1#2#isSet = true in #1#2 = #1#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t63 = #1#6 in true) && (let final dynamic #t64 = a#case#1 = #1#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic} in true) && a#case#1{dynamic}.<(5) && (let final dynamic #t65 = #t57 = a#case#1 in true)) {
+                    dynamic a = #t57{dynamic};
+                    {
+                      core::print(a);
+                      break #L15;
+                    }
+                  }
+                }
+                {
+                  dynamic a;
+                  if(#1#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#1#4#isSet ?{core::bool} #1#4{core::bool} : let final dynamic #t66 = #1#4#isSet = true in #1#4 = (#1#2#isSet ?{core::int} #1#2{core::int} : let final dynamic #t67 = #1#2#isSet = true in #1#2 = #1#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && #1#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && (let final dynamic #t68 = a = #1#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C4){(core::Object?) → dynamic} in true)) {
+                    {
+                      core::print(a);
+                      continue #L14;
+                    }
+                  }
+                }
+                {
+                  if(#C1 =={core::num::==}{(core::Object) → core::bool} #1#0) {
+                    {
+                      core::print(o2);
+                      #t56 = 0;
+                      break #L16;
+                    }
+                  }
+                }
+                {
+                  if(#C4 =={core::num::==}{(core::Object) → core::bool} #1#0) {
+                    #t56 = 0;
+                    break #L16;
+                  }
+                }
+                {
+                  if(#C7 =={core::num::==}{(core::Object) → core::bool} #1#0) {
+                    #t56 = 1;
+                    break #L16;
+                  }
+                }
+              }
+              switch(#t56) {
+                #L17:
+                case #C1:
+                  {
+                    {
+                      core::print(1);
+                      continue #L18;
+                    }
+                  }
+                #L18:
+                case #C4:
+                  {
+                    {
+                      core::print(2);
+                      continue #L13;
+                    }
+                  }
+              }
+            }
+          }
+        }
+    }
+  }
+}
+static method switchStatementEnum(self::E o) → dynamic {
+  #L19:
+  switch(o) /*isExplicitlyExhaustive*/ {
+    #L20:
+    case #C3:
+      {
+        core::print("a");
+        break #L19;
+      }
+    #L21:
+    case #C6:
+      {
+        core::print("b");
+        break #L19;
+      }
+    #L22:
+    case #C9:
+      {
+        core::print("c");
+      }
+  }
+}
+static method switchStatementEnumWithGuard(self::E o) → dynamic {
+  #L23:
+  {
+    final synthesized self::E #0#0 = o;
+    {
+      if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0 && true) {
+        {
+          core::print("a");
+          break #L23;
+        }
+      }
+    }
+    {
+      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+        {
+          core::print("b");
+          break #L23;
+        }
+      }
+    }
+    {
+      if(true) {
+      }
+    }
+  }
+}
+static method switchStatementEnumWithLabel(self::E o) → dynamic {
+  #L24:
+  switch(o) /*isExplicitlyExhaustive*/ {
+    #L25:
+    case #C3:
+      {
+        core::print("a");
+        break #L24;
+      }
+    #L26:
+    case #C6:
+      {
+        core::print("b");
+        break #L24;
+      }
+    #L27:
+    case #C9:
+      {
+        core::print("c");
+      }
+  }
+}
+static method switchStatementEnumWithContinue(self::E o) → dynamic {
+  #L28:
+  switch(o) /*isExplicitlyExhaustive*/ {
+    #L29:
+    case #C3:
+      {
+        core::print("a");
+        continue #L30;
+      }
+    #L30:
+    case #C6:
+      {
+        core::print("b");
+        continue #L31;
+      }
+    #L31:
+    case #C9:
+      {
+        core::print("c");
+      }
+  }
+}
+static method switchStatementPrimitiveEquals(dynamic o) → dynamic {
+  #L32:
+  switch(o) {
+    #L33:
+    case #C11:
+      {
+        core::print("a");
+        break #L32;
+      }
+    #L34:
+    case #C12:
+      {
+        core::print("b");
+      }
+  }
+}
+static method switchStatementNonPrimitiveEquals(dynamic o) → dynamic {
+  #L35:
+  {
+    final synthesized dynamic #0#0 = o;
+    {
+      if(#C13 =={self::NonPrimitiveEquals::==}{(core::Object) → core::bool} #0#0) {
+        {
+          core::print("a");
+          break #L35;
+        }
+      }
+    }
+    {
+      if(#C14 =={self::NonPrimitiveEquals::==}{(core::Object) → core::bool} #0#0) {
+        {
+          core::print("b");
+        }
+      }
+    }
+  }
+}
+static method switchExpression(dynamic o) → dynamic {
+  return block {
+    dynamic #t69;
+    final synthesized dynamic #0#0 = o;
+    synthesized core::bool #0#4;
+    synthesized core::bool #0#4#isSet = false;
+    #L36:
+    {
+      {
+        dynamic a;
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t70 = #0#4#isSet = true in #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C4) && (let final dynamic #t71 = a = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} in true)) {
+          #t69 = a;
+          break #L36;
+        }
+      }
+      {
+        dynamic a;
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final dynamic #t72 = #0#4#isSet = true in #0#4 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C4) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && (let final dynamic #t73 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C4){(core::Object?) → dynamic} in true)) {
+          #t69 = a;
+          break #L36;
+        }
+      }
+      {
+        if(true) {
+          #t69 = null;
+          break #L36;
+        }
+      }
+    }
+  } =>#t69;
+}
+static method switchExpressionEnum(self::E o) → dynamic {
+  return block {
+    core::int #t74;
+    #L37:
+    switch(o) /*isExplicitlyExhaustive*/ {
+      #L38:
+      case #C3:
+        {
+          #t74 = 0;
+          break #L37;
+        }
+      #L39:
+      case #C6:
+        {
+          #t74 = 1;
+          break #L37;
+        }
+      #L40:
+      case #C9:
+        {
+          #t74 = 2;
+          break #L37;
+        }
+    }
+  } =>#t74;
+}
+static method switchExpressionEnumWithGuard(self::E o) → dynamic {
+  return block {
+    core::int #t75;
+    final synthesized self::E #0#0 = o;
+    #L41:
+    {
+      {
+        if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0 && true) {
+          #t75 = 0;
+          break #L41;
+        }
+      }
+      {
+        if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+          #t75 = 1;
+          break #L41;
+        }
+      }
+      {
+        if(true) {
+          #t75 = 2;
+          break #L41;
+        }
+      }
+    }
+  } =>#t75;
+}
+static method switchExpressionPrimitiveEquals(dynamic o) → dynamic {
+  return block {
+    core::int #t76;
+    final synthesized dynamic #0#0 = o;
+    #L42:
+    {
+      {
+        if(#C11 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+          #t76 = 0;
+          break #L42;
+        }
+      }
+      {
+        if(#C12 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+          #t76 = 1;
+          break #L42;
+        }
+      }
+      {
+        if(true) {
+          #t76 = 2;
+          break #L42;
+        }
+      }
+    }
+  } =>#t76;
+}
+static method switchExpressionNonPrimitiveEquals(dynamic o) → dynamic {
+  return block {
+    core::int #t77;
+    final synthesized dynamic #0#0 = o;
+    #L43:
+    {
+      {
+        if(#C13 =={self::NonPrimitiveEquals::==}{(core::Object) → core::bool} #0#0) {
+          #t77 = 0;
+          break #L43;
+        }
+      }
+      {
+        if(#C14 =={self::NonPrimitiveEquals::==}{(core::Object) → core::bool} #0#0) {
+          #t77 = 1;
+          break #L43;
+        }
+      }
+      {
+        if(true) {
+          #t77 = 2;
+          break #L43;
+        }
+      }
+    }
+  } =>#t77;
+}
+static method switchStatementSymbol(core::Symbol s) → dynamic {
+  #L44:
+  {
+    final synthesized core::Symbol #0#0 = s;
+    {
+      if(#C15 =={core::Symbol::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return 0;
+        }
+      }
+    }
+    {
+      if(#C16 =={core::Symbol::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return 1;
+        }
+      }
+    }
+    {
+      {
+        {
+          return 2;
+        }
+      }
+    }
+  }
+}
+static method switchExpressionSymbol(core::Symbol s) → dynamic {
+  return block {
+    core::int #t78;
+    final synthesized core::Symbol #0#0 = s;
+    #L45:
+    {
+      {
+        if(#C15 =={core::Symbol::==}{(core::Object) → core::bool} #0#0) {
+          #t78 = 0;
+          break #L45;
+        }
+      }
+      {
+        if(#C16 =={core::Symbol::==}{(core::Object) → core::bool} #0#0) {
+          #t78 = 1;
+          break #L45;
+        }
+      }
+      {
+        if(true) {
+          #t78 = 2;
+          break #L45;
+        }
+      }
+    }
+  } =>#t78;
+}
+
+constants  {
+  #C1 = 0
+  #C2 = "a"
+  #C3 = self::E {index:#C1, _name:#C2}
+  #C4 = 1
+  #C5 = "b"
+  #C6 = self::E {index:#C4, _name:#C5}
+  #C7 = 2
+  #C8 = "c"
+  #C9 = self::E {index:#C7, _name:#C8}
+  #C10 = <self::E*>[#C3, #C6, #C9]
+  #C11 = self::PrimitiveEquals {field:#C1}
+  #C12 = self::PrimitiveEquals {field:#C4}
+  #C13 = self::NonPrimitiveEquals {field:#C1}
+  #C14 = self::NonPrimitiveEquals {field:#C4}
+  #C15 = #a
+  #C16 = #b
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///switch_encoding.dart:
+- E. (from org-dartlang-testcase:///switch_encoding.dart:5:6)
+- _Enum. (from org-dartlang-sdk:///sdk/lib/core/enum.dart)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart)
+- PrimitiveEquals. (from org-dartlang-testcase:///switch_encoding.dart:10:9)
+- NonPrimitiveEquals. (from org-dartlang-testcase:///switch_encoding.dart:16:9)
diff --git a/pkg/front_end/testcases/patterns/switch_encoding.dart.weak.outline.expect b/pkg/front_end/testcases/patterns/switch_encoding.dart.weak.outline.expect
new file mode 100644
index 00000000000..10594d48b27
--- /dev/null
+++ b/pkg/front_end/testcases/patterns/switch_encoding.dart.weak.outline.expect
@@ -0,0 +1,73 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+class E extends core::_Enum /*isEnum*/  {
+  static const field core::List<self::E> values = const <self::E>[self::E::a, self::E::b, self::E::c];
+  enum-element static const field self::E a = const self::E::•(0, "a");
+  enum-element static const field self::E b = const self::E::•(1, "b");
+  enum-element static const field self::E c = const self::E::•(2, "c");
+  const constructor •(core::int #index, core::String #name) → self::E
+    : super core::_Enum::•(#index, #name)
+    ;
+  method _enumToString() → core::String
+    return "E.${this.{core::_Enum::_name}{core::String}}";
+}
+class PrimitiveEquals extends core::Object /*hasConstConstructor*/  {
+  final field core::int field;
+  const constructor •(core::int field) → self::PrimitiveEquals
+    : self::PrimitiveEquals::field = field, super core::Object::•()
+    ;
+}
+class NonPrimitiveEquals extends core::Object /*hasConstConstructor*/  {
+  final field core::int field;
+  const constructor •(core::int field) → self::NonPrimitiveEquals
+    : self::NonPrimitiveEquals::field = field, super core::Object::•()
+    ;
+  get hashCode() → core::int
+    ;
+  operator ==(core::Object other) → core::bool
+    ;
+}
+static method switchStatement(dynamic o) → dynamic
+  ;
+static method switchStatementWithLabel(dynamic o) → dynamic
+  ;
+static method switchStatementWithContinue(dynamic o) → dynamic
+  ;
+static method switchStatementWithContinueNested(dynamic o1, dynamic o2) → dynamic
+  ;
+static method switchStatementEnum(self::E o) → dynamic
+  ;
+static method switchStatementEnumWithGuard(self::E o) → dynamic
+  ;
+static method switchStatementEnumWithLabel(self::E o) → dynamic
+  ;
+static method switchStatementEnumWithContinue(self::E o) → dynamic
+  ;
+static method switchStatementPrimitiveEquals(dynamic o) → dynamic
+  ;
+static method switchStatementNonPrimitiveEquals(dynamic o) → dynamic
+  ;
+static method switchExpression(dynamic o) → dynamic
+  ;
+static method switchExpressionEnum(self::E o) → dynamic
+  ;
+static method switchExpressionEnumWithGuard(self::E o) → dynamic
+  ;
+static method switchExpressionPrimitiveEquals(dynamic o) → dynamic
+  ;
+static method switchExpressionNonPrimitiveEquals(dynamic o) → dynamic
+  ;
+static method switchStatementSymbol(core::Symbol s) → dynamic
+  ;
+static method switchExpressionSymbol(core::Symbol s) → dynamic
+  ;
+
+
+Extra constant evaluation status:
+Evaluated: ListLiteral @ org-dartlang-testcase:///switch_encoding.dart:5:6 -> ListConstant(const <E*>[const E{_Enum.index: 0, _Enum._name: "a"}, const E{_Enum.index: 1, _Enum._name: "b"}, const E{_Enum.index: 2, _Enum._name: "c"}])
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///switch_encoding.dart:5:10 -> InstanceConstant(const E{_Enum.index: 0, _Enum._name: "a"})
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///switch_encoding.dart:5:13 -> InstanceConstant(const E{_Enum.index: 1, _Enum._name: "b"})
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///switch_encoding.dart:5:16 -> InstanceConstant(const E{_Enum.index: 2, _Enum._name: "c"})
+Extra constant evaluation: evaluated: 11, effectively constant: 4
diff --git a/pkg/front_end/testcases/patterns/switch_encoding.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/switch_encoding.dart.weak.transformed.expect
new file mode 100644
index 00000000000..97a90c3194c
--- /dev/null
+++ b/pkg/front_end/testcases/patterns/switch_encoding.dart.weak.transformed.expect
@@ -0,0 +1,752 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+class E extends core::_Enum /*isEnum*/  {
+  static const field core::List<self::E> values = #C10;
+  enum-element static const field self::E a = #C3;
+  enum-element static const field self::E b = #C6;
+  enum-element static const field self::E c = #C9;
+  const constructor •(core::int #index, core::String #name) → self::E
+    : super core::_Enum::•(#index, #name)
+    ;
+  method _enumToString() → core::String
+    return "E.${this.{core::_Enum::_name}{core::String}}";
+}
+class PrimitiveEquals extends core::Object /*hasConstConstructor*/  {
+  final field core::int field;
+  const constructor •(core::int field) → self::PrimitiveEquals
+    : self::PrimitiveEquals::field = field, super core::Object::•()
+    ;
+}
+class NonPrimitiveEquals extends core::Object /*hasConstConstructor*/  {
+  final field core::int field;
+  const constructor •(core::int field) → self::NonPrimitiveEquals
+    : self::NonPrimitiveEquals::field = field, super core::Object::•()
+    ;
+  get hashCode() → core::int
+    return this.{self::NonPrimitiveEquals::field}{core::int}.{core::num::hashCode}{core::int};
+  operator ==(core::Object other) → core::bool {
+    if(core::identical(this, other))
+      return true;
+    return other is{ForNonNullableByDefault} self::NonPrimitiveEquals && this.{self::NonPrimitiveEquals::field}{core::int} =={core::num::==}{(core::Object) → core::bool} other{self::NonPrimitiveEquals}.{self::NonPrimitiveEquals::field}{core::int};
+  }
+}
+static method switchStatement(dynamic o) → dynamic {
+  #L1:
+  {
+    final synthesized dynamic #0#0 = o;
+    synthesized core::bool #0#4;
+    synthesized core::bool #0#4#isSet = false;
+    synthesized core::int #0#2;
+    synthesized core::bool #0#2#isSet = false;
+    function ##0#6#initializer() → dynamic
+      return #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
+    late final synthesized dynamic #0#6 = ##0#6#initializer(){() → dynamic};
+    dynamic #t1;
+    {
+      lowered dynamic a#case#0;
+      lowered dynamic a#case#1;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t2 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t3 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && (let final dynamic #t4 = a#case#0 = #0#6 in true) && a#case#0{dynamic}.>(5) && (let final dynamic #t5 = #t1 = a#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t6 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t7 = #0#6 in true) && (let final dynamic #t8 = a#case#1 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic} in true) && a#case#1{dynamic}.<(5) && (let final dynamic #t9 = #t1 = a#case#1 in true)) {
+        dynamic a = #t1{dynamic};
+        {
+          core::print(a);
+          break #L1;
+        }
+      }
+    }
+    {
+      dynamic a;
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t10 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t11 = #0#2#isSet = true in #0#2 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && (let final dynamic #t12 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C4){(core::Object?) → dynamic} in true)) {
+        {
+          core::print(a);
+        }
+      }
+    }
+  }
+}
+static method switchStatementWithLabel(dynamic o) → dynamic {
+  #L2:
+  {
+    final synthesized dynamic #0#0 = o;
+    synthesized core::bool #0#4;
+    synthesized core::bool #0#4#isSet = false;
+    synthesized core::int #0#2;
+    synthesized core::bool #0#2#isSet = false;
+    function ##0#6#initializer() → dynamic
+      return #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
+    late final synthesized dynamic #0#6 = ##0#6#initializer(){() → dynamic};
+    dynamic #t13;
+    {
+      lowered dynamic a#case#0;
+      lowered dynamic a#case#1;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t14 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t15 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && (let final dynamic #t16 = a#case#0 = #0#6 in true) && a#case#0{dynamic}.>(5) && (let final dynamic #t17 = #t13 = a#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t18 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t19 = #0#6 in true) && (let final dynamic #t20 = a#case#1 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic} in true) && a#case#1{dynamic}.<(5) && (let final dynamic #t21 = #t13 = a#case#1 in true)) {
+        dynamic a = #t13{dynamic};
+        {
+          core::print(a);
+          break #L2;
+        }
+      }
+    }
+    {
+      dynamic a;
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t22 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t23 = #0#2#isSet = true in #0#2 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && (let final dynamic #t24 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C4){(core::Object?) → dynamic} in true)) {
+        {
+          core::print(a);
+          break #L2;
+        }
+      }
+    }
+    {
+      if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          core::print(1);
+        }
+      }
+    }
+  }
+}
+static method switchStatementWithContinue(dynamic o) → dynamic {
+  #L3:
+  {
+    core::int #t25 = -1;
+    final synthesized dynamic #0#0 = o;
+    synthesized core::bool #0#4;
+    synthesized core::bool #0#4#isSet = false;
+    synthesized core::int #0#2;
+    synthesized core::bool #0#2#isSet = false;
+    function ##0#6#initializer() → dynamic
+      return #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
+    late final synthesized dynamic #0#6 = ##0#6#initializer(){() → dynamic};
+    dynamic #t26;
+    #L4:
+    {
+      {
+        lowered dynamic a#case#0;
+        lowered dynamic a#case#1;
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t27 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t28 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && (let final dynamic #t29 = a#case#0 = #0#6 in true) && a#case#0{dynamic}.>(5) && (let final dynamic #t30 = #t26 = a#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t31 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t32 = #0#6 in true) && (let final dynamic #t33 = a#case#1 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic} in true) && a#case#1{dynamic}.<(5) && (let final dynamic #t34 = #t26 = a#case#1 in true)) {
+          dynamic a = #t26{dynamic};
+          {
+            core::print(a);
+            break #L3;
+          }
+        }
+      }
+      {
+        dynamic a;
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t35 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t36 = #0#2#isSet = true in #0#2 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && (let final dynamic #t37 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C4){(core::Object?) → dynamic} in true)) {
+          {
+            core::print(a);
+            #t25 = 0;
+            break #L4;
+          }
+        }
+      }
+      {
+        if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+          {
+            core::print(o);
+            break #L3;
+          }
+        }
+      }
+      {
+        if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+          #t25 = 0;
+          break #L4;
+        }
+      }
+      {
+        if(#C7 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+          #t25 = 1;
+          break #L4;
+        }
+      }
+    }
+    switch(#t25) {
+      #L5:
+      case #C1:
+        {
+          {
+            core::print(1);
+            continue #L6;
+          }
+        }
+      #L6:
+      case #C4:
+        {
+          {
+            core::print(2);
+          }
+        }
+    }
+  }
+}
+static method switchStatementWithContinueNested(dynamic o1, dynamic o2) → dynamic {
+  #L7:
+  {
+    core::int #t38 = -1;
+    final synthesized dynamic #2#0 = o1;
+    synthesized core::bool #2#4;
+    synthesized core::bool #2#4#isSet = false;
+    #L8:
+    {
+      {
+        dynamic a;
+        if(#2#0 is{ForNonNullableByDefault} core::List<dynamic> && (#2#4#isSet ?{core::bool} #2#4{core::bool} : let final core::bool* #t39 = #2#4#isSet = true in #2#4 = #2#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C4) && (let final dynamic #t40 = a = #2#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} in true)) {
+          {
+            core::print(a);
+            break #L7;
+          }
+        }
+      }
+      {
+        dynamic a;
+        if(#2#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#2#4#isSet ?{core::bool} #2#4{core::bool} : let final core::bool* #t41 = #2#4#isSet = true in #2#4 = #2#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C4) && #2#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && (let final dynamic #t42 = a = #2#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C4){(core::Object?) → dynamic} in true)) {
+          {
+            core::print(a);
+            #L9:
+            {
+              core::int #t43 = -1;
+              final synthesized dynamic #0#0 = o2;
+              synthesized core::bool #0#4;
+              synthesized core::bool #0#4#isSet = false;
+              synthesized core::int #0#2;
+              synthesized core::bool #0#2#isSet = false;
+              function ##0#6#initializer() → dynamic
+                return #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
+              late final synthesized dynamic #0#6 = ##0#6#initializer(){() → dynamic};
+              dynamic #t44;
+              #L10:
+              {
+                {
+                  lowered dynamic a#case#0;
+                  lowered dynamic a#case#1;
+                  if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t45 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t46 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && (let final dynamic #t47 = a#case#0 = #0#6 in true) && a#case#0{dynamic}.>(5) && (let final dynamic #t48 = #t44 = a#case#0 in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t49 = #0#2#isSet = true in #0#2 = #0#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t50 = #0#6 in true) && (let final dynamic #t51 = a#case#1 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic} in true) && a#case#1{dynamic}.<(5) && (let final dynamic #t52 = #t44 = a#case#1 in true)) {
+                    dynamic a = #t44{dynamic};
+                    {
+                      core::print(a);
+                      break #L9;
+                    }
+                  }
+                }
+                {
+                  dynamic a;
+                  if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t53 = #0#4#isSet = true in #0#4 = (#0#2#isSet ?{core::int} #0#2{core::int} : let final core::bool* #t54 = #0#2#isSet = true in #0#2 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && (let final dynamic #t55 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C4){(core::Object?) → dynamic} in true)) {
+                    {
+                      core::print(a);
+                      #t38 = 1;
+                      break #L8;
+                    }
+                  }
+                }
+                {
+                  if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+                    {
+                      core::print(o2);
+                      #t43 = 0;
+                      break #L10;
+                    }
+                  }
+                }
+                {
+                  if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+                    #t43 = 0;
+                    break #L10;
+                  }
+                }
+                {
+                  if(#C7 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+                    #t43 = 1;
+                    break #L10;
+                  }
+                }
+              }
+              switch(#t43) {
+                #L11:
+                case #C1:
+                  {
+                    {
+                      core::print(1);
+                      continue #L12;
+                    }
+                  }
+                #L12:
+                case #C4:
+                  {
+                    {
+                      core::print(2);
+                      #t38 = 0;
+                      break #L8;
+                    }
+                  }
+              }
+            }
+            break #L7;
+          }
+        }
+      }
+      {
+        if(#C1 =={core::num::==}{(core::Object) → core::bool} #2#0) {
+          {
+            core::print(o1);
+            break #L7;
+          }
+        }
+      }
+      {
+        if(#C4 =={core::num::==}{(core::Object) → core::bool} #2#0) {
+          #t38 = 0;
+          break #L8;
+        }
+      }
+      {
+        if(#C7 =={core::num::==}{(core::Object) → core::bool} #2#0) {
+          #t38 = 1;
+          break #L8;
+        }
+      }
+    }
+    switch(#t38) {
+      #L13:
+      case #C1:
+        {
+          {
+            core::print(1);
+            continue #L14;
+          }
+        }
+      #L14:
+      case #C4:
+        {
+          {
+            core::print(2);
+            #L15:
+            {
+              core::int #t56 = -1;
+              final synthesized dynamic #1#0 = o2;
+              synthesized core::bool #1#4;
+              synthesized core::bool #1#4#isSet = false;
+              synthesized core::int #1#2;
+              synthesized core::bool #1#2#isSet = false;
+              function ##1#6#initializer() → dynamic
+                return #1#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
+              late final synthesized dynamic #1#6 = ##1#6#initializer(){() → dynamic};
+              dynamic #t57;
+              #L16:
+              {
+                {
+                  lowered dynamic a#case#0;
+                  lowered dynamic a#case#1;
+                  if(#1#0 is{ForNonNullableByDefault} core::List<dynamic> && (#1#4#isSet ?{core::bool} #1#4{core::bool} : let final core::bool* #t58 = #1#4#isSet = true in #1#4 = (#1#2#isSet ?{core::int} #1#2{core::int} : let final core::bool* #t59 = #1#2#isSet = true in #1#2 = #1#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && (let final dynamic #t60 = a#case#0 = #1#6 in true) && a#case#0{dynamic}.>(5) && (let final dynamic #t61 = #t57 = a#case#0 in true) || #1#0 is{ForNonNullableByDefault} core::List<dynamic> && (#1#2#isSet ?{core::int} #1#2{core::int} : let final core::bool* #t62 = #1#2#isSet = true in #1#2 = #1#0{core::List<dynamic>}.{core::List::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C7 && (let final dynamic #t63 = #1#6 in true) && (let final dynamic #t64 = a#case#1 = #1#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic} in true) && a#case#1{dynamic}.<(5) && (let final dynamic #t65 = #t57 = a#case#1 in true)) {
+                    dynamic a = #t57{dynamic};
+                    {
+                      core::print(a);
+                      break #L15;
+                    }
+                  }
+                }
+                {
+                  dynamic a;
+                  if(#1#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#1#4#isSet ?{core::bool} #1#4{core::bool} : let final core::bool* #t66 = #1#4#isSet = true in #1#4 = (#1#2#isSet ?{core::int} #1#2{core::int} : let final core::bool* #t67 = #1#2#isSet = true in #1#2 = #1#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int}) =={core::num::==}{(core::Object) → core::bool} #C4) && #1#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && (let final dynamic #t68 = a = #1#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C4){(core::Object?) → dynamic} in true)) {
+                    {
+                      core::print(a);
+                      continue #L14;
+                    }
+                  }
+                }
+                {
+                  if(#C1 =={core::num::==}{(core::Object) → core::bool} #1#0) {
+                    {
+                      core::print(o2);
+                      #t56 = 0;
+                      break #L16;
+                    }
+                  }
+                }
+                {
+                  if(#C4 =={core::num::==}{(core::Object) → core::bool} #1#0) {
+                    #t56 = 0;
+                    break #L16;
+                  }
+                }
+                {
+                  if(#C7 =={core::num::==}{(core::Object) → core::bool} #1#0) {
+                    #t56 = 1;
+                    break #L16;
+                  }
+                }
+              }
+              switch(#t56) {
+                #L17:
+                case #C1:
+                  {
+                    {
+                      core::print(1);
+                      continue #L18;
+                    }
+                  }
+                #L18:
+                case #C4:
+                  {
+                    {
+                      core::print(2);
+                      continue #L13;
+                    }
+                  }
+              }
+            }
+          }
+        }
+    }
+  }
+}
+static method switchStatementEnum(self::E o) → dynamic {
+  #L19:
+  switch(o) /*isExplicitlyExhaustive*/ {
+    #L20:
+    case #C3:
+      {
+        core::print("a");
+        break #L19;
+      }
+    #L21:
+    case #C6:
+      {
+        core::print("b");
+        break #L19;
+      }
+    #L22:
+    case #C9:
+      {
+        core::print("c");
+      }
+  }
+}
+static method switchStatementEnumWithGuard(self::E o) → dynamic {
+  #L23:
+  {
+    final synthesized self::E #0#0 = o;
+    {
+      if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0 && true) {
+        {
+          core::print("a");
+          break #L23;
+        }
+      }
+    }
+    {
+      if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+        {
+          core::print("b");
+          break #L23;
+        }
+      }
+    }
+    {
+      if(true) {
+      }
+    }
+  }
+}
+static method switchStatementEnumWithLabel(self::E o) → dynamic {
+  #L24:
+  switch(o) /*isExplicitlyExhaustive*/ {
+    #L25:
+    case #C3:
+      {
+        core::print("a");
+        break #L24;
+      }
+    #L26:
+    case #C6:
+      {
+        core::print("b");
+        break #L24;
+      }
+    #L27:
+    case #C9:
+      {
+        core::print("c");
+      }
+  }
+}
+static method switchStatementEnumWithContinue(self::E o) → dynamic {
+  #L28:
+  switch(o) /*isExplicitlyExhaustive*/ {
+    #L29:
+    case #C3:
+      {
+        core::print("a");
+        continue #L30;
+      }
+    #L30:
+    case #C6:
+      {
+        core::print("b");
+        continue #L31;
+      }
+    #L31:
+    case #C9:
+      {
+        core::print("c");
+      }
+  }
+}
+static method switchStatementPrimitiveEquals(dynamic o) → dynamic {
+  #L32:
+  switch(o) {
+    #L33:
+    case #C11:
+      {
+        core::print("a");
+        break #L32;
+      }
+    #L34:
+    case #C12:
+      {
+        core::print("b");
+      }
+  }
+}
+static method switchStatementNonPrimitiveEquals(dynamic o) → dynamic {
+  #L35:
+  {
+    final synthesized dynamic #0#0 = o;
+    {
+      if(#C13 =={self::NonPrimitiveEquals::==}{(core::Object) → core::bool} #0#0) {
+        {
+          core::print("a");
+          break #L35;
+        }
+      }
+    }
+    {
+      if(#C14 =={self::NonPrimitiveEquals::==}{(core::Object) → core::bool} #0#0) {
+        {
+          core::print("b");
+        }
+      }
+    }
+  }
+}
+static method switchExpression(dynamic o) → dynamic {
+  return block {
+    dynamic #t69;
+    final synthesized dynamic #0#0 = o;
+    synthesized core::bool #0#4;
+    synthesized core::bool #0#4#isSet = false;
+    #L36:
+    {
+      {
+        dynamic a;
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t70 = #0#4#isSet = true in #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C4) && (let final dynamic #t71 = a = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} in true)) {
+          #t69 = a;
+          break #L36;
+        }
+      }
+      {
+        dynamic a;
+        if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#0#4#isSet ?{core::bool} #0#4{core::bool} : let final core::bool* #t72 = #0#4#isSet = true in #0#4 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C4) && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C4){(core::Object?) → core::bool} && (let final dynamic #t73 = a = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C4){(core::Object?) → dynamic} in true)) {
+          #t69 = a;
+          break #L36;
+        }
+      }
+      {
+        if(true) {
+          #t69 = null;
+          break #L36;
+        }
+      }
+    }
+  } =>#t69;
+}
+static method switchExpressionEnum(self::E o) → dynamic {
+  return block {
+    core::int #t74;
+    #L37:
+    switch(o) /*isExplicitlyExhaustive*/ {
+      #L38:
+      case #C3:
+        {
+          #t74 = 0;
+          break #L37;
+        }
+      #L39:
+      case #C6:
+        {
+          #t74 = 1;
+          break #L37;
+        }
+      #L40:
+      case #C9:
+        {
+          #t74 = 2;
+          break #L37;
+        }
+    }
+  } =>#t74;
+}
+static method switchExpressionEnumWithGuard(self::E o) → dynamic {
+  return block {
+    core::int #t75;
+    final synthesized self::E #0#0 = o;
+    #L41:
+    {
+      {
+        if(#C3 =={core::Object::==}{(core::Object) → core::bool} #0#0 && true) {
+          #t75 = 0;
+          break #L41;
+        }
+      }
+      {
+        if(#C6 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+          #t75 = 1;
+          break #L41;
+        }
+      }
+      {
+        if(true) {
+          #t75 = 2;
+          break #L41;
+        }
+      }
+    }
+  } =>#t75;
+}
+static method switchExpressionPrimitiveEquals(dynamic o) → dynamic {
+  return block {
+    core::int #t76;
+    final synthesized dynamic #0#0 = o;
+    #L42:
+    {
+      {
+        if(#C11 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+          #t76 = 0;
+          break #L42;
+        }
+      }
+      {
+        if(#C12 =={core::Object::==}{(core::Object) → core::bool} #0#0) {
+          #t76 = 1;
+          break #L42;
+        }
+      }
+      {
+        if(true) {
+          #t76 = 2;
+          break #L42;
+        }
+      }
+    }
+  } =>#t76;
+}
+static method switchExpressionNonPrimitiveEquals(dynamic o) → dynamic {
+  return block {
+    core::int #t77;
+    final synthesized dynamic #0#0 = o;
+    #L43:
+    {
+      {
+        if(#C13 =={self::NonPrimitiveEquals::==}{(core::Object) → core::bool} #0#0) {
+          #t77 = 0;
+          break #L43;
+        }
+      }
+      {
+        if(#C14 =={self::NonPrimitiveEquals::==}{(core::Object) → core::bool} #0#0) {
+          #t77 = 1;
+          break #L43;
+        }
+      }
+      {
+        if(true) {
+          #t77 = 2;
+          break #L43;
+        }
+      }
+    }
+  } =>#t77;
+}
+static method switchStatementSymbol(core::Symbol s) → dynamic {
+  #L44:
+  {
+    final synthesized core::Symbol #0#0 = s;
+    {
+      if(#C15 =={core::Symbol::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return 0;
+        }
+      }
+    }
+    {
+      if(#C16 =={core::Symbol::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return 1;
+        }
+      }
+    }
+    {
+      {
+        {
+          return 2;
+        }
+      }
+    }
+  }
+}
+static method switchExpressionSymbol(core::Symbol s) → dynamic {
+  return block {
+    core::int #t78;
+    final synthesized core::Symbol #0#0 = s;
+    #L45:
+    {
+      {
+        if(#C15 =={core::Symbol::==}{(core::Object) → core::bool} #0#0) {
+          #t78 = 0;
+          break #L45;
+        }
+      }
+      {
+        if(#C16 =={core::Symbol::==}{(core::Object) → core::bool} #0#0) {
+          #t78 = 1;
+          break #L45;
+        }
+      }
+      {
+        if(true) {
+          #t78 = 2;
+          break #L45;
+        }
+      }
+    }
+  } =>#t78;
+}
+
+constants  {
+  #C1 = 0
+  #C2 = "a"
+  #C3 = self::E {index:#C1, _name:#C2}
+  #C4 = 1
+  #C5 = "b"
+  #C6 = self::E {index:#C4, _name:#C5}
+  #C7 = 2
+  #C8 = "c"
+  #C9 = self::E {index:#C7, _name:#C8}
+  #C10 = <self::E*>[#C3, #C6, #C9]
+  #C11 = self::PrimitiveEquals {field:#C1}
+  #C12 = self::PrimitiveEquals {field:#C4}
+  #C13 = self::NonPrimitiveEquals {field:#C1}
+  #C14 = self::NonPrimitiveEquals {field:#C4}
+  #C15 = #a
+  #C16 = #b
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///switch_encoding.dart:
+- E. (from org-dartlang-testcase:///switch_encoding.dart:5:6)
+- _Enum. (from org-dartlang-sdk:///sdk/lib/core/enum.dart)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart)
+- PrimitiveEquals. (from org-dartlang-testcase:///switch_encoding.dart:10:9)
+- NonPrimitiveEquals. (from org-dartlang-testcase:///switch_encoding.dart:16:9)
diff --git a/pkg/front_end/testcases/patterns/switch_expressions_variable_capture.dart.strong.expect b/pkg/front_end/testcases/patterns/switch_expressions_variable_capture.dart.strong.expect
index 28cd9c887f4..81eff14e6dc 100644
--- a/pkg/front_end/testcases/patterns/switch_expressions_variable_capture.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/switch_expressions_variable_capture.dart.strong.expect
@@ -14,69 +14,97 @@ static field (dynamic) →? dynamic captured;
 static method test1(dynamic x) → dynamic
   return block {
     core::double? #t1;
-    core::double r;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} self::Circle && (let final dynamic #t2 = r = #0#0{self::Circle}.{self::Circle::radius}{core::double} in true) && r.{core::num::>}(0){(core::num) → core::bool})
-      #t1 = r.{core::double::*}(r){(core::num) → core::double}.{core::double::*}(#C1){(core::num) → core::double};
-    else
-      if(true)
-        #t1 = null;
+    #L1:
+    {
+      {
+        core::double r;
+        if(#0#0 is{ForNonNullableByDefault} self::Circle && (let final dynamic #t2 = r = #0#0{self::Circle}.{self::Circle::radius}{core::double} in true) && r.{core::num::>}(0){(core::num) → core::bool}) {
+          #t1 = r.{core::double::*}(r){(core::num) → core::double}.{core::double::*}(#C1){(core::num) → core::double};
+          break #L1;
+        }
+      }
+      {
+        if(true) {
+          #t1 = null;
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
 static method test2(dynamic x) → dynamic
   return block {
     dynamic #t3;
-    core::int a;
-    core::int b;
-    core::String a#1;
-    core::String b#1;
     final synthesized dynamic #0#0 = x;
     late final synthesized core::bool #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2;
     late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
     late final synthesized dynamic #0#7 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t4 = a = #0#6{core::int} in true)) && (#0#7 is{ForNonNullableByDefault} core::int && (let final dynamic #t5 = b = #0#7{core::int} in true)) && (self::captured = (dynamic x) → core::int {
-      return a.{core::num::+}(b){(core::num) → core::int};
-    }) is{ForNonNullableByDefault} dynamic)
-      #t3 = self::captured!(a = b){(dynamic) → dynamic};
-    else
-      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::String && (let final dynamic #t6 = a#1 = #0#6{core::String} in true)) && (#0#7 is{ForNonNullableByDefault} core::String && (let final dynamic #t7 = b#1 = #0#7{core::String} in true)) && (self::captured = (dynamic x) → core::String {
-        return a#1.{core::String::+}(b#1){(core::String) → core::String};
-      }) is{ForNonNullableByDefault} dynamic)
-        #t3 = self::captured!(a#1 = b#1){(dynamic) → dynamic};
-      else
-        if(true)
-          #t3 = null;
-  } =>#t3;
-static method test3(dynamic x) → dynamic {
-  #L1:
-  {
-    core::int a;
-    core::int b;
-    core::String a#1;
-    core::String b#1;
-    final synthesized dynamic #0#0 = x;
-    late final synthesized core::bool #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2;
-    late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
-    late final synthesized dynamic #0#7 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t8 = a = #0#6{core::int} in true)) && (#0#7 is{ForNonNullableByDefault} core::int && (let final dynamic #t9 = b = #0#7{core::int} in true)) && (self::captured = (dynamic x) → core::int {
-      return a.{core::num::+}(b){(core::num) → core::int};
-    }) is{ForNonNullableByDefault} dynamic) {
+    #L2:
+    {
       {
-        return self::captured!(a = b){(dynamic) → dynamic};
-      }
-    }
-    else
-      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::String && (let final dynamic #t10 = a#1 = #0#6{core::String} in true)) && (#0#7 is{ForNonNullableByDefault} core::String && (let final dynamic #t11 = b#1 = #0#7{core::String} in true)) && (self::captured = (dynamic x) → core::String {
-        return a#1.{core::String::+}(b#1){(core::String) → core::String};
-      }) is{ForNonNullableByDefault} dynamic) {
-        {
-          return self::captured!(a#1 = b#1){(dynamic) → dynamic};
+        core::int a;
+        core::int b;
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t4 = a = #0#6{core::int} in true)) && (#0#7 is{ForNonNullableByDefault} core::int && (let final dynamic #t5 = b = #0#7{core::int} in true)) && (self::captured = (dynamic x) → core::int {
+          return a.{core::num::+}(b){(core::num) → core::int};
+        }) is{ForNonNullableByDefault} dynamic) {
+          #t3 = self::captured!(a = b){(dynamic) → dynamic};
+          break #L2;
         }
       }
-      else {
+      {
+        core::String a;
+        core::String b;
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::String && (let final dynamic #t6 = a = #0#6{core::String} in true)) && (#0#7 is{ForNonNullableByDefault} core::String && (let final dynamic #t7 = b = #0#7{core::String} in true)) && (self::captured = (dynamic x) → core::String {
+          return a.{core::String::+}(b){(core::String) → core::String};
+        }) is{ForNonNullableByDefault} dynamic) {
+          #t3 = self::captured!(a = b){(dynamic) → dynamic};
+          break #L2;
+        }
+      }
+      {
+        if(true) {
+          #t3 = null;
+          break #L2;
+        }
+      }
+    }
+  } =>#t3;
+static method test3(dynamic x) → dynamic {
+  #L3:
+  {
+    final synthesized dynamic #0#0 = x;
+    late final synthesized core::bool #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2;
+    late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
+    late final synthesized dynamic #0#7 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic};
+    {
+      core::int a;
+      core::int b;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t8 = a = #0#6{core::int} in true)) && (#0#7 is{ForNonNullableByDefault} core::int && (let final dynamic #t9 = b = #0#7{core::int} in true)) && (self::captured = (dynamic x) → core::int {
+        return a.{core::num::+}(b){(core::num) → core::int};
+      }) is{ForNonNullableByDefault} dynamic) {
+        {
+          return self::captured!(a = b){(dynamic) → dynamic};
+        }
+      }
+    }
+    {
+      core::String a;
+      core::String b;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::String && (let final dynamic #t10 = a = #0#6{core::String} in true)) && (#0#7 is{ForNonNullableByDefault} core::String && (let final dynamic #t11 = b = #0#7{core::String} in true)) && (self::captured = (dynamic x) → core::String {
+        return a.{core::String::+}(b){(core::String) → core::String};
+      }) is{ForNonNullableByDefault} dynamic) {
+        {
+          return self::captured!(a = b){(dynamic) → dynamic};
+        }
+      }
+    }
+    {
+      {
         {
           return null;
         }
       }
+    }
   }
 }
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/patterns/switch_expressions_variable_capture.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/switch_expressions_variable_capture.dart.strong.transformed.expect
index bce419db2f9..874fb2ac1ab 100644
--- a/pkg/front_end/testcases/patterns/switch_expressions_variable_capture.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/switch_expressions_variable_capture.dart.strong.transformed.expect
@@ -14,21 +14,27 @@ static field (dynamic) →? dynamic captured;
 static method test1(dynamic x) → dynamic
   return block {
     core::double? #t1;
-    core::double r;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} self::Circle && (let final core::double #t2 = r = #0#0{self::Circle}.{self::Circle::radius}{core::double} in true) && r.{core::num::>}(0){(core::num) → core::bool})
-      #t1 = r.{core::double::*}(r){(core::num) → core::double}.{core::double::*}(#C1){(core::num) → core::double};
-    else
-      if(true)
-        #t1 = null;
+    #L1:
+    {
+      {
+        core::double r;
+        if(#0#0 is{ForNonNullableByDefault} self::Circle && (let final core::double #t2 = r = #0#0{self::Circle}.{self::Circle::radius}{core::double} in true) && r.{core::num::>}(0){(core::num) → core::bool}) {
+          #t1 = r.{core::double::*}(r){(core::num) → core::double}.{core::double::*}(#C1){(core::num) → core::double};
+          break #L1;
+        }
+      }
+      {
+        if(true) {
+          #t1 = null;
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
 static method test2(dynamic x) → dynamic
   return block {
     dynamic #t3;
-    core::int a;
-    core::int b;
-    core::String a#1;
-    core::String b#1;
     final synthesized dynamic #0#0 = x;
     function ##0#4#initializer() → core::bool
       return #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2;
@@ -39,56 +45,78 @@ static method test2(dynamic x) → dynamic
     function ##0#7#initializer() → dynamic
       return #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic};
     late final synthesized dynamic #0#7 = ##0#7#initializer(){() → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final core::int #t4 = a = #0#6{core::int} in true)) && (#0#7 is{ForNonNullableByDefault} core::int && (let final core::int #t5 = b = #0#7{core::int} in true)) && (self::captured = (dynamic x) → core::int {
-      return a.{core::num::+}(b){(core::num) → core::int};
-    }) is{ForNonNullableByDefault} dynamic)
-      #t3 = self::captured!(a = b){(dynamic) → dynamic};
-    else
-      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::String && (let final core::String #t6 = a#1 = #0#6{core::String} in true)) && (#0#7 is{ForNonNullableByDefault} core::String && (let final core::String #t7 = b#1 = #0#7{core::String} in true)) && (self::captured = (dynamic x) → core::String {
-        return a#1.{core::String::+}(b#1){(core::String) → core::String};
-      }) is{ForNonNullableByDefault} dynamic)
-        #t3 = self::captured!(a#1 = b#1){(dynamic) → dynamic};
-      else
-        if(true)
-          #t3 = null;
-  } =>#t3;
-static method test3(dynamic x) → dynamic {
-  #L1:
-  {
-    core::int a;
-    core::int b;
-    core::String a#1;
-    core::String b#1;
-    final synthesized dynamic #0#0 = x;
-    function ##0#4#initializer() → core::bool
-      return #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2;
-    late final synthesized core::bool #0#4 = ##0#4#initializer(){() → core::bool};
-    function ##0#6#initializer() → dynamic
-      return #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
-    late final synthesized dynamic #0#6 = ##0#6#initializer(){() → dynamic};
-    function ##0#7#initializer() → dynamic
-      return #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic};
-    late final synthesized dynamic #0#7 = ##0#7#initializer(){() → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final core::int #t8 = a = #0#6{core::int} in true)) && (#0#7 is{ForNonNullableByDefault} core::int && (let final core::int #t9 = b = #0#7{core::int} in true)) && (self::captured = (dynamic x) → core::int {
-      return a.{core::num::+}(b){(core::num) → core::int};
-    }) is{ForNonNullableByDefault} dynamic) {
+    #L2:
+    {
       {
-        return self::captured!(a = b){(dynamic) → dynamic};
-      }
-    }
-    else
-      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::String && (let final core::String #t10 = a#1 = #0#6{core::String} in true)) && (#0#7 is{ForNonNullableByDefault} core::String && (let final core::String #t11 = b#1 = #0#7{core::String} in true)) && (self::captured = (dynamic x) → core::String {
-        return a#1.{core::String::+}(b#1){(core::String) → core::String};
-      }) is{ForNonNullableByDefault} dynamic) {
-        {
-          return self::captured!(a#1 = b#1){(dynamic) → dynamic};
+        core::int a;
+        core::int b;
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final core::int #t4 = a = #0#6{core::int} in true)) && (#0#7 is{ForNonNullableByDefault} core::int && (let final core::int #t5 = b = #0#7{core::int} in true)) && (self::captured = (dynamic x) → core::int {
+          return a.{core::num::+}(b){(core::num) → core::int};
+        }) is{ForNonNullableByDefault} dynamic) {
+          #t3 = self::captured!(a = b){(dynamic) → dynamic};
+          break #L2;
         }
       }
-      else {
+      {
+        core::String a;
+        core::String b;
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::String && (let final core::String #t6 = a = #0#6{core::String} in true)) && (#0#7 is{ForNonNullableByDefault} core::String && (let final core::String #t7 = b = #0#7{core::String} in true)) && (self::captured = (dynamic x) → core::String {
+          return a.{core::String::+}(b){(core::String) → core::String};
+        }) is{ForNonNullableByDefault} dynamic) {
+          #t3 = self::captured!(a = b){(dynamic) → dynamic};
+          break #L2;
+        }
+      }
+      {
+        if(true) {
+          #t3 = null;
+          break #L2;
+        }
+      }
+    }
+  } =>#t3;
+static method test3(dynamic x) → dynamic {
+  #L3:
+  {
+    final synthesized dynamic #0#0 = x;
+    function ##0#4#initializer() → core::bool
+      return #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2;
+    late final synthesized core::bool #0#4 = ##0#4#initializer(){() → core::bool};
+    function ##0#6#initializer() → dynamic
+      return #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
+    late final synthesized dynamic #0#6 = ##0#6#initializer(){() → dynamic};
+    function ##0#7#initializer() → dynamic
+      return #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic};
+    late final synthesized dynamic #0#7 = ##0#7#initializer(){() → dynamic};
+    {
+      core::int a;
+      core::int b;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final core::int #t8 = a = #0#6{core::int} in true)) && (#0#7 is{ForNonNullableByDefault} core::int && (let final core::int #t9 = b = #0#7{core::int} in true)) && (self::captured = (dynamic x) → core::int {
+        return a.{core::num::+}(b){(core::num) → core::int};
+      }) is{ForNonNullableByDefault} dynamic) {
+        {
+          return self::captured!(a = b){(dynamic) → dynamic};
+        }
+      }
+    }
+    {
+      core::String a;
+      core::String b;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::String && (let final core::String #t10 = a = #0#6{core::String} in true)) && (#0#7 is{ForNonNullableByDefault} core::String && (let final core::String #t11 = b = #0#7{core::String} in true)) && (self::captured = (dynamic x) → core::String {
+        return a.{core::String::+}(b){(core::String) → core::String};
+      }) is{ForNonNullableByDefault} dynamic) {
+        {
+          return self::captured!(a = b){(dynamic) → dynamic};
+        }
+      }
+    }
+    {
+      {
         {
           return null;
         }
       }
+    }
   }
 }
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/patterns/switch_expressions_variable_capture.dart.weak.expect b/pkg/front_end/testcases/patterns/switch_expressions_variable_capture.dart.weak.expect
index 28cd9c887f4..81eff14e6dc 100644
--- a/pkg/front_end/testcases/patterns/switch_expressions_variable_capture.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/switch_expressions_variable_capture.dart.weak.expect
@@ -14,69 +14,97 @@ static field (dynamic) →? dynamic captured;
 static method test1(dynamic x) → dynamic
   return block {
     core::double? #t1;
-    core::double r;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} self::Circle && (let final dynamic #t2 = r = #0#0{self::Circle}.{self::Circle::radius}{core::double} in true) && r.{core::num::>}(0){(core::num) → core::bool})
-      #t1 = r.{core::double::*}(r){(core::num) → core::double}.{core::double::*}(#C1){(core::num) → core::double};
-    else
-      if(true)
-        #t1 = null;
+    #L1:
+    {
+      {
+        core::double r;
+        if(#0#0 is{ForNonNullableByDefault} self::Circle && (let final dynamic #t2 = r = #0#0{self::Circle}.{self::Circle::radius}{core::double} in true) && r.{core::num::>}(0){(core::num) → core::bool}) {
+          #t1 = r.{core::double::*}(r){(core::num) → core::double}.{core::double::*}(#C1){(core::num) → core::double};
+          break #L1;
+        }
+      }
+      {
+        if(true) {
+          #t1 = null;
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
 static method test2(dynamic x) → dynamic
   return block {
     dynamic #t3;
-    core::int a;
-    core::int b;
-    core::String a#1;
-    core::String b#1;
     final synthesized dynamic #0#0 = x;
     late final synthesized core::bool #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2;
     late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
     late final synthesized dynamic #0#7 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t4 = a = #0#6{core::int} in true)) && (#0#7 is{ForNonNullableByDefault} core::int && (let final dynamic #t5 = b = #0#7{core::int} in true)) && (self::captured = (dynamic x) → core::int {
-      return a.{core::num::+}(b){(core::num) → core::int};
-    }) is{ForNonNullableByDefault} dynamic)
-      #t3 = self::captured!(a = b){(dynamic) → dynamic};
-    else
-      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::String && (let final dynamic #t6 = a#1 = #0#6{core::String} in true)) && (#0#7 is{ForNonNullableByDefault} core::String && (let final dynamic #t7 = b#1 = #0#7{core::String} in true)) && (self::captured = (dynamic x) → core::String {
-        return a#1.{core::String::+}(b#1){(core::String) → core::String};
-      }) is{ForNonNullableByDefault} dynamic)
-        #t3 = self::captured!(a#1 = b#1){(dynamic) → dynamic};
-      else
-        if(true)
-          #t3 = null;
-  } =>#t3;
-static method test3(dynamic x) → dynamic {
-  #L1:
-  {
-    core::int a;
-    core::int b;
-    core::String a#1;
-    core::String b#1;
-    final synthesized dynamic #0#0 = x;
-    late final synthesized core::bool #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2;
-    late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
-    late final synthesized dynamic #0#7 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t8 = a = #0#6{core::int} in true)) && (#0#7 is{ForNonNullableByDefault} core::int && (let final dynamic #t9 = b = #0#7{core::int} in true)) && (self::captured = (dynamic x) → core::int {
-      return a.{core::num::+}(b){(core::num) → core::int};
-    }) is{ForNonNullableByDefault} dynamic) {
+    #L2:
+    {
       {
-        return self::captured!(a = b){(dynamic) → dynamic};
-      }
-    }
-    else
-      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::String && (let final dynamic #t10 = a#1 = #0#6{core::String} in true)) && (#0#7 is{ForNonNullableByDefault} core::String && (let final dynamic #t11 = b#1 = #0#7{core::String} in true)) && (self::captured = (dynamic x) → core::String {
-        return a#1.{core::String::+}(b#1){(core::String) → core::String};
-      }) is{ForNonNullableByDefault} dynamic) {
-        {
-          return self::captured!(a#1 = b#1){(dynamic) → dynamic};
+        core::int a;
+        core::int b;
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t4 = a = #0#6{core::int} in true)) && (#0#7 is{ForNonNullableByDefault} core::int && (let final dynamic #t5 = b = #0#7{core::int} in true)) && (self::captured = (dynamic x) → core::int {
+          return a.{core::num::+}(b){(core::num) → core::int};
+        }) is{ForNonNullableByDefault} dynamic) {
+          #t3 = self::captured!(a = b){(dynamic) → dynamic};
+          break #L2;
         }
       }
-      else {
+      {
+        core::String a;
+        core::String b;
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::String && (let final dynamic #t6 = a = #0#6{core::String} in true)) && (#0#7 is{ForNonNullableByDefault} core::String && (let final dynamic #t7 = b = #0#7{core::String} in true)) && (self::captured = (dynamic x) → core::String {
+          return a.{core::String::+}(b){(core::String) → core::String};
+        }) is{ForNonNullableByDefault} dynamic) {
+          #t3 = self::captured!(a = b){(dynamic) → dynamic};
+          break #L2;
+        }
+      }
+      {
+        if(true) {
+          #t3 = null;
+          break #L2;
+        }
+      }
+    }
+  } =>#t3;
+static method test3(dynamic x) → dynamic {
+  #L3:
+  {
+    final synthesized dynamic #0#0 = x;
+    late final synthesized core::bool #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2;
+    late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
+    late final synthesized dynamic #0#7 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic};
+    {
+      core::int a;
+      core::int b;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t8 = a = #0#6{core::int} in true)) && (#0#7 is{ForNonNullableByDefault} core::int && (let final dynamic #t9 = b = #0#7{core::int} in true)) && (self::captured = (dynamic x) → core::int {
+        return a.{core::num::+}(b){(core::num) → core::int};
+      }) is{ForNonNullableByDefault} dynamic) {
+        {
+          return self::captured!(a = b){(dynamic) → dynamic};
+        }
+      }
+    }
+    {
+      core::String a;
+      core::String b;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::String && (let final dynamic #t10 = a = #0#6{core::String} in true)) && (#0#7 is{ForNonNullableByDefault} core::String && (let final dynamic #t11 = b = #0#7{core::String} in true)) && (self::captured = (dynamic x) → core::String {
+        return a.{core::String::+}(b){(core::String) → core::String};
+      }) is{ForNonNullableByDefault} dynamic) {
+        {
+          return self::captured!(a = b){(dynamic) → dynamic};
+        }
+      }
+    }
+    {
+      {
         {
           return null;
         }
       }
+    }
   }
 }
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/patterns/switch_expressions_variable_capture.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/switch_expressions_variable_capture.dart.weak.modular.expect
index 28cd9c887f4..81eff14e6dc 100644
--- a/pkg/front_end/testcases/patterns/switch_expressions_variable_capture.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/switch_expressions_variable_capture.dart.weak.modular.expect
@@ -14,69 +14,97 @@ static field (dynamic) →? dynamic captured;
 static method test1(dynamic x) → dynamic
   return block {
     core::double? #t1;
-    core::double r;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} self::Circle && (let final dynamic #t2 = r = #0#0{self::Circle}.{self::Circle::radius}{core::double} in true) && r.{core::num::>}(0){(core::num) → core::bool})
-      #t1 = r.{core::double::*}(r){(core::num) → core::double}.{core::double::*}(#C1){(core::num) → core::double};
-    else
-      if(true)
-        #t1 = null;
+    #L1:
+    {
+      {
+        core::double r;
+        if(#0#0 is{ForNonNullableByDefault} self::Circle && (let final dynamic #t2 = r = #0#0{self::Circle}.{self::Circle::radius}{core::double} in true) && r.{core::num::>}(0){(core::num) → core::bool}) {
+          #t1 = r.{core::double::*}(r){(core::num) → core::double}.{core::double::*}(#C1){(core::num) → core::double};
+          break #L1;
+        }
+      }
+      {
+        if(true) {
+          #t1 = null;
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
 static method test2(dynamic x) → dynamic
   return block {
     dynamic #t3;
-    core::int a;
-    core::int b;
-    core::String a#1;
-    core::String b#1;
     final synthesized dynamic #0#0 = x;
     late final synthesized core::bool #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2;
     late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
     late final synthesized dynamic #0#7 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t4 = a = #0#6{core::int} in true)) && (#0#7 is{ForNonNullableByDefault} core::int && (let final dynamic #t5 = b = #0#7{core::int} in true)) && (self::captured = (dynamic x) → core::int {
-      return a.{core::num::+}(b){(core::num) → core::int};
-    }) is{ForNonNullableByDefault} dynamic)
-      #t3 = self::captured!(a = b){(dynamic) → dynamic};
-    else
-      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::String && (let final dynamic #t6 = a#1 = #0#6{core::String} in true)) && (#0#7 is{ForNonNullableByDefault} core::String && (let final dynamic #t7 = b#1 = #0#7{core::String} in true)) && (self::captured = (dynamic x) → core::String {
-        return a#1.{core::String::+}(b#1){(core::String) → core::String};
-      }) is{ForNonNullableByDefault} dynamic)
-        #t3 = self::captured!(a#1 = b#1){(dynamic) → dynamic};
-      else
-        if(true)
-          #t3 = null;
-  } =>#t3;
-static method test3(dynamic x) → dynamic {
-  #L1:
-  {
-    core::int a;
-    core::int b;
-    core::String a#1;
-    core::String b#1;
-    final synthesized dynamic #0#0 = x;
-    late final synthesized core::bool #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2;
-    late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
-    late final synthesized dynamic #0#7 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t8 = a = #0#6{core::int} in true)) && (#0#7 is{ForNonNullableByDefault} core::int && (let final dynamic #t9 = b = #0#7{core::int} in true)) && (self::captured = (dynamic x) → core::int {
-      return a.{core::num::+}(b){(core::num) → core::int};
-    }) is{ForNonNullableByDefault} dynamic) {
+    #L2:
+    {
       {
-        return self::captured!(a = b){(dynamic) → dynamic};
-      }
-    }
-    else
-      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::String && (let final dynamic #t10 = a#1 = #0#6{core::String} in true)) && (#0#7 is{ForNonNullableByDefault} core::String && (let final dynamic #t11 = b#1 = #0#7{core::String} in true)) && (self::captured = (dynamic x) → core::String {
-        return a#1.{core::String::+}(b#1){(core::String) → core::String};
-      }) is{ForNonNullableByDefault} dynamic) {
-        {
-          return self::captured!(a#1 = b#1){(dynamic) → dynamic};
+        core::int a;
+        core::int b;
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t4 = a = #0#6{core::int} in true)) && (#0#7 is{ForNonNullableByDefault} core::int && (let final dynamic #t5 = b = #0#7{core::int} in true)) && (self::captured = (dynamic x) → core::int {
+          return a.{core::num::+}(b){(core::num) → core::int};
+        }) is{ForNonNullableByDefault} dynamic) {
+          #t3 = self::captured!(a = b){(dynamic) → dynamic};
+          break #L2;
         }
       }
-      else {
+      {
+        core::String a;
+        core::String b;
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::String && (let final dynamic #t6 = a = #0#6{core::String} in true)) && (#0#7 is{ForNonNullableByDefault} core::String && (let final dynamic #t7 = b = #0#7{core::String} in true)) && (self::captured = (dynamic x) → core::String {
+          return a.{core::String::+}(b){(core::String) → core::String};
+        }) is{ForNonNullableByDefault} dynamic) {
+          #t3 = self::captured!(a = b){(dynamic) → dynamic};
+          break #L2;
+        }
+      }
+      {
+        if(true) {
+          #t3 = null;
+          break #L2;
+        }
+      }
+    }
+  } =>#t3;
+static method test3(dynamic x) → dynamic {
+  #L3:
+  {
+    final synthesized dynamic #0#0 = x;
+    late final synthesized core::bool #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2;
+    late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
+    late final synthesized dynamic #0#7 = #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic};
+    {
+      core::int a;
+      core::int b;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t8 = a = #0#6{core::int} in true)) && (#0#7 is{ForNonNullableByDefault} core::int && (let final dynamic #t9 = b = #0#7{core::int} in true)) && (self::captured = (dynamic x) → core::int {
+        return a.{core::num::+}(b){(core::num) → core::int};
+      }) is{ForNonNullableByDefault} dynamic) {
+        {
+          return self::captured!(a = b){(dynamic) → dynamic};
+        }
+      }
+    }
+    {
+      core::String a;
+      core::String b;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::String && (let final dynamic #t10 = a = #0#6{core::String} in true)) && (#0#7 is{ForNonNullableByDefault} core::String && (let final dynamic #t11 = b = #0#7{core::String} in true)) && (self::captured = (dynamic x) → core::String {
+        return a.{core::String::+}(b){(core::String) → core::String};
+      }) is{ForNonNullableByDefault} dynamic) {
+        {
+          return self::captured!(a = b){(dynamic) → dynamic};
+        }
+      }
+    }
+    {
+      {
         {
           return null;
         }
       }
+    }
   }
 }
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/patterns/switch_expressions_variable_capture.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/switch_expressions_variable_capture.dart.weak.transformed.expect
index bce419db2f9..874fb2ac1ab 100644
--- a/pkg/front_end/testcases/patterns/switch_expressions_variable_capture.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/switch_expressions_variable_capture.dart.weak.transformed.expect
@@ -14,21 +14,27 @@ static field (dynamic) →? dynamic captured;
 static method test1(dynamic x) → dynamic
   return block {
     core::double? #t1;
-    core::double r;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} self::Circle && (let final core::double #t2 = r = #0#0{self::Circle}.{self::Circle::radius}{core::double} in true) && r.{core::num::>}(0){(core::num) → core::bool})
-      #t1 = r.{core::double::*}(r){(core::num) → core::double}.{core::double::*}(#C1){(core::num) → core::double};
-    else
-      if(true)
-        #t1 = null;
+    #L1:
+    {
+      {
+        core::double r;
+        if(#0#0 is{ForNonNullableByDefault} self::Circle && (let final core::double #t2 = r = #0#0{self::Circle}.{self::Circle::radius}{core::double} in true) && r.{core::num::>}(0){(core::num) → core::bool}) {
+          #t1 = r.{core::double::*}(r){(core::num) → core::double}.{core::double::*}(#C1){(core::num) → core::double};
+          break #L1;
+        }
+      }
+      {
+        if(true) {
+          #t1 = null;
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
 static method test2(dynamic x) → dynamic
   return block {
     dynamic #t3;
-    core::int a;
-    core::int b;
-    core::String a#1;
-    core::String b#1;
     final synthesized dynamic #0#0 = x;
     function ##0#4#initializer() → core::bool
       return #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2;
@@ -39,56 +45,78 @@ static method test2(dynamic x) → dynamic
     function ##0#7#initializer() → dynamic
       return #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic};
     late final synthesized dynamic #0#7 = ##0#7#initializer(){() → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final core::int #t4 = a = #0#6{core::int} in true)) && (#0#7 is{ForNonNullableByDefault} core::int && (let final core::int #t5 = b = #0#7{core::int} in true)) && (self::captured = (dynamic x) → core::int {
-      return a.{core::num::+}(b){(core::num) → core::int};
-    }) is{ForNonNullableByDefault} dynamic)
-      #t3 = self::captured!(a = b){(dynamic) → dynamic};
-    else
-      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::String && (let final core::String #t6 = a#1 = #0#6{core::String} in true)) && (#0#7 is{ForNonNullableByDefault} core::String && (let final core::String #t7 = b#1 = #0#7{core::String} in true)) && (self::captured = (dynamic x) → core::String {
-        return a#1.{core::String::+}(b#1){(core::String) → core::String};
-      }) is{ForNonNullableByDefault} dynamic)
-        #t3 = self::captured!(a#1 = b#1){(dynamic) → dynamic};
-      else
-        if(true)
-          #t3 = null;
-  } =>#t3;
-static method test3(dynamic x) → dynamic {
-  #L1:
-  {
-    core::int a;
-    core::int b;
-    core::String a#1;
-    core::String b#1;
-    final synthesized dynamic #0#0 = x;
-    function ##0#4#initializer() → core::bool
-      return #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2;
-    late final synthesized core::bool #0#4 = ##0#4#initializer(){() → core::bool};
-    function ##0#6#initializer() → dynamic
-      return #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
-    late final synthesized dynamic #0#6 = ##0#6#initializer(){() → dynamic};
-    function ##0#7#initializer() → dynamic
-      return #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic};
-    late final synthesized dynamic #0#7 = ##0#7#initializer(){() → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final core::int #t8 = a = #0#6{core::int} in true)) && (#0#7 is{ForNonNullableByDefault} core::int && (let final core::int #t9 = b = #0#7{core::int} in true)) && (self::captured = (dynamic x) → core::int {
-      return a.{core::num::+}(b){(core::num) → core::int};
-    }) is{ForNonNullableByDefault} dynamic) {
+    #L2:
+    {
       {
-        return self::captured!(a = b){(dynamic) → dynamic};
-      }
-    }
-    else
-      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::String && (let final core::String #t10 = a#1 = #0#6{core::String} in true)) && (#0#7 is{ForNonNullableByDefault} core::String && (let final core::String #t11 = b#1 = #0#7{core::String} in true)) && (self::captured = (dynamic x) → core::String {
-        return a#1.{core::String::+}(b#1){(core::String) → core::String};
-      }) is{ForNonNullableByDefault} dynamic) {
-        {
-          return self::captured!(a#1 = b#1){(dynamic) → dynamic};
+        core::int a;
+        core::int b;
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final core::int #t4 = a = #0#6{core::int} in true)) && (#0#7 is{ForNonNullableByDefault} core::int && (let final core::int #t5 = b = #0#7{core::int} in true)) && (self::captured = (dynamic x) → core::int {
+          return a.{core::num::+}(b){(core::num) → core::int};
+        }) is{ForNonNullableByDefault} dynamic) {
+          #t3 = self::captured!(a = b){(dynamic) → dynamic};
+          break #L2;
         }
       }
-      else {
+      {
+        core::String a;
+        core::String b;
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::String && (let final core::String #t6 = a = #0#6{core::String} in true)) && (#0#7 is{ForNonNullableByDefault} core::String && (let final core::String #t7 = b = #0#7{core::String} in true)) && (self::captured = (dynamic x) → core::String {
+          return a.{core::String::+}(b){(core::String) → core::String};
+        }) is{ForNonNullableByDefault} dynamic) {
+          #t3 = self::captured!(a = b){(dynamic) → dynamic};
+          break #L2;
+        }
+      }
+      {
+        if(true) {
+          #t3 = null;
+          break #L2;
+        }
+      }
+    }
+  } =>#t3;
+static method test3(dynamic x) → dynamic {
+  #L3:
+  {
+    final synthesized dynamic #0#0 = x;
+    function ##0#4#initializer() → core::bool
+      return #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2;
+    late final synthesized core::bool #0#4 = ##0#4#initializer(){() → core::bool};
+    function ##0#6#initializer() → dynamic
+      return #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
+    late final synthesized dynamic #0#6 = ##0#6#initializer(){() → dynamic};
+    function ##0#7#initializer() → dynamic
+      return #0#0{core::List<dynamic>}.{core::List::[]}(1){(core::int) → dynamic};
+    late final synthesized dynamic #0#7 = ##0#7#initializer(){() → dynamic};
+    {
+      core::int a;
+      core::int b;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final core::int #t8 = a = #0#6{core::int} in true)) && (#0#7 is{ForNonNullableByDefault} core::int && (let final core::int #t9 = b = #0#7{core::int} in true)) && (self::captured = (dynamic x) → core::int {
+        return a.{core::num::+}(b){(core::num) → core::int};
+      }) is{ForNonNullableByDefault} dynamic) {
+        {
+          return self::captured!(a = b){(dynamic) → dynamic};
+        }
+      }
+    }
+    {
+      core::String a;
+      core::String b;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::String && (let final core::String #t10 = a = #0#6{core::String} in true)) && (#0#7 is{ForNonNullableByDefault} core::String && (let final core::String #t11 = b = #0#7{core::String} in true)) && (self::captured = (dynamic x) → core::String {
+        return a.{core::String::+}(b){(core::String) → core::String};
+      }) is{ForNonNullableByDefault} dynamic) {
+        {
+          return self::captured!(a = b){(dynamic) → dynamic};
+        }
+      }
+    }
+    {
+      {
         {
           return null;
         }
       }
+    }
   }
 }
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/patterns/switch_variables.dart.strong.expect b/pkg/front_end/testcases/patterns/switch_variables.dart.strong.expect
index 7fab0d8085b..af58102b48b 100644
--- a/pkg/front_end/testcases/patterns/switch_variables.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/switch_variables.dart.strong.expect
@@ -5,21 +5,24 @@ import "dart:core" as core;
 static method method(dynamic o) → dynamic {
   #L1:
   {
-    core::String a;
-    core::int a#1;
     final synthesized dynamic #0#0 = o;
-    if(#0#0 is{ForNonNullableByDefault} core::String && (let final dynamic #t1 = a = #0#0{core::String} in true)) {
-      {
-        core::print(a);
-        break #L1;
-      }
-    }
-    else
-      if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = a#1 = #0#0{core::int} in true)) {
+    {
+      core::String a;
+      if(#0#0 is{ForNonNullableByDefault} core::String && (let final dynamic #t1 = a = #0#0{core::String} in true)) {
         {
-          core::print(a#1);
+          core::print(a);
           break #L1;
         }
       }
+    }
+    {
+      core::int a;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = a = #0#0{core::int} in true)) {
+        {
+          core::print(a);
+          break #L1;
+        }
+      }
+    }
   }
 }
diff --git a/pkg/front_end/testcases/patterns/switch_variables.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/switch_variables.dart.strong.transformed.expect
index bff7eba2fe3..8d04bee4938 100644
--- a/pkg/front_end/testcases/patterns/switch_variables.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/switch_variables.dart.strong.transformed.expect
@@ -5,21 +5,24 @@ import "dart:core" as core;
 static method method(dynamic o) → dynamic {
   #L1:
   {
-    core::String a;
-    core::int a#1;
     final synthesized dynamic #0#0 = o;
-    if(#0#0 is{ForNonNullableByDefault} core::String && (let final core::String #t1 = a = #0#0{core::String} in true)) {
-      {
-        core::print(a);
-        break #L1;
-      }
-    }
-    else
-      if(#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t2 = a#1 = #0#0{core::int} in true)) {
+    {
+      core::String a;
+      if(#0#0 is{ForNonNullableByDefault} core::String && (let final core::String #t1 = a = #0#0{core::String} in true)) {
         {
-          core::print(a#1);
+          core::print(a);
           break #L1;
         }
       }
+    }
+    {
+      core::int a;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t2 = a = #0#0{core::int} in true)) {
+        {
+          core::print(a);
+          break #L1;
+        }
+      }
+    }
   }
 }
diff --git a/pkg/front_end/testcases/patterns/switch_variables.dart.weak.expect b/pkg/front_end/testcases/patterns/switch_variables.dart.weak.expect
index 7fab0d8085b..af58102b48b 100644
--- a/pkg/front_end/testcases/patterns/switch_variables.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/switch_variables.dart.weak.expect
@@ -5,21 +5,24 @@ import "dart:core" as core;
 static method method(dynamic o) → dynamic {
   #L1:
   {
-    core::String a;
-    core::int a#1;
     final synthesized dynamic #0#0 = o;
-    if(#0#0 is{ForNonNullableByDefault} core::String && (let final dynamic #t1 = a = #0#0{core::String} in true)) {
-      {
-        core::print(a);
-        break #L1;
-      }
-    }
-    else
-      if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = a#1 = #0#0{core::int} in true)) {
+    {
+      core::String a;
+      if(#0#0 is{ForNonNullableByDefault} core::String && (let final dynamic #t1 = a = #0#0{core::String} in true)) {
         {
-          core::print(a#1);
+          core::print(a);
           break #L1;
         }
       }
+    }
+    {
+      core::int a;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = a = #0#0{core::int} in true)) {
+        {
+          core::print(a);
+          break #L1;
+        }
+      }
+    }
   }
 }
diff --git a/pkg/front_end/testcases/patterns/switch_variables.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/switch_variables.dart.weak.modular.expect
index 7fab0d8085b..af58102b48b 100644
--- a/pkg/front_end/testcases/patterns/switch_variables.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/switch_variables.dart.weak.modular.expect
@@ -5,21 +5,24 @@ import "dart:core" as core;
 static method method(dynamic o) → dynamic {
   #L1:
   {
-    core::String a;
-    core::int a#1;
     final synthesized dynamic #0#0 = o;
-    if(#0#0 is{ForNonNullableByDefault} core::String && (let final dynamic #t1 = a = #0#0{core::String} in true)) {
-      {
-        core::print(a);
-        break #L1;
-      }
-    }
-    else
-      if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = a#1 = #0#0{core::int} in true)) {
+    {
+      core::String a;
+      if(#0#0 is{ForNonNullableByDefault} core::String && (let final dynamic #t1 = a = #0#0{core::String} in true)) {
         {
-          core::print(a#1);
+          core::print(a);
           break #L1;
         }
       }
+    }
+    {
+      core::int a;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = a = #0#0{core::int} in true)) {
+        {
+          core::print(a);
+          break #L1;
+        }
+      }
+    }
   }
 }
diff --git a/pkg/front_end/testcases/patterns/switch_variables.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/switch_variables.dart.weak.transformed.expect
index bff7eba2fe3..8d04bee4938 100644
--- a/pkg/front_end/testcases/patterns/switch_variables.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/switch_variables.dart.weak.transformed.expect
@@ -5,21 +5,24 @@ import "dart:core" as core;
 static method method(dynamic o) → dynamic {
   #L1:
   {
-    core::String a;
-    core::int a#1;
     final synthesized dynamic #0#0 = o;
-    if(#0#0 is{ForNonNullableByDefault} core::String && (let final core::String #t1 = a = #0#0{core::String} in true)) {
-      {
-        core::print(a);
-        break #L1;
-      }
-    }
-    else
-      if(#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t2 = a#1 = #0#0{core::int} in true)) {
+    {
+      core::String a;
+      if(#0#0 is{ForNonNullableByDefault} core::String && (let final core::String #t1 = a = #0#0{core::String} in true)) {
         {
-          core::print(a#1);
+          core::print(a);
           break #L1;
         }
       }
+    }
+    {
+      core::int a;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t2 = a = #0#0{core::int} in true)) {
+        {
+          core::print(a);
+          break #L1;
+        }
+      }
+    }
   }
 }
diff --git a/pkg/front_end/testcases/patterns/switch_with_continue.dart.strong.expect b/pkg/front_end/testcases/patterns/switch_with_continue.dart.strong.expect
index 0e504c6770f..637d2f36652 100644
--- a/pkg/front_end/testcases/patterns/switch_with_continue.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/switch_with_continue.dart.strong.expect
@@ -6,72 +6,70 @@ static method test(dynamic o) → core::int {
   #L1:
   {
     core::int #t1 = -1;
-    dynamic a;
     final synthesized dynamic #0#0 = o;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final dynamic #t2 = a = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} in true))
-      #t1 = 0;
-    else
-      if(#C2 =={core::num::==}{(core::Object) → core::bool} #0#0)
-        #t1 = 1;
-      else
-        if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0)
-          #t1 = 2;
-        else
-          if(#C3 =={core::num::==}{(core::Object) → core::bool} #0#0)
-            #t1 = 3;
-          else
-            if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0)
-              #t1 = 4;
-            else
-              if(#C5 =={core::num::==}{(core::Object) → core::bool} #0#0)
-                #t1 = 5;
-              else
-                #t1 = 6;
-    switch(#t1) {
-      #L2:
-      case #C2:
-        {
+    #L2:
+    {
+      {
+        dynamic a;
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final dynamic #t2 = a = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} in true)) {
           {
             return a as{TypeError,ForDynamic,ForNonNullableByDefault} core::int;
           }
         }
-      #L3:
-      case #C1:
-        {
+      }
+      {
+        if(#C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
           {
-            continue #L4;
+            #t1 = 0;
+            break #L2;
           }
         }
-      #L5:
-      case #C3:
-        {
+      }
+      {
+        if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
           {
             return 1;
           }
         }
-      #L4:
-      case #C4:
+      }
+      {
+        if(#C3 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+          #t1 = 0;
+          break #L2;
+        }
+      }
+      {
+        if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+          {
+            #t1 = 1;
+            break #L2;
+          }
+        }
+      }
+      {
+        if(#C5 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+          {
+            return 4;
+          }
+        }
+      }
+      {
+        {
+          #t1 = 1;
+          break #L2;
+        }
+      }
+    }
+    switch(#t1) {
+      #L3:
+      case #C2:
         {
           {
             return 2;
           }
         }
-      #L6:
-      case #C5:
-        {
-          {
-            continue #L7;
-          }
-        }
-      #L8:
-      case #C6:
-        {
-          {
-            return 4;
-          }
-        }
-      #L7:
-      case #C7:
+      #L4:
+      case #C1:
       default:
         {
           {
@@ -104,6 +102,4 @@ constants  {
   #C3 = 2
   #C4 = 3
   #C5 = 4
-  #C6 = 5
-  #C7 = 6
 }
diff --git a/pkg/front_end/testcases/patterns/switch_with_continue.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/switch_with_continue.dart.strong.transformed.expect
index 1466d75ab7a..3b38e4015c3 100644
--- a/pkg/front_end/testcases/patterns/switch_with_continue.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/switch_with_continue.dart.strong.transformed.expect
@@ -6,72 +6,70 @@ static method test(dynamic o) → core::int {
   #L1:
   {
     core::int #t1 = -1;
-    dynamic a;
     final synthesized dynamic #0#0 = o;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final dynamic #t2 = a = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} in true))
-      #t1 = 0;
-    else
-      if(#C2 =={core::num::==}{(core::Object) → core::bool} #0#0)
-        #t1 = 1;
-      else
-        if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0)
-          #t1 = 2;
-        else
-          if(#C3 =={core::num::==}{(core::Object) → core::bool} #0#0)
-            #t1 = 3;
-          else
-            if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0)
-              #t1 = 4;
-            else
-              if(#C5 =={core::num::==}{(core::Object) → core::bool} #0#0)
-                #t1 = 5;
-              else
-                #t1 = 6;
-    switch(#t1) {
-      #L2:
-      case #C2:
-        {
+    #L2:
+    {
+      {
+        dynamic a;
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final dynamic #t2 = a = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} in true)) {
           {
             return a as{TypeError,ForDynamic,ForNonNullableByDefault} core::int;
           }
         }
-      #L3:
-      case #C1:
-        {
+      }
+      {
+        if(#C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
           {
-            continue #L4;
+            #t1 = 0;
+            break #L2;
           }
         }
-      #L5:
-      case #C3:
-        {
+      }
+      {
+        if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
           {
             return 1;
           }
         }
-      #L4:
-      case #C4:
+      }
+      {
+        if(#C3 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+          #t1 = 0;
+          break #L2;
+        }
+      }
+      {
+        if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+          {
+            #t1 = 1;
+            break #L2;
+          }
+        }
+      }
+      {
+        if(#C5 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+          {
+            return 4;
+          }
+        }
+      }
+      {
+        {
+          #t1 = 1;
+          break #L2;
+        }
+      }
+    }
+    switch(#t1) {
+      #L3:
+      case #C2:
         {
           {
             return 2;
           }
         }
-      #L6:
-      case #C5:
-        {
-          {
-            continue #L7;
-          }
-        }
-      #L8:
-      case #C6:
-        {
-          {
-            return 4;
-          }
-        }
-      #L7:
-      case #C7:
+      #L4:
+      case #C1:
       default:
         {
           {
@@ -104,8 +102,6 @@ constants  {
   #C3 = 2
   #C4 = 3
   #C5 = 4
-  #C6 = 5
-  #C7 = 6
 }
 
 Extra constant evaluation status:
@@ -113,4 +109,4 @@ Evaluated: InstanceInvocation @ org-dartlang-testcase:///switch_with_continue.da
 Evaluated: InstanceInvocation @ org-dartlang-testcase:///switch_with_continue.dart:33:10 -> IntConstant(-1)
 Evaluated: InstanceInvocation @ org-dartlang-testcase:///switch_with_continue.dart:35:10 -> IntConstant(-1)
 Evaluated: InstanceInvocation @ org-dartlang-testcase:///switch_with_continue.dart:36:10 -> IntConstant(-1)
-Extra constant evaluation: evaluated: 65, effectively constant: 4
+Extra constant evaluation: evaluated: 62, effectively constant: 4
diff --git a/pkg/front_end/testcases/patterns/switch_with_continue.dart.weak.expect b/pkg/front_end/testcases/patterns/switch_with_continue.dart.weak.expect
index 0e504c6770f..637d2f36652 100644
--- a/pkg/front_end/testcases/patterns/switch_with_continue.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/switch_with_continue.dart.weak.expect
@@ -6,72 +6,70 @@ static method test(dynamic o) → core::int {
   #L1:
   {
     core::int #t1 = -1;
-    dynamic a;
     final synthesized dynamic #0#0 = o;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final dynamic #t2 = a = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} in true))
-      #t1 = 0;
-    else
-      if(#C2 =={core::num::==}{(core::Object) → core::bool} #0#0)
-        #t1 = 1;
-      else
-        if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0)
-          #t1 = 2;
-        else
-          if(#C3 =={core::num::==}{(core::Object) → core::bool} #0#0)
-            #t1 = 3;
-          else
-            if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0)
-              #t1 = 4;
-            else
-              if(#C5 =={core::num::==}{(core::Object) → core::bool} #0#0)
-                #t1 = 5;
-              else
-                #t1 = 6;
-    switch(#t1) {
-      #L2:
-      case #C2:
-        {
+    #L2:
+    {
+      {
+        dynamic a;
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final dynamic #t2 = a = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} in true)) {
           {
             return a as{TypeError,ForDynamic,ForNonNullableByDefault} core::int;
           }
         }
-      #L3:
-      case #C1:
-        {
+      }
+      {
+        if(#C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
           {
-            continue #L4;
+            #t1 = 0;
+            break #L2;
           }
         }
-      #L5:
-      case #C3:
-        {
+      }
+      {
+        if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
           {
             return 1;
           }
         }
-      #L4:
-      case #C4:
+      }
+      {
+        if(#C3 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+          #t1 = 0;
+          break #L2;
+        }
+      }
+      {
+        if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+          {
+            #t1 = 1;
+            break #L2;
+          }
+        }
+      }
+      {
+        if(#C5 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+          {
+            return 4;
+          }
+        }
+      }
+      {
+        {
+          #t1 = 1;
+          break #L2;
+        }
+      }
+    }
+    switch(#t1) {
+      #L3:
+      case #C2:
         {
           {
             return 2;
           }
         }
-      #L6:
-      case #C5:
-        {
-          {
-            continue #L7;
-          }
-        }
-      #L8:
-      case #C6:
-        {
-          {
-            return 4;
-          }
-        }
-      #L7:
-      case #C7:
+      #L4:
+      case #C1:
       default:
         {
           {
@@ -104,6 +102,4 @@ constants  {
   #C3 = 2
   #C4 = 3
   #C5 = 4
-  #C6 = 5
-  #C7 = 6
 }
diff --git a/pkg/front_end/testcases/patterns/switch_with_continue.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/switch_with_continue.dart.weak.modular.expect
index 0e504c6770f..637d2f36652 100644
--- a/pkg/front_end/testcases/patterns/switch_with_continue.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/switch_with_continue.dart.weak.modular.expect
@@ -6,72 +6,70 @@ static method test(dynamic o) → core::int {
   #L1:
   {
     core::int #t1 = -1;
-    dynamic a;
     final synthesized dynamic #0#0 = o;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final dynamic #t2 = a = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} in true))
-      #t1 = 0;
-    else
-      if(#C2 =={core::num::==}{(core::Object) → core::bool} #0#0)
-        #t1 = 1;
-      else
-        if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0)
-          #t1 = 2;
-        else
-          if(#C3 =={core::num::==}{(core::Object) → core::bool} #0#0)
-            #t1 = 3;
-          else
-            if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0)
-              #t1 = 4;
-            else
-              if(#C5 =={core::num::==}{(core::Object) → core::bool} #0#0)
-                #t1 = 5;
-              else
-                #t1 = 6;
-    switch(#t1) {
-      #L2:
-      case #C2:
-        {
+    #L2:
+    {
+      {
+        dynamic a;
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final dynamic #t2 = a = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} in true)) {
           {
             return a as{TypeError,ForDynamic,ForNonNullableByDefault} core::int;
           }
         }
-      #L3:
-      case #C1:
-        {
+      }
+      {
+        if(#C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
           {
-            continue #L4;
+            #t1 = 0;
+            break #L2;
           }
         }
-      #L5:
-      case #C3:
-        {
+      }
+      {
+        if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
           {
             return 1;
           }
         }
-      #L4:
-      case #C4:
+      }
+      {
+        if(#C3 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+          #t1 = 0;
+          break #L2;
+        }
+      }
+      {
+        if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+          {
+            #t1 = 1;
+            break #L2;
+          }
+        }
+      }
+      {
+        if(#C5 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+          {
+            return 4;
+          }
+        }
+      }
+      {
+        {
+          #t1 = 1;
+          break #L2;
+        }
+      }
+    }
+    switch(#t1) {
+      #L3:
+      case #C2:
         {
           {
             return 2;
           }
         }
-      #L6:
-      case #C5:
-        {
-          {
-            continue #L7;
-          }
-        }
-      #L8:
-      case #C6:
-        {
-          {
-            return 4;
-          }
-        }
-      #L7:
-      case #C7:
+      #L4:
+      case #C1:
       default:
         {
           {
@@ -104,6 +102,4 @@ constants  {
   #C3 = 2
   #C4 = 3
   #C5 = 4
-  #C6 = 5
-  #C7 = 6
 }
diff --git a/pkg/front_end/testcases/patterns/switch_with_continue.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/switch_with_continue.dart.weak.transformed.expect
index 1466d75ab7a..3b38e4015c3 100644
--- a/pkg/front_end/testcases/patterns/switch_with_continue.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/switch_with_continue.dart.weak.transformed.expect
@@ -6,72 +6,70 @@ static method test(dynamic o) → core::int {
   #L1:
   {
     core::int #t1 = -1;
-    dynamic a;
     final synthesized dynamic #0#0 = o;
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final dynamic #t2 = a = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} in true))
-      #t1 = 0;
-    else
-      if(#C2 =={core::num::==}{(core::Object) → core::bool} #0#0)
-        #t1 = 1;
-      else
-        if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0)
-          #t1 = 2;
-        else
-          if(#C3 =={core::num::==}{(core::Object) → core::bool} #0#0)
-            #t1 = 3;
-          else
-            if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0)
-              #t1 = 4;
-            else
-              if(#C5 =={core::num::==}{(core::Object) → core::bool} #0#0)
-                #t1 = 5;
-              else
-                #t1 = 6;
-    switch(#t1) {
-      #L2:
-      case #C2:
-        {
+    #L2:
+    {
+      {
+        dynamic a;
+        if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final dynamic #t2 = a = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} in true)) {
           {
             return a as{TypeError,ForDynamic,ForNonNullableByDefault} core::int;
           }
         }
-      #L3:
-      case #C1:
-        {
+      }
+      {
+        if(#C2 =={core::num::==}{(core::Object) → core::bool} #0#0) {
           {
-            continue #L4;
+            #t1 = 0;
+            break #L2;
           }
         }
-      #L5:
-      case #C3:
-        {
+      }
+      {
+        if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
           {
             return 1;
           }
         }
-      #L4:
-      case #C4:
+      }
+      {
+        if(#C3 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+          #t1 = 0;
+          break #L2;
+        }
+      }
+      {
+        if(#C4 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+          {
+            #t1 = 1;
+            break #L2;
+          }
+        }
+      }
+      {
+        if(#C5 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+          {
+            return 4;
+          }
+        }
+      }
+      {
+        {
+          #t1 = 1;
+          break #L2;
+        }
+      }
+    }
+    switch(#t1) {
+      #L3:
+      case #C2:
         {
           {
             return 2;
           }
         }
-      #L6:
-      case #C5:
-        {
-          {
-            continue #L7;
-          }
-        }
-      #L8:
-      case #C6:
-        {
-          {
-            return 4;
-          }
-        }
-      #L7:
-      case #C7:
+      #L4:
+      case #C1:
       default:
         {
           {
@@ -104,8 +102,6 @@ constants  {
   #C3 = 2
   #C4 = 3
   #C5 = 4
-  #C6 = 5
-  #C7 = 6
 }
 
 Extra constant evaluation status:
@@ -113,4 +109,4 @@ Evaluated: InstanceInvocation @ org-dartlang-testcase:///switch_with_continue.da
 Evaluated: InstanceInvocation @ org-dartlang-testcase:///switch_with_continue.dart:33:10 -> IntConstant(-1)
 Evaluated: InstanceInvocation @ org-dartlang-testcase:///switch_with_continue.dart:35:10 -> IntConstant(-1)
 Evaluated: InstanceInvocation @ org-dartlang-testcase:///switch_with_continue.dart:36:10 -> IntConstant(-1)
-Extra constant evaluation: evaluated: 65, effectively constant: 4
+Extra constant evaluation: evaluated: 62, effectively constant: 4
diff --git a/pkg/front_end/testcases/patterns/two_switch_statements.dart.strong.expect b/pkg/front_end/testcases/patterns/two_switch_statements.dart.strong.expect
index 0541cc38570..8fd725f28c5 100644
--- a/pkg/front_end/testcases/patterns/two_switch_statements.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/two_switch_statements.dart.strong.expect
@@ -5,21 +5,25 @@ import "dart:core" as core;
 static method test(dynamic o) → dynamic {
   #L1:
   {
-    core::int a;
     final synthesized dynamic #0#0 = o;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = a = #0#0{core::int} in true)) {
-      {
-        return 1;
+    {
+      core::int a;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = a = #0#0{core::int} in true)) {
+        {
+          return 1;
+        }
       }
     }
   }
   #L2:
   {
-    core::String a;
     final synthesized dynamic #1#0 = o;
-    if(#1#0 is{ForNonNullableByDefault} core::String && (let final dynamic #t2 = a = #1#0{core::String} in true)) {
-      {
-        return 2;
+    {
+      core::String a;
+      if(#1#0 is{ForNonNullableByDefault} core::String && (let final dynamic #t2 = a = #1#0{core::String} in true)) {
+        {
+          return 2;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/two_switch_statements.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/two_switch_statements.dart.strong.transformed.expect
index b6475389ca5..004bfa14a79 100644
--- a/pkg/front_end/testcases/patterns/two_switch_statements.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/two_switch_statements.dart.strong.transformed.expect
@@ -5,21 +5,25 @@ import "dart:core" as core;
 static method test(dynamic o) → dynamic {
   #L1:
   {
-    core::int a;
     final synthesized dynamic #0#0 = o;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = a = #0#0{core::int} in true)) {
-      {
-        return 1;
+    {
+      core::int a;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = a = #0#0{core::int} in true)) {
+        {
+          return 1;
+        }
       }
     }
   }
   #L2:
   {
-    core::String a;
     final synthesized dynamic #1#0 = o;
-    if(#1#0 is{ForNonNullableByDefault} core::String && (let final core::String #t2 = a = #1#0{core::String} in true)) {
-      {
-        return 2;
+    {
+      core::String a;
+      if(#1#0 is{ForNonNullableByDefault} core::String && (let final core::String #t2 = a = #1#0{core::String} in true)) {
+        {
+          return 2;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/two_switch_statements.dart.weak.expect b/pkg/front_end/testcases/patterns/two_switch_statements.dart.weak.expect
index 0541cc38570..8fd725f28c5 100644
--- a/pkg/front_end/testcases/patterns/two_switch_statements.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/two_switch_statements.dart.weak.expect
@@ -5,21 +5,25 @@ import "dart:core" as core;
 static method test(dynamic o) → dynamic {
   #L1:
   {
-    core::int a;
     final synthesized dynamic #0#0 = o;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = a = #0#0{core::int} in true)) {
-      {
-        return 1;
+    {
+      core::int a;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = a = #0#0{core::int} in true)) {
+        {
+          return 1;
+        }
       }
     }
   }
   #L2:
   {
-    core::String a;
     final synthesized dynamic #1#0 = o;
-    if(#1#0 is{ForNonNullableByDefault} core::String && (let final dynamic #t2 = a = #1#0{core::String} in true)) {
-      {
-        return 2;
+    {
+      core::String a;
+      if(#1#0 is{ForNonNullableByDefault} core::String && (let final dynamic #t2 = a = #1#0{core::String} in true)) {
+        {
+          return 2;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/two_switch_statements.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/two_switch_statements.dart.weak.modular.expect
index 0541cc38570..8fd725f28c5 100644
--- a/pkg/front_end/testcases/patterns/two_switch_statements.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/two_switch_statements.dart.weak.modular.expect
@@ -5,21 +5,25 @@ import "dart:core" as core;
 static method test(dynamic o) → dynamic {
   #L1:
   {
-    core::int a;
     final synthesized dynamic #0#0 = o;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = a = #0#0{core::int} in true)) {
-      {
-        return 1;
+    {
+      core::int a;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = a = #0#0{core::int} in true)) {
+        {
+          return 1;
+        }
       }
     }
   }
   #L2:
   {
-    core::String a;
     final synthesized dynamic #1#0 = o;
-    if(#1#0 is{ForNonNullableByDefault} core::String && (let final dynamic #t2 = a = #1#0{core::String} in true)) {
-      {
-        return 2;
+    {
+      core::String a;
+      if(#1#0 is{ForNonNullableByDefault} core::String && (let final dynamic #t2 = a = #1#0{core::String} in true)) {
+        {
+          return 2;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/two_switch_statements.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/two_switch_statements.dart.weak.transformed.expect
index b6475389ca5..004bfa14a79 100644
--- a/pkg/front_end/testcases/patterns/two_switch_statements.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/two_switch_statements.dart.weak.transformed.expect
@@ -5,21 +5,25 @@ import "dart:core" as core;
 static method test(dynamic o) → dynamic {
   #L1:
   {
-    core::int a;
     final synthesized dynamic #0#0 = o;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = a = #0#0{core::int} in true)) {
-      {
-        return 1;
+    {
+      core::int a;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = a = #0#0{core::int} in true)) {
+        {
+          return 1;
+        }
       }
     }
   }
   #L2:
   {
-    core::String a;
     final synthesized dynamic #1#0 = o;
-    if(#1#0 is{ForNonNullableByDefault} core::String && (let final core::String #t2 = a = #1#0{core::String} in true)) {
-      {
-        return 2;
+    {
+      core::String a;
+      if(#1#0 is{ForNonNullableByDefault} core::String && (let final core::String #t2 = a = #1#0{core::String} in true)) {
+        {
+          return 2;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_final_variable_inside_case.dart.strong.expect b/pkg/front_end/testcases/patterns/typed_final_variable_inside_case.dart.strong.expect
index cd7fbe9a7d5..96eb2681b3d 100644
--- a/pkg/front_end/testcases/patterns/typed_final_variable_inside_case.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/typed_final_variable_inside_case.dart.strong.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final core::int y;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = y = #0#0{core::int} in true)) {
-      {
-        break #L1;
+    {
+      final core::int y;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = y = #0#0{core::int} in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_final_variable_inside_case.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/typed_final_variable_inside_case.dart.strong.transformed.expect
index adb0b07c4aa..e356be8e60d 100644
--- a/pkg/front_end/testcases/patterns/typed_final_variable_inside_case.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/typed_final_variable_inside_case.dart.strong.transformed.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final core::int y;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = y = #0#0{core::int} in true)) {
-      {
-        break #L1;
+    {
+      final core::int y;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = y = #0#0{core::int} in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_final_variable_inside_case.dart.weak.expect b/pkg/front_end/testcases/patterns/typed_final_variable_inside_case.dart.weak.expect
index cd7fbe9a7d5..96eb2681b3d 100644
--- a/pkg/front_end/testcases/patterns/typed_final_variable_inside_case.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/typed_final_variable_inside_case.dart.weak.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final core::int y;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = y = #0#0{core::int} in true)) {
-      {
-        break #L1;
+    {
+      final core::int y;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = y = #0#0{core::int} in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_final_variable_inside_case.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/typed_final_variable_inside_case.dart.weak.modular.expect
index cd7fbe9a7d5..96eb2681b3d 100644
--- a/pkg/front_end/testcases/patterns/typed_final_variable_inside_case.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/typed_final_variable_inside_case.dart.weak.modular.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final core::int y;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = y = #0#0{core::int} in true)) {
-      {
-        break #L1;
+    {
+      final core::int y;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = y = #0#0{core::int} in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_final_variable_inside_case.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/typed_final_variable_inside_case.dart.weak.transformed.expect
index adb0b07c4aa..e356be8e60d 100644
--- a/pkg/front_end/testcases/patterns/typed_final_variable_inside_case.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/typed_final_variable_inside_case.dart.weak.transformed.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final core::int y;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = y = #0#0{core::int} in true)) {
-      {
-        break #L1;
+    {
+      final core::int y;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = y = #0#0{core::int} in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_final_variable_inside_cast.dart.strong.expect b/pkg/front_end/testcases/patterns/typed_final_variable_inside_cast.dart.strong.expect
index 19ee1256f6e..6de92e49b84 100644
--- a/pkg/front_end/testcases/patterns/typed_final_variable_inside_cast.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/typed_final_variable_inside_cast.dart.strong.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final core::int y;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in (#0#0 as{ForNonNullableByDefault} core::Object) is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = y = (#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} core::int in true)) {
-      {
-        break #L1;
+    {
+      final core::int y;
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in (#0#0 as{ForNonNullableByDefault} core::Object) is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = y = (#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} core::int in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_final_variable_inside_cast.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/typed_final_variable_inside_cast.dart.strong.transformed.expect
index 4ad205e17df..54a50173b19 100644
--- a/pkg/front_end/testcases/patterns/typed_final_variable_inside_cast.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/typed_final_variable_inside_cast.dart.strong.transformed.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final core::int y;
     final synthesized dynamic #0#0 = x;
-    if(let final core::Object #t1 = let dynamic #t2 = #0#0 in #t2 == null ?{core::Object} #t2 as{ForNonNullableByDefault} core::Object : #t2{core::Object} in (let dynamic #t3 = #0#0 in #t3 == null ?{core::Object} #t3 as{ForNonNullableByDefault} core::Object : #t3{core::Object}) is{ForNonNullableByDefault} core::int && (let final core::int #t4 = y = (let dynamic #t5 = #0#0 in #t5 == null ?{core::Object} #t5 as{ForNonNullableByDefault} core::Object : #t5{core::Object}) as{ForNonNullableByDefault} core::int in true)) {
-      {
-        break #L1;
+    {
+      final core::int y;
+      if(let final core::Object #t1 = let dynamic #t2 = #0#0 in #t2 == null ?{core::Object} #t2 as{ForNonNullableByDefault} core::Object : #t2{core::Object} in (let dynamic #t3 = #0#0 in #t3 == null ?{core::Object} #t3 as{ForNonNullableByDefault} core::Object : #t3{core::Object}) is{ForNonNullableByDefault} core::int && (let final core::int #t4 = y = (let dynamic #t5 = #0#0 in #t5 == null ?{core::Object} #t5 as{ForNonNullableByDefault} core::Object : #t5{core::Object}) as{ForNonNullableByDefault} core::int in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_final_variable_inside_cast.dart.weak.expect b/pkg/front_end/testcases/patterns/typed_final_variable_inside_cast.dart.weak.expect
index 19ee1256f6e..6de92e49b84 100644
--- a/pkg/front_end/testcases/patterns/typed_final_variable_inside_cast.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/typed_final_variable_inside_cast.dart.weak.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final core::int y;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in (#0#0 as{ForNonNullableByDefault} core::Object) is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = y = (#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} core::int in true)) {
-      {
-        break #L1;
+    {
+      final core::int y;
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in (#0#0 as{ForNonNullableByDefault} core::Object) is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = y = (#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} core::int in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_final_variable_inside_cast.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/typed_final_variable_inside_cast.dart.weak.modular.expect
index 19ee1256f6e..6de92e49b84 100644
--- a/pkg/front_end/testcases/patterns/typed_final_variable_inside_cast.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/typed_final_variable_inside_cast.dart.weak.modular.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final core::int y;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in (#0#0 as{ForNonNullableByDefault} core::Object) is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = y = (#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} core::int in true)) {
-      {
-        break #L1;
+    {
+      final core::int y;
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in (#0#0 as{ForNonNullableByDefault} core::Object) is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = y = (#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} core::int in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_final_variable_inside_cast.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/typed_final_variable_inside_cast.dart.weak.transformed.expect
index 83605dcd77c..5ceae29697e 100644
--- a/pkg/front_end/testcases/patterns/typed_final_variable_inside_cast.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/typed_final_variable_inside_cast.dart.weak.transformed.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final core::int y;
     final synthesized dynamic #0#0 = x;
-    if(let final core::Object #t1 = #0#0 in #0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t2 = y = #0#0 as{ForNonNullableByDefault} core::int in true)) {
-      {
-        break #L1;
+    {
+      final core::int y;
+      if(let final core::Object #t1 = #0#0 in #0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t2 = y = #0#0 as{ForNonNullableByDefault} core::int in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_final_variable_inside_null_assert.dart.strong.expect b/pkg/front_end/testcases/patterns/typed_final_variable_inside_null_assert.dart.strong.expect
index df9d66718e4..30fc6004d58 100644
--- a/pkg/front_end/testcases/patterns/typed_final_variable_inside_null_assert.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/typed_final_variable_inside_null_assert.dart.strong.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final core::int y;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = y = #0#0! as{ForNonNullableByDefault} core::int in true)) {
-      {
-        break #L1;
+    {
+      final core::int y;
+      if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = y = #0#0! as{ForNonNullableByDefault} core::int in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_final_variable_inside_null_assert.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/typed_final_variable_inside_null_assert.dart.strong.transformed.expect
index a1b9db3b6e8..8ad9864c459 100644
--- a/pkg/front_end/testcases/patterns/typed_final_variable_inside_null_assert.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/typed_final_variable_inside_null_assert.dart.strong.transformed.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final core::int y;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::int && (let final core::int #t2 = y = #0#0! as{ForNonNullableByDefault} core::int in true)) {
-      {
-        break #L1;
+    {
+      final core::int y;
+      if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::int && (let final core::int #t2 = y = #0#0! as{ForNonNullableByDefault} core::int in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_final_variable_inside_null_assert.dart.weak.expect b/pkg/front_end/testcases/patterns/typed_final_variable_inside_null_assert.dart.weak.expect
index df9d66718e4..30fc6004d58 100644
--- a/pkg/front_end/testcases/patterns/typed_final_variable_inside_null_assert.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/typed_final_variable_inside_null_assert.dart.weak.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final core::int y;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = y = #0#0! as{ForNonNullableByDefault} core::int in true)) {
-      {
-        break #L1;
+    {
+      final core::int y;
+      if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = y = #0#0! as{ForNonNullableByDefault} core::int in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_final_variable_inside_null_assert.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/typed_final_variable_inside_null_assert.dart.weak.modular.expect
index df9d66718e4..30fc6004d58 100644
--- a/pkg/front_end/testcases/patterns/typed_final_variable_inside_null_assert.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/typed_final_variable_inside_null_assert.dart.weak.modular.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final core::int y;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = y = #0#0! as{ForNonNullableByDefault} core::int in true)) {
-      {
-        break #L1;
+    {
+      final core::int y;
+      if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = y = #0#0! as{ForNonNullableByDefault} core::int in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_final_variable_inside_null_assert.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/typed_final_variable_inside_null_assert.dart.weak.transformed.expect
index a1b9db3b6e8..8ad9864c459 100644
--- a/pkg/front_end/testcases/patterns/typed_final_variable_inside_null_assert.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/typed_final_variable_inside_null_assert.dart.weak.transformed.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final core::int y;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::int && (let final core::int #t2 = y = #0#0! as{ForNonNullableByDefault} core::int in true)) {
-      {
-        break #L1;
+    {
+      final core::int y;
+      if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::int && (let final core::int #t2 = y = #0#0! as{ForNonNullableByDefault} core::int in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_final_variable_inside_null_check.dart.strong.expect b/pkg/front_end/testcases/patterns/typed_final_variable_inside_null_check.dart.strong.expect
index bb039186035..7c9e67486cd 100644
--- a/pkg/front_end/testcases/patterns/typed_final_variable_inside_null_check.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/typed_final_variable_inside_null_check.dart.strong.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final core::int y;
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = y = #0#0{core::int} in true) : false) {
-      {
-        break #L1;
+    {
+      final core::int y;
+      if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = y = #0#0{core::int} in true) : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_final_variable_inside_null_check.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/typed_final_variable_inside_null_check.dart.strong.transformed.expect
index 587e0dac8dd..c45db922649 100644
--- a/pkg/front_end/testcases/patterns/typed_final_variable_inside_null_check.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/typed_final_variable_inside_null_check.dart.strong.transformed.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final core::int y;
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = y = #0#0{core::int} in true) : false) {
-      {
-        break #L1;
+    {
+      final core::int y;
+      if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = y = #0#0{core::int} in true) : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_final_variable_inside_null_check.dart.weak.expect b/pkg/front_end/testcases/patterns/typed_final_variable_inside_null_check.dart.weak.expect
index bb039186035..7c9e67486cd 100644
--- a/pkg/front_end/testcases/patterns/typed_final_variable_inside_null_check.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/typed_final_variable_inside_null_check.dart.weak.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final core::int y;
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = y = #0#0{core::int} in true) : false) {
-      {
-        break #L1;
+    {
+      final core::int y;
+      if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = y = #0#0{core::int} in true) : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_final_variable_inside_null_check.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/typed_final_variable_inside_null_check.dart.weak.modular.expect
index bb039186035..7c9e67486cd 100644
--- a/pkg/front_end/testcases/patterns/typed_final_variable_inside_null_check.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/typed_final_variable_inside_null_check.dart.weak.modular.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final core::int y;
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = y = #0#0{core::int} in true) : false) {
-      {
-        break #L1;
+    {
+      final core::int y;
+      if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = y = #0#0{core::int} in true) : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_final_variable_inside_null_check.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/typed_final_variable_inside_null_check.dart.weak.transformed.expect
index 587e0dac8dd..c45db922649 100644
--- a/pkg/front_end/testcases/patterns/typed_final_variable_inside_null_check.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/typed_final_variable_inside_null_check.dart.weak.transformed.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    final core::int y;
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = y = #0#0{core::int} in true) : false) {
-      {
-        break #L1;
+    {
+      final core::int y;
+      if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = y = #0#0{core::int} in true) : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_inside_case.dart.strong.expect b/pkg/front_end/testcases/patterns/typed_variable_inside_case.dart.strong.expect
index e916f81e4f7..d2cdd51caf2 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_inside_case.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_inside_case.dart.strong.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int y;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = y = #0#0{core::int} in true)) {
-      {
-        break #L1;
+    {
+      core::int y;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = y = #0#0{core::int} in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_inside_case.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/typed_variable_inside_case.dart.strong.transformed.expect
index ef0ff962471..cea6276d529 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_inside_case.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_inside_case.dart.strong.transformed.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int y;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = y = #0#0{core::int} in true)) {
-      {
-        break #L1;
+    {
+      core::int y;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = y = #0#0{core::int} in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_inside_case.dart.weak.expect b/pkg/front_end/testcases/patterns/typed_variable_inside_case.dart.weak.expect
index e916f81e4f7..d2cdd51caf2 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_inside_case.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_inside_case.dart.weak.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int y;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = y = #0#0{core::int} in true)) {
-      {
-        break #L1;
+    {
+      core::int y;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = y = #0#0{core::int} in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_inside_case.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/typed_variable_inside_case.dart.weak.modular.expect
index e916f81e4f7..d2cdd51caf2 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_inside_case.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_inside_case.dart.weak.modular.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int y;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = y = #0#0{core::int} in true)) {
-      {
-        break #L1;
+    {
+      core::int y;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = y = #0#0{core::int} in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_inside_case.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/typed_variable_inside_case.dart.weak.transformed.expect
index ef0ff962471..cea6276d529 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_inside_case.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_inside_case.dart.weak.transformed.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int y;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = y = #0#0{core::int} in true)) {
-      {
-        break #L1;
+    {
+      core::int y;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = y = #0#0{core::int} in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_inside_cast.dart.strong.expect b/pkg/front_end/testcases/patterns/typed_variable_inside_cast.dart.strong.expect
index 92861407e0f..4b711395239 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_inside_cast.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_inside_cast.dart.strong.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int y;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in (#0#0 as{ForNonNullableByDefault} core::Object) is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = y = (#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} core::int in true)) {
-      {
-        break #L1;
+    {
+      core::int y;
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in (#0#0 as{ForNonNullableByDefault} core::Object) is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = y = (#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} core::int in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_inside_cast.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/typed_variable_inside_cast.dart.strong.transformed.expect
index 545ba99c4db..4fd24a4ea9c 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_inside_cast.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_inside_cast.dart.strong.transformed.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int y;
     final synthesized dynamic #0#0 = x;
-    if(let final core::Object #t1 = let dynamic #t2 = #0#0 in #t2 == null ?{core::Object} #t2 as{ForNonNullableByDefault} core::Object : #t2{core::Object} in (let dynamic #t3 = #0#0 in #t3 == null ?{core::Object} #t3 as{ForNonNullableByDefault} core::Object : #t3{core::Object}) is{ForNonNullableByDefault} core::int && (let final core::int #t4 = y = (let dynamic #t5 = #0#0 in #t5 == null ?{core::Object} #t5 as{ForNonNullableByDefault} core::Object : #t5{core::Object}) as{ForNonNullableByDefault} core::int in true)) {
-      {
-        break #L1;
+    {
+      core::int y;
+      if(let final core::Object #t1 = let dynamic #t2 = #0#0 in #t2 == null ?{core::Object} #t2 as{ForNonNullableByDefault} core::Object : #t2{core::Object} in (let dynamic #t3 = #0#0 in #t3 == null ?{core::Object} #t3 as{ForNonNullableByDefault} core::Object : #t3{core::Object}) is{ForNonNullableByDefault} core::int && (let final core::int #t4 = y = (let dynamic #t5 = #0#0 in #t5 == null ?{core::Object} #t5 as{ForNonNullableByDefault} core::Object : #t5{core::Object}) as{ForNonNullableByDefault} core::int in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_inside_cast.dart.weak.expect b/pkg/front_end/testcases/patterns/typed_variable_inside_cast.dart.weak.expect
index 92861407e0f..4b711395239 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_inside_cast.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_inside_cast.dart.weak.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int y;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in (#0#0 as{ForNonNullableByDefault} core::Object) is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = y = (#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} core::int in true)) {
-      {
-        break #L1;
+    {
+      core::int y;
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in (#0#0 as{ForNonNullableByDefault} core::Object) is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = y = (#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} core::int in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_inside_cast.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/typed_variable_inside_cast.dart.weak.modular.expect
index 92861407e0f..4b711395239 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_inside_cast.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_inside_cast.dart.weak.modular.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int y;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in (#0#0 as{ForNonNullableByDefault} core::Object) is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = y = (#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} core::int in true)) {
-      {
-        break #L1;
+    {
+      core::int y;
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in (#0#0 as{ForNonNullableByDefault} core::Object) is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = y = (#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} core::int in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_inside_cast.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/typed_variable_inside_cast.dart.weak.transformed.expect
index 4950a91595a..4c59f0fb411 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_inside_cast.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_inside_cast.dart.weak.transformed.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int y;
     final synthesized dynamic #0#0 = x;
-    if(let final core::Object #t1 = #0#0 in #0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t2 = y = #0#0 as{ForNonNullableByDefault} core::int in true)) {
-      {
-        break #L1;
+    {
+      core::int y;
+      if(let final core::Object #t1 = #0#0 in #0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t2 = y = #0#0 as{ForNonNullableByDefault} core::int in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_inside_null_assert.dart.strong.expect b/pkg/front_end/testcases/patterns/typed_variable_inside_null_assert.dart.strong.expect
index e3f86974654..f1810a34ad5 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_inside_null_assert.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_inside_null_assert.dart.strong.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int y;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = y = #0#0! as{ForNonNullableByDefault} core::int in true)) {
-      {
-        break #L1;
+    {
+      core::int y;
+      if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = y = #0#0! as{ForNonNullableByDefault} core::int in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_inside_null_assert.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/typed_variable_inside_null_assert.dart.strong.transformed.expect
index 2b0750a58b3..f0b589a588b 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_inside_null_assert.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_inside_null_assert.dart.strong.transformed.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int y;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::int && (let final core::int #t2 = y = #0#0! as{ForNonNullableByDefault} core::int in true)) {
-      {
-        break #L1;
+    {
+      core::int y;
+      if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::int && (let final core::int #t2 = y = #0#0! as{ForNonNullableByDefault} core::int in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_inside_null_assert.dart.weak.expect b/pkg/front_end/testcases/patterns/typed_variable_inside_null_assert.dart.weak.expect
index e3f86974654..f1810a34ad5 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_inside_null_assert.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_inside_null_assert.dart.weak.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int y;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = y = #0#0! as{ForNonNullableByDefault} core::int in true)) {
-      {
-        break #L1;
+    {
+      core::int y;
+      if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = y = #0#0! as{ForNonNullableByDefault} core::int in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_inside_null_assert.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/typed_variable_inside_null_assert.dart.weak.modular.expect
index e3f86974654..f1810a34ad5 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_inside_null_assert.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_inside_null_assert.dart.weak.modular.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int y;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = y = #0#0! as{ForNonNullableByDefault} core::int in true)) {
-      {
-        break #L1;
+    {
+      core::int y;
+      if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = y = #0#0! as{ForNonNullableByDefault} core::int in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_inside_null_assert.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/typed_variable_inside_null_assert.dart.weak.transformed.expect
index 2b0750a58b3..f0b589a588b 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_inside_null_assert.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_inside_null_assert.dart.weak.transformed.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int y;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::int && (let final core::int #t2 = y = #0#0! as{ForNonNullableByDefault} core::int in true)) {
-      {
-        break #L1;
+    {
+      core::int y;
+      if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::int && (let final core::int #t2 = y = #0#0! as{ForNonNullableByDefault} core::int in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_inside_null_check.dart.strong.expect b/pkg/front_end/testcases/patterns/typed_variable_inside_null_check.dart.strong.expect
index c7da99aba8e..9506de18c3a 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_inside_null_check.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_inside_null_check.dart.strong.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int y;
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = y = #0#0{core::int} in true) : false) {
-      {
-        break #L1;
+    {
+      core::int y;
+      if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = y = #0#0{core::int} in true) : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_inside_null_check.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/typed_variable_inside_null_check.dart.strong.transformed.expect
index 6998bbc4f21..d4d232f2e93 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_inside_null_check.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_inside_null_check.dart.strong.transformed.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int y;
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = y = #0#0{core::int} in true) : false) {
-      {
-        break #L1;
+    {
+      core::int y;
+      if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = y = #0#0{core::int} in true) : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_inside_null_check.dart.weak.expect b/pkg/front_end/testcases/patterns/typed_variable_inside_null_check.dart.weak.expect
index c7da99aba8e..9506de18c3a 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_inside_null_check.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_inside_null_check.dart.weak.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int y;
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = y = #0#0{core::int} in true) : false) {
-      {
-        break #L1;
+    {
+      core::int y;
+      if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = y = #0#0{core::int} in true) : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_inside_null_check.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/typed_variable_inside_null_check.dart.weak.modular.expect
index c7da99aba8e..9506de18c3a 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_inside_null_check.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_inside_null_check.dart.weak.modular.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int y;
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = y = #0#0{core::int} in true) : false) {
-      {
-        break #L1;
+    {
+      core::int y;
+      if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = y = #0#0{core::int} in true) : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_inside_null_check.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/typed_variable_inside_null_check.dart.weak.transformed.expect
index 6998bbc4f21..d4d232f2e93 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_inside_null_check.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_inside_null_check.dart.weak.transformed.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int y;
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = y = #0#0{core::int} in true) : false) {
-      {
-        break #L1;
+    {
+      core::int y;
+      if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = y = #0#0{core::int} in true) : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_case.dart.strong.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_case.dart.strong.expect
index e23f0c815ff..c22c349f157 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_case.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_case.dart.strong.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#0{core::int} in true)) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#0{core::int} in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_case.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_case.dart.strong.transformed.expect
index 89a9a851690..b6025c44674 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_case.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_case.dart.strong.transformed.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = as = #0#0{core::int} in true)) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = as = #0#0{core::int} in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_case.dart.weak.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_case.dart.weak.expect
index e23f0c815ff..c22c349f157 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_case.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_case.dart.weak.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#0{core::int} in true)) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#0{core::int} in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_case.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_case.dart.weak.modular.expect
index e23f0c815ff..c22c349f157 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_case.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_case.dart.weak.modular.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#0{core::int} in true)) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#0{core::int} in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_case.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_case.dart.weak.transformed.expect
index 89a9a851690..b6025c44674 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_case.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_case.dart.weak.transformed.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = as = #0#0{core::int} in true)) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = as = #0#0{core::int} in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_cast.dart.strong.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_cast.dart.strong.expect
index f7a3b0b5072..b7632983deb 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_cast.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_cast.dart.strong.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in (#0#0 as{ForNonNullableByDefault} core::Object) is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = as = (#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} core::int in true)) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in (#0#0 as{ForNonNullableByDefault} core::Object) is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = as = (#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} core::int in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_cast.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_cast.dart.strong.transformed.expect
index 3c287ff0008..65f1c3af60a 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_cast.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_cast.dart.strong.transformed.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
-    if(let final core::Object #t1 = let dynamic #t2 = #0#0 in #t2 == null ?{core::Object} #t2 as{ForNonNullableByDefault} core::Object : #t2{core::Object} in (let dynamic #t3 = #0#0 in #t3 == null ?{core::Object} #t3 as{ForNonNullableByDefault} core::Object : #t3{core::Object}) is{ForNonNullableByDefault} core::int && (let final core::int #t4 = as = (let dynamic #t5 = #0#0 in #t5 == null ?{core::Object} #t5 as{ForNonNullableByDefault} core::Object : #t5{core::Object}) as{ForNonNullableByDefault} core::int in true)) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(let final core::Object #t1 = let dynamic #t2 = #0#0 in #t2 == null ?{core::Object} #t2 as{ForNonNullableByDefault} core::Object : #t2{core::Object} in (let dynamic #t3 = #0#0 in #t3 == null ?{core::Object} #t3 as{ForNonNullableByDefault} core::Object : #t3{core::Object}) is{ForNonNullableByDefault} core::int && (let final core::int #t4 = as = (let dynamic #t5 = #0#0 in #t5 == null ?{core::Object} #t5 as{ForNonNullableByDefault} core::Object : #t5{core::Object}) as{ForNonNullableByDefault} core::int in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_cast.dart.weak.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_cast.dart.weak.expect
index f7a3b0b5072..b7632983deb 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_cast.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_cast.dart.weak.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in (#0#0 as{ForNonNullableByDefault} core::Object) is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = as = (#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} core::int in true)) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in (#0#0 as{ForNonNullableByDefault} core::Object) is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = as = (#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} core::int in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_cast.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_cast.dart.weak.modular.expect
index f7a3b0b5072..b7632983deb 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_cast.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_cast.dart.weak.modular.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in (#0#0 as{ForNonNullableByDefault} core::Object) is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = as = (#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} core::int in true)) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in (#0#0 as{ForNonNullableByDefault} core::Object) is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = as = (#0#0 as{ForNonNullableByDefault} core::Object) as{ForNonNullableByDefault} core::int in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_cast.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_cast.dart.weak.transformed.expect
index 28242bd3681..404ac10e8c0 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_cast.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_cast.dart.weak.transformed.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
-    if(let final core::Object #t1 = #0#0 in #0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t2 = as = #0#0 as{ForNonNullableByDefault} core::int in true)) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(let final core::Object #t1 = #0#0 in #0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t2 = as = #0#0 as{ForNonNullableByDefault} core::int in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern.dart.strong.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern.dart.strong.expect
index d8e1c2fee61..216230ca38a 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern.dart.strong.expect
@@ -11,12 +11,14 @@ class C extends core::Object {
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
     late final synthesized core::int? #0#2 = #0#0{self::C}.{self::C::f}{core::int?};
-    if(#0#0 is{ForNonNullableByDefault} self::C && (#0#2 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#2{core::int} in true))) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} self::C && (#0#2 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#2{core::int} in true))) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern.dart.strong.transformed.expect
index 2c527f3ca0d..972580ee60c 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern.dart.strong.transformed.expect
@@ -11,14 +11,16 @@ class C extends core::Object {
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
     function ##0#2#initializer() → core::int?
       return #0#0{self::C}.{self::C::f}{core::int?};
     late final synthesized core::int? #0#2 = ##0#2#initializer(){() → core::int?};
-    if(#0#0 is{ForNonNullableByDefault} self::C && (#0#2 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = as = #0#2{core::int} in true))) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} self::C && (#0#2 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = as = #0#2{core::int} in true))) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern.dart.weak.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern.dart.weak.expect
index d8e1c2fee61..216230ca38a 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern.dart.weak.expect
@@ -11,12 +11,14 @@ class C extends core::Object {
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
     late final synthesized core::int? #0#2 = #0#0{self::C}.{self::C::f}{core::int?};
-    if(#0#0 is{ForNonNullableByDefault} self::C && (#0#2 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#2{core::int} in true))) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} self::C && (#0#2 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#2{core::int} in true))) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern.dart.weak.modular.expect
index d8e1c2fee61..216230ca38a 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern.dart.weak.modular.expect
@@ -11,12 +11,14 @@ class C extends core::Object {
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
     late final synthesized core::int? #0#2 = #0#0{self::C}.{self::C::f}{core::int?};
-    if(#0#0 is{ForNonNullableByDefault} self::C && (#0#2 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#2{core::int} in true))) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} self::C && (#0#2 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#2{core::int} in true))) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern.dart.weak.transformed.expect
index 2c527f3ca0d..972580ee60c 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern.dart.weak.transformed.expect
@@ -11,14 +11,16 @@ class C extends core::Object {
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
     function ##0#2#initializer() → core::int?
       return #0#0{self::C}.{self::C::f}{core::int?};
     late final synthesized core::int? #0#2 = ##0#2#initializer(){() → core::int?};
-    if(#0#0 is{ForNonNullableByDefault} self::C && (#0#2 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = as = #0#2{core::int} in true))) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} self::C && (#0#2 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = as = #0#2{core::int} in true))) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart.strong.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart.strong.expect
index e6a67080800..ead0b9e0d6e 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart.strong.expect
@@ -20,9 +20,10 @@ class C extends core::Object {
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} self::C && (let final dynamic #t1 = invalid-expression "pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart:10:12: Error: The getter 'as' isn't defined for the class 'C'.
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} self::C && (let final dynamic #t1 = invalid-expression "pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart:10:12: Error: The getter 'as' isn't defined for the class 'C'.
  - 'C' is from 'pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart'.
 Try correcting the name to the name of an existing getter, or defining a getter or field named 'as'.
     case C(: int as):
@@ -31,8 +32,9 @@ Try correcting the name to the name of an existing getter, or defining a getter
 Try correcting the name to the name of an existing getter, or defining a getter or field named 'as'.
     case C(: int as):
            ^^")) {
-      {
-        break #L1;
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart.strong.transformed.expect
index ce53b960b90..163dc315e89 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart.strong.transformed.expect
@@ -20,9 +20,10 @@ class C extends core::Object {
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} self::C && (let final invalid-type #t1 = invalid-expression "pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart:10:12: Error: The getter 'as' isn't defined for the class 'C'.
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} self::C && (let final invalid-type #t1 = invalid-expression "pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart:10:12: Error: The getter 'as' isn't defined for the class 'C'.
  - 'C' is from 'pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart'.
 Try correcting the name to the name of an existing getter, or defining a getter or field named 'as'.
     case C(: int as):
@@ -31,8 +32,9 @@ Try correcting the name to the name of an existing getter, or defining a getter
 Try correcting the name to the name of an existing getter, or defining a getter or field named 'as'.
     case C(: int as):
            ^^")) {
-      {
-        break #L1;
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart.weak.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart.weak.expect
index e6a67080800..ead0b9e0d6e 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart.weak.expect
@@ -20,9 +20,10 @@ class C extends core::Object {
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} self::C && (let final dynamic #t1 = invalid-expression "pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart:10:12: Error: The getter 'as' isn't defined for the class 'C'.
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} self::C && (let final dynamic #t1 = invalid-expression "pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart:10:12: Error: The getter 'as' isn't defined for the class 'C'.
  - 'C' is from 'pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart'.
 Try correcting the name to the name of an existing getter, or defining a getter or field named 'as'.
     case C(: int as):
@@ -31,8 +32,9 @@ Try correcting the name to the name of an existing getter, or defining a getter
 Try correcting the name to the name of an existing getter, or defining a getter or field named 'as'.
     case C(: int as):
            ^^")) {
-      {
-        break #L1;
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart.weak.modular.expect
index e6a67080800..ead0b9e0d6e 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart.weak.modular.expect
@@ -20,9 +20,10 @@ class C extends core::Object {
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} self::C && (let final dynamic #t1 = invalid-expression "pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart:10:12: Error: The getter 'as' isn't defined for the class 'C'.
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} self::C && (let final dynamic #t1 = invalid-expression "pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart:10:12: Error: The getter 'as' isn't defined for the class 'C'.
  - 'C' is from 'pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart'.
 Try correcting the name to the name of an existing getter, or defining a getter or field named 'as'.
     case C(: int as):
@@ -31,8 +32,9 @@ Try correcting the name to the name of an existing getter, or defining a getter
 Try correcting the name to the name of an existing getter, or defining a getter or field named 'as'.
     case C(: int as):
            ^^")) {
-      {
-        break #L1;
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart.weak.transformed.expect
index ce53b960b90..163dc315e89 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart.weak.transformed.expect
@@ -20,9 +20,10 @@ class C extends core::Object {
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} self::C && (let final invalid-type #t1 = invalid-expression "pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart:10:12: Error: The getter 'as' isn't defined for the class 'C'.
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} self::C && (let final invalid-type #t1 = invalid-expression "pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart:10:12: Error: The getter 'as' isn't defined for the class 'C'.
  - 'C' is from 'pkg/front_end/testcases/patterns/typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart'.
 Try correcting the name to the name of an existing getter, or defining a getter or field named 'as'.
     case C(: int as):
@@ -31,8 +32,9 @@ Try correcting the name to the name of an existing getter, or defining a getter
 Try correcting the name to the name of an existing getter, or defining a getter or field named 'as'.
     case C(: int as):
            ^^")) {
-      {
-        break #L1;
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_list_pattern.dart.strong.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_list_pattern.dart.strong.expect
index 587fe05c667..5e0f737d34a 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_list_pattern.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_list_pattern.dart.strong.expect
@@ -5,12 +5,14 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
     late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#6{core::int} in true))) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#6{core::int} in true))) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_list_pattern.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_list_pattern.dart.strong.transformed.expect
index 3194637b4ee..7f02b1411f6 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_list_pattern.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_list_pattern.dart.strong.transformed.expect
@@ -5,14 +5,16 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
     function ##0#6#initializer() → dynamic
       return #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
     late final synthesized dynamic #0#6 = ##0#6#initializer(){() → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (#0#6 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = as = #0#6{core::int} in true))) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (#0#6 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = as = #0#6{core::int} in true))) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_list_pattern.dart.weak.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_list_pattern.dart.weak.expect
index 587fe05c667..5e0f737d34a 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_list_pattern.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_list_pattern.dart.weak.expect
@@ -5,12 +5,14 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
     late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#6{core::int} in true))) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#6{core::int} in true))) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_list_pattern.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_list_pattern.dart.weak.modular.expect
index 587fe05c667..5e0f737d34a 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_list_pattern.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_list_pattern.dart.weak.modular.expect
@@ -5,12 +5,14 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
     late final synthesized dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#6{core::int} in true))) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#6{core::int} in true))) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_list_pattern.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_list_pattern.dart.weak.transformed.expect
index 3194637b4ee..7f02b1411f6 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_list_pattern.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_list_pattern.dart.weak.transformed.expect
@@ -5,14 +5,16 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
     function ##0#6#initializer() → dynamic
       return #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
     late final synthesized dynamic #0#6 = ##0#6#initializer(){() → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (#0#6 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = as = #0#6{core::int} in true))) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (#0#6 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = as = #0#6{core::int} in true))) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_and_lhs.dart.strong.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_and_lhs.dart.strong.expect
index 6aee6c8a69c..363eadf5d2a 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_and_lhs.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_and_lhs.dart.strong.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#0{core::int} in true) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#0{core::int} in true) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_and_lhs.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_and_lhs.dart.strong.transformed.expect
index 39eb3228d83..e46654fb07c 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_and_lhs.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_and_lhs.dart.strong.transformed.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = as = #0#0{core::int} in true) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = as = #0#0{core::int} in true) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_and_lhs.dart.weak.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_and_lhs.dart.weak.expect
index 6aee6c8a69c..363eadf5d2a 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_and_lhs.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_and_lhs.dart.weak.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#0{core::int} in true) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#0{core::int} in true) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_and_lhs.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_and_lhs.dart.weak.modular.expect
index 6aee6c8a69c..363eadf5d2a 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_and_lhs.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_and_lhs.dart.weak.modular.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#0{core::int} in true) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#0{core::int} in true) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_and_lhs.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_and_lhs.dart.weak.transformed.expect
index 39eb3228d83..e46654fb07c 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_and_lhs.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_and_lhs.dart.weak.transformed.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = as = #0#0{core::int} in true) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = as = #0#0{core::int} in true) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_and_rhs.dart.strong.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_and_rhs.dart.strong.expect
index 7a5ba05ab7d..1dbb263f6e4 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_and_rhs.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_and_rhs.dart.strong.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && (#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#0{core::int} in true))) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && (#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#0{core::int} in true))) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_and_rhs.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_and_rhs.dart.strong.transformed.expect
index 7d332e6b0de..2c6e78e1b89 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_and_rhs.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_and_rhs.dart.strong.transformed.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && (#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = as = #0#0{core::int} in true))) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && (#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = as = #0#0{core::int} in true))) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_and_rhs.dart.weak.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_and_rhs.dart.weak.expect
index 7a5ba05ab7d..1dbb263f6e4 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_and_rhs.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_and_rhs.dart.weak.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && (#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#0{core::int} in true))) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && (#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#0{core::int} in true))) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_and_rhs.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_and_rhs.dart.weak.modular.expect
index 7a5ba05ab7d..1dbb263f6e4 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_and_rhs.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_and_rhs.dart.weak.modular.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && (#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#0{core::int} in true))) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && (#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#0{core::int} in true))) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_and_rhs.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_and_rhs.dart.weak.transformed.expect
index 7d332e6b0de..2c6e78e1b89 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_and_rhs.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_and_rhs.dart.weak.transformed.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && (#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = as = #0#0{core::int} in true))) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 && (#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = as = #0#0{core::int} in true))) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_or_lhs.dart.strong.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_or_lhs.dart.strong.expect
index e174f9d4db6..241c406771d 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_or_lhs.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_or_lhs.dart.strong.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    invalid-type as;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#0{invalid-type} in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final dynamic #t2 = as = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} as{ForNonNullableByDefault} invalid-type in true)) {
-      {
-        break #L1;
+    {
+      invalid-type as;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#0{invalid-type} in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final dynamic #t2 = as = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} as{ForNonNullableByDefault} invalid-type in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_or_lhs.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_or_lhs.dart.strong.transformed.expect
index bc2d3cab673..34f118dc0e0 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_or_lhs.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_or_lhs.dart.strong.transformed.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    invalid-type as;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final invalid-type #t1 = as = #0#0{invalid-type} in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final invalid-type #t2 = as = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} as{ForNonNullableByDefault} invalid-type in true)) {
-      {
-        break #L1;
+    {
+      invalid-type as;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final invalid-type #t1 = as = #0#0{invalid-type} in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final invalid-type #t2 = as = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} as{ForNonNullableByDefault} invalid-type in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_or_lhs.dart.weak.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_or_lhs.dart.weak.expect
index e174f9d4db6..241c406771d 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_or_lhs.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_or_lhs.dart.weak.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    invalid-type as;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#0{invalid-type} in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final dynamic #t2 = as = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} as{ForNonNullableByDefault} invalid-type in true)) {
-      {
-        break #L1;
+    {
+      invalid-type as;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#0{invalid-type} in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final dynamic #t2 = as = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} as{ForNonNullableByDefault} invalid-type in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_or_lhs.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_or_lhs.dart.weak.modular.expect
index e174f9d4db6..241c406771d 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_or_lhs.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_or_lhs.dart.weak.modular.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    invalid-type as;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#0{invalid-type} in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final dynamic #t2 = as = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} as{ForNonNullableByDefault} invalid-type in true)) {
-      {
-        break #L1;
+    {
+      invalid-type as;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#0{invalid-type} in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final dynamic #t2 = as = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} as{ForNonNullableByDefault} invalid-type in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_or_lhs.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_or_lhs.dart.weak.transformed.expect
index bc2d3cab673..34f118dc0e0 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_or_lhs.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_or_lhs.dart.weak.transformed.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    invalid-type as;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final invalid-type #t1 = as = #0#0{invalid-type} in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final invalid-type #t2 = as = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} as{ForNonNullableByDefault} invalid-type in true)) {
-      {
-        break #L1;
+    {
+      invalid-type as;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final invalid-type #t1 = as = #0#0{invalid-type} in true) || #0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (let final invalid-type #t2 = as = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} as{ForNonNullableByDefault} invalid-type in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_or_rhs.dart.strong.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_or_rhs.dart.strong.expect
index 99e99800022..505c0b506ca 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_or_rhs.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_or_rhs.dart.strong.expect
@@ -15,9 +15,11 @@ static method test(dynamic x) → dynamic {
   {
     core::int as;
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || #0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#0{core::int} in true)) {
-      {
-        break #L1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || #0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#0{core::int} in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_or_rhs.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_or_rhs.dart.strong.transformed.expect
index 815a24715a0..d65eda0257a 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_or_rhs.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_or_rhs.dart.strong.transformed.expect
@@ -15,9 +15,11 @@ static method test(dynamic x) → dynamic {
   {
     core::int as;
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || #0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = as = #0#0{core::int} in true)) {
-      {
-        break #L1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || #0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = as = #0#0{core::int} in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_or_rhs.dart.weak.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_or_rhs.dart.weak.expect
index 99e99800022..505c0b506ca 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_or_rhs.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_or_rhs.dart.weak.expect
@@ -15,9 +15,11 @@ static method test(dynamic x) → dynamic {
   {
     core::int as;
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || #0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#0{core::int} in true)) {
-      {
-        break #L1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || #0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#0{core::int} in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_or_rhs.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_or_rhs.dart.weak.modular.expect
index 99e99800022..505c0b506ca 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_or_rhs.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_or_rhs.dart.weak.modular.expect
@@ -15,9 +15,11 @@ static method test(dynamic x) → dynamic {
   {
     core::int as;
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || #0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#0{core::int} in true)) {
-      {
-        break #L1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || #0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#0{core::int} in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_or_rhs.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_or_rhs.dart.weak.transformed.expect
index 815a24715a0..d65eda0257a 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_or_rhs.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_logical_or_rhs.dart.weak.transformed.expect
@@ -15,9 +15,11 @@ static method test(dynamic x) → dynamic {
   {
     core::int as;
     final synthesized dynamic #0#0 = x;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || #0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = as = #0#0{core::int} in true)) {
-      {
-        break #L1;
+    {
+      if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0 || #0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = as = #0#0{core::int} in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_map_pattern.dart.strong.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_map_pattern.dart.strong.expect
index 60c74ea5c9a..3de09c69940 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_map_pattern.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_map_pattern.dart.strong.expect
@@ -5,12 +5,14 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
     late final synthesized dynamic #0#8 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (#0#8 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#8{core::int} in true))) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (#0#8 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#8{core::int} in true))) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_map_pattern.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_map_pattern.dart.strong.transformed.expect
index 0cfa191eaa2..5af9b672b08 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_map_pattern.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_map_pattern.dart.strong.transformed.expect
@@ -5,14 +5,16 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
     function ##0#8#initializer() → dynamic
       return #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic};
     late final synthesized dynamic #0#8 = ##0#8#initializer(){() → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (#0#8 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = as = #0#8{core::int} in true))) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (#0#8 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = as = #0#8{core::int} in true))) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_map_pattern.dart.weak.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_map_pattern.dart.weak.expect
index 60c74ea5c9a..3de09c69940 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_map_pattern.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_map_pattern.dart.weak.expect
@@ -5,12 +5,14 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
     late final synthesized dynamic #0#8 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (#0#8 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#8{core::int} in true))) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (#0#8 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#8{core::int} in true))) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_map_pattern.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_map_pattern.dart.weak.modular.expect
index 60c74ea5c9a..3de09c69940 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_map_pattern.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_map_pattern.dart.weak.modular.expect
@@ -5,12 +5,14 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
     late final synthesized dynamic #0#8 = #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (#0#8 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#8{core::int} in true))) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (#0#8 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#8{core::int} in true))) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_map_pattern.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_map_pattern.dart.weak.transformed.expect
index 0cfa191eaa2..5af9b672b08 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_map_pattern.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_map_pattern.dart.weak.transformed.expect
@@ -5,14 +5,16 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
     function ##0#8#initializer() → dynamic
       return #0#0{core::Map<dynamic, dynamic>}.{core::Map::[]}(#C1){(core::Object?) → dynamic};
     late final synthesized dynamic #0#8 = ##0#8#initializer(){() → dynamic};
-    if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (#0#8 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = as = #0#8{core::int} in true))) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && #0#0{core::Map<dynamic, dynamic>}.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2 && #0#0{core::Map<dynamic, dynamic>}.{core::Map::containsKey}(#C1){(core::Object?) → core::bool} && (#0#8 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = as = #0#8{core::int} in true))) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_null_assert.dart.strong.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_null_assert.dart.strong.expect
index 2cb4d9cf6b4..e78e7bd9867 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_null_assert.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_null_assert.dart.strong.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = as = #0#0! as{ForNonNullableByDefault} core::int in true)) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = as = #0#0! as{ForNonNullableByDefault} core::int in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_null_assert.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_null_assert.dart.strong.transformed.expect
index 56542b8c2a2..da66a0a0739 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_null_assert.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_null_assert.dart.strong.transformed.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::int && (let final core::int #t2 = as = #0#0! as{ForNonNullableByDefault} core::int in true)) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::int && (let final core::int #t2 = as = #0#0! as{ForNonNullableByDefault} core::int in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_null_assert.dart.weak.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_null_assert.dart.weak.expect
index 2cb4d9cf6b4..e78e7bd9867 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_null_assert.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_null_assert.dart.weak.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = as = #0#0! as{ForNonNullableByDefault} core::int in true)) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = as = #0#0! as{ForNonNullableByDefault} core::int in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_null_assert.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_null_assert.dart.weak.modular.expect
index 2cb4d9cf6b4..e78e7bd9867 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_null_assert.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_null_assert.dart.weak.modular.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = as = #0#0! as{ForNonNullableByDefault} core::int in true)) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = as = #0#0! as{ForNonNullableByDefault} core::int in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_null_assert.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_null_assert.dart.weak.transformed.expect
index 56542b8c2a2..da66a0a0739 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_null_assert.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_null_assert.dart.weak.transformed.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::int && (let final core::int #t2 = as = #0#0! as{ForNonNullableByDefault} core::int in true)) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(let final dynamic #t1 = #0#0! in #0#0! is{ForNonNullableByDefault} core::int && (let final core::int #t2 = as = #0#0! as{ForNonNullableByDefault} core::int in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_null_check.dart.strong.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_null_check.dart.strong.expect
index a9afa4a8648..d41fa2eb7c9 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_null_check.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_null_check.dart.strong.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#0{core::int} in true) : false) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#0{core::int} in true) : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_null_check.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_null_check.dart.strong.transformed.expect
index c7ef174cc6c..61c1e76c356 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_null_check.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_null_check.dart.strong.transformed.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = as = #0#0{core::int} in true) : false) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = as = #0#0{core::int} in true) : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_null_check.dart.weak.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_null_check.dart.weak.expect
index a9afa4a8648..d41fa2eb7c9 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_null_check.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_null_check.dart.weak.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#0{core::int} in true) : false) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#0{core::int} in true) : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_null_check.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_null_check.dart.weak.modular.expect
index a9afa4a8648..d41fa2eb7c9 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_null_check.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_null_check.dart.weak.modular.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#0{core::int} in true) : false) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#0{core::int} in true) : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_null_check.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_null_check.dart.weak.transformed.expect
index c7ef174cc6c..61c1e76c356 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_null_check.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_null_check.dart.weak.transformed.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = as = #0#0{core::int} in true) : false) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(!(#0#0 == null) ?{core::bool} #0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = as = #0#0{core::int} in true) : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_parenthesized_pattern.dart.strong.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_parenthesized_pattern.dart.strong.expect
index e23f0c815ff..c22c349f157 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_parenthesized_pattern.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_parenthesized_pattern.dart.strong.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#0{core::int} in true)) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#0{core::int} in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_parenthesized_pattern.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_parenthesized_pattern.dart.strong.transformed.expect
index 89a9a851690..b6025c44674 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_parenthesized_pattern.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_parenthesized_pattern.dart.strong.transformed.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = as = #0#0{core::int} in true)) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = as = #0#0{core::int} in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_parenthesized_pattern.dart.weak.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_parenthesized_pattern.dart.weak.expect
index e23f0c815ff..c22c349f157 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_parenthesized_pattern.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_parenthesized_pattern.dart.weak.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#0{core::int} in true)) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#0{core::int} in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_parenthesized_pattern.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_parenthesized_pattern.dart.weak.modular.expect
index e23f0c815ff..c22c349f157 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_parenthesized_pattern.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_parenthesized_pattern.dart.weak.modular.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#0{core::int} in true)) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#0{core::int} in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_parenthesized_pattern.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_parenthesized_pattern.dart.weak.transformed.expect
index 89a9a851690..b6025c44674 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_parenthesized_pattern.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_parenthesized_pattern.dart.weak.transformed.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = as = #0#0{core::int} in true)) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = as = #0#0{core::int} in true)) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_implicitly_named.dart.strong.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_implicitly_named.dart.strong.expect
index 8e380a06f5a..e2cbfd76457 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_implicitly_named.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_implicitly_named.dart.strong.expect
@@ -5,12 +5,14 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
     late final synthesized core::Object? #0#2 = #0#0{(core::Object?, {as: core::Object?})}.as{core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, {as: core::Object?}) && (#0#2 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#2{core::int} in true)) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {as: core::Object?})}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, {as: core::Object?}) && (#0#2 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#2{core::int} in true)) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {as: core::Object?})}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_implicitly_named.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_implicitly_named.dart.strong.transformed.expect
index b547493b31f..7c7e8b66f63 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_implicitly_named.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_implicitly_named.dart.strong.transformed.expect
@@ -5,14 +5,16 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
     function ##0#2#initializer() → core::Object?
       return #0#0{(core::Object?, {as: core::Object?})}.as{core::Object?};
     late final synthesized core::Object? #0#2 = ##0#2#initializer(){() → core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, {as: core::Object?}) && (#0#2 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = as = #0#2{core::int} in true)) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {as: core::Object?})}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, {as: core::Object?}) && (#0#2 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = as = #0#2{core::int} in true)) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {as: core::Object?})}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_implicitly_named.dart.weak.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_implicitly_named.dart.weak.expect
index 8e380a06f5a..e2cbfd76457 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_implicitly_named.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_implicitly_named.dart.weak.expect
@@ -5,12 +5,14 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
     late final synthesized core::Object? #0#2 = #0#0{(core::Object?, {as: core::Object?})}.as{core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, {as: core::Object?}) && (#0#2 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#2{core::int} in true)) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {as: core::Object?})}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, {as: core::Object?}) && (#0#2 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#2{core::int} in true)) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {as: core::Object?})}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_implicitly_named.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_implicitly_named.dart.weak.modular.expect
index 8e380a06f5a..e2cbfd76457 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_implicitly_named.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_implicitly_named.dart.weak.modular.expect
@@ -5,12 +5,14 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
     late final synthesized core::Object? #0#2 = #0#0{(core::Object?, {as: core::Object?})}.as{core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, {as: core::Object?}) && (#0#2 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#2{core::int} in true)) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {as: core::Object?})}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, {as: core::Object?}) && (#0#2 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#2{core::int} in true)) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {as: core::Object?})}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_implicitly_named.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_implicitly_named.dart.weak.transformed.expect
index b547493b31f..7c7e8b66f63 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_implicitly_named.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_implicitly_named.dart.weak.transformed.expect
@@ -5,14 +5,16 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
     function ##0#2#initializer() → core::Object?
       return #0#0{(core::Object?, {as: core::Object?})}.as{core::Object?};
     late final synthesized core::Object? #0#2 = ##0#2#initializer(){() → core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, {as: core::Object?}) && (#0#2 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = as = #0#2{core::int} in true)) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {as: core::Object?})}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, {as: core::Object?}) && (#0#2 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = as = #0#2{core::int} in true)) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {as: core::Object?})}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_named.dart.strong.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_named.dart.strong.expect
index 7e3a8911cb5..6dc3cf9aabb 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_named.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_named.dart.strong.expect
@@ -5,12 +5,14 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
     late final synthesized core::Object? #0#2 = #0#0{(core::Object?, {n: core::Object?})}.n{core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (#0#2 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#2{core::int} in true)) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (#0#2 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#2{core::int} in true)) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_named.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_named.dart.strong.transformed.expect
index 2fbdd93e7cc..0636f058881 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_named.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_named.dart.strong.transformed.expect
@@ -5,14 +5,16 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
     function ##0#2#initializer() → core::Object?
       return #0#0{(core::Object?, {n: core::Object?})}.n{core::Object?};
     late final synthesized core::Object? #0#2 = ##0#2#initializer(){() → core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (#0#2 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = as = #0#2{core::int} in true)) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (#0#2 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = as = #0#2{core::int} in true)) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_named.dart.weak.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_named.dart.weak.expect
index 7e3a8911cb5..6dc3cf9aabb 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_named.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_named.dart.weak.expect
@@ -5,12 +5,14 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
     late final synthesized core::Object? #0#2 = #0#0{(core::Object?, {n: core::Object?})}.n{core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (#0#2 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#2{core::int} in true)) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (#0#2 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#2{core::int} in true)) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_named.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_named.dart.weak.modular.expect
index 7e3a8911cb5..6dc3cf9aabb 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_named.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_named.dart.weak.modular.expect
@@ -5,12 +5,14 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
     late final synthesized core::Object? #0#2 = #0#0{(core::Object?, {n: core::Object?})}.n{core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (#0#2 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#2{core::int} in true)) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (#0#2 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#2{core::int} in true)) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_named.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_named.dart.weak.transformed.expect
index 2fbdd93e7cc..0636f058881 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_named.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_named.dart.weak.transformed.expect
@@ -5,14 +5,16 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
     function ##0#2#initializer() → core::Object?
       return #0#0{(core::Object?, {n: core::Object?})}.n{core::Object?};
     late final synthesized core::Object? #0#2 = ##0#2#initializer(){() → core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (#0#2 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = as = #0#2{core::int} in true)) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, {n: core::Object?}) && (#0#2 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = as = #0#2{core::int} in true)) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, {n: core::Object?})}.$1{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_unnamed.dart.strong.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_unnamed.dart.strong.expect
index ebd5cf5148e..6c72761e0d6 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_unnamed.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_unnamed.dart.strong.expect
@@ -5,12 +5,14 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
     late final synthesized core::Object? #0#2 = #0#0{(core::Object?, core::Object?)}.$1{core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && (#0#2 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#2{core::int} in true)) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && (#0#2 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#2{core::int} in true)) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_unnamed.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_unnamed.dart.strong.transformed.expect
index 193d40572dc..b3bb05941e4 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_unnamed.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_unnamed.dart.strong.transformed.expect
@@ -5,14 +5,16 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
     function ##0#2#initializer() → core::Object?
       return #0#0{(core::Object?, core::Object?)}.$1{core::Object?};
     late final synthesized core::Object? #0#2 = ##0#2#initializer(){() → core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && (#0#2 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = as = #0#2{core::int} in true)) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && (#0#2 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = as = #0#2{core::int} in true)) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_unnamed.dart.weak.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_unnamed.dart.weak.expect
index ebd5cf5148e..6c72761e0d6 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_unnamed.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_unnamed.dart.weak.expect
@@ -5,12 +5,14 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
     late final synthesized core::Object? #0#2 = #0#0{(core::Object?, core::Object?)}.$1{core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && (#0#2 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#2{core::int} in true)) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && (#0#2 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#2{core::int} in true)) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_unnamed.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_unnamed.dart.weak.modular.expect
index ebd5cf5148e..6c72761e0d6 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_unnamed.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_unnamed.dart.weak.modular.expect
@@ -5,12 +5,14 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
     late final synthesized core::Object? #0#2 = #0#0{(core::Object?, core::Object?)}.$1{core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && (#0#2 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#2{core::int} in true)) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && (#0#2 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = as = #0#2{core::int} in true)) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_unnamed.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_unnamed.dart.weak.transformed.expect
index 193d40572dc..b3bb05941e4 100644
--- a/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_unnamed.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/typed_variable_named_as_inside_record_pattern_unnamed.dart.weak.transformed.expect
@@ -5,14 +5,16 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int as;
     final synthesized dynamic #0#0 = x;
     function ##0#2#initializer() → core::Object?
       return #0#0{(core::Object?, core::Object?)}.$1{core::Object?};
     late final synthesized core::Object? #0#2 = ##0#2#initializer(){() → core::Object?};
-    if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && (#0#2 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = as = #0#2{core::int} in true)) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
-      {
-        break #L1;
+    {
+      core::int as;
+      if(#0#0 is{ForNonNullableByDefault} (core::Object?, core::Object?) && (#0#2 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = as = #0#2{core::int} in true)) && #C1 =={core::num::==}{(core::Object) → core::bool} #0#0{(core::Object?, core::Object?)}.$2{core::Object?}) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/unused_joint_variable_is_not_joint.dart.strong.expect b/pkg/front_end/testcases/patterns/unused_joint_variable_is_not_joint.dart.strong.expect
index 98aeee6f3f6..e994b486182 100644
--- a/pkg/front_end/testcases/patterns/unused_joint_variable_is_not_joint.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/unused_joint_variable_is_not_joint.dart.strong.expect
@@ -5,17 +5,21 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int x;
-    core::String x#1;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = x = #0#0{core::int} in true) && x.{core::num::>}(0){(core::num) → core::bool} || #0#0 is{ForNonNullableByDefault} core::String && (let final dynamic #t2 = x#1 = #0#0{core::String} in true) && x#1.{core::String::startsWith}("f"){(core::Pattern, [core::int]) → core::bool}) {
-      {
-        return 1;
+    {
+      lowered core::int x#case#0;
+      lowered core::String x#case#1;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = x#case#0 = #0#0{core::int} in true) && x#case#0.{core::num::>}(0){(core::num) → core::bool} || #0#0 is{ForNonNullableByDefault} core::String && (let final dynamic #t2 = x#case#1 = #0#0{core::String} in true) && x#case#1.{core::String::startsWith}("f"){(core::Pattern, [core::int]) → core::bool}) {
+        {
+          return 1;
+        }
       }
     }
-    else {
+    {
       {
-        return 0;
+        {
+          return 0;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/unused_joint_variable_is_not_joint.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/unused_joint_variable_is_not_joint.dart.strong.transformed.expect
index 75490d03d88..008913c977a 100644
--- a/pkg/front_end/testcases/patterns/unused_joint_variable_is_not_joint.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/unused_joint_variable_is_not_joint.dart.strong.transformed.expect
@@ -5,17 +5,21 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int x;
-    core::String x#1;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = x = #0#0{core::int} in true) && x.{core::num::>}(0){(core::num) → core::bool} || #0#0 is{ForNonNullableByDefault} core::String && (let final core::String #t2 = x#1 = #0#0{core::String} in true) && x#1.{core::String::startsWith}("f"){(core::Pattern, [core::int]) → core::bool}) {
-      {
-        return 1;
+    {
+      lowered core::int x#case#0;
+      lowered core::String x#case#1;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = x#case#0 = #0#0{core::int} in true) && x#case#0.{core::num::>}(0){(core::num) → core::bool} || #0#0 is{ForNonNullableByDefault} core::String && (let final core::String #t2 = x#case#1 = #0#0{core::String} in true) && x#case#1.{core::String::startsWith}("f"){(core::Pattern, [core::int]) → core::bool}) {
+        {
+          return 1;
+        }
       }
     }
-    else {
+    {
       {
-        return 0;
+        {
+          return 0;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/unused_joint_variable_is_not_joint.dart.weak.expect b/pkg/front_end/testcases/patterns/unused_joint_variable_is_not_joint.dart.weak.expect
index 98aeee6f3f6..e994b486182 100644
--- a/pkg/front_end/testcases/patterns/unused_joint_variable_is_not_joint.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/unused_joint_variable_is_not_joint.dart.weak.expect
@@ -5,17 +5,21 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int x;
-    core::String x#1;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = x = #0#0{core::int} in true) && x.{core::num::>}(0){(core::num) → core::bool} || #0#0 is{ForNonNullableByDefault} core::String && (let final dynamic #t2 = x#1 = #0#0{core::String} in true) && x#1.{core::String::startsWith}("f"){(core::Pattern, [core::int]) → core::bool}) {
-      {
-        return 1;
+    {
+      lowered core::int x#case#0;
+      lowered core::String x#case#1;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = x#case#0 = #0#0{core::int} in true) && x#case#0.{core::num::>}(0){(core::num) → core::bool} || #0#0 is{ForNonNullableByDefault} core::String && (let final dynamic #t2 = x#case#1 = #0#0{core::String} in true) && x#case#1.{core::String::startsWith}("f"){(core::Pattern, [core::int]) → core::bool}) {
+        {
+          return 1;
+        }
       }
     }
-    else {
+    {
       {
-        return 0;
+        {
+          return 0;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/unused_joint_variable_is_not_joint.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/unused_joint_variable_is_not_joint.dart.weak.modular.expect
index 98aeee6f3f6..e994b486182 100644
--- a/pkg/front_end/testcases/patterns/unused_joint_variable_is_not_joint.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/unused_joint_variable_is_not_joint.dart.weak.modular.expect
@@ -5,17 +5,21 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int x;
-    core::String x#1;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = x = #0#0{core::int} in true) && x.{core::num::>}(0){(core::num) → core::bool} || #0#0 is{ForNonNullableByDefault} core::String && (let final dynamic #t2 = x#1 = #0#0{core::String} in true) && x#1.{core::String::startsWith}("f"){(core::Pattern, [core::int]) → core::bool}) {
-      {
-        return 1;
+    {
+      lowered core::int x#case#0;
+      lowered core::String x#case#1;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = x#case#0 = #0#0{core::int} in true) && x#case#0.{core::num::>}(0){(core::num) → core::bool} || #0#0 is{ForNonNullableByDefault} core::String && (let final dynamic #t2 = x#case#1 = #0#0{core::String} in true) && x#case#1.{core::String::startsWith}("f"){(core::Pattern, [core::int]) → core::bool}) {
+        {
+          return 1;
+        }
       }
     }
-    else {
+    {
       {
-        return 0;
+        {
+          return 0;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/unused_joint_variable_is_not_joint.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/unused_joint_variable_is_not_joint.dart.weak.transformed.expect
index 75490d03d88..008913c977a 100644
--- a/pkg/front_end/testcases/patterns/unused_joint_variable_is_not_joint.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/unused_joint_variable_is_not_joint.dart.weak.transformed.expect
@@ -5,17 +5,21 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::int x;
-    core::String x#1;
     final synthesized dynamic #0#0 = x;
-    if(#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = x = #0#0{core::int} in true) && x.{core::num::>}(0){(core::num) → core::bool} || #0#0 is{ForNonNullableByDefault} core::String && (let final core::String #t2 = x#1 = #0#0{core::String} in true) && x#1.{core::String::startsWith}("f"){(core::Pattern, [core::int]) → core::bool}) {
-      {
-        return 1;
+    {
+      lowered core::int x#case#0;
+      lowered core::String x#case#1;
+      if(#0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = x#case#0 = #0#0{core::int} in true) && x#case#0.{core::num::>}(0){(core::num) → core::bool} || #0#0 is{ForNonNullableByDefault} core::String && (let final core::String #t2 = x#case#1 = #0#0{core::String} in true) && x#case#1.{core::String::startsWith}("f"){(core::Pattern, [core::int]) → core::bool}) {
+        {
+          return 1;
+        }
       }
     }
-    else {
+    {
       {
-        return 0;
+        {
+          return 0;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/user_defined_equals.dart.strong.expect b/pkg/front_end/testcases/patterns/user_defined_equals.dart.strong.expect
index 99e3d8d6b04..859d88368cb 100644
--- a/pkg/front_end/testcases/patterns/user_defined_equals.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/user_defined_equals.dart.strong.expect
@@ -24,14 +24,18 @@ static method test1(dynamic o) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = o;
-    if(#C1 =={self::Class1::==}{(core::Object) → core::bool} #0#0) {
-      {
-        return true;
+    {
+      if(#C1 =={self::Class1::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return true;
+        }
       }
     }
-    else {
+    {
       {
-        return false;
+        {
+          return false;
+        }
       }
     }
   }
@@ -40,14 +44,18 @@ static method test2(dynamic o) → dynamic {
   #L2:
   {
     final synthesized dynamic #0#0 = o;
-    if(#C2 =={self::Class2::==}{(core::Object) → core::bool} #0#0) {
-      {
-        return true;
+    {
+      if(#C2 =={self::Class2::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return true;
+        }
       }
     }
-    else {
+    {
       {
-        return false;
+        {
+          return false;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/user_defined_equals.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/user_defined_equals.dart.strong.transformed.expect
index 99e3d8d6b04..859d88368cb 100644
--- a/pkg/front_end/testcases/patterns/user_defined_equals.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/user_defined_equals.dart.strong.transformed.expect
@@ -24,14 +24,18 @@ static method test1(dynamic o) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = o;
-    if(#C1 =={self::Class1::==}{(core::Object) → core::bool} #0#0) {
-      {
-        return true;
+    {
+      if(#C1 =={self::Class1::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return true;
+        }
       }
     }
-    else {
+    {
       {
-        return false;
+        {
+          return false;
+        }
       }
     }
   }
@@ -40,14 +44,18 @@ static method test2(dynamic o) → dynamic {
   #L2:
   {
     final synthesized dynamic #0#0 = o;
-    if(#C2 =={self::Class2::==}{(core::Object) → core::bool} #0#0) {
-      {
-        return true;
+    {
+      if(#C2 =={self::Class2::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return true;
+        }
       }
     }
-    else {
+    {
       {
-        return false;
+        {
+          return false;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/user_defined_equals.dart.weak.expect b/pkg/front_end/testcases/patterns/user_defined_equals.dart.weak.expect
index 99e3d8d6b04..859d88368cb 100644
--- a/pkg/front_end/testcases/patterns/user_defined_equals.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/user_defined_equals.dart.weak.expect
@@ -24,14 +24,18 @@ static method test1(dynamic o) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = o;
-    if(#C1 =={self::Class1::==}{(core::Object) → core::bool} #0#0) {
-      {
-        return true;
+    {
+      if(#C1 =={self::Class1::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return true;
+        }
       }
     }
-    else {
+    {
       {
-        return false;
+        {
+          return false;
+        }
       }
     }
   }
@@ -40,14 +44,18 @@ static method test2(dynamic o) → dynamic {
   #L2:
   {
     final synthesized dynamic #0#0 = o;
-    if(#C2 =={self::Class2::==}{(core::Object) → core::bool} #0#0) {
-      {
-        return true;
+    {
+      if(#C2 =={self::Class2::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return true;
+        }
       }
     }
-    else {
+    {
       {
-        return false;
+        {
+          return false;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/user_defined_equals.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/user_defined_equals.dart.weak.modular.expect
index 99e3d8d6b04..859d88368cb 100644
--- a/pkg/front_end/testcases/patterns/user_defined_equals.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/user_defined_equals.dart.weak.modular.expect
@@ -24,14 +24,18 @@ static method test1(dynamic o) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = o;
-    if(#C1 =={self::Class1::==}{(core::Object) → core::bool} #0#0) {
-      {
-        return true;
+    {
+      if(#C1 =={self::Class1::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return true;
+        }
       }
     }
-    else {
+    {
       {
-        return false;
+        {
+          return false;
+        }
       }
     }
   }
@@ -40,14 +44,18 @@ static method test2(dynamic o) → dynamic {
   #L2:
   {
     final synthesized dynamic #0#0 = o;
-    if(#C2 =={self::Class2::==}{(core::Object) → core::bool} #0#0) {
-      {
-        return true;
+    {
+      if(#C2 =={self::Class2::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return true;
+        }
       }
     }
-    else {
+    {
       {
-        return false;
+        {
+          return false;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/user_defined_equals.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/user_defined_equals.dart.weak.transformed.expect
index 99e3d8d6b04..859d88368cb 100644
--- a/pkg/front_end/testcases/patterns/user_defined_equals.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/user_defined_equals.dart.weak.transformed.expect
@@ -24,14 +24,18 @@ static method test1(dynamic o) → dynamic {
   #L1:
   {
     final synthesized dynamic #0#0 = o;
-    if(#C1 =={self::Class1::==}{(core::Object) → core::bool} #0#0) {
-      {
-        return true;
+    {
+      if(#C1 =={self::Class1::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return true;
+        }
       }
     }
-    else {
+    {
       {
-        return false;
+        {
+          return false;
+        }
       }
     }
   }
@@ -40,14 +44,18 @@ static method test2(dynamic o) → dynamic {
   #L2:
   {
     final synthesized dynamic #0#0 = o;
-    if(#C2 =={self::Class2::==}{(core::Object) → core::bool} #0#0) {
-      {
-        return true;
+    {
+      if(#C2 =={self::Class2::==}{(core::Object) → core::bool} #0#0) {
+        {
+          return true;
+        }
       }
     }
-    else {
+    {
       {
-        return false;
+        {
+          return false;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/var_variable_inside_case.dart.strong.expect b/pkg/front_end/testcases/patterns/var_variable_inside_case.dart.strong.expect
index d5d5a9e6226..cc6601cf70c 100644
--- a/pkg/front_end/testcases/patterns/var_variable_inside_case.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/var_variable_inside_case.dart.strong.expect
@@ -4,11 +4,13 @@ import self as self;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    dynamic y;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = y = #0#0 in true) {
-      {
-        break #L1;
+    {
+      dynamic y;
+      if(let final dynamic #t1 = y = #0#0 in true) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/var_variable_inside_case.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/var_variable_inside_case.dart.strong.transformed.expect
index d5d5a9e6226..cc6601cf70c 100644
--- a/pkg/front_end/testcases/patterns/var_variable_inside_case.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/var_variable_inside_case.dart.strong.transformed.expect
@@ -4,11 +4,13 @@ import self as self;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    dynamic y;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = y = #0#0 in true) {
-      {
-        break #L1;
+    {
+      dynamic y;
+      if(let final dynamic #t1 = y = #0#0 in true) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/var_variable_inside_case.dart.weak.expect b/pkg/front_end/testcases/patterns/var_variable_inside_case.dart.weak.expect
index d5d5a9e6226..cc6601cf70c 100644
--- a/pkg/front_end/testcases/patterns/var_variable_inside_case.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/var_variable_inside_case.dart.weak.expect
@@ -4,11 +4,13 @@ import self as self;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    dynamic y;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = y = #0#0 in true) {
-      {
-        break #L1;
+    {
+      dynamic y;
+      if(let final dynamic #t1 = y = #0#0 in true) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/var_variable_inside_case.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/var_variable_inside_case.dart.weak.modular.expect
index d5d5a9e6226..cc6601cf70c 100644
--- a/pkg/front_end/testcases/patterns/var_variable_inside_case.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/var_variable_inside_case.dart.weak.modular.expect
@@ -4,11 +4,13 @@ import self as self;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    dynamic y;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = y = #0#0 in true) {
-      {
-        break #L1;
+    {
+      dynamic y;
+      if(let final dynamic #t1 = y = #0#0 in true) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/var_variable_inside_case.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/var_variable_inside_case.dart.weak.transformed.expect
index d5d5a9e6226..cc6601cf70c 100644
--- a/pkg/front_end/testcases/patterns/var_variable_inside_case.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/var_variable_inside_case.dart.weak.transformed.expect
@@ -4,11 +4,13 @@ import self as self;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    dynamic y;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = y = #0#0 in true) {
-      {
-        break #L1;
+    {
+      dynamic y;
+      if(let final dynamic #t1 = y = #0#0 in true) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/var_variable_inside_cast.dart.strong.expect b/pkg/front_end/testcases/patterns/var_variable_inside_cast.dart.strong.expect
index 9767872f182..7d08ea61c57 100644
--- a/pkg/front_end/testcases/patterns/var_variable_inside_cast.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/var_variable_inside_cast.dart.strong.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::Object y;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in let final dynamic #t2 = y = #0#0 as{ForNonNullableByDefault} core::Object in true) {
-      {
-        break #L1;
+    {
+      core::Object y;
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in let final dynamic #t2 = y = #0#0 as{ForNonNullableByDefault} core::Object in true) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/var_variable_inside_cast.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/var_variable_inside_cast.dart.strong.transformed.expect
index db771088e64..fcad5acfe0b 100644
--- a/pkg/front_end/testcases/patterns/var_variable_inside_cast.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/var_variable_inside_cast.dart.strong.transformed.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::Object y;
     final synthesized dynamic #0#0 = x;
-    if(let final core::Object #t1 = let dynamic #t2 = #0#0 in #t2 == null ?{core::Object} #t2 as{ForNonNullableByDefault} core::Object : #t2{core::Object} in let final core::Object #t3 = y = let dynamic #t4 = #0#0 in #t4 == null ?{core::Object} #t4 as{ForNonNullableByDefault} core::Object : #t4{core::Object} in true) {
-      {
-        break #L1;
+    {
+      core::Object y;
+      if(let final core::Object #t1 = let dynamic #t2 = #0#0 in #t2 == null ?{core::Object} #t2 as{ForNonNullableByDefault} core::Object : #t2{core::Object} in let final core::Object #t3 = y = let dynamic #t4 = #0#0 in #t4 == null ?{core::Object} #t4 as{ForNonNullableByDefault} core::Object : #t4{core::Object} in true) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/var_variable_inside_cast.dart.weak.expect b/pkg/front_end/testcases/patterns/var_variable_inside_cast.dart.weak.expect
index 9767872f182..7d08ea61c57 100644
--- a/pkg/front_end/testcases/patterns/var_variable_inside_cast.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/var_variable_inside_cast.dart.weak.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::Object y;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in let final dynamic #t2 = y = #0#0 as{ForNonNullableByDefault} core::Object in true) {
-      {
-        break #L1;
+    {
+      core::Object y;
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in let final dynamic #t2 = y = #0#0 as{ForNonNullableByDefault} core::Object in true) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/var_variable_inside_cast.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/var_variable_inside_cast.dart.weak.modular.expect
index 9767872f182..7d08ea61c57 100644
--- a/pkg/front_end/testcases/patterns/var_variable_inside_cast.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/var_variable_inside_cast.dart.weak.modular.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::Object y;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in let final dynamic #t2 = y = #0#0 as{ForNonNullableByDefault} core::Object in true) {
-      {
-        break #L1;
+    {
+      core::Object y;
+      if(let final dynamic #t1 = #0#0 as{ForNonNullableByDefault} core::Object in let final dynamic #t2 = y = #0#0 as{ForNonNullableByDefault} core::Object in true) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/var_variable_inside_cast.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/var_variable_inside_cast.dart.weak.transformed.expect
index ee895721657..9c3ca6fa233 100644
--- a/pkg/front_end/testcases/patterns/var_variable_inside_cast.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/var_variable_inside_cast.dart.weak.transformed.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    core::Object y;
     final synthesized dynamic #0#0 = x;
-    if(let final core::Object #t1 = #0#0 in let final core::Object #t2 = y = #0#0 in true) {
-      {
-        break #L1;
+    {
+      core::Object y;
+      if(let final core::Object #t1 = #0#0 in let final core::Object #t2 = y = #0#0 in true) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/var_variable_inside_null_assert.dart.strong.expect b/pkg/front_end/testcases/patterns/var_variable_inside_null_assert.dart.strong.expect
index 15a286fca90..32bbb14eaab 100644
--- a/pkg/front_end/testcases/patterns/var_variable_inside_null_assert.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/var_variable_inside_null_assert.dart.strong.expect
@@ -4,11 +4,13 @@ import self as self;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    dynamic y;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in let final dynamic #t2 = y = #0#0! in true) {
-      {
-        break #L1;
+    {
+      dynamic y;
+      if(let final dynamic #t1 = #0#0! in let final dynamic #t2 = y = #0#0! in true) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/var_variable_inside_null_assert.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/var_variable_inside_null_assert.dart.strong.transformed.expect
index 15a286fca90..32bbb14eaab 100644
--- a/pkg/front_end/testcases/patterns/var_variable_inside_null_assert.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/var_variable_inside_null_assert.dart.strong.transformed.expect
@@ -4,11 +4,13 @@ import self as self;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    dynamic y;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in let final dynamic #t2 = y = #0#0! in true) {
-      {
-        break #L1;
+    {
+      dynamic y;
+      if(let final dynamic #t1 = #0#0! in let final dynamic #t2 = y = #0#0! in true) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/var_variable_inside_null_assert.dart.weak.expect b/pkg/front_end/testcases/patterns/var_variable_inside_null_assert.dart.weak.expect
index 15a286fca90..32bbb14eaab 100644
--- a/pkg/front_end/testcases/patterns/var_variable_inside_null_assert.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/var_variable_inside_null_assert.dart.weak.expect
@@ -4,11 +4,13 @@ import self as self;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    dynamic y;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in let final dynamic #t2 = y = #0#0! in true) {
-      {
-        break #L1;
+    {
+      dynamic y;
+      if(let final dynamic #t1 = #0#0! in let final dynamic #t2 = y = #0#0! in true) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/var_variable_inside_null_assert.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/var_variable_inside_null_assert.dart.weak.modular.expect
index 15a286fca90..32bbb14eaab 100644
--- a/pkg/front_end/testcases/patterns/var_variable_inside_null_assert.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/var_variable_inside_null_assert.dart.weak.modular.expect
@@ -4,11 +4,13 @@ import self as self;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    dynamic y;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in let final dynamic #t2 = y = #0#0! in true) {
-      {
-        break #L1;
+    {
+      dynamic y;
+      if(let final dynamic #t1 = #0#0! in let final dynamic #t2 = y = #0#0! in true) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/var_variable_inside_null_assert.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/var_variable_inside_null_assert.dart.weak.transformed.expect
index 15a286fca90..32bbb14eaab 100644
--- a/pkg/front_end/testcases/patterns/var_variable_inside_null_assert.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/var_variable_inside_null_assert.dart.weak.transformed.expect
@@ -4,11 +4,13 @@ import self as self;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    dynamic y;
     final synthesized dynamic #0#0 = x;
-    if(let final dynamic #t1 = #0#0! in let final dynamic #t2 = y = #0#0! in true) {
-      {
-        break #L1;
+    {
+      dynamic y;
+      if(let final dynamic #t1 = #0#0! in let final dynamic #t2 = y = #0#0! in true) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/var_variable_inside_null_check.dart.strong.expect b/pkg/front_end/testcases/patterns/var_variable_inside_null_check.dart.strong.expect
index 760af0528f5..2e240b5c9c1 100644
--- a/pkg/front_end/testcases/patterns/var_variable_inside_null_check.dart.strong.expect
+++ b/pkg/front_end/testcases/patterns/var_variable_inside_null_check.dart.strong.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    dynamic y;
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} let final dynamic #t1 = y = #0#0 in true : false) {
-      {
-        break #L1;
+    {
+      dynamic y;
+      if(!(#0#0 == null) ?{core::bool} let final dynamic #t1 = y = #0#0 in true : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/var_variable_inside_null_check.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/var_variable_inside_null_check.dart.strong.transformed.expect
index 760af0528f5..2e240b5c9c1 100644
--- a/pkg/front_end/testcases/patterns/var_variable_inside_null_check.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/patterns/var_variable_inside_null_check.dart.strong.transformed.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    dynamic y;
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} let final dynamic #t1 = y = #0#0 in true : false) {
-      {
-        break #L1;
+    {
+      dynamic y;
+      if(!(#0#0 == null) ?{core::bool} let final dynamic #t1 = y = #0#0 in true : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/var_variable_inside_null_check.dart.weak.expect b/pkg/front_end/testcases/patterns/var_variable_inside_null_check.dart.weak.expect
index 760af0528f5..2e240b5c9c1 100644
--- a/pkg/front_end/testcases/patterns/var_variable_inside_null_check.dart.weak.expect
+++ b/pkg/front_end/testcases/patterns/var_variable_inside_null_check.dart.weak.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    dynamic y;
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} let final dynamic #t1 = y = #0#0 in true : false) {
-      {
-        break #L1;
+    {
+      dynamic y;
+      if(!(#0#0 == null) ?{core::bool} let final dynamic #t1 = y = #0#0 in true : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/var_variable_inside_null_check.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/var_variable_inside_null_check.dart.weak.modular.expect
index 760af0528f5..2e240b5c9c1 100644
--- a/pkg/front_end/testcases/patterns/var_variable_inside_null_check.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/patterns/var_variable_inside_null_check.dart.weak.modular.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    dynamic y;
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} let final dynamic #t1 = y = #0#0 in true : false) {
-      {
-        break #L1;
+    {
+      dynamic y;
+      if(!(#0#0 == null) ?{core::bool} let final dynamic #t1 = y = #0#0 in true : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/patterns/var_variable_inside_null_check.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/var_variable_inside_null_check.dart.weak.transformed.expect
index 760af0528f5..2e240b5c9c1 100644
--- a/pkg/front_end/testcases/patterns/var_variable_inside_null_check.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/patterns/var_variable_inside_null_check.dart.weak.transformed.expect
@@ -5,11 +5,13 @@ import "dart:core" as core;
 static method test(dynamic x) → dynamic {
   #L1:
   {
-    dynamic y;
     final synthesized dynamic #0#0 = x;
-    if(!(#0#0 == null) ?{core::bool} let final dynamic #t1 = y = #0#0 in true : false) {
-      {
-        break #L1;
+    {
+      dynamic y;
+      if(!(#0#0 == null) ?{core::bool} let final dynamic #t1 = y = #0#0 in true : false) {
+        {
+          break #L1;
+        }
       }
     }
   }
diff --git a/pkg/front_end/testcases/records/block_combine_statements.dart.strong.expect b/pkg/front_end/testcases/records/block_combine_statements.dart.strong.expect
index ddf1a5d7dbb..d616c244c33 100644
--- a/pkg/front_end/testcases/records/block_combine_statements.dart.strong.expect
+++ b/pkg/front_end/testcases/records/block_combine_statements.dart.strong.expect
@@ -10,28 +10,38 @@ static method main() → void {
 static method split<A extends core::Object? = dynamic>(core::Iterable<self::split::A%> it) → core::Iterable<(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)>
   return block {
     core::Iterable<(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)> #t1;
-    self::split::A% x;
     final synthesized core::Iterable<self::split::A%> #1#0 = it;
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #1#0.{core::Iterable::isEmpty}{core::bool})
-      #t1 = <(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)>[(new _in::EmptyIterable::•<self::split::A%>(), new _in::EmptyIterable::•<self::split::A%>())];
-    else
-      if(let final dynamic #t2 = x = #1#0.{core::Iterable::first}{self::split::A%} in true)
-        #t1 = (() → core::Iterable<(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)> sync* {
-          yield(new _in::EmptyIterable::•<self::split::A%>(), it);
-          for (final(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>) #t3 in self::split<self::split::A%>(it.{core::Iterable::skip}(1){(core::int) → core::Iterable<self::split::A%>})) {
-            core::Iterable<self::split::A%> ls;
-            core::Iterable<self::split::A%> rs;
-            {
-              final synthesized dynamic #0#0 = #t3;
-              if(!((let final dynamic #t4 = ls = #0#0{(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)}.$1{core::Iterable<self::split::A%>} in true) && (let final dynamic #t5 = rs = #0#0{(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)}.$2{core::Iterable<self::split::A%>} in true)))
-                throw new _in::ReachabilityError::•();
+    #L1:
+    {
+      {
+        if(#C1 =={core::Object::==}{(core::Object) → core::bool} #1#0.{core::Iterable::isEmpty}{core::bool}) {
+          #t1 = <(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)>[(new _in::EmptyIterable::•<self::split::A%>(), new _in::EmptyIterable::•<self::split::A%>())];
+          break #L1;
+        }
+      }
+      {
+        self::split::A% x;
+        if(let final dynamic #t2 = x = #1#0.{core::Iterable::first}{self::split::A%} in true) {
+          #t1 = (() → core::Iterable<(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)> sync* {
+            yield(new _in::EmptyIterable::•<self::split::A%>(), it);
+            for (final(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>) #t3 in self::split<self::split::A%>(it.{core::Iterable::skip}(1){(core::int) → core::Iterable<self::split::A%>})) {
+              core::Iterable<self::split::A%> ls;
+              core::Iterable<self::split::A%> rs;
+              {
+                final synthesized dynamic #0#0 = #t3;
+                if(!((let final dynamic #t4 = ls = #0#0{(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)}.$1{core::Iterable<self::split::A%>} in true) && (let final dynamic #t5 = rs = #0#0{(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)}.$2{core::Iterable<self::split::A%>} in true)))
+                  throw new _in::ReachabilityError::•();
+              }
+              yield( block {
+                final core::List<self::split::A%> #t6 = <self::split::A%>[x];
+                #t6.{core::List::addAll}{Invariant}(ls){(core::Iterable<self::split::A%>) → void};
+              } =>#t6, rs);
             }
-            yield( block {
-              final core::List<self::split::A%> #t6 = <self::split::A%>[x];
-              #t6.{core::List::addAll}{Invariant}(ls){(core::Iterable<self::split::A%>) → void};
-            } =>#t6, rs);
-          }
-        })(){() → core::Iterable<(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)>};
+          })(){() → core::Iterable<(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)>};
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
 
 constants  {
diff --git a/pkg/front_end/testcases/records/block_combine_statements.dart.strong.transformed.expect b/pkg/front_end/testcases/records/block_combine_statements.dart.strong.transformed.expect
index 5d7a26bb375..d2fd5e4dddc 100644
--- a/pkg/front_end/testcases/records/block_combine_statements.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/records/block_combine_statements.dart.strong.transformed.expect
@@ -15,34 +15,44 @@ static method main() → void {
 static method split<A extends core::Object? = dynamic>(core::Iterable<self::split::A%> it) → core::Iterable<(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)>
   return block {
     core::Iterable<(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)> #t1;
-    self::split::A% x;
     final synthesized core::Iterable<self::split::A%> #1#0 = it;
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #1#0.{core::Iterable::isEmpty}{core::bool})
-      #t1 = core::_GrowableList::_literal1<(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)>((new _in::EmptyIterable::•<self::split::A%>(), new _in::EmptyIterable::•<self::split::A%>()));
-    else
-      if(let final self::split::A% #t2 = x = #1#0.{core::Iterable::first}{self::split::A%} in true)
-        #t1 = (() → core::Iterable<(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)> sync* {
-          yield(new _in::EmptyIterable::•<self::split::A%>(), it);
-          {
-            synthesized core::Iterator<(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)> :sync-for-iterator = self::split<self::split::A%>(it.{core::Iterable::skip}(1){(core::int) → core::Iterable<self::split::A%>}).{core::Iterable::iterator}{core::Iterator<(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)>};
-            for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
-              final(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>) #t3 = :sync-for-iterator.{core::Iterator::current}{(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)};
-              {
-                core::Iterable<self::split::A%> ls;
-                core::Iterable<self::split::A%> rs;
+    #L1:
+    {
+      {
+        if(#C1 =={core::Object::==}{(core::Object) → core::bool} #1#0.{core::Iterable::isEmpty}{core::bool}) {
+          #t1 = core::_GrowableList::_literal1<(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)>((new _in::EmptyIterable::•<self::split::A%>(), new _in::EmptyIterable::•<self::split::A%>()));
+          break #L1;
+        }
+      }
+      {
+        self::split::A% x;
+        if(let final self::split::A% #t2 = x = #1#0.{core::Iterable::first}{self::split::A%} in true) {
+          #t1 = (() → core::Iterable<(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)> sync* {
+            yield(new _in::EmptyIterable::•<self::split::A%>(), it);
+            {
+              synthesized core::Iterator<(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)> :sync-for-iterator = self::split<self::split::A%>(it.{core::Iterable::skip}(1){(core::int) → core::Iterable<self::split::A%>}).{core::Iterable::iterator}{core::Iterator<(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)>};
+              for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
+                final(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>) #t3 = :sync-for-iterator.{core::Iterator::current}{(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)};
                 {
-                  final synthesized dynamic #0#0 = #t3;
-                  if(!((let final core::Iterable<self::split::A%> #t4 = ls = #0#0{(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)}.$1{core::Iterable<self::split::A%>} in true) && (let final core::Iterable<self::split::A%> #t5 = rs = #0#0{(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)}.$2{core::Iterable<self::split::A%>} in true)))
-                    throw new _in::ReachabilityError::•();
+                  core::Iterable<self::split::A%> ls;
+                  core::Iterable<self::split::A%> rs;
+                  {
+                    final synthesized dynamic #0#0 = #t3;
+                    if(!((let final core::Iterable<self::split::A%> #t4 = ls = #0#0{(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)}.$1{core::Iterable<self::split::A%>} in true) && (let final core::Iterable<self::split::A%> #t5 = rs = #0#0{(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)}.$2{core::Iterable<self::split::A%>} in true)))
+                      throw new _in::ReachabilityError::•();
+                  }
+                  yield( block {
+                    final core::List<self::split::A%> #t6 = core::_GrowableList::_literal1<self::split::A%>(x);
+                    #t6.{core::List::addAll}{Invariant}(ls){(core::Iterable<self::split::A%>) → void};
+                  } =>#t6, rs);
                 }
-                yield( block {
-                  final core::List<self::split::A%> #t6 = core::_GrowableList::_literal1<self::split::A%>(x);
-                  #t6.{core::List::addAll}{Invariant}(ls){(core::Iterable<self::split::A%>) → void};
-                } =>#t6, rs);
               }
             }
-          }
-        })(){() → core::Iterable<(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)>};
+          })(){() → core::Iterable<(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)>};
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
 
 constants  {
diff --git a/pkg/front_end/testcases/records/block_combine_statements.dart.weak.expect b/pkg/front_end/testcases/records/block_combine_statements.dart.weak.expect
index ddf1a5d7dbb..d616c244c33 100644
--- a/pkg/front_end/testcases/records/block_combine_statements.dart.weak.expect
+++ b/pkg/front_end/testcases/records/block_combine_statements.dart.weak.expect
@@ -10,28 +10,38 @@ static method main() → void {
 static method split<A extends core::Object? = dynamic>(core::Iterable<self::split::A%> it) → core::Iterable<(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)>
   return block {
     core::Iterable<(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)> #t1;
-    self::split::A% x;
     final synthesized core::Iterable<self::split::A%> #1#0 = it;
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #1#0.{core::Iterable::isEmpty}{core::bool})
-      #t1 = <(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)>[(new _in::EmptyIterable::•<self::split::A%>(), new _in::EmptyIterable::•<self::split::A%>())];
-    else
-      if(let final dynamic #t2 = x = #1#0.{core::Iterable::first}{self::split::A%} in true)
-        #t1 = (() → core::Iterable<(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)> sync* {
-          yield(new _in::EmptyIterable::•<self::split::A%>(), it);
-          for (final(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>) #t3 in self::split<self::split::A%>(it.{core::Iterable::skip}(1){(core::int) → core::Iterable<self::split::A%>})) {
-            core::Iterable<self::split::A%> ls;
-            core::Iterable<self::split::A%> rs;
-            {
-              final synthesized dynamic #0#0 = #t3;
-              if(!((let final dynamic #t4 = ls = #0#0{(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)}.$1{core::Iterable<self::split::A%>} in true) && (let final dynamic #t5 = rs = #0#0{(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)}.$2{core::Iterable<self::split::A%>} in true)))
-                throw new _in::ReachabilityError::•();
+    #L1:
+    {
+      {
+        if(#C1 =={core::Object::==}{(core::Object) → core::bool} #1#0.{core::Iterable::isEmpty}{core::bool}) {
+          #t1 = <(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)>[(new _in::EmptyIterable::•<self::split::A%>(), new _in::EmptyIterable::•<self::split::A%>())];
+          break #L1;
+        }
+      }
+      {
+        self::split::A% x;
+        if(let final dynamic #t2 = x = #1#0.{core::Iterable::first}{self::split::A%} in true) {
+          #t1 = (() → core::Iterable<(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)> sync* {
+            yield(new _in::EmptyIterable::•<self::split::A%>(), it);
+            for (final(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>) #t3 in self::split<self::split::A%>(it.{core::Iterable::skip}(1){(core::int) → core::Iterable<self::split::A%>})) {
+              core::Iterable<self::split::A%> ls;
+              core::Iterable<self::split::A%> rs;
+              {
+                final synthesized dynamic #0#0 = #t3;
+                if(!((let final dynamic #t4 = ls = #0#0{(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)}.$1{core::Iterable<self::split::A%>} in true) && (let final dynamic #t5 = rs = #0#0{(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)}.$2{core::Iterable<self::split::A%>} in true)))
+                  throw new _in::ReachabilityError::•();
+              }
+              yield( block {
+                final core::List<self::split::A%> #t6 = <self::split::A%>[x];
+                #t6.{core::List::addAll}{Invariant}(ls){(core::Iterable<self::split::A%>) → void};
+              } =>#t6, rs);
             }
-            yield( block {
-              final core::List<self::split::A%> #t6 = <self::split::A%>[x];
-              #t6.{core::List::addAll}{Invariant}(ls){(core::Iterable<self::split::A%>) → void};
-            } =>#t6, rs);
-          }
-        })(){() → core::Iterable<(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)>};
+          })(){() → core::Iterable<(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)>};
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
 
 constants  {
diff --git a/pkg/front_end/testcases/records/block_combine_statements.dart.weak.modular.expect b/pkg/front_end/testcases/records/block_combine_statements.dart.weak.modular.expect
index ddf1a5d7dbb..d616c244c33 100644
--- a/pkg/front_end/testcases/records/block_combine_statements.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/records/block_combine_statements.dart.weak.modular.expect
@@ -10,28 +10,38 @@ static method main() → void {
 static method split<A extends core::Object? = dynamic>(core::Iterable<self::split::A%> it) → core::Iterable<(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)>
   return block {
     core::Iterable<(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)> #t1;
-    self::split::A% x;
     final synthesized core::Iterable<self::split::A%> #1#0 = it;
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #1#0.{core::Iterable::isEmpty}{core::bool})
-      #t1 = <(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)>[(new _in::EmptyIterable::•<self::split::A%>(), new _in::EmptyIterable::•<self::split::A%>())];
-    else
-      if(let final dynamic #t2 = x = #1#0.{core::Iterable::first}{self::split::A%} in true)
-        #t1 = (() → core::Iterable<(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)> sync* {
-          yield(new _in::EmptyIterable::•<self::split::A%>(), it);
-          for (final(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>) #t3 in self::split<self::split::A%>(it.{core::Iterable::skip}(1){(core::int) → core::Iterable<self::split::A%>})) {
-            core::Iterable<self::split::A%> ls;
-            core::Iterable<self::split::A%> rs;
-            {
-              final synthesized dynamic #0#0 = #t3;
-              if(!((let final dynamic #t4 = ls = #0#0{(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)}.$1{core::Iterable<self::split::A%>} in true) && (let final dynamic #t5 = rs = #0#0{(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)}.$2{core::Iterable<self::split::A%>} in true)))
-                throw new _in::ReachabilityError::•();
+    #L1:
+    {
+      {
+        if(#C1 =={core::Object::==}{(core::Object) → core::bool} #1#0.{core::Iterable::isEmpty}{core::bool}) {
+          #t1 = <(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)>[(new _in::EmptyIterable::•<self::split::A%>(), new _in::EmptyIterable::•<self::split::A%>())];
+          break #L1;
+        }
+      }
+      {
+        self::split::A% x;
+        if(let final dynamic #t2 = x = #1#0.{core::Iterable::first}{self::split::A%} in true) {
+          #t1 = (() → core::Iterable<(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)> sync* {
+            yield(new _in::EmptyIterable::•<self::split::A%>(), it);
+            for (final(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>) #t3 in self::split<self::split::A%>(it.{core::Iterable::skip}(1){(core::int) → core::Iterable<self::split::A%>})) {
+              core::Iterable<self::split::A%> ls;
+              core::Iterable<self::split::A%> rs;
+              {
+                final synthesized dynamic #0#0 = #t3;
+                if(!((let final dynamic #t4 = ls = #0#0{(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)}.$1{core::Iterable<self::split::A%>} in true) && (let final dynamic #t5 = rs = #0#0{(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)}.$2{core::Iterable<self::split::A%>} in true)))
+                  throw new _in::ReachabilityError::•();
+              }
+              yield( block {
+                final core::List<self::split::A%> #t6 = <self::split::A%>[x];
+                #t6.{core::List::addAll}{Invariant}(ls){(core::Iterable<self::split::A%>) → void};
+              } =>#t6, rs);
             }
-            yield( block {
-              final core::List<self::split::A%> #t6 = <self::split::A%>[x];
-              #t6.{core::List::addAll}{Invariant}(ls){(core::Iterable<self::split::A%>) → void};
-            } =>#t6, rs);
-          }
-        })(){() → core::Iterable<(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)>};
+          })(){() → core::Iterable<(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)>};
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
 
 constants  {
diff --git a/pkg/front_end/testcases/records/block_combine_statements.dart.weak.transformed.expect b/pkg/front_end/testcases/records/block_combine_statements.dart.weak.transformed.expect
index 5d7a26bb375..d2fd5e4dddc 100644
--- a/pkg/front_end/testcases/records/block_combine_statements.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/records/block_combine_statements.dart.weak.transformed.expect
@@ -15,34 +15,44 @@ static method main() → void {
 static method split<A extends core::Object? = dynamic>(core::Iterable<self::split::A%> it) → core::Iterable<(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)>
   return block {
     core::Iterable<(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)> #t1;
-    self::split::A% x;
     final synthesized core::Iterable<self::split::A%> #1#0 = it;
-    if(#C1 =={core::Object::==}{(core::Object) → core::bool} #1#0.{core::Iterable::isEmpty}{core::bool})
-      #t1 = core::_GrowableList::_literal1<(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)>((new _in::EmptyIterable::•<self::split::A%>(), new _in::EmptyIterable::•<self::split::A%>()));
-    else
-      if(let final self::split::A% #t2 = x = #1#0.{core::Iterable::first}{self::split::A%} in true)
-        #t1 = (() → core::Iterable<(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)> sync* {
-          yield(new _in::EmptyIterable::•<self::split::A%>(), it);
-          {
-            synthesized core::Iterator<(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)> :sync-for-iterator = self::split<self::split::A%>(it.{core::Iterable::skip}(1){(core::int) → core::Iterable<self::split::A%>}).{core::Iterable::iterator}{core::Iterator<(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)>};
-            for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
-              final(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>) #t3 = :sync-for-iterator.{core::Iterator::current}{(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)};
-              {
-                core::Iterable<self::split::A%> ls;
-                core::Iterable<self::split::A%> rs;
+    #L1:
+    {
+      {
+        if(#C1 =={core::Object::==}{(core::Object) → core::bool} #1#0.{core::Iterable::isEmpty}{core::bool}) {
+          #t1 = core::_GrowableList::_literal1<(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)>((new _in::EmptyIterable::•<self::split::A%>(), new _in::EmptyIterable::•<self::split::A%>()));
+          break #L1;
+        }
+      }
+      {
+        self::split::A% x;
+        if(let final self::split::A% #t2 = x = #1#0.{core::Iterable::first}{self::split::A%} in true) {
+          #t1 = (() → core::Iterable<(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)> sync* {
+            yield(new _in::EmptyIterable::•<self::split::A%>(), it);
+            {
+              synthesized core::Iterator<(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)> :sync-for-iterator = self::split<self::split::A%>(it.{core::Iterable::skip}(1){(core::int) → core::Iterable<self::split::A%>}).{core::Iterable::iterator}{core::Iterator<(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)>};
+              for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
+                final(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>) #t3 = :sync-for-iterator.{core::Iterator::current}{(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)};
                 {
-                  final synthesized dynamic #0#0 = #t3;
-                  if(!((let final core::Iterable<self::split::A%> #t4 = ls = #0#0{(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)}.$1{core::Iterable<self::split::A%>} in true) && (let final core::Iterable<self::split::A%> #t5 = rs = #0#0{(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)}.$2{core::Iterable<self::split::A%>} in true)))
-                    throw new _in::ReachabilityError::•();
+                  core::Iterable<self::split::A%> ls;
+                  core::Iterable<self::split::A%> rs;
+                  {
+                    final synthesized dynamic #0#0 = #t3;
+                    if(!((let final core::Iterable<self::split::A%> #t4 = ls = #0#0{(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)}.$1{core::Iterable<self::split::A%>} in true) && (let final core::Iterable<self::split::A%> #t5 = rs = #0#0{(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)}.$2{core::Iterable<self::split::A%>} in true)))
+                      throw new _in::ReachabilityError::•();
+                  }
+                  yield( block {
+                    final core::List<self::split::A%> #t6 = core::_GrowableList::_literal1<self::split::A%>(x);
+                    #t6.{core::List::addAll}{Invariant}(ls){(core::Iterable<self::split::A%>) → void};
+                  } =>#t6, rs);
                 }
-                yield( block {
-                  final core::List<self::split::A%> #t6 = core::_GrowableList::_literal1<self::split::A%>(x);
-                  #t6.{core::List::addAll}{Invariant}(ls){(core::Iterable<self::split::A%>) → void};
-                } =>#t6, rs);
               }
             }
-          }
-        })(){() → core::Iterable<(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)>};
+          })(){() → core::Iterable<(core::Iterable<self::split::A%>, core::Iterable<self::split::A%>)>};
+          break #L1;
+        }
+      }
+    }
   } =>#t1;
 
 constants  {
diff --git a/pkg/front_end/testcases/regress/issue_39040.dart.strong.expect b/pkg/front_end/testcases/regress/issue_39040.dart.strong.expect
index d4d4f2ddf1c..ded3e22cb2c 100644
--- a/pkg/front_end/testcases/regress/issue_39040.dart.strong.expect
+++ b/pkg/front_end/testcases/regress/issue_39040.dart.strong.expect
@@ -7,47 +7,32 @@ static method main() → void {
   core::int outer = 1;
   core::int inner = 0;
   #L1:
-  {
-    final synthesized core::int #1#0 = outer;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #1#0) {
+  switch(outer) {
+    #L2:
+    case #C1:
       {
         whereWasI.{core::List::add}("outer 0"){(core::String) → void};
         break #L1;
       }
-    }
-    else
-      if(#C2 =={core::num::==}{(core::Object) → core::bool} #1#0) {
-        {
-          (() → Null {
-            #L2:
-            {
-              core::int #t1 = -1;
-              final synthesized core::int #0#0 = inner;
-              if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0)
-                #t1 = 0;
-              else
-                if(#C2 =={core::num::==}{(core::Object) → core::bool} #0#0)
-                  #t1 = 1;
-              switch(#t1) {
-                #L3:
-                case #C1:
-                  {
-                    {
-                      whereWasI.{core::List::add}("inner 0"){(core::String) → void};
-                      continue #L4;
-                    }
-                  }
-                #L4:
-                case #C2:
-                  {
-                    {
-                      whereWasI.{core::List::add}("inner 1"){(core::String) → void};
-                    }
-                  }
+    #L3:
+    case #C2:
+      {
+        (() → Null {
+          #L4:
+          switch(inner) {
+            #L5:
+            case #C1:
+              {
+                whereWasI.{core::List::add}("inner 0"){(core::String) → void};
+                continue #L6;
               }
-            }
-          })(){() → Null};
-        }
+            #L6:
+            case #C2:
+              {
+                whereWasI.{core::List::add}("inner 1"){(core::String) → void};
+              }
+          }
+        })(){() → Null};
       }
   }
   if(!(whereWasI.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} 2) || !(whereWasI.{core::List::[]}(0){(core::int) → core::String} =={core::String::==}{(core::Object) → core::bool} "inner 0") || !(whereWasI.{core::List::[]}(1){(core::int) → core::String} =={core::String::==}{(core::Object) → core::bool} "inner 1")) {
diff --git a/pkg/front_end/testcases/regress/issue_39040.dart.strong.transformed.expect b/pkg/front_end/testcases/regress/issue_39040.dart.strong.transformed.expect
index b9139224716..0491217f01b 100644
--- a/pkg/front_end/testcases/regress/issue_39040.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/regress/issue_39040.dart.strong.transformed.expect
@@ -7,47 +7,32 @@ static method main() → void {
   core::int outer = 1;
   core::int inner = 0;
   #L1:
-  {
-    final synthesized core::int #1#0 = outer;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #1#0) {
+  switch(outer) {
+    #L2:
+    case #C1:
       {
         whereWasI.{core::List::add}("outer 0"){(core::String) → void};
         break #L1;
       }
-    }
-    else
-      if(#C2 =={core::num::==}{(core::Object) → core::bool} #1#0) {
-        {
-          (() → Null {
-            #L2:
-            {
-              core::int #t1 = -1;
-              final synthesized core::int #0#0 = inner;
-              if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0)
-                #t1 = 0;
-              else
-                if(#C2 =={core::num::==}{(core::Object) → core::bool} #0#0)
-                  #t1 = 1;
-              switch(#t1) {
-                #L3:
-                case #C1:
-                  {
-                    {
-                      whereWasI.{core::List::add}("inner 0"){(core::String) → void};
-                      continue #L4;
-                    }
-                  }
-                #L4:
-                case #C2:
-                  {
-                    {
-                      whereWasI.{core::List::add}("inner 1"){(core::String) → void};
-                    }
-                  }
+    #L3:
+    case #C2:
+      {
+        (() → Null {
+          #L4:
+          switch(inner) {
+            #L5:
+            case #C1:
+              {
+                whereWasI.{core::List::add}("inner 0"){(core::String) → void};
+                continue #L6;
               }
-            }
-          })(){() → Null};
-        }
+            #L6:
+            case #C2:
+              {
+                whereWasI.{core::List::add}("inner 1"){(core::String) → void};
+              }
+          }
+        })(){() → Null};
       }
   }
   if(!(whereWasI.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} 2) || !(whereWasI.{core::List::[]}(0){(core::int) → core::String} =={core::String::==}{(core::Object) → core::bool} "inner 0") || !(whereWasI.{core::List::[]}(1){(core::int) → core::String} =={core::String::==}{(core::Object) → core::bool} "inner 1")) {
diff --git a/pkg/front_end/testcases/regress/issue_39040.dart.weak.expect b/pkg/front_end/testcases/regress/issue_39040.dart.weak.expect
index d4d4f2ddf1c..ded3e22cb2c 100644
--- a/pkg/front_end/testcases/regress/issue_39040.dart.weak.expect
+++ b/pkg/front_end/testcases/regress/issue_39040.dart.weak.expect
@@ -7,47 +7,32 @@ static method main() → void {
   core::int outer = 1;
   core::int inner = 0;
   #L1:
-  {
-    final synthesized core::int #1#0 = outer;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #1#0) {
+  switch(outer) {
+    #L2:
+    case #C1:
       {
         whereWasI.{core::List::add}("outer 0"){(core::String) → void};
         break #L1;
       }
-    }
-    else
-      if(#C2 =={core::num::==}{(core::Object) → core::bool} #1#0) {
-        {
-          (() → Null {
-            #L2:
-            {
-              core::int #t1 = -1;
-              final synthesized core::int #0#0 = inner;
-              if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0)
-                #t1 = 0;
-              else
-                if(#C2 =={core::num::==}{(core::Object) → core::bool} #0#0)
-                  #t1 = 1;
-              switch(#t1) {
-                #L3:
-                case #C1:
-                  {
-                    {
-                      whereWasI.{core::List::add}("inner 0"){(core::String) → void};
-                      continue #L4;
-                    }
-                  }
-                #L4:
-                case #C2:
-                  {
-                    {
-                      whereWasI.{core::List::add}("inner 1"){(core::String) → void};
-                    }
-                  }
+    #L3:
+    case #C2:
+      {
+        (() → Null {
+          #L4:
+          switch(inner) {
+            #L5:
+            case #C1:
+              {
+                whereWasI.{core::List::add}("inner 0"){(core::String) → void};
+                continue #L6;
               }
-            }
-          })(){() → Null};
-        }
+            #L6:
+            case #C2:
+              {
+                whereWasI.{core::List::add}("inner 1"){(core::String) → void};
+              }
+          }
+        })(){() → Null};
       }
   }
   if(!(whereWasI.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} 2) || !(whereWasI.{core::List::[]}(0){(core::int) → core::String} =={core::String::==}{(core::Object) → core::bool} "inner 0") || !(whereWasI.{core::List::[]}(1){(core::int) → core::String} =={core::String::==}{(core::Object) → core::bool} "inner 1")) {
diff --git a/pkg/front_end/testcases/regress/issue_39040.dart.weak.modular.expect b/pkg/front_end/testcases/regress/issue_39040.dart.weak.modular.expect
index d4d4f2ddf1c..ded3e22cb2c 100644
--- a/pkg/front_end/testcases/regress/issue_39040.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/regress/issue_39040.dart.weak.modular.expect
@@ -7,47 +7,32 @@ static method main() → void {
   core::int outer = 1;
   core::int inner = 0;
   #L1:
-  {
-    final synthesized core::int #1#0 = outer;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #1#0) {
+  switch(outer) {
+    #L2:
+    case #C1:
       {
         whereWasI.{core::List::add}("outer 0"){(core::String) → void};
         break #L1;
       }
-    }
-    else
-      if(#C2 =={core::num::==}{(core::Object) → core::bool} #1#0) {
-        {
-          (() → Null {
-            #L2:
-            {
-              core::int #t1 = -1;
-              final synthesized core::int #0#0 = inner;
-              if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0)
-                #t1 = 0;
-              else
-                if(#C2 =={core::num::==}{(core::Object) → core::bool} #0#0)
-                  #t1 = 1;
-              switch(#t1) {
-                #L3:
-                case #C1:
-                  {
-                    {
-                      whereWasI.{core::List::add}("inner 0"){(core::String) → void};
-                      continue #L4;
-                    }
-                  }
-                #L4:
-                case #C2:
-                  {
-                    {
-                      whereWasI.{core::List::add}("inner 1"){(core::String) → void};
-                    }
-                  }
+    #L3:
+    case #C2:
+      {
+        (() → Null {
+          #L4:
+          switch(inner) {
+            #L5:
+            case #C1:
+              {
+                whereWasI.{core::List::add}("inner 0"){(core::String) → void};
+                continue #L6;
               }
-            }
-          })(){() → Null};
-        }
+            #L6:
+            case #C2:
+              {
+                whereWasI.{core::List::add}("inner 1"){(core::String) → void};
+              }
+          }
+        })(){() → Null};
       }
   }
   if(!(whereWasI.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} 2) || !(whereWasI.{core::List::[]}(0){(core::int) → core::String} =={core::String::==}{(core::Object) → core::bool} "inner 0") || !(whereWasI.{core::List::[]}(1){(core::int) → core::String} =={core::String::==}{(core::Object) → core::bool} "inner 1")) {
diff --git a/pkg/front_end/testcases/regress/issue_39040.dart.weak.transformed.expect b/pkg/front_end/testcases/regress/issue_39040.dart.weak.transformed.expect
index b9139224716..0491217f01b 100644
--- a/pkg/front_end/testcases/regress/issue_39040.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/regress/issue_39040.dart.weak.transformed.expect
@@ -7,47 +7,32 @@ static method main() → void {
   core::int outer = 1;
   core::int inner = 0;
   #L1:
-  {
-    final synthesized core::int #1#0 = outer;
-    if(#C1 =={core::num::==}{(core::Object) → core::bool} #1#0) {
+  switch(outer) {
+    #L2:
+    case #C1:
       {
         whereWasI.{core::List::add}("outer 0"){(core::String) → void};
         break #L1;
       }
-    }
-    else
-      if(#C2 =={core::num::==}{(core::Object) → core::bool} #1#0) {
-        {
-          (() → Null {
-            #L2:
-            {
-              core::int #t1 = -1;
-              final synthesized core::int #0#0 = inner;
-              if(#C1 =={core::num::==}{(core::Object) → core::bool} #0#0)
-                #t1 = 0;
-              else
-                if(#C2 =={core::num::==}{(core::Object) → core::bool} #0#0)
-                  #t1 = 1;
-              switch(#t1) {
-                #L3:
-                case #C1:
-                  {
-                    {
-                      whereWasI.{core::List::add}("inner 0"){(core::String) → void};
-                      continue #L4;
-                    }
-                  }
-                #L4:
-                case #C2:
-                  {
-                    {
-                      whereWasI.{core::List::add}("inner 1"){(core::String) → void};
-                    }
-                  }
+    #L3:
+    case #C2:
+      {
+        (() → Null {
+          #L4:
+          switch(inner) {
+            #L5:
+            case #C1:
+              {
+                whereWasI.{core::List::add}("inner 0"){(core::String) → void};
+                continue #L6;
               }
-            }
-          })(){() → Null};
-        }
+            #L6:
+            case #C2:
+              {
+                whereWasI.{core::List::add}("inner 1"){(core::String) → void};
+              }
+          }
+        })(){() → Null};
       }
   }
   if(!(whereWasI.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} 2) || !(whereWasI.{core::List::[]}(0){(core::int) → core::String} =={core::String::==}{(core::Object) → core::bool} "inner 0") || !(whereWasI.{core::List::[]}(1){(core::int) → core::String} =={core::String::==}{(core::Object) → core::bool} "inner 1")) {
diff --git a/pkg/vm/testcases/transformations/type_flow/summary_collector/control_flow.dart.expect b/pkg/vm/testcases/transformations/type_flow/summary_collector/control_flow.dart.expect
index b90cc9bccab..55c4f2aaae3 100644
--- a/pkg/vm/testcases/transformations/type_flow/summary_collector/control_flow.dart.expect
+++ b/pkg/vm/testcases/transformations/type_flow/summary_collector/control_flow.dart.expect
@@ -248,31 +248,26 @@ RESULT: x_0
 ------------ switch1 ------------
 %selector = _Parameter #0 [_T (dart.core::int)+?]
 t1* = _Call direct [#lib::C1.] (_T (#lib::C1))
-t2* = _Call [dart.core::num.==] (_T (dart.core::int)+?, _T (dart.core::int)+?)
-t3* = _Call direct [#lib::C2.] (_T (#lib::C2))
-t4* = _Call [dart.core::num.==] (_T (dart.core::int)+?, _T (dart.core::int)+?)
-t5* = _Call direct [#lib::C3.] (_T (#lib::C3))
-x_0 = _Join [dynamic] (t5, t1)
-x_1 = _Join [dynamic] (x_0, t3)
-RESULT: x_1
+t2* = _Call direct [#lib::C2.] (_T (#lib::C2))
+t3* = _Call direct [#lib::C3.] (_T (#lib::C3))
+x_2 = _Join [dynamic] (t3, t1)
+x_3 = _Join [dynamic] (x_2, t2)
+RESULT: x_3
 ------------ switch2 ------------
 %selector = _Parameter #0 [_T (dart.core::int)+?]
 t1 = _Call direct [#lib::C1.] (_T (#lib::C1))
-t2* = _Call [dart.core::num.==] (_T (dart.core::int)+?, _T (dart.core::int)+?)
-t3* = _Call direct [#lib::C2.] (_T (#lib::C2))
-t4* = _Call direct [#lib::C3.] (_T (#lib::C3))
-x_0 = _Join [dynamic] (t4, t3)
-RESULT: x_0
+t2* = _Call direct [#lib::C2.] (_T (#lib::C2))
+t3* = _Call direct [#lib::C3.] (_T (#lib::C3))
+x_2 = _Join [dynamic] (t3, t2)
+RESULT: x_2
 ------------ switch3 ------------
 %selector = _Parameter #0 [_T (dart.core::int)+?]
 t1* = _Call direct [#lib::C1.] (_T (#lib::C1))
-t2* = _Call [dart.core::num.==] (_T (dart.core::int)+?, _T (dart.core::int)+?)
-t3* = _Call [dart.core::num.==] (_T (dart.core::int)+?, _T (dart.core::int)+?)
-t4* = _Call direct [#lib::C2.] (_T (#lib::C2))
-x_1 = _Join [dynamic] (t1, t4)
-t6 = _Call direct [#lib::foo] (x_1)
-t7* = _Call direct [#lib::C3.] (_T (#lib::C3))
-x_2 = _Join [dynamic] (t1, t7)
+t2* = _Call direct [#lib::C2.] (_T (#lib::C2))
+x_1 = _Join [dynamic] (t1, t2)
+t4 = _Call direct [#lib::foo] (x_1)
+t5* = _Call direct [#lib::C3.] (_T (#lib::C3))
+x_2 = _Join [dynamic] (t1, t5)
 RESULT: x_2
 ------------ cast1 ------------
 %x = _Parameter #0 [_T ANY?]
diff --git a/pkg/vm/testcases/transformations/type_flow/summary_collector/implicit_return_null.dart.expect b/pkg/vm/testcases/transformations/type_flow/summary_collector/implicit_return_null.dart.expect
index 47041b4060e..8b3a90946c8 100644
--- a/pkg/vm/testcases/transformations/type_flow/summary_collector/implicit_return_null.dart.expect
+++ b/pkg/vm/testcases/transformations/type_flow/summary_collector/implicit_return_null.dart.expect
@@ -73,8 +73,6 @@ RESULT: %result
 %c = _Parameter #0 [_T (dart.core::bool)+?]
 %i = _Parameter #1 [_T (dart.core::int)+?]
 t2* = _Call direct [#lib::T.] (_T (#lib::T))
-t3* = _Call [dart.core::num.==] (_T (dart.core::int)+?, _T (dart.core::int)+?)
-t4* = _Call [dart.core::num.==] (_T (dart.core::int)+?, _T (dart.core::int)+?)
 %result = _Join [dynamic] (t2, _T {}?)
 RESULT: %result
 ------------ if1 ------------