diff --git a/DEPS b/DEPS
index 90d3669..dc14ff7 100644
--- a/DEPS
+++ b/DEPS
@@ -107,7 +107,7 @@
   #     and land the review.
   #
   # For more details, see https://github.com/dart-lang/sdk/issues/30164
-  "dart_style_rev": "6f894c0ca33686122be9085f06e5b9bf6ad55262",
+  "dart_style_rev": "d7b73536a8079331c888b7da539b80e6825270ea",
 
   "dartdoc_rev" : "a39f378f8100b907e6285ac825967d764fd664ad",
   "devtools_rev" : "b9f2039239cc72ac8b26f8a5fe46123f34d53ce1",
diff --git a/pkg/analyzer/test/src/dart/resolution/extension_override_test.dart b/pkg/analyzer/test/src/dart/resolution/extension_override_test.dart
index e95fb08..cfc5917 100644
--- a/pkg/analyzer/test/src/dart/resolution/extension_override_test.dart
+++ b/pkg/analyzer/test/src/dart/resolution/extension_override_test.dart
@@ -2,11 +2,7 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-import 'package:analyzer/dart/ast/ast.dart';
-import 'package:analyzer/dart/element/element.dart';
-import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/error/codes.dart';
-import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 import 'context_collection_resolution.dart';
@@ -133,24 +129,6 @@
 }
 
 mixin ExtensionOverrideTestCases on PubPackageResolutionTest {
-  late ExtensionElement extension;
-  late ExtensionOverride extensionOverride;
-
-  void findDeclarationAndOverride(
-      {required String declarationName,
-      required String overrideSearch,
-      String? declarationUri}) {
-    if (declarationUri == null) {
-      ExtensionDeclaration declaration =
-          findNode.extensionDeclaration('extension $declarationName');
-      extension = declaration.declaredElement as ExtensionElement;
-    } else {
-      extension =
-          findElement.importFind(declarationUri).extension_(declarationName);
-    }
-    extensionOverride = findNode.extensionOverride(overrideSearch);
-  }
-
   test_call_noPrefix_noTypeArguments() async {
     await assertNoErrorsInCode('''
 class A {}
@@ -161,9 +139,65 @@
   E(a)('');
 }
 ''');
-    findDeclarationAndOverride(declarationName: 'E ', overrideSearch: 'E(a)');
-    validateOverride();
-    validateCall();
+
+    var node = findNode.functionExpressionInvocation('E(a)');
+    if (isNullSafetyEnabled) {
+      assertResolvedNodeText(node, r'''
+FunctionExpressionInvocation
+  function: ExtensionOverride
+    extensionName: SimpleIdentifier
+      token: E
+      staticElement: self::@extension::E
+      staticType: null
+    argumentList: ArgumentList
+      leftParenthesis: (
+      arguments
+        SimpleIdentifier
+          token: a
+          staticElement: a@68
+          staticType: A
+      rightParenthesis: )
+    extendedType: A
+    staticType: null
+  argumentList: ArgumentList
+    leftParenthesis: (
+    arguments
+      SimpleStringLiteral
+        literal: ''
+    rightParenthesis: )
+  staticElement: self::@extension::E::@method::call
+  staticInvokeType: int Function(String)
+  staticType: int
+''');
+    } else {
+      assertResolvedNodeText(node, r'''
+FunctionExpressionInvocation
+  function: ExtensionOverride
+    extensionName: SimpleIdentifier
+      token: E
+      staticElement: self::@extension::E
+      staticType: null
+    argumentList: ArgumentList
+      leftParenthesis: (
+      arguments
+        SimpleIdentifier
+          token: a
+          staticElement: a@68
+          staticType: A*
+      rightParenthesis: )
+    extendedType: A*
+    staticType: null
+  argumentList: ArgumentList
+    leftParenthesis: (
+    arguments
+      SimpleStringLiteral
+        literal: ''
+    rightParenthesis: )
+  staticElement: self::@extension::E::@method::call
+  staticInvokeType: int* Function(String*)*
+  staticType: int*
+''');
+    }
   }
 
   test_call_noPrefix_typeArguments() async {
@@ -177,9 +211,93 @@
   E<String>(a)('');
 }
 ''');
-    findDeclarationAndOverride(declarationName: 'E<T>', overrideSearch: 'E<S');
-    validateOverride(typeArguments: [stringType]);
-    validateCall();
+
+    var node = findNode.functionExpressionInvocation('(a)');
+    if (isNullSafetyEnabled) {
+      assertResolvedNodeText(node, r'''
+FunctionExpressionInvocation
+  function: ExtensionOverride
+    extensionName: SimpleIdentifier
+      token: E
+      staticElement: self::@extension::E
+      staticType: null
+    typeArguments: TypeArgumentList
+      leftBracket: <
+      arguments
+        NamedType
+          name: SimpleIdentifier
+            token: String
+            staticElement: dart:core::@class::String
+            staticType: null
+          type: String
+      rightBracket: >
+    argumentList: ArgumentList
+      leftParenthesis: (
+      arguments
+        SimpleIdentifier
+          token: a
+          staticElement: a@66
+          staticType: A
+      rightParenthesis: )
+    extendedType: A
+    staticType: null
+    typeArgumentTypes
+      String
+  argumentList: ArgumentList
+    leftParenthesis: (
+    arguments
+      SimpleStringLiteral
+        literal: ''
+    rightParenthesis: )
+  staticElement: MethodMember
+    base: self::@extension::E::@method::call
+    substitution: {T: String}
+  staticInvokeType: int Function(String)
+  staticType: int
+''');
+    } else {
+      assertResolvedNodeText(node, r'''
+FunctionExpressionInvocation
+  function: ExtensionOverride
+    extensionName: SimpleIdentifier
+      token: E
+      staticElement: self::@extension::E
+      staticType: null
+    typeArguments: TypeArgumentList
+      leftBracket: <
+      arguments
+        NamedType
+          name: SimpleIdentifier
+            token: String
+            staticElement: dart:core::@class::String
+            staticType: null
+          type: String*
+      rightBracket: >
+    argumentList: ArgumentList
+      leftParenthesis: (
+      arguments
+        SimpleIdentifier
+          token: a
+          staticElement: a@66
+          staticType: A*
+      rightParenthesis: )
+    extendedType: A*
+    staticType: null
+    typeArgumentTypes
+      String*
+  argumentList: ArgumentList
+    leftParenthesis: (
+    arguments
+      SimpleStringLiteral
+        literal: ''
+    rightParenthesis: )
+  staticElement: MethodMember
+    base: self::@extension::E::@method::call
+    substitution: {T: String*}
+  staticInvokeType: int* Function(String*)*
+  staticType: int*
+''');
+    }
   }
 
   test_call_prefix_noTypeArguments() async {
@@ -195,12 +313,81 @@
   p.E(a)('');
 }
 ''');
-    findDeclarationAndOverride(
-        declarationName: 'E',
-        declarationUri: 'package:test/lib.dart',
-        overrideSearch: 'E(a)');
-    validateOverride();
-    validateCall();
+
+    var node = findNode.functionExpressionInvocation('E(a)');
+    if (isNullSafetyEnabled) {
+      assertResolvedNodeText(node, r'''
+FunctionExpressionInvocation
+  function: ExtensionOverride
+    extensionName: PrefixedIdentifier
+      prefix: SimpleIdentifier
+        token: p
+        staticElement: self::@prefix::p
+        staticType: null
+      period: .
+      identifier: SimpleIdentifier
+        token: E
+        staticElement: package:test/lib.dart::@extension::E
+        staticType: null
+      staticElement: package:test/lib.dart::@extension::E
+      staticType: null
+    argumentList: ArgumentList
+      leftParenthesis: (
+      arguments
+        SimpleIdentifier
+          token: a
+          staticElement: a@35
+          staticType: A
+      rightParenthesis: )
+    extendedType: A
+    staticType: null
+  argumentList: ArgumentList
+    leftParenthesis: (
+    arguments
+      SimpleStringLiteral
+        literal: ''
+    rightParenthesis: )
+  staticElement: package:test/lib.dart::@extension::E::@method::call
+  staticInvokeType: int Function(String)
+  staticType: int
+''');
+    } else {
+      assertResolvedNodeText(node, r'''
+FunctionExpressionInvocation
+  function: ExtensionOverride
+    extensionName: PrefixedIdentifier
+      prefix: SimpleIdentifier
+        token: p
+        staticElement: self::@prefix::p
+        staticType: null
+      period: .
+      identifier: SimpleIdentifier
+        token: E
+        staticElement: package:test/lib.dart::@extension::E
+        staticType: null
+      staticElement: package:test/lib.dart::@extension::E
+      staticType: null
+    argumentList: ArgumentList
+      leftParenthesis: (
+      arguments
+        SimpleIdentifier
+          token: a
+          staticElement: a@35
+          staticType: A*
+      rightParenthesis: )
+    extendedType: A*
+    staticType: null
+  argumentList: ArgumentList
+    leftParenthesis: (
+    arguments
+      SimpleStringLiteral
+        literal: ''
+    rightParenthesis: )
+  staticElement: package:test/lib.dart::@extension::E::@method::call
+  staticInvokeType: int* Function(String*)*
+  staticType: int*
+''');
+    }
   }
 
   test_call_prefix_typeArguments() async {
@@ -217,12 +404,109 @@
   p.E<String>(a)('');
 }
 ''');
-    findDeclarationAndOverride(
-        declarationName: 'E',
-        declarationUri: 'package:test/lib.dart',
-        overrideSearch: 'E<S');
-    validateOverride(typeArguments: [stringType]);
-    validateCall();
+
+    var node = findNode.functionExpressionInvocation('(a)');
+    if (isNullSafetyEnabled) {
+      assertResolvedNodeText(node, r'''
+FunctionExpressionInvocation
+  function: ExtensionOverride
+    extensionName: PrefixedIdentifier
+      prefix: SimpleIdentifier
+        token: p
+        staticElement: self::@prefix::p
+        staticType: null
+      period: .
+      identifier: SimpleIdentifier
+        token: E
+        staticElement: package:test/lib.dart::@extension::E
+        staticType: null
+      staticElement: package:test/lib.dart::@extension::E
+      staticType: null
+    typeArguments: TypeArgumentList
+      leftBracket: <
+      arguments
+        NamedType
+          name: SimpleIdentifier
+            token: String
+            staticElement: dart:core::@class::String
+            staticType: null
+          type: String
+      rightBracket: >
+    argumentList: ArgumentList
+      leftParenthesis: (
+      arguments
+        SimpleIdentifier
+          token: a
+          staticElement: a@35
+          staticType: A
+      rightParenthesis: )
+    extendedType: A
+    staticType: null
+    typeArgumentTypes
+      String
+  argumentList: ArgumentList
+    leftParenthesis: (
+    arguments
+      SimpleStringLiteral
+        literal: ''
+    rightParenthesis: )
+  staticElement: MethodMember
+    base: package:test/lib.dart::@extension::E::@method::call
+    substitution: {T: String}
+  staticInvokeType: int Function(String)
+  staticType: int
+''');
+    } else {
+      assertResolvedNodeText(node, r'''
+FunctionExpressionInvocation
+  function: ExtensionOverride
+    extensionName: PrefixedIdentifier
+      prefix: SimpleIdentifier
+        token: p
+        staticElement: self::@prefix::p
+        staticType: null
+      period: .
+      identifier: SimpleIdentifier
+        token: E
+        staticElement: package:test/lib.dart::@extension::E
+        staticType: null
+      staticElement: package:test/lib.dart::@extension::E
+      staticType: null
+    typeArguments: TypeArgumentList
+      leftBracket: <
+      arguments
+        NamedType
+          name: SimpleIdentifier
+            token: String
+            staticElement: dart:core::@class::String
+            staticType: null
+          type: String*
+      rightBracket: >
+    argumentList: ArgumentList
+      leftParenthesis: (
+      arguments
+        SimpleIdentifier
+          token: a
+          staticElement: a@35
+          staticType: A*
+      rightParenthesis: )
+    extendedType: A*
+    staticType: null
+    typeArgumentTypes
+      String*
+  argumentList: ArgumentList
+    leftParenthesis: (
+    arguments
+      SimpleStringLiteral
+        literal: ''
+    rightParenthesis: )
+  staticElement: MethodMember
+    base: package:test/lib.dart::@extension::E::@method::call
+    substitution: {T: String*}
+  staticInvokeType: int* Function(String*)*
+  staticType: int*
+''');
+    }
   }
 
   test_getter_noPrefix_noTypeArguments() async {
@@ -235,14 +519,59 @@
   E(a).g;
 }
 ''');
-    findDeclarationAndOverride(declarationName: 'E ', overrideSearch: 'E(a)');
-    validateOverride();
 
-    assertPropertyAccess2(
-      findNode.propertyAccess('.g'),
-      element: findElement.getter('g'),
-      type: 'int',
-    );
+    var node = findNode.propertyAccess('E(a)');
+    if (isNullSafetyEnabled) {
+      assertResolvedNodeText(node, r'''
+PropertyAccess
+  target: ExtensionOverride
+    extensionName: SimpleIdentifier
+      token: E
+      staticElement: self::@extension::E
+      staticType: null
+    argumentList: ArgumentList
+      leftParenthesis: (
+      arguments
+        SimpleIdentifier
+          token: a
+          staticElement: a@59
+          staticType: A
+      rightParenthesis: )
+    extendedType: A
+    staticType: null
+  operator: .
+  propertyName: SimpleIdentifier
+    token: g
+    staticElement: self::@extension::E::@getter::g
+    staticType: int
+  staticType: int
+''');
+    } else {
+      assertResolvedNodeText(node, r'''
+PropertyAccess
+  target: ExtensionOverride
+    extensionName: SimpleIdentifier
+      token: E
+      staticElement: self::@extension::E
+      staticType: null
+    argumentList: ArgumentList
+      leftParenthesis: (
+      arguments
+        SimpleIdentifier
+          token: a
+          staticElement: a@59
+          staticType: A*
+      rightParenthesis: )
+    extendedType: A*
+    staticType: null
+  operator: .
+  propertyName: SimpleIdentifier
+    token: g
+    staticElement: self::@extension::E::@getter::g
+    staticType: int*
+  staticType: int*
+''');
+    }
   }
 
   test_getter_noPrefix_noTypeArguments_functionExpressionInvocation() async {
@@ -257,17 +586,81 @@
   E(a).g(0);
 }
 ''');
-    findDeclarationAndOverride(declarationName: 'E ', overrideSearch: 'E(a)');
-    validateOverride();
 
-    var invocation = findNode.functionExpressionInvocation('g(0)');
-    assertElementNull(invocation);
-    assertInvokeType(invocation, 'double Function(int)');
-    assertType(invocation, 'double');
-
-    var function = invocation.function as PropertyAccess;
-    assertElement(function.propertyName, findElement.getter('g', of: 'E'));
-    assertType(function.propertyName, 'double Function(int)');
+    var node = findNode.functionExpressionInvocation('E(a)');
+    if (isNullSafetyEnabled) {
+      assertResolvedNodeText(node, r'''
+FunctionExpressionInvocation
+  function: PropertyAccess
+    target: ExtensionOverride
+      extensionName: SimpleIdentifier
+        token: E
+        staticElement: self::@extension::E
+        staticType: null
+      argumentList: ArgumentList
+        leftParenthesis: (
+        arguments
+          SimpleIdentifier
+            token: a
+            staticElement: a@87
+            staticType: A
+        rightParenthesis: )
+      extendedType: A
+      staticType: null
+    operator: .
+    propertyName: SimpleIdentifier
+      token: g
+      staticElement: self::@extension::E::@getter::g
+      staticType: double Function(int)
+    staticType: double Function(int)
+  argumentList: ArgumentList
+    leftParenthesis: (
+    arguments
+      IntegerLiteral
+        literal: 0
+        staticType: int
+    rightParenthesis: )
+  staticElement: <null>
+  staticInvokeType: double Function(int)
+  staticType: double
+''');
+    } else {
+      assertResolvedNodeText(node, r'''
+FunctionExpressionInvocation
+  function: PropertyAccess
+    target: ExtensionOverride
+      extensionName: SimpleIdentifier
+        token: E
+        staticElement: self::@extension::E
+        staticType: null
+      argumentList: ArgumentList
+        leftParenthesis: (
+        arguments
+          SimpleIdentifier
+            token: a
+            staticElement: a@87
+            staticType: A*
+        rightParenthesis: )
+      extendedType: A*
+      staticType: null
+    operator: .
+    propertyName: SimpleIdentifier
+      token: g
+      staticElement: self::@extension::E::@getter::g
+      staticType: double* Function(int*)*
+    staticType: double* Function(int*)*
+  argumentList: ArgumentList
+    leftParenthesis: (
+    arguments
+      IntegerLiteral
+        literal: 0
+        staticType: int*
+    rightParenthesis: )
+  staticElement: <null>
+  staticInvokeType: double* Function(int*)*
+  staticType: double*
+''');
+    }
   }
 
   test_getter_noPrefix_typeArguments() async {
@@ -280,17 +673,87 @@
   E<int>(a).g;
 }
 ''');
-    findDeclarationAndOverride(declarationName: 'E', overrideSearch: 'E<int>');
-    validateOverride(typeArguments: [intType]);
 
-    assertPropertyAccess2(
-      findNode.propertyAccess('.g'),
-      element: elementMatcher(
-        findElement.getter('g'),
-        substitution: {'T': 'int'},
-      ),
-      type: 'int',
-    );
+    var node = findNode.propertyAccess('(a)');
+    if (isNullSafetyEnabled) {
+      assertResolvedNodeText(node, r'''
+PropertyAccess
+  target: ExtensionOverride
+    extensionName: SimpleIdentifier
+      token: E
+      staticElement: self::@extension::E
+      staticType: null
+    typeArguments: TypeArgumentList
+      leftBracket: <
+      arguments
+        NamedType
+          name: SimpleIdentifier
+            token: int
+            staticElement: dart:core::@class::int
+            staticType: null
+          type: int
+      rightBracket: >
+    argumentList: ArgumentList
+      leftParenthesis: (
+      arguments
+        SimpleIdentifier
+          token: a
+          staticElement: a@62
+          staticType: A
+      rightParenthesis: )
+    extendedType: A
+    staticType: null
+    typeArgumentTypes
+      int
+  operator: .
+  propertyName: SimpleIdentifier
+    token: g
+    staticElement: PropertyAccessorMember
+      base: self::@extension::E::@getter::g
+      substitution: {T: int}
+    staticType: int
+  staticType: int
+''');
+    } else {
+      assertResolvedNodeText(node, r'''
+PropertyAccess
+  target: ExtensionOverride
+    extensionName: SimpleIdentifier
+      token: E
+      staticElement: self::@extension::E
+      staticType: null
+    typeArguments: TypeArgumentList
+      leftBracket: <
+      arguments
+        NamedType
+          name: SimpleIdentifier
+            token: int
+            staticElement: dart:core::@class::int
+            staticType: null
+          type: int*
+      rightBracket: >
+    argumentList: ArgumentList
+      leftParenthesis: (
+      arguments
+        SimpleIdentifier
+          token: a
+          staticElement: a@62
+          staticType: A*
+      rightParenthesis: )
+    extendedType: A*
+    staticType: null
+    typeArgumentTypes
+      int*
+  operator: .
+  propertyName: SimpleIdentifier
+    token: g
+    staticElement: PropertyAccessorMember
+      base: self::@extension::E::@getter::g
+      substitution: {T: int*}
+    staticType: int*
+  staticType: int*
+''');
+    }
   }
 
   test_getter_prefix_noTypeArguments() async {
@@ -306,18 +769,75 @@
   p.E(a).g;
 }
 ''');
-    findDeclarationAndOverride(
-        declarationName: 'E',
-        declarationUri: 'package:test/lib.dart',
-        overrideSearch: 'E(a)');
-    validateOverride();
 
-    var importFind = findElement.importFind('package:test/lib.dart');
-    assertPropertyAccess2(
-      findNode.propertyAccess('.g'),
-      element: importFind.getter('g'),
-      type: 'int',
-    );
+    var node = findNode.propertyAccess('E(a)');
+    if (isNullSafetyEnabled) {
+      assertResolvedNodeText(node, r'''
+PropertyAccess
+  target: ExtensionOverride
+    extensionName: PrefixedIdentifier
+      prefix: SimpleIdentifier
+        token: p
+        staticElement: self::@prefix::p
+        staticType: null
+      period: .
+      identifier: SimpleIdentifier
+        token: E
+        staticElement: package:test/lib.dart::@extension::E
+        staticType: null
+      staticElement: package:test/lib.dart::@extension::E
+      staticType: null
+    argumentList: ArgumentList
+      leftParenthesis: (
+      arguments
+        SimpleIdentifier
+          token: a
+          staticElement: a@35
+          staticType: A
+      rightParenthesis: )
+    extendedType: A
+    staticType: null
+  operator: .
+  propertyName: SimpleIdentifier
+    token: g
+    staticElement: package:test/lib.dart::@extension::E::@getter::g
+    staticType: int
+  staticType: int
+''');
+    } else {
+      assertResolvedNodeText(node, r'''
+PropertyAccess
+  target: ExtensionOverride
+    extensionName: PrefixedIdentifier
+      prefix: SimpleIdentifier
+        token: p
+        staticElement: self::@prefix::p
+        staticType: null
+      period: .
+      identifier: SimpleIdentifier
+        token: E
+        staticElement: package:test/lib.dart::@extension::E
+        staticType: null
+      staticElement: package:test/lib.dart::@extension::E
+      staticType: null
+    argumentList: ArgumentList
+      leftParenthesis: (
+      arguments
+        SimpleIdentifier
+          token: a
+          staticElement: a@35
+          staticType: A*
+      rightParenthesis: )
+    extendedType: A*
+    staticType: null
+  operator: .
+  propertyName: SimpleIdentifier
+    token: g
+    staticElement: package:test/lib.dart::@extension::E::@getter::g
+    staticType: int*
+  staticType: int*
+''');
+    }
   }
 
   test_getter_prefix_typeArguments() async {
@@ -333,21 +853,103 @@
   p.E<int>(a).g;
 }
 ''');
-    findDeclarationAndOverride(
-        declarationName: 'E',
-        declarationUri: 'package:test/lib.dart',
-        overrideSearch: 'E<int>');
-    validateOverride(typeArguments: [intType]);
 
-    var importFind = findElement.importFind('package:test/lib.dart');
-    assertPropertyAccess2(
-      findNode.propertyAccess('.g'),
-      element: elementMatcher(
-        importFind.getter('g'),
-        substitution: {'T': 'int'},
-      ),
-      type: 'int',
-    );
+    var node = findNode.propertyAccess('(a)');
+    if (isNullSafetyEnabled) {
+      assertResolvedNodeText(node, r'''
+PropertyAccess
+  target: ExtensionOverride
+    extensionName: PrefixedIdentifier
+      prefix: SimpleIdentifier
+        token: p
+        staticElement: self::@prefix::p
+        staticType: null
+      period: .
+      identifier: SimpleIdentifier
+        token: E
+        staticElement: package:test/lib.dart::@extension::E
+        staticType: null
+      staticElement: package:test/lib.dart::@extension::E
+      staticType: null
+    typeArguments: TypeArgumentList
+      leftBracket: <
+      arguments
+        NamedType
+          name: SimpleIdentifier
+            token: int
+            staticElement: dart:core::@class::int
+            staticType: null
+          type: int
+      rightBracket: >
+    argumentList: ArgumentList
+      leftParenthesis: (
+      arguments
+        SimpleIdentifier
+          token: a
+          staticElement: a@35
+          staticType: A
+      rightParenthesis: )
+    extendedType: A
+    staticType: null
+    typeArgumentTypes
+      int
+  operator: .
+  propertyName: SimpleIdentifier
+    token: g
+    staticElement: PropertyAccessorMember
+      base: package:test/lib.dart::@extension::E::@getter::g
+      substitution: {T: int}
+    staticType: int
+  staticType: int
+''');
+    } else {
+      assertResolvedNodeText(node, r'''
+PropertyAccess
+  target: ExtensionOverride
+    extensionName: PrefixedIdentifier
+      prefix: SimpleIdentifier
+        token: p
+        staticElement: self::@prefix::p
+        staticType: null
+      period: .
+      identifier: SimpleIdentifier
+        token: E
+        staticElement: package:test/lib.dart::@extension::E
+        staticType: null
+      staticElement: package:test/lib.dart::@extension::E
+      staticType: null
+    typeArguments: TypeArgumentList
+      leftBracket: <
+      arguments
+        NamedType
+          name: SimpleIdentifier
+            token: int
+            staticElement: dart:core::@class::int
+            staticType: null
+          type: int*
+      rightBracket: >
+    argumentList: ArgumentList
+      leftParenthesis: (
+      arguments
+        SimpleIdentifier
+          token: a
+          staticElement: a@35
+          staticType: A*
+      rightParenthesis: )
+    extendedType: A*
+    staticType: null
+    typeArgumentTypes
+      int*
+  operator: .
+  propertyName: SimpleIdentifier
+    token: g
+    staticElement: PropertyAccessorMember
+      base: package:test/lib.dart::@extension::E::@getter::g
+      substitution: {T: int*}
+    staticType: int*
+  staticType: int*
+''');
+    }
   }
 
   test_method_noPrefix_noTypeArguments() async {
@@ -360,9 +962,67 @@
   E(a).m();
 }
 ''');
-    findDeclarationAndOverride(declarationName: 'E ', overrideSearch: 'E(a)');
-    validateOverride();
-    validateInvocation();
+
+    var node = findNode.methodInvocation('E(a)');
+    if (isNullSafetyEnabled) {
+      assertResolvedNodeText(node, r'''
+MethodInvocation
+  target: ExtensionOverride
+    extensionName: SimpleIdentifier
+      token: E
+      staticElement: self::@extension::E
+      staticType: null
+    argumentList: ArgumentList
+      leftParenthesis: (
+      arguments
+        SimpleIdentifier
+          token: a
+          staticElement: a@55
+          staticType: A
+      rightParenthesis: )
+    extendedType: A
+    staticType: null
+  operator: .
+  methodName: SimpleIdentifier
+    token: m
+    staticElement: self::@extension::E::@method::m
+    staticType: void Function()
+  argumentList: ArgumentList
+    leftParenthesis: (
+    rightParenthesis: )
+  staticInvokeType: void Function()
+  staticType: void
+''');
+    } else {
+      assertResolvedNodeText(node, r'''
+MethodInvocation
+  target: ExtensionOverride
+    extensionName: SimpleIdentifier
+      token: E
+      staticElement: self::@extension::E
+      staticType: null
+    argumentList: ArgumentList
+      leftParenthesis: (
+      arguments
+        SimpleIdentifier
+          token: a
+          staticElement: a@55
+          staticType: A*
+      rightParenthesis: )
+    extendedType: A*
+    staticType: null
+  operator: .
+  methodName: SimpleIdentifier
+    token: m
+    staticElement: self::@extension::E::@method::m
+    staticType: void Function()*
+  argumentList: ArgumentList
+    leftParenthesis: (
+    rightParenthesis: )
+  staticInvokeType: void Function()*
+  staticType: void
+''');
+    }
   }
 
   test_method_noPrefix_typeArguments() async {
@@ -375,9 +1035,95 @@
   E<int>(a).m();
 }
 ''');
-    findDeclarationAndOverride(declarationName: 'E', overrideSearch: 'E<int>');
-    validateOverride(typeArguments: [intType]);
-    validateInvocation();
+
+    var node = findNode.methodInvocation('(a)');
+    if (isNullSafetyEnabled) {
+      assertResolvedNodeText(node, r'''
+MethodInvocation
+  target: ExtensionOverride
+    extensionName: SimpleIdentifier
+      token: E
+      staticElement: self::@extension::E
+      staticType: null
+    typeArguments: TypeArgumentList
+      leftBracket: <
+      arguments
+        NamedType
+          name: SimpleIdentifier
+            token: int
+            staticElement: dart:core::@class::int
+            staticType: null
+          type: int
+      rightBracket: >
+    argumentList: ArgumentList
+      leftParenthesis: (
+      arguments
+        SimpleIdentifier
+          token: a
+          staticElement: a@58
+          staticType: A
+      rightParenthesis: )
+    extendedType: A
+    staticType: null
+    typeArgumentTypes
+      int
+  operator: .
+  methodName: SimpleIdentifier
+    token: m
+    staticElement: MethodMember
+      base: self::@extension::E::@method::m
+      substitution: {T: int}
+    staticType: void Function()
+  argumentList: ArgumentList
+    leftParenthesis: (
+    rightParenthesis: )
+  staticInvokeType: void Function()
+  staticType: void
+''');
+    } else {
+      assertResolvedNodeText(node, r'''
+MethodInvocation
+  target: ExtensionOverride
+    extensionName: SimpleIdentifier
+      token: E
+      staticElement: self::@extension::E
+      staticType: null
+    typeArguments: TypeArgumentList
+      leftBracket: <
+      arguments
+        NamedType
+          name: SimpleIdentifier
+            token: int
+            staticElement: dart:core::@class::int
+            staticType: null
+          type: int*
+      rightBracket: >
+    argumentList: ArgumentList
+      leftParenthesis: (
+      arguments
+        SimpleIdentifier
+          token: a
+          staticElement: a@58
+          staticType: A*
+      rightParenthesis: )
+    extendedType: A*
+    staticType: null
+    typeArgumentTypes
+      int*
+  operator: .
+  methodName: SimpleIdentifier
+    token: m
+    staticElement: MethodMember
+      base: self::@extension::E::@method::m
+      substitution: {T: int*}
+    staticType: void Function()*
+  argumentList: ArgumentList
+    leftParenthesis: (
+    rightParenthesis: )
+  staticInvokeType: void Function()*
+  staticType: void
+''');
+    }
   }
 
   test_method_prefix_noTypeArguments() async {
@@ -393,12 +1139,83 @@
   p.E(a).m();
 }
 ''');
-    findDeclarationAndOverride(
-        declarationName: 'E',
-        declarationUri: 'package:test/lib.dart',
-        overrideSearch: 'E(a)');
-    validateOverride();
-    validateInvocation();
+
+    var node = findNode.methodInvocation('E(a)');
+    if (isNullSafetyEnabled) {
+      assertResolvedNodeText(node, r'''
+MethodInvocation
+  target: ExtensionOverride
+    extensionName: PrefixedIdentifier
+      prefix: SimpleIdentifier
+        token: p
+        staticElement: self::@prefix::p
+        staticType: null
+      period: .
+      identifier: SimpleIdentifier
+        token: E
+        staticElement: package:test/lib.dart::@extension::E
+        staticType: null
+      staticElement: package:test/lib.dart::@extension::E
+      staticType: null
+    argumentList: ArgumentList
+      leftParenthesis: (
+      arguments
+        SimpleIdentifier
+          token: a
+          staticElement: a@35
+          staticType: A
+      rightParenthesis: )
+    extendedType: A
+    staticType: null
+  operator: .
+  methodName: SimpleIdentifier
+    token: m
+    staticElement: package:test/lib.dart::@extension::E::@method::m
+    staticType: void Function()
+  argumentList: ArgumentList
+    leftParenthesis: (
+    rightParenthesis: )
+  staticInvokeType: void Function()
+  staticType: void
+''');
+    } else {
+      assertResolvedNodeText(node, r'''
+MethodInvocation
+  target: ExtensionOverride
+    extensionName: PrefixedIdentifier
+      prefix: SimpleIdentifier
+        token: p
+        staticElement: self::@prefix::p
+        staticType: null
+      period: .
+      identifier: SimpleIdentifier
+        token: E
+        staticElement: package:test/lib.dart::@extension::E
+        staticType: null
+      staticElement: package:test/lib.dart::@extension::E
+      staticType: null
+    argumentList: ArgumentList
+      leftParenthesis: (
+      arguments
+        SimpleIdentifier
+          token: a
+          staticElement: a@35
+          staticType: A*
+      rightParenthesis: )
+    extendedType: A*
+    staticType: null
+  operator: .
+  methodName: SimpleIdentifier
+    token: m
+    staticElement: package:test/lib.dart::@extension::E::@method::m
+    staticType: void Function()*
+  argumentList: ArgumentList
+    leftParenthesis: (
+    rightParenthesis: )
+  staticInvokeType: void Function()*
+  staticType: void
+''');
+    }
   }
 
   test_method_prefix_typeArguments() async {
@@ -414,12 +1231,111 @@
   p.E<int>(a).m();
 }
 ''');
-    findDeclarationAndOverride(
-        declarationName: 'E',
-        declarationUri: 'package:test/lib.dart',
-        overrideSearch: 'E<int>');
-    validateOverride(typeArguments: [intType]);
-    validateInvocation();
+
+    var node = findNode.methodInvocation('(a)');
+    if (isNullSafetyEnabled) {
+      assertResolvedNodeText(node, r'''
+MethodInvocation
+  target: ExtensionOverride
+    extensionName: PrefixedIdentifier
+      prefix: SimpleIdentifier
+        token: p
+        staticElement: self::@prefix::p
+        staticType: null
+      period: .
+      identifier: SimpleIdentifier
+        token: E
+        staticElement: package:test/lib.dart::@extension::E
+        staticType: null
+      staticElement: package:test/lib.dart::@extension::E
+      staticType: null
+    typeArguments: TypeArgumentList
+      leftBracket: <
+      arguments
+        NamedType
+          name: SimpleIdentifier
+            token: int
+            staticElement: dart:core::@class::int
+            staticType: null
+          type: int
+      rightBracket: >
+    argumentList: ArgumentList
+      leftParenthesis: (
+      arguments
+        SimpleIdentifier
+          token: a
+          staticElement: a@35
+          staticType: A
+      rightParenthesis: )
+    extendedType: A
+    staticType: null
+    typeArgumentTypes
+      int
+  operator: .
+  methodName: SimpleIdentifier
+    token: m
+    staticElement: MethodMember
+      base: package:test/lib.dart::@extension::E::@method::m
+      substitution: {T: int}
+    staticType: void Function()
+  argumentList: ArgumentList
+    leftParenthesis: (
+    rightParenthesis: )
+  staticInvokeType: void Function()
+  staticType: void
+''');
+    } else {
+      assertResolvedNodeText(node, r'''
+MethodInvocation
+  target: ExtensionOverride
+    extensionName: PrefixedIdentifier
+      prefix: SimpleIdentifier
+        token: p
+        staticElement: self::@prefix::p
+        staticType: null
+      period: .
+      identifier: SimpleIdentifier
+        token: E
+        staticElement: package:test/lib.dart::@extension::E
+        staticType: null
+      staticElement: package:test/lib.dart::@extension::E
+      staticType: null
+    typeArguments: TypeArgumentList
+      leftBracket: <
+      arguments
+        NamedType
+          name: SimpleIdentifier
+            token: int
+            staticElement: dart:core::@class::int
+            staticType: null
+          type: int*
+      rightBracket: >
+    argumentList: ArgumentList
+      leftParenthesis: (
+      arguments
+        SimpleIdentifier
+          token: a
+          staticElement: a@35
+          staticType: A*
+      rightParenthesis: )
+    extendedType: A*
+    staticType: null
+    typeArgumentTypes
+      int*
+  operator: .
+  methodName: SimpleIdentifier
+    token: m
+    staticElement: MethodMember
+      base: package:test/lib.dart::@extension::E::@method::m
+      substitution: {T: int*}
+    staticType: void Function()*
+  argumentList: ArgumentList
+    leftParenthesis: (
+    rightParenthesis: )
+  staticInvokeType: void Function()*
+  staticType: void
+''');
+    }
   }
 
   test_operator_noPrefix_noTypeArguments() async {
@@ -432,9 +1348,61 @@
   E(a) + 1;
 }
 ''');
-    findDeclarationAndOverride(declarationName: 'E ', overrideSearch: 'E(a)');
-    validateOverride();
-    validateBinaryExpression();
+
+    var node = findNode.binary('(a)');
+    if (isNullSafetyEnabled) {
+      assertResolvedNodeText(node, r'''
+BinaryExpression
+  leftOperand: ExtensionOverride
+    extensionName: SimpleIdentifier
+      token: E
+      staticElement: self::@extension::E
+      staticType: null
+    argumentList: ArgumentList
+      leftParenthesis: (
+      arguments
+        SimpleIdentifier
+          token: a
+          staticElement: a@74
+          staticType: A
+      rightParenthesis: )
+    extendedType: A
+    staticType: null
+  operator: +
+  rightOperand: IntegerLiteral
+    literal: 1
+    staticType: int
+  staticElement: self::@extension::E::@method::+
+  staticInvokeType: void Function(int)
+  staticType: void
+''');
+    } else {
+      assertResolvedNodeText(node, r'''
+BinaryExpression
+  leftOperand: ExtensionOverride
+    extensionName: SimpleIdentifier
+      token: E
+      staticElement: self::@extension::E
+      staticType: null
+    argumentList: ArgumentList
+      leftParenthesis: (
+      arguments
+        SimpleIdentifier
+          token: a
+          staticElement: a@74
+          staticType: A*
+      rightParenthesis: )
+    extendedType: A*
+    staticType: null
+  operator: +
+  rightOperand: IntegerLiteral
+    literal: 1
+    staticType: int*
+  staticElement: self::@extension::E::@method::+
+  staticInvokeType: void Function(int*)*
+  staticType: void
+''');
+    }
   }
 
   test_operator_noPrefix_typeArguments() async {
@@ -447,9 +1415,85 @@
   E<int>(a) + 1;
 }
 ''');
-    findDeclarationAndOverride(declarationName: 'E', overrideSearch: 'E<int>');
-    validateOverride(typeArguments: [intType]);
-    validateBinaryExpression();
+
+    var node = findNode.binary('(a)');
+    if (isNullSafetyEnabled) {
+      assertResolvedNodeText(node, r'''
+BinaryExpression
+  leftOperand: ExtensionOverride
+    extensionName: SimpleIdentifier
+      token: E
+      staticElement: self::@extension::E
+      staticType: null
+    typeArguments: TypeArgumentList
+      leftBracket: <
+      arguments
+        NamedType
+          name: SimpleIdentifier
+            token: int
+            staticElement: dart:core::@class::int
+            staticType: null
+          type: int
+      rightBracket: >
+    argumentList: ArgumentList
+      leftParenthesis: (
+      arguments
+        SimpleIdentifier
+          token: a
+          staticElement: a@77
+          staticType: A
+      rightParenthesis: )
+    extendedType: A
+    staticType: null
+    typeArgumentTypes
+      int
+  operator: +
+  rightOperand: IntegerLiteral
+    literal: 1
+    staticType: int
+  staticElement: self::@extension::E::@method::+
+  staticInvokeType: void Function(int)
+  staticType: void
+''');
+    } else {
+      assertResolvedNodeText(node, r'''
+BinaryExpression
+  leftOperand: ExtensionOverride
+    extensionName: SimpleIdentifier
+      token: E
+      staticElement: self::@extension::E
+      staticType: null
+    typeArguments: TypeArgumentList
+      leftBracket: <
+      arguments
+        NamedType
+          name: SimpleIdentifier
+            token: int
+            staticElement: dart:core::@class::int
+            staticType: null
+          type: int*
+      rightBracket: >
+    argumentList: ArgumentList
+      leftParenthesis: (
+      arguments
+        SimpleIdentifier
+          token: a
+          staticElement: a@77
+          staticType: A*
+      rightParenthesis: )
+    extendedType: A*
+    staticType: null
+    typeArgumentTypes
+      int*
+  operator: +
+  rightOperand: IntegerLiteral
+    literal: 1
+    staticType: int*
+  staticElement: self::@extension::E::@method::+
+  staticInvokeType: void Function(int*)*
+  staticType: void
+''');
+    }
   }
 
   test_operator_onTearOff() async {
@@ -465,8 +1509,73 @@
 ''', [
       error(CompileTimeErrorCode.UNDEFINED_EXTENSION_SETTER, 45, 1),
     ]);
-    findDeclarationAndOverride(declarationName: 'E ', overrideSearch: 'E(0)');
-    validateOverride();
+
+    var node = findNode.postfix('++;');
+    if (isNullSafetyEnabled) {
+      assertResolvedNodeText(node, r'''
+PostfixExpression
+  operand: PropertyAccess
+    target: ExtensionOverride
+      extensionName: SimpleIdentifier
+        token: E
+        staticElement: self::@extension::E
+        staticType: null
+      argumentList: ArgumentList
+        leftParenthesis: (
+        arguments
+          IntegerLiteral
+            literal: 0
+            staticType: int
+        rightParenthesis: )
+      extendedType: int
+      staticType: null
+    operator: .
+    propertyName: SimpleIdentifier
+      token: v
+      staticElement: <null>
+      staticType: null
+    staticType: null
+  operator: ++
+  readElement: self::@extension::E::@method::v
+  readType: dynamic
+  writeElement: <null>
+  writeType: dynamic
+  staticElement: <null>
+  staticType: dynamic
+''');
+    } else {
+      assertResolvedNodeText(node, r'''
+PostfixExpression
+  operand: PropertyAccess
+    target: ExtensionOverride
+      extensionName: SimpleIdentifier
+        token: E
+        staticElement: self::@extension::E
+        staticType: null
+      argumentList: ArgumentList
+        leftParenthesis: (
+        arguments
+          IntegerLiteral
+            literal: 0
+            staticType: int*
+        rightParenthesis: )
+      extendedType: int*
+      staticType: null
+    operator: .
+    propertyName: SimpleIdentifier
+      token: v
+      staticElement: <null>
+      staticType: null
+    staticType: null
+  operator: ++
+  readElement: self::@extension::E::@method::v
+  readType: dynamic
+  writeElement: <null>
+  writeType: dynamic
+  staticElement: <null>
+  staticType: dynamic
+''');
+    }
   }
 
   test_operator_prefix_noTypeArguments() async {
@@ -482,12 +1591,77 @@
   p.E(a) + 1;
 }
 ''');
-    findDeclarationAndOverride(
-        declarationName: 'E',
-        declarationUri: 'package:test/lib.dart',
-        overrideSearch: 'E(a)');
-    validateOverride();
-    validateBinaryExpression();
+
+    var node = findNode.binary('(a)');
+    if (isNullSafetyEnabled) {
+      assertResolvedNodeText(node, r'''
+BinaryExpression
+  leftOperand: ExtensionOverride
+    extensionName: PrefixedIdentifier
+      prefix: SimpleIdentifier
+        token: p
+        staticElement: self::@prefix::p
+        staticType: null
+      period: .
+      identifier: SimpleIdentifier
+        token: E
+        staticElement: package:test/lib.dart::@extension::E
+        staticType: null
+      staticElement: package:test/lib.dart::@extension::E
+      staticType: null
+    argumentList: ArgumentList
+      leftParenthesis: (
+      arguments
+        SimpleIdentifier
+          token: a
+          staticElement: a@35
+          staticType: A
+      rightParenthesis: )
+    extendedType: A
+    staticType: null
+  operator: +
+  rightOperand: IntegerLiteral
+    literal: 1
+    staticType: int
+  staticElement: package:test/lib.dart::@extension::E::@method::+
+  staticInvokeType: void Function(int)
+  staticType: void
+''');
+    } else {
+      assertResolvedNodeText(node, r'''
+BinaryExpression
+  leftOperand: ExtensionOverride
+    extensionName: PrefixedIdentifier
+      prefix: SimpleIdentifier
+        token: p
+        staticElement: self::@prefix::p
+        staticType: null
+      period: .
+      identifier: SimpleIdentifier
+        token: E
+        staticElement: package:test/lib.dart::@extension::E
+        staticType: null
+      staticElement: package:test/lib.dart::@extension::E
+      staticType: null
+    argumentList: ArgumentList
+      leftParenthesis: (
+      arguments
+        SimpleIdentifier
+          token: a
+          staticElement: a@35
+          staticType: A*
+      rightParenthesis: )
+    extendedType: A*
+    staticType: null
+  operator: +
+  rightOperand: IntegerLiteral
+    literal: 1
+    staticType: int*
+  staticElement: package:test/lib.dart::@extension::E::@method::+
+  staticInvokeType: void Function(int*)*
+  staticType: void
+''');
+    }
   }
 
   test_operator_prefix_typeArguments() async {
@@ -503,12 +1677,101 @@
   p.E<int>(a) + 1;
 }
 ''');
-    findDeclarationAndOverride(
-        declarationName: 'E',
-        declarationUri: 'package:test/lib.dart',
-        overrideSearch: 'E<int>');
-    validateOverride(typeArguments: [intType]);
-    validateBinaryExpression();
+
+    var node = findNode.binary('(a)');
+    if (isNullSafetyEnabled) {
+      assertResolvedNodeText(node, r'''
+BinaryExpression
+  leftOperand: ExtensionOverride
+    extensionName: PrefixedIdentifier
+      prefix: SimpleIdentifier
+        token: p
+        staticElement: self::@prefix::p
+        staticType: null
+      period: .
+      identifier: SimpleIdentifier
+        token: E
+        staticElement: package:test/lib.dart::@extension::E
+        staticType: null
+      staticElement: package:test/lib.dart::@extension::E
+      staticType: null
+    typeArguments: TypeArgumentList
+      leftBracket: <
+      arguments
+        NamedType
+          name: SimpleIdentifier
+            token: int
+            staticElement: dart:core::@class::int
+            staticType: null
+          type: int
+      rightBracket: >
+    argumentList: ArgumentList
+      leftParenthesis: (
+      arguments
+        SimpleIdentifier
+          token: a
+          staticElement: a@35
+          staticType: A
+      rightParenthesis: )
+    extendedType: A
+    staticType: null
+    typeArgumentTypes
+      int
+  operator: +
+  rightOperand: IntegerLiteral
+    literal: 1
+    staticType: int
+  staticElement: package:test/lib.dart::@extension::E::@method::+
+  staticInvokeType: void Function(int)
+  staticType: void
+''');
+    } else {
+      assertResolvedNodeText(node, r'''
+BinaryExpression
+  leftOperand: ExtensionOverride
+    extensionName: PrefixedIdentifier
+      prefix: SimpleIdentifier
+        token: p
+        staticElement: self::@prefix::p
+        staticType: null
+      period: .
+      identifier: SimpleIdentifier
+        token: E
+        staticElement: package:test/lib.dart::@extension::E
+        staticType: null
+      staticElement: package:test/lib.dart::@extension::E
+      staticType: null
+    typeArguments: TypeArgumentList
+      leftBracket: <
+      arguments
+        NamedType
+          name: SimpleIdentifier
+            token: int
+            staticElement: dart:core::@class::int
+            staticType: null
+          type: int*
+      rightBracket: >
+    argumentList: ArgumentList
+      leftParenthesis: (
+      arguments
+        SimpleIdentifier
+          token: a
+          staticElement: a@35
+          staticType: A*
+      rightParenthesis: )
+    extendedType: A*
+    staticType: null
+    typeArgumentTypes
+      int*
+  operator: +
+  rightOperand: IntegerLiteral
+    literal: 1
+    staticType: int*
+  staticElement: package:test/lib.dart::@extension::E::@method::+
+  staticInvokeType: void Function(int*)*
+  staticType: void
+''');
+    }
   }
 
   test_setter_noPrefix_noTypeArguments() async {
@@ -521,18 +1784,81 @@
   E(a).s = 0;
 }
 ''');
-    findDeclarationAndOverride(declarationName: 'E ', overrideSearch: 'E(a)');
-    validateOverride();
 
-    assertAssignment(
-      findNode.assignment('s ='),
-      readElement: null,
-      readType: null,
-      writeElement: findElement.setter('s', of: 'E'),
-      writeType: 'int',
-      operatorElement: null,
-      type: 'int',
-    );
+    var node = findNode.assignment('(a)');
+    if (isNullSafetyEnabled) {
+      assertResolvedNodeText(node, r'''
+AssignmentExpression
+  leftHandSide: PropertyAccess
+    target: ExtensionOverride
+      extensionName: SimpleIdentifier
+        token: E
+        staticElement: self::@extension::E
+        staticType: null
+      argumentList: ArgumentList
+        leftParenthesis: (
+        arguments
+          SimpleIdentifier
+            token: a
+            staticElement: a@59
+            staticType: A
+        rightParenthesis: )
+      extendedType: A
+      staticType: null
+    operator: .
+    propertyName: SimpleIdentifier
+      token: s
+      staticElement: <null>
+      staticType: null
+    staticType: null
+  operator: =
+  rightHandSide: IntegerLiteral
+    literal: 0
+    staticType: int
+  readElement: <null>
+  readType: null
+  writeElement: self::@extension::E::@setter::s
+  writeType: int
+  staticElement: <null>
+  staticType: int
+''');
+    } else {
+      assertResolvedNodeText(node, r'''
+AssignmentExpression
+  leftHandSide: PropertyAccess
+    target: ExtensionOverride
+      extensionName: SimpleIdentifier
+        token: E
+        staticElement: self::@extension::E
+        staticType: null
+      argumentList: ArgumentList
+        leftParenthesis: (
+        arguments
+          SimpleIdentifier
+            token: a
+            staticElement: a@59
+            staticType: A*
+        rightParenthesis: )
+      extendedType: A*
+      staticType: null
+    operator: .
+    propertyName: SimpleIdentifier
+      token: s
+      staticElement: <null>
+      staticType: null
+    staticType: null
+  operator: =
+  rightHandSide: IntegerLiteral
+    literal: 0
+    staticType: int*
+  readElement: <null>
+  readType: null
+  writeElement: self::@extension::E::@setter::s
+  writeType: int*
+  staticElement: <null>
+  staticType: int*
+''');
+    }
   }
 
   test_setter_noPrefix_typeArguments() async {
@@ -545,21 +1871,109 @@
   E<int>(a).s = 0;
 }
 ''');
-    findDeclarationAndOverride(declarationName: 'E', overrideSearch: 'E<int>');
-    validateOverride(typeArguments: [intType]);
 
-    assertAssignment(
-      findNode.assignment('s ='),
-      readElement: null,
-      readType: null,
-      writeElement: elementMatcher(
-        findElement.setter('s', of: 'E'),
-        substitution: {'T': 'int'},
-      ),
-      writeType: 'int',
-      operatorElement: null,
-      type: 'int',
-    );
+    var node = findNode.assignment('(a)');
+    if (isNullSafetyEnabled) {
+      assertResolvedNodeText(node, r'''
+AssignmentExpression
+  leftHandSide: PropertyAccess
+    target: ExtensionOverride
+      extensionName: SimpleIdentifier
+        token: E
+        staticElement: self::@extension::E
+        staticType: null
+      typeArguments: TypeArgumentList
+        leftBracket: <
+        arguments
+          NamedType
+            name: SimpleIdentifier
+              token: int
+              staticElement: dart:core::@class::int
+              staticType: null
+            type: int
+        rightBracket: >
+      argumentList: ArgumentList
+        leftParenthesis: (
+        arguments
+          SimpleIdentifier
+            token: a
+            staticElement: a@62
+            staticType: A
+        rightParenthesis: )
+      extendedType: A
+      staticType: null
+      typeArgumentTypes
+        int
+    operator: .
+    propertyName: SimpleIdentifier
+      token: s
+      staticElement: <null>
+      staticType: null
+    staticType: null
+  operator: =
+  rightHandSide: IntegerLiteral
+    literal: 0
+    staticType: int
+  readElement: <null>
+  readType: null
+  writeElement: PropertyAccessorMember
+    base: self::@extension::E::@setter::s
+    substitution: {T: int}
+  writeType: int
+  staticElement: <null>
+  staticType: int
+''');
+    } else {
+      assertResolvedNodeText(node, r'''
+AssignmentExpression
+  leftHandSide: PropertyAccess
+    target: ExtensionOverride
+      extensionName: SimpleIdentifier
+        token: E
+        staticElement: self::@extension::E
+        staticType: null
+      typeArguments: TypeArgumentList
+        leftBracket: <
+        arguments
+          NamedType
+            name: SimpleIdentifier
+              token: int
+              staticElement: dart:core::@class::int
+              staticType: null
+            type: int*
+        rightBracket: >
+      argumentList: ArgumentList
+        leftParenthesis: (
+        arguments
+          SimpleIdentifier
+            token: a
+            staticElement: a@62
+            staticType: A*
+        rightParenthesis: )
+      extendedType: A*
+      staticType: null
+      typeArgumentTypes
+        int*
+    operator: .
+    propertyName: SimpleIdentifier
+      token: s
+      staticElement: <null>
+      staticType: null
+    staticType: null
+  operator: =
+  rightHandSide: IntegerLiteral
+    literal: 0
+    staticType: int*
+  readElement: <null>
+  readType: null
+  writeElement: PropertyAccessorMember
+    base: self::@extension::E::@setter::s
+    substitution: {T: int*}
+  writeType: int*
+  staticElement: <null>
+  staticType: int*
+''');
+    }
   }
 
   test_setter_prefix_noTypeArguments() async {
@@ -575,22 +1989,97 @@
   p.E(a).s = 0;
 }
 ''');
-    findDeclarationAndOverride(
-        declarationName: 'E',
-        declarationUri: 'package:test/lib.dart',
-        overrideSearch: 'E(a)');
-    validateOverride();
 
-    var importFind = findElement.importFind('package:test/lib.dart');
-    assertAssignment(
-      findNode.assignment('s ='),
-      readElement: null,
-      readType: null,
-      writeElement: importFind.setter('s', of: 'E'),
-      writeType: 'int',
-      operatorElement: null,
-      type: 'int',
-    );
+    var node = findNode.assignment('(a)');
+    if (isNullSafetyEnabled) {
+      assertResolvedNodeText(node, r'''
+AssignmentExpression
+  leftHandSide: PropertyAccess
+    target: ExtensionOverride
+      extensionName: PrefixedIdentifier
+        prefix: SimpleIdentifier
+          token: p
+          staticElement: self::@prefix::p
+          staticType: null
+        period: .
+        identifier: SimpleIdentifier
+          token: E
+          staticElement: package:test/lib.dart::@extension::E
+          staticType: null
+        staticElement: package:test/lib.dart::@extension::E
+        staticType: null
+      argumentList: ArgumentList
+        leftParenthesis: (
+        arguments
+          SimpleIdentifier
+            token: a
+            staticElement: a@35
+            staticType: A
+        rightParenthesis: )
+      extendedType: A
+      staticType: null
+    operator: .
+    propertyName: SimpleIdentifier
+      token: s
+      staticElement: <null>
+      staticType: null
+    staticType: null
+  operator: =
+  rightHandSide: IntegerLiteral
+    literal: 0
+    staticType: int
+  readElement: <null>
+  readType: null
+  writeElement: package:test/lib.dart::@extension::E::@setter::s
+  writeType: int
+  staticElement: <null>
+  staticType: int
+''');
+    } else {
+      assertResolvedNodeText(node, r'''
+AssignmentExpression
+  leftHandSide: PropertyAccess
+    target: ExtensionOverride
+      extensionName: PrefixedIdentifier
+        prefix: SimpleIdentifier
+          token: p
+          staticElement: self::@prefix::p
+          staticType: null
+        period: .
+        identifier: SimpleIdentifier
+          token: E
+          staticElement: package:test/lib.dart::@extension::E
+          staticType: null
+        staticElement: package:test/lib.dart::@extension::E
+        staticType: null
+      argumentList: ArgumentList
+        leftParenthesis: (
+        arguments
+          SimpleIdentifier
+            token: a
+            staticElement: a@35
+            staticType: A*
+        rightParenthesis: )
+      extendedType: A*
+      staticType: null
+    operator: .
+    propertyName: SimpleIdentifier
+      token: s
+      staticElement: <null>
+      staticType: null
+    staticType: null
+  operator: =
+  rightHandSide: IntegerLiteral
+    literal: 0
+    staticType: int*
+  readElement: <null>
+  readType: null
+  writeElement: package:test/lib.dart::@extension::E::@setter::s
+  writeType: int*
+  staticElement: <null>
+  staticType: int*
+''');
+    }
   }
 
   test_setter_prefix_typeArguments() async {
@@ -606,25 +2095,125 @@
   p.E<int>(a).s = 0;
 }
 ''');
-    findDeclarationAndOverride(
-        declarationName: 'E',
-        declarationUri: 'package:test/lib.dart',
-        overrideSearch: 'E<int>');
-    validateOverride(typeArguments: [intType]);
 
-    var importFind = findElement.importFind('package:test/lib.dart');
-    assertAssignment(
-      findNode.assignment('s ='),
-      readElement: null,
-      readType: null,
-      writeElement: elementMatcher(
-        importFind.setter('s', of: 'E'),
-        substitution: {'T': 'int'},
-      ),
-      writeType: 'int',
-      operatorElement: null,
-      type: 'int',
-    );
+    var node = findNode.assignment('(a)');
+    if (isNullSafetyEnabled) {
+      assertResolvedNodeText(node, r'''
+AssignmentExpression
+  leftHandSide: PropertyAccess
+    target: ExtensionOverride
+      extensionName: PrefixedIdentifier
+        prefix: SimpleIdentifier
+          token: p
+          staticElement: self::@prefix::p
+          staticType: null
+        period: .
+        identifier: SimpleIdentifier
+          token: E
+          staticElement: package:test/lib.dart::@extension::E
+          staticType: null
+        staticElement: package:test/lib.dart::@extension::E
+        staticType: null
+      typeArguments: TypeArgumentList
+        leftBracket: <
+        arguments
+          NamedType
+            name: SimpleIdentifier
+              token: int
+              staticElement: dart:core::@class::int
+              staticType: null
+            type: int
+        rightBracket: >
+      argumentList: ArgumentList
+        leftParenthesis: (
+        arguments
+          SimpleIdentifier
+            token: a
+            staticElement: a@35
+            staticType: A
+        rightParenthesis: )
+      extendedType: A
+      staticType: null
+      typeArgumentTypes
+        int
+    operator: .
+    propertyName: SimpleIdentifier
+      token: s
+      staticElement: <null>
+      staticType: null
+    staticType: null
+  operator: =
+  rightHandSide: IntegerLiteral
+    literal: 0
+    staticType: int
+  readElement: <null>
+  readType: null
+  writeElement: PropertyAccessorMember
+    base: package:test/lib.dart::@extension::E::@setter::s
+    substitution: {T: int}
+  writeType: int
+  staticElement: <null>
+  staticType: int
+''');
+    } else {
+      assertResolvedNodeText(node, r'''
+AssignmentExpression
+  leftHandSide: PropertyAccess
+    target: ExtensionOverride
+      extensionName: PrefixedIdentifier
+        prefix: SimpleIdentifier
+          token: p
+          staticElement: self::@prefix::p
+          staticType: null
+        period: .
+        identifier: SimpleIdentifier
+          token: E
+          staticElement: package:test/lib.dart::@extension::E
+          staticType: null
+        staticElement: package:test/lib.dart::@extension::E
+        staticType: null
+      typeArguments: TypeArgumentList
+        leftBracket: <
+        arguments
+          NamedType
+            name: SimpleIdentifier
+              token: int
+              staticElement: dart:core::@class::int
+              staticType: null
+            type: int*
+        rightBracket: >
+      argumentList: ArgumentList
+        leftParenthesis: (
+        arguments
+          SimpleIdentifier
+            token: a
+            staticElement: a@35
+            staticType: A*
+        rightParenthesis: )
+      extendedType: A*
+      staticType: null
+      typeArgumentTypes
+        int*
+    operator: .
+    propertyName: SimpleIdentifier
+      token: s
+      staticElement: <null>
+      staticType: null
+    staticType: null
+  operator: =
+  rightHandSide: IntegerLiteral
+    literal: 0
+    staticType: int*
+  readElement: <null>
+  readType: null
+  writeElement: PropertyAccessorMember
+    base: package:test/lib.dart::@extension::E::@setter::s
+    substitution: {T: int*}
+  writeType: int*
+  staticElement: <null>
+  staticType: int*
+''');
+    }
   }
 
   test_setterAndGetter_noPrefix_noTypeArguments() async {
@@ -638,21 +2227,83 @@
   E(a).s += 0;
 }
 ''');
-    findDeclarationAndOverride(declarationName: 'E ', overrideSearch: 'E(a)');
-    validateOverride();
 
-    assertAssignment(
-      findNode.assignment('s +='),
-      readElement: findElement.getter('s', of: 'E'),
-      readType: 'int',
-      writeElement: findElement.setter('s', of: 'E'),
-      writeType: 'int',
-      operatorElement: elementMatcher(
-        numElement.getMethod('+'),
-        isLegacy: isLegacyLibrary,
-      ),
-      type: 'int',
-    );
+    var node = findNode.assignment('(a)');
+    if (isNullSafetyEnabled) {
+      assertResolvedNodeText(node, r'''
+AssignmentExpression
+  leftHandSide: PropertyAccess
+    target: ExtensionOverride
+      extensionName: SimpleIdentifier
+        token: E
+        staticElement: self::@extension::E
+        staticType: null
+      argumentList: ArgumentList
+        leftParenthesis: (
+        arguments
+          SimpleIdentifier
+            token: a
+            staticElement: a@77
+            staticType: A
+        rightParenthesis: )
+      extendedType: A
+      staticType: null
+    operator: .
+    propertyName: SimpleIdentifier
+      token: s
+      staticElement: <null>
+      staticType: null
+    staticType: null
+  operator: +=
+  rightHandSide: IntegerLiteral
+    literal: 0
+    staticType: int
+  readElement: self::@extension::E::@getter::s
+  readType: int
+  writeElement: self::@extension::E::@setter::s
+  writeType: int
+  staticElement: dart:core::@class::num::@method::+
+  staticType: int
+''');
+    } else {
+      assertResolvedNodeText(node, r'''
+AssignmentExpression
+  leftHandSide: PropertyAccess
+    target: ExtensionOverride
+      extensionName: SimpleIdentifier
+        token: E
+        staticElement: self::@extension::E
+        staticType: null
+      argumentList: ArgumentList
+        leftParenthesis: (
+        arguments
+          SimpleIdentifier
+            token: a
+            staticElement: a@77
+            staticType: A*
+        rightParenthesis: )
+      extendedType: A*
+      staticType: null
+    operator: .
+    propertyName: SimpleIdentifier
+      token: s
+      staticElement: <null>
+      staticType: null
+    staticType: null
+  operator: +=
+  rightHandSide: IntegerLiteral
+    literal: 0
+    staticType: int*
+  readElement: self::@extension::E::@getter::s
+  readType: int*
+  writeElement: self::@extension::E::@setter::s
+  writeType: int*
+  staticElement: MethodMember
+    base: dart:core::@class::num::@method::+
+    isLegacy: true
+  staticType: int*
+''');
+    }
   }
 
   test_setterAndGetter_noPrefix_typeArguments() async {
@@ -666,27 +2317,115 @@
   E<int>(a).s += 0;
 }
 ''');
-    findDeclarationAndOverride(declarationName: 'E', overrideSearch: 'E<int>');
-    validateOverride(typeArguments: [intType]);
 
-    assertAssignment(
-      findNode.assignment('s +='),
-      readElement: elementMatcher(
-        findElement.getter('s', of: 'E'),
-        substitution: {'T': 'int'},
-      ),
-      readType: 'int',
-      writeElement: elementMatcher(
-        findElement.setter('s', of: 'E'),
-        substitution: {'T': 'int'},
-      ),
-      writeType: 'int',
-      operatorElement: elementMatcher(
-        numElement.getMethod('+'),
-        isLegacy: isLegacyLibrary,
-      ),
-      type: 'int',
-    );
+    var node = findNode.assignment('(a)');
+    if (isNullSafetyEnabled) {
+      assertResolvedNodeText(node, r'''
+AssignmentExpression
+  leftHandSide: PropertyAccess
+    target: ExtensionOverride
+      extensionName: SimpleIdentifier
+        token: E
+        staticElement: self::@extension::E
+        staticType: null
+      typeArguments: TypeArgumentList
+        leftBracket: <
+        arguments
+          NamedType
+            name: SimpleIdentifier
+              token: int
+              staticElement: dart:core::@class::int
+              staticType: null
+            type: int
+        rightBracket: >
+      argumentList: ArgumentList
+        leftParenthesis: (
+        arguments
+          SimpleIdentifier
+            token: a
+            staticElement: a@80
+            staticType: A
+        rightParenthesis: )
+      extendedType: A
+      staticType: null
+      typeArgumentTypes
+        int
+    operator: .
+    propertyName: SimpleIdentifier
+      token: s
+      staticElement: <null>
+      staticType: null
+    staticType: null
+  operator: +=
+  rightHandSide: IntegerLiteral
+    literal: 0
+    staticType: int
+  readElement: PropertyAccessorMember
+    base: self::@extension::E::@getter::s
+    substitution: {T: int}
+  readType: int
+  writeElement: PropertyAccessorMember
+    base: self::@extension::E::@setter::s
+    substitution: {T: int}
+  writeType: int
+  staticElement: dart:core::@class::num::@method::+
+  staticType: int
+''');
+    } else {
+      assertResolvedNodeText(node, r'''
+AssignmentExpression
+  leftHandSide: PropertyAccess
+    target: ExtensionOverride
+      extensionName: SimpleIdentifier
+        token: E
+        staticElement: self::@extension::E
+        staticType: null
+      typeArguments: TypeArgumentList
+        leftBracket: <
+        arguments
+          NamedType
+            name: SimpleIdentifier
+              token: int
+              staticElement: dart:core::@class::int
+              staticType: null
+            type: int*
+        rightBracket: >
+      argumentList: ArgumentList
+        leftParenthesis: (
+        arguments
+          SimpleIdentifier
+            token: a
+            staticElement: a@80
+            staticType: A*
+        rightParenthesis: )
+      extendedType: A*
+      staticType: null
+      typeArgumentTypes
+        int*
+    operator: .
+    propertyName: SimpleIdentifier
+      token: s
+      staticElement: <null>
+      staticType: null
+    staticType: null
+  operator: +=
+  rightHandSide: IntegerLiteral
+    literal: 0
+    staticType: int*
+  readElement: PropertyAccessorMember
+    base: self::@extension::E::@getter::s
+    substitution: {T: int*}
+  readType: int*
+  writeElement: PropertyAccessorMember
+    base: self::@extension::E::@setter::s
+    substitution: {T: int*}
+  writeType: int*
+  staticElement: MethodMember
+    base: dart:core::@class::num::@method::+
+    isLegacy: true
+  staticType: int*
+''');
+    }
   }
 
   test_setterAndGetter_prefix_noTypeArguments() async {
@@ -703,25 +2442,99 @@
   p.E(a).s += 0;
 }
 ''');
-    findDeclarationAndOverride(
-        declarationName: 'E',
-        declarationUri: 'package:test/lib.dart',
-        overrideSearch: 'E(a)');
-    validateOverride();
 
-    var importFind = findElement.importFind('package:test/lib.dart');
-    assertAssignment(
-      findNode.assignment('s +='),
-      readElement: importFind.getter('s', of: 'E'),
-      readType: 'int',
-      writeElement: importFind.setter('s', of: 'E'),
-      writeType: 'int',
-      operatorElement: elementMatcher(
-        numElement.getMethod('+'),
-        isLegacy: isLegacyLibrary,
-      ),
-      type: 'int',
-    );
+    var node = findNode.assignment('(a)');
+    if (isNullSafetyEnabled) {
+      assertResolvedNodeText(node, r'''
+AssignmentExpression
+  leftHandSide: PropertyAccess
+    target: ExtensionOverride
+      extensionName: PrefixedIdentifier
+        prefix: SimpleIdentifier
+          token: p
+          staticElement: self::@prefix::p
+          staticType: null
+        period: .
+        identifier: SimpleIdentifier
+          token: E
+          staticElement: package:test/lib.dart::@extension::E
+          staticType: null
+        staticElement: package:test/lib.dart::@extension::E
+        staticType: null
+      argumentList: ArgumentList
+        leftParenthesis: (
+        arguments
+          SimpleIdentifier
+            token: a
+            staticElement: a@35
+            staticType: A
+        rightParenthesis: )
+      extendedType: A
+      staticType: null
+    operator: .
+    propertyName: SimpleIdentifier
+      token: s
+      staticElement: <null>
+      staticType: null
+    staticType: null
+  operator: +=
+  rightHandSide: IntegerLiteral
+    literal: 0
+    staticType: int
+  readElement: package:test/lib.dart::@extension::E::@getter::s
+  readType: int
+  writeElement: package:test/lib.dart::@extension::E::@setter::s
+  writeType: int
+  staticElement: dart:core::@class::num::@method::+
+  staticType: int
+''');
+    } else {
+      assertResolvedNodeText(node, r'''
+AssignmentExpression
+  leftHandSide: PropertyAccess
+    target: ExtensionOverride
+      extensionName: PrefixedIdentifier
+        prefix: SimpleIdentifier
+          token: p
+          staticElement: self::@prefix::p
+          staticType: null
+        period: .
+        identifier: SimpleIdentifier
+          token: E
+          staticElement: package:test/lib.dart::@extension::E
+          staticType: null
+        staticElement: package:test/lib.dart::@extension::E
+        staticType: null
+      argumentList: ArgumentList
+        leftParenthesis: (
+        arguments
+          SimpleIdentifier
+            token: a
+            staticElement: a@35
+            staticType: A*
+        rightParenthesis: )
+      extendedType: A*
+      staticType: null
+    operator: .
+    propertyName: SimpleIdentifier
+      token: s
+      staticElement: <null>
+      staticType: null
+    staticType: null
+  operator: +=
+  rightHandSide: IntegerLiteral
+    literal: 0
+    staticType: int*
+  readElement: package:test/lib.dart::@extension::E::@getter::s
+  readType: int*
+  writeElement: package:test/lib.dart::@extension::E::@setter::s
+  writeType: int*
+  staticElement: MethodMember
+    base: dart:core::@class::num::@method::+
+    isLegacy: true
+  staticType: int*
+''');
+    }
   }
 
   test_setterAndGetter_prefix_typeArguments() async {
@@ -738,31 +2551,131 @@
   p.E<int>(a).s += 0;
 }
 ''');
-    findDeclarationAndOverride(
-        declarationName: 'E',
-        declarationUri: 'package:test/lib.dart',
-        overrideSearch: 'E<int>');
-    validateOverride(typeArguments: [intType]);
 
-    var importFind = findElement.importFind('package:test/lib.dart');
-    assertAssignment(
-      findNode.assignment('s +='),
-      readElement: elementMatcher(
-        importFind.getter('s', of: 'E'),
-        substitution: {'T': 'int'},
-      ),
-      readType: 'int',
-      writeElement: elementMatcher(
-        importFind.setter('s', of: 'E'),
-        substitution: {'T': 'int'},
-      ),
-      writeType: 'int',
-      operatorElement: elementMatcher(
-        numElement.getMethod('+'),
-        isLegacy: isLegacyLibrary,
-      ),
-      type: 'int',
-    );
+    var node = findNode.assignment('(a)');
+    if (isNullSafetyEnabled) {
+      assertResolvedNodeText(node, r'''
+AssignmentExpression
+  leftHandSide: PropertyAccess
+    target: ExtensionOverride
+      extensionName: PrefixedIdentifier
+        prefix: SimpleIdentifier
+          token: p
+          staticElement: self::@prefix::p
+          staticType: null
+        period: .
+        identifier: SimpleIdentifier
+          token: E
+          staticElement: package:test/lib.dart::@extension::E
+          staticType: null
+        staticElement: package:test/lib.dart::@extension::E
+        staticType: null
+      typeArguments: TypeArgumentList
+        leftBracket: <
+        arguments
+          NamedType
+            name: SimpleIdentifier
+              token: int
+              staticElement: dart:core::@class::int
+              staticType: null
+            type: int
+        rightBracket: >
+      argumentList: ArgumentList
+        leftParenthesis: (
+        arguments
+          SimpleIdentifier
+            token: a
+            staticElement: a@35
+            staticType: A
+        rightParenthesis: )
+      extendedType: A
+      staticType: null
+      typeArgumentTypes
+        int
+    operator: .
+    propertyName: SimpleIdentifier
+      token: s
+      staticElement: <null>
+      staticType: null
+    staticType: null
+  operator: +=
+  rightHandSide: IntegerLiteral
+    literal: 0
+    staticType: int
+  readElement: PropertyAccessorMember
+    base: package:test/lib.dart::@extension::E::@getter::s
+    substitution: {T: int}
+  readType: int
+  writeElement: PropertyAccessorMember
+    base: package:test/lib.dart::@extension::E::@setter::s
+    substitution: {T: int}
+  writeType: int
+  staticElement: dart:core::@class::num::@method::+
+  staticType: int
+''');
+    } else {
+      assertResolvedNodeText(node, r'''
+AssignmentExpression
+  leftHandSide: PropertyAccess
+    target: ExtensionOverride
+      extensionName: PrefixedIdentifier
+        prefix: SimpleIdentifier
+          token: p
+          staticElement: self::@prefix::p
+          staticType: null
+        period: .
+        identifier: SimpleIdentifier
+          token: E
+          staticElement: package:test/lib.dart::@extension::E
+          staticType: null
+        staticElement: package:test/lib.dart::@extension::E
+        staticType: null
+      typeArguments: TypeArgumentList
+        leftBracket: <
+        arguments
+          NamedType
+            name: SimpleIdentifier
+              token: int
+              staticElement: dart:core::@class::int
+              staticType: null
+            type: int*
+        rightBracket: >
+      argumentList: ArgumentList
+        leftParenthesis: (
+        arguments
+          SimpleIdentifier
+            token: a
+            staticElement: a@35
+            staticType: A*
+        rightParenthesis: )
+      extendedType: A*
+      staticType: null
+      typeArgumentTypes
+        int*
+    operator: .
+    propertyName: SimpleIdentifier
+      token: s
+      staticElement: <null>
+      staticType: null
+    staticType: null
+  operator: +=
+  rightHandSide: IntegerLiteral
+    literal: 0
+    staticType: int*
+  readElement: PropertyAccessorMember
+    base: package:test/lib.dart::@extension::E::@getter::s
+    substitution: {T: int*}
+  readType: int*
+  writeElement: PropertyAccessorMember
+    base: package:test/lib.dart::@extension::E::@setter::s
+    substitution: {T: int*}
+  writeType: int*
+  staticElement: MethodMember
+    base: dart:core::@class::num::@method::+
+    isLegacy: true
+  staticType: int*
+''');
+    }
   }
 
   test_tearOff() async {
@@ -775,59 +2688,59 @@
 
 f(C c) => E(c).a;
 ''');
-    var identifier = findNode.simple('a;');
-    assertElement(identifier, findElement.method('a'));
-    assertType(identifier, 'void Function(int)');
-  }
 
-  void validateBinaryExpression() {
-    BinaryExpression binary = extensionOverride.parent as BinaryExpression;
-    Element? resolvedElement = binary.staticElement;
-    expect(resolvedElement, extension.getMethod('+'));
-  }
-
-  void validateCall() {
-    FunctionExpressionInvocation invocation =
-        extensionOverride.parent as FunctionExpressionInvocation;
-    Element? resolvedElement = invocation.staticElement;
-    expect(resolvedElement, extension.getMethod('call'));
-
-    NodeList<Expression> arguments = invocation.argumentList.arguments;
-    for (int i = 0; i < arguments.length; i++) {
-      expect(arguments[i].staticParameterElement, isNotNull);
-    }
-  }
-
-  void validateInvocation() {
-    MethodInvocation invocation = extensionOverride.parent as MethodInvocation;
-
-    assertMethodInvocation(
-      invocation,
-      extension.getMethod('m'),
-      'void Function()',
-    );
-
-    NodeList<Expression> arguments = invocation.argumentList.arguments;
-    for (int i = 0; i < arguments.length; i++) {
-      expect(arguments[i].staticParameterElement, isNotNull);
-    }
-  }
-
-  void validateOverride({List<DartType>? typeArguments}) {
-    expect(extensionOverride.extensionName.staticElement, extension);
-
-    expect(extensionOverride.staticType, isNull);
-    expect(extensionOverride.extensionName.staticType, isNull);
-
-    if (typeArguments == null) {
-      expect(extensionOverride.typeArguments, isNull);
+    var node = findNode.propertyAccess('E(c)');
+    if (isNullSafetyEnabled) {
+      assertResolvedNodeText(node, r'''
+PropertyAccess
+  target: ExtensionOverride
+    extensionName: SimpleIdentifier
+      token: E
+      staticElement: self::@extension::E
+      staticType: null
+    argumentList: ArgumentList
+      leftParenthesis: (
+      arguments
+        SimpleIdentifier
+          token: c
+          staticElement: c@57
+          staticType: C
+      rightParenthesis: )
+    extendedType: C
+    staticType: null
+  operator: .
+  propertyName: SimpleIdentifier
+    token: a
+    staticElement: self::@extension::E::@method::a
+    staticType: void Function(int)
+  staticType: void Function(int)
+''');
     } else {
-      expect(
-          extensionOverride.typeArguments!.arguments
-              .map((annotation) => annotation.type),
-          unorderedEquals(typeArguments));
+      assertResolvedNodeText(node, r'''
+PropertyAccess
+  target: ExtensionOverride
+    extensionName: SimpleIdentifier
+      token: E
+      staticElement: self::@extension::E
+      staticType: null
+    argumentList: ArgumentList
+      leftParenthesis: (
+      arguments
+        SimpleIdentifier
+          token: c
+          staticElement: c@57
+          staticType: C*
+      rightParenthesis: )
+    extendedType: C*
+    staticType: null
+  operator: .
+  propertyName: SimpleIdentifier
+    token: a
+    staticElement: self::@extension::E::@method::a
+    staticType: void Function(int*)*
+  staticType: void Function(int*)*
+''');
     }
-    expect(extensionOverride.argumentList.arguments, hasLength(1));
   }
 }
 
diff --git a/pkg/front_end/testcases/enhanced_enums/conflicting_elements.dart.textual_outline.expect b/pkg/front_end/testcases/enhanced_enums/conflicting_elements.dart.textual_outline.expect
index aa6cb56..1a83d84 100644
--- a/pkg/front_end/testcases/enhanced_enums/conflicting_elements.dart.textual_outline.expect
+++ b/pkg/front_end/testcases/enhanced_enums/conflicting_elements.dart.textual_outline.expect
@@ -1,20 +1,60 @@
-enum E1 { element; final int element = 42; }
-enum E2 { element, element; }
-enum E3 { element; void element() {} }
-enum E4 { element; static void element() {} }
-enum E5 { element; static int element = 42; }
-enum E6 { element; void set element(E6 value) {} }
-enum E7 { element; static void set element(E7 value) {} }
+enum E1 {
+  element;
+
+  final int element = 42;
+}
+
+enum E2 {
+  element,
+  element;
+}
+
+enum E3 {
+  element;
+
+  void element() {}
+}
+
+enum E4 {
+  element;
+
+  static void element() {}
+}
+
+enum E5 {
+  element;
+
+  static int element = 42;
+}
+
+enum E6 {
+  element;
+
+  void set element(E6 value) {}
+}
+
+enum E7 {
+  element;
+
+  static void set element(E7 value) {}
+}
+
 class A8 {
   void set element(dynamic value) {}
 }
+
 enum E8 with A8 { element }
+
 class A9 {
   int element = 42;
 }
+
 enum E9 with A9 { element }
+
 class A10 {
   void element() {}
 }
+
 enum E10 with A10 { element }
+
 main() {}
diff --git a/pkg/front_end/testcases/enhanced_enums/conflicting_elements.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/enhanced_enums/conflicting_elements.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..2ef28c8
--- /dev/null
+++ b/pkg/front_end/testcases/enhanced_enums/conflicting_elements.dart.textual_outline_modelled.expect
@@ -0,0 +1,60 @@
+class A10 {
+  void element() {}
+}
+
+class A8 {
+  void set element(dynamic value) {}
+}
+
+class A9 {
+  int element = 42;
+}
+
+enum E1 {
+  element;
+
+  final int element = 42;
+}
+
+enum E10 with A10 { element }
+
+enum E2 {
+  element,
+  element;
+}
+
+enum E3 {
+  element;
+
+  void element() {}
+}
+
+enum E4 {
+  element;
+
+  static void element() {}
+}
+
+enum E5 {
+  element;
+
+  static int element = 42;
+}
+
+enum E6 {
+  element;
+
+  void set element(E6 value) {}
+}
+
+enum E7 {
+  element;
+
+  static void set element(E7 value) {}
+}
+
+enum E8 with A8 { element }
+
+enum E9 with A9 { element }
+
+main() {}
diff --git a/pkg/front_end/testcases/enhanced_enums/constructor_calls.dart.textual_outline.expect b/pkg/front_end/testcases/enhanced_enums/constructor_calls.dart.textual_outline.expect
index 672888e..e490318 100644
--- a/pkg/front_end/testcases/enhanced_enums/constructor_calls.dart.textual_outline.expect
+++ b/pkg/front_end/testcases/enhanced_enums/constructor_calls.dart.textual_outline.expect
@@ -1,3 +1,20 @@
-enum E { one, two.named(), three.f(), four.f2(); const E(); const E.named() : this(); factory E.f() => values.first; factory E.f2() { return const E(); } const factory E.f3() = E; factory E.f4() = E; factory E.f5() = E.f; factory E.f6(int value) = E.f; }
+enum E {
+  one,
+  two.named(),
+  three.f(),
+  four.f2();
+
+  const E();
+  const E.named() : this();
+  factory E.f() => values.first;
+  factory E.f2() {
+    return const E();
+  }
+  const factory E.f3() = E;
+  factory E.f4() = E;
+  factory E.f5() = E.f;
+  factory E.f6(int value) = E.f;
+}
+
 test() {}
 main() {}
diff --git a/pkg/front_end/testcases/enhanced_enums/constructor_calls.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/enhanced_enums/constructor_calls.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..0351378
--- /dev/null
+++ b/pkg/front_end/testcases/enhanced_enums/constructor_calls.dart.textual_outline_modelled.expect
@@ -0,0 +1,20 @@
+enum E {
+  one,
+  two.named(),
+  three.f(),
+  four.f2();
+
+  const E();
+  const E.named() : this();
+  factory E.f() => values.first;
+  factory E.f2() {
+    return const E();
+  }
+  const factory E.f3() = E;
+  factory E.f4() = E;
+  factory E.f5() = E.f;
+  factory E.f6(int value) = E.f;
+}
+
+main() {}
+test() {}
diff --git a/pkg/front_end/testcases/enhanced_enums/constructor_not_found.dart.textual_outline.expect b/pkg/front_end/testcases/enhanced_enums/constructor_not_found.dart.textual_outline.expect
index 474ee41..99971da 100644
--- a/pkg/front_end/testcases/enhanced_enums/constructor_not_found.dart.textual_outline.expect
+++ b/pkg/front_end/testcases/enhanced_enums/constructor_not_found.dart.textual_outline.expect
@@ -1,3 +1,13 @@
-enum T { t; const T.named(); }
-enum S { s.named(); const S(); }
+enum T {
+  t;
+
+  const T.named();
+}
+
+enum S {
+  s.named();
+
+  const S();
+}
+
 void main() {}
diff --git a/pkg/front_end/testcases/enhanced_enums/constructor_not_found.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/enhanced_enums/constructor_not_found.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..487c963
--- /dev/null
+++ b/pkg/front_end/testcases/enhanced_enums/constructor_not_found.dart.textual_outline_modelled.expect
@@ -0,0 +1,13 @@
+enum S {
+  s.named();
+
+  const S();
+}
+
+enum T {
+  t;
+
+  const T.named();
+}
+
+void main() {}
diff --git a/pkg/front_end/testcases/enhanced_enums/declared_values.dart.textual_outline.expect b/pkg/front_end/testcases/enhanced_enums/declared_values.dart.textual_outline.expect
index ee99a49..2c03b28 100644
--- a/pkg/front_end/testcases/enhanced_enums/declared_values.dart.textual_outline.expect
+++ b/pkg/front_end/testcases/enhanced_enums/declared_values.dart.textual_outline.expect
@@ -1,8 +1,44 @@
-enum E1 { element; static const List<E1> values = [E1.element]; }
-enum E2 { element; int values = 42; }
-enum E3 { element; static const List<E3> values = [E3.element]; int values = 42; }
-enum E4 { element; static void set values(List<E4> x) {} }
-enum E5 { element; static void set values(dynamic x) {} }
-enum E6 { element; static void set values(Never x) {} }
-enum E7 { element; void values() {} }
+enum E1 {
+  element;
+
+  static const List<E1> values = [E1.element];
+}
+
+enum E2 {
+  element;
+
+  int values = 42;
+}
+
+enum E3 {
+  element;
+
+  static const List<E3> values = [E3.element];
+  int values = 42;
+}
+
+enum E4 {
+  element;
+
+  static void set values(List<E4> x) {}
+}
+
+enum E5 {
+  element;
+
+  static void set values(dynamic x) {}
+}
+
+enum E6 {
+  element;
+
+  static void set values(Never x) {}
+}
+
+enum E7 {
+  element;
+
+  void values() {}
+}
+
 main() {}
diff --git a/pkg/front_end/testcases/enhanced_enums/declared_values.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/enhanced_enums/declared_values.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..2c03b28
--- /dev/null
+++ b/pkg/front_end/testcases/enhanced_enums/declared_values.dart.textual_outline_modelled.expect
@@ -0,0 +1,44 @@
+enum E1 {
+  element;
+
+  static const List<E1> values = [E1.element];
+}
+
+enum E2 {
+  element;
+
+  int values = 42;
+}
+
+enum E3 {
+  element;
+
+  static const List<E3> values = [E3.element];
+  int values = 42;
+}
+
+enum E4 {
+  element;
+
+  static void set values(List<E4> x) {}
+}
+
+enum E5 {
+  element;
+
+  static void set values(dynamic x) {}
+}
+
+enum E6 {
+  element;
+
+  static void set values(Never x) {}
+}
+
+enum E7 {
+  element;
+
+  void values() {}
+}
+
+main() {}
diff --git a/pkg/front_end/testcases/enhanced_enums/enum_as_supertype.dart.textual_outline.expect b/pkg/front_end/testcases/enhanced_enums/enum_as_supertype.dart.textual_outline.expect
index 4344750..c5514b9 100644
--- a/pkg/front_end/testcases/enhanced_enums/enum_as_supertype.dart.textual_outline.expect
+++ b/pkg/front_end/testcases/enhanced_enums/enum_as_supertype.dart.textual_outline.expect
@@ -1,18 +1,26 @@
 abstract class A extends Enum {
   int get foo => index;
 }
+
 enum EA with A { element }
+
 abstract class B implements Enum {
   int get foo => index;
 }
+
 enum EB with B { element }
+
 mixin M on Enum {
   int get foo => index;
 }
+
 enum EM with M { element }
+
 mixin N implements Enum {
   int get foo => index;
 }
+
 enum EN with N { element }
+
 expectEquals(x, y) {}
 main() {}
diff --git a/pkg/front_end/testcases/enhanced_enums/enum_as_supertype.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/enhanced_enums/enum_as_supertype.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..1a4630a
--- /dev/null
+++ b/pkg/front_end/testcases/enhanced_enums/enum_as_supertype.dart.textual_outline_modelled.expect
@@ -0,0 +1,24 @@
+abstract class A extends Enum {
+  int get foo => index;
+}
+
+abstract class B implements Enum {
+  int get foo => index;
+}
+
+enum EA with A { element }
+
+enum EB with B { element }
+
+enum EM with M { element }
+
+enum EN with N { element }
+
+expectEquals(x, y) {}
+main() {}
+mixin M on Enum {
+  int get foo => index;
+}
+mixin N implements Enum {
+  int get foo => index;
+}
diff --git a/pkg/front_end/testcases/enhanced_enums/inference_in_constructor_parameters.dart.textual_outline.expect b/pkg/front_end/testcases/enhanced_enums/inference_in_constructor_parameters.dart.textual_outline.expect
index 707dc9c..4f3495e 100644
--- a/pkg/front_end/testcases/enhanced_enums/inference_in_constructor_parameters.dart.textual_outline.expect
+++ b/pkg/front_end/testcases/enhanced_enums/inference_in_constructor_parameters.dart.textual_outline.expect
@@ -1,5 +1,17 @@
 X foo<X>(X x) => x;
-enum E1 { bar(foo); const E1(int Function(int) f); }
-enum E2<X> { bar(foo); const E2(X f); }
+
+enum E1 {
+  bar(foo);
+
+  const E1(int Function(int) f);
+}
+
+enum E2<X> {
+  bar(foo);
+
+  const E2(X f);
+}
+
 enum E3<X extends num, Y extends String, Z extends Function(X, Y)> { element }
+
 main() {}
diff --git a/pkg/front_end/testcases/enhanced_enums/inference_in_constructor_parameters.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/enhanced_enums/inference_in_constructor_parameters.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..4f3495e
--- /dev/null
+++ b/pkg/front_end/testcases/enhanced_enums/inference_in_constructor_parameters.dart.textual_outline_modelled.expect
@@ -0,0 +1,17 @@
+X foo<X>(X x) => x;
+
+enum E1 {
+  bar(foo);
+
+  const E1(int Function(int) f);
+}
+
+enum E2<X> {
+  bar(foo);
+
+  const E2(X f);
+}
+
+enum E3<X extends num, Y extends String, Z extends Function(X, Y)> { element }
+
+main() {}
diff --git a/pkg/front_end/testcases/enhanced_enums/instantiated_generic_enum_types.dart.textual_outline.expect b/pkg/front_end/testcases/enhanced_enums/instantiated_generic_enum_types.dart.textual_outline.expect
index 8ce4f0c..88e3d26 100644
--- a/pkg/front_end/testcases/enhanced_enums/instantiated_generic_enum_types.dart.textual_outline.expect
+++ b/pkg/front_end/testcases/enhanced_enums/instantiated_generic_enum_types.dart.textual_outline.expect
@@ -1,4 +1,11 @@
-enum E<X> { one(1), two("2"); final X field; const E(this.field); }
+enum E<X> {
+  one(1),
+  two("2");
+
+  final X field;
+  const E(this.field);
+}
+
 test() {}
 foo(E<int> ei, E<String> es) {}
 bar(E<int> ei, E<String> es) {}
diff --git a/pkg/front_end/testcases/enhanced_enums/instantiated_generic_enum_types.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/enhanced_enums/instantiated_generic_enum_types.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..d32b67f
--- /dev/null
+++ b/pkg/front_end/testcases/enhanced_enums/instantiated_generic_enum_types.dart.textual_outline_modelled.expect
@@ -0,0 +1,17 @@
+bar(E<int> ei, E<String> es) {}
+baz(E<Object> ei, E<Object> es) {}
+boz(E<Never> ei, E<Never> es) {}
+checkIsNotType<T>(x) {}
+checkIsType<T>(x) {}
+
+enum E<X> {
+  one(1),
+  two("2");
+
+  final X field;
+  const E(this.field);
+}
+
+foo(E<int> ei, E<String> es) {}
+main() {}
+test() {}
diff --git a/pkg/front_end/testcases/enhanced_enums/issue48084.dart.textual_outline.expect b/pkg/front_end/testcases/enhanced_enums/issue48084.dart.textual_outline.expect
index 57d7640..b188f35 100644
--- a/pkg/front_end/testcases/enhanced_enums/issue48084.dart.textual_outline.expect
+++ b/pkg/front_end/testcases/enhanced_enums/issue48084.dart.textual_outline.expect
@@ -1,3 +1,12 @@
-enum E { one("foo"), two("bar"); final String field; const E(this.field); @override String toString() => field; }
+enum E {
+  one("foo"),
+  two("bar");
+
+  final String field;
+  const E(this.field);
+  @override
+  String toString() => field;
+}
+
 expectEquals(a, b) {}
 main() {}
diff --git a/pkg/front_end/testcases/enhanced_enums/issue48084.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/enhanced_enums/issue48084.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..b188f35
--- /dev/null
+++ b/pkg/front_end/testcases/enhanced_enums/issue48084.dart.textual_outline_modelled.expect
@@ -0,0 +1,12 @@
+enum E {
+  one("foo"),
+  two("bar");
+
+  final String field;
+  const E(this.field);
+  @override
+  String toString() => field;
+}
+
+expectEquals(a, b) {}
+main() {}
diff --git a/pkg/front_end/testcases/enhanced_enums/issue48181.dart.textual_outline.expect b/pkg/front_end/testcases/enhanced_enums/issue48181.dart.textual_outline.expect
index ac00eb5e..90d4341 100644
--- a/pkg/front_end/testcases/enhanced_enums/issue48181.dart.textual_outline.expect
+++ b/pkg/front_end/testcases/enhanced_enums/issue48181.dart.textual_outline.expect
@@ -1,3 +1,16 @@
-enum E { e1, e2; factory E.f(int i) => E.values[i]; }
-enum F { f1, f2(42), f3.foo(); factory F(int i) => F.values[i]; }
+enum E {
+  e1,
+  e2;
+
+  factory E.f(int i) => E.values[i];
+}
+
+enum F {
+  f1,
+  f2(42),
+  f3.foo();
+
+  factory F(int i) => F.values[i];
+}
+
 main() {}
diff --git a/pkg/front_end/testcases/enhanced_enums/issue48181.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/enhanced_enums/issue48181.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..90d4341
--- /dev/null
+++ b/pkg/front_end/testcases/enhanced_enums/issue48181.dart.textual_outline_modelled.expect
@@ -0,0 +1,16 @@
+enum E {
+  e1,
+  e2;
+
+  factory E.f(int i) => E.values[i];
+}
+
+enum F {
+  f1,
+  f2(42),
+  f3.foo();
+
+  factory F(int i) => F.values[i];
+}
+
+main() {}
diff --git a/pkg/front_end/testcases/enhanced_enums/issue48232.dart.textual_outline.expect b/pkg/front_end/testcases/enhanced_enums/issue48232.dart.textual_outline.expect
index 1f73072..359a7ab 100644
--- a/pkg/front_end/testcases/enhanced_enums/issue48232.dart.textual_outline.expect
+++ b/pkg/front_end/testcases/enhanced_enums/issue48232.dart.textual_outline.expect
@@ -1,2 +1,7 @@
-enum E { v([]); const E(_); }
+enum E {
+  v([]);
+
+  const E(_);
+}
+
 main() {}
diff --git a/pkg/front_end/testcases/enhanced_enums/issue48232.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/enhanced_enums/issue48232.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..359a7ab
--- /dev/null
+++ b/pkg/front_end/testcases/enhanced_enums/issue48232.dart.textual_outline_modelled.expect
@@ -0,0 +1,7 @@
+enum E {
+  v([]);
+
+  const E(_);
+}
+
+main() {}
diff --git a/pkg/front_end/testcases/enhanced_enums/issue48303.dart.textual_outline.expect b/pkg/front_end/testcases/enhanced_enums/issue48303.dart.textual_outline.expect
index b70621c..f5732c3 100644
--- a/pkg/front_end/testcases/enhanced_enums/issue48303.dart.textual_outline.expect
+++ b/pkg/front_end/testcases/enhanced_enums/issue48303.dart.textual_outline.expect
@@ -1,6 +1,12 @@
 mixin M1 on Enum {
   int mixedInMethod1(int v) => v;
 }
-enum E with M1 { e1, e2, e3; }
+
+enum E with M1 {
+  e1,
+  e2,
+  e3;
+}
+
 expectEquals(x, y) {}
 main() {}
diff --git a/pkg/front_end/testcases/enhanced_enums/issue48303.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/enhanced_enums/issue48303.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..5c66761
--- /dev/null
+++ b/pkg/front_end/testcases/enhanced_enums/issue48303.dart.textual_outline_modelled.expect
@@ -0,0 +1,11 @@
+enum E with M1 {
+  e1,
+  e2,
+  e3;
+}
+
+expectEquals(x, y) {}
+main() {}
+mixin M1 on Enum {
+  int mixedInMethod1(int v) => v;
+}
diff --git a/pkg/front_end/testcases/enhanced_enums/malformed_constructors.dart.textual_outline.expect b/pkg/front_end/testcases/enhanced_enums/malformed_constructors.dart.textual_outline.expect
index 4aac745..47d7784 100644
--- a/pkg/front_end/testcases/enhanced_enums/malformed_constructors.dart.textual_outline.expect
+++ b/pkg/front_end/testcases/enhanced_enums/malformed_constructors.dart.textual_outline.expect
@@ -1,3 +1,16 @@
-enum E1 { element; E1(); E1.named(); }
-enum E2 { one.named1(), two.named2(); const E2.named1() : super(); const E2.named2() : super(42, "42"); }
+enum E1 {
+  element;
+
+  E1();
+  E1.named();
+}
+
+enum E2 {
+  one.named1(),
+  two.named2();
+
+  const E2.named1() : super();
+  const E2.named2() : super(42, "42");
+}
+
 main() {}
diff --git a/pkg/front_end/testcases/enhanced_enums/malformed_constructors.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/enhanced_enums/malformed_constructors.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..47d7784
--- /dev/null
+++ b/pkg/front_end/testcases/enhanced_enums/malformed_constructors.dart.textual_outline_modelled.expect
@@ -0,0 +1,16 @@
+enum E1 {
+  element;
+
+  E1();
+  E1.named();
+}
+
+enum E2 {
+  one.named1(),
+  two.named2();
+
+  const E2.named1() : super();
+  const E2.named2() : super(42, "42");
+}
+
+main() {}
diff --git a/pkg/front_end/testcases/enhanced_enums/members.dart.textual_outline.expect b/pkg/front_end/testcases/enhanced_enums/members.dart.textual_outline.expect
index 1037478..4235f68 100644
--- a/pkg/front_end/testcases/enhanced_enums/members.dart.textual_outline.expect
+++ b/pkg/front_end/testcases/enhanced_enums/members.dart.textual_outline.expect
@@ -1,3 +1,27 @@
-enum E { one(1), two(2); final int foo; final int bar = 42; static E staticFoo = new E.f(); const E(this.foo); factory E.f() => E.one; int method(int value) => value + 10; String staticMethod(double d, bool b) => "$d$b"; }
-enum E2<X> { one<num>(1), two("2"); final X foo; final X? bar = null; static var staticFoo = () => new E2.f(); const E2(this.foo); factory E2.f() => throw 42; int method(int value) => value + 10; String staticMethod(double d, X x) => "$d$x"; }
+enum E {
+  one(1),
+  two(2);
+
+  final int foo;
+  final int bar = 42;
+  static E staticFoo = new E.f();
+  const E(this.foo);
+  factory E.f() => E.one;
+  int method(int value) => value + 10;
+  String staticMethod(double d, bool b) => "$d$b";
+}
+
+enum E2<X> {
+  one<num>(1),
+  two("2");
+
+  final X foo;
+  final X? bar = null;
+  static var staticFoo = () => new E2.f();
+  const E2(this.foo);
+  factory E2.f() => throw 42;
+  int method(int value) => value + 10;
+  String staticMethod(double d, X x) => "$d$x";
+}
+
 main() {}
diff --git a/pkg/front_end/testcases/enhanced_enums/members.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/enhanced_enums/members.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..4235f68
--- /dev/null
+++ b/pkg/front_end/testcases/enhanced_enums/members.dart.textual_outline_modelled.expect
@@ -0,0 +1,27 @@
+enum E {
+  one(1),
+  two(2);
+
+  final int foo;
+  final int bar = 42;
+  static E staticFoo = new E.f();
+  const E(this.foo);
+  factory E.f() => E.one;
+  int method(int value) => value + 10;
+  String staticMethod(double d, bool b) => "$d$b";
+}
+
+enum E2<X> {
+  one<num>(1),
+  two("2");
+
+  final X foo;
+  final X? bar = null;
+  static var staticFoo = () => new E2.f();
+  const E2(this.foo);
+  factory E2.f() => throw 42;
+  int method(int value) => value + 10;
+  String staticMethod(double d, X x) => "$d$x";
+}
+
+main() {}
diff --git a/pkg/front_end/testcases/enhanced_enums/named_arguments.dart.textual_outline.expect b/pkg/front_end/testcases/enhanced_enums/named_arguments.dart.textual_outline.expect
index c2dd324..1cff5f7 100644
--- a/pkg/front_end/testcases/enhanced_enums/named_arguments.dart.textual_outline.expect
+++ b/pkg/front_end/testcases/enhanced_enums/named_arguments.dart.textual_outline.expect
@@ -1,4 +1,29 @@
-enum E0 { one(1, bar: 1), two(2, bar: 2); final int foo; final int bar; const E0(this.foo, {required this.bar}); }
-enum E1<X> { one(foo: "1"), two(foo: 2); final X foo; const E1({required this.foo}); }
-enum E2<X, Y, Z> { one(1, bar: "1", baz: 3.14), two("2", baz: 3.14, bar: 2), three(3.0, bar: false); final X foo; final Y bar; final Z? baz; const E2(this.foo, {required this.bar, this.baz = null}); }
+enum E0 {
+  one(1, bar: 1),
+  two(2, bar: 2);
+
+  final int foo;
+  final int bar;
+  const E0(this.foo, {required this.bar});
+}
+
+enum E1<X> {
+  one(foo: "1"),
+  two(foo: 2);
+
+  final X foo;
+  const E1({required this.foo});
+}
+
+enum E2<X, Y, Z> {
+  one(1, bar: "1", baz: 3.14),
+  two("2", baz: 3.14, bar: 2),
+  three(3.0, bar: false);
+
+  final X foo;
+  final Y bar;
+  final Z? baz;
+  const E2(this.foo, {required this.bar, this.baz = null});
+}
+
 main() {}
diff --git a/pkg/front_end/testcases/enhanced_enums/named_arguments.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/enhanced_enums/named_arguments.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..1cff5f7
--- /dev/null
+++ b/pkg/front_end/testcases/enhanced_enums/named_arguments.dart.textual_outline_modelled.expect
@@ -0,0 +1,29 @@
+enum E0 {
+  one(1, bar: 1),
+  two(2, bar: 2);
+
+  final int foo;
+  final int bar;
+  const E0(this.foo, {required this.bar});
+}
+
+enum E1<X> {
+  one(foo: "1"),
+  two(foo: 2);
+
+  final X foo;
+  const E1({required this.foo});
+}
+
+enum E2<X, Y, Z> {
+  one(1, bar: "1", baz: 3.14),
+  two("2", baz: 3.14, bar: 2),
+  three(3.0, bar: false);
+
+  final X foo;
+  final Y bar;
+  final Z? baz;
+  const E2(this.foo, {required this.bar, this.baz = null});
+}
+
+main() {}
diff --git a/pkg/front_end/testcases/enhanced_enums/named_arguments_anywhere/redirecting_constructor.dart.textual_outline.expect b/pkg/front_end/testcases/enhanced_enums/named_arguments_anywhere/redirecting_constructor.dart.textual_outline.expect
index 03be650..d49769a 100644
--- a/pkg/front_end/testcases/enhanced_enums/named_arguments_anywhere/redirecting_constructor.dart.textual_outline.expect
+++ b/pkg/front_end/testcases/enhanced_enums/named_arguments_anywhere/redirecting_constructor.dart.textual_outline.expect
@@ -1,3 +1,18 @@
-enum C { a(1, 2, z: 3), b(z: 3, 1, 2), c(1, z: 3, 2), d.named1(1, 2, 3), e.named2(1, 2, 3), f.named3(1, 2, 3), ; final String log; const C(int x, int y, {int z = 42}) : this.log = "x=$x, y=$y, z=$z"; const C.named1(int x, int y, int z) : this(x, y, z: z); const C.named2(int x, int y, int z) : this(x, z: z, y); const C.named3(int x, int y, int z) : this(z: z, x, y); }
+enum C {
+  a(1, 2, z: 3),
+  b(z: 3, 1, 2),
+  c(1, z: 3, 2),
+  d.named1(1, 2, 3),
+  e.named2(1, 2, 3),
+  f.named3(1, 2, 3),
+  ;
+
+  final String log;
+  const C(int x, int y, {int z = 42}) : this.log = "x=$x, y=$y, z=$z";
+  const C.named1(int x, int y, int z) : this(x, y, z: z);
+  const C.named2(int x, int y, int z) : this(x, z: z, y);
+  const C.named3(int x, int y, int z) : this(z: z, x, y);
+}
+
 main() {}
 expect(expected, actual) {}
diff --git a/pkg/front_end/testcases/enhanced_enums/named_arguments_anywhere/redirecting_constructor.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/enhanced_enums/named_arguments_anywhere/redirecting_constructor.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..8fff920
--- /dev/null
+++ b/pkg/front_end/testcases/enhanced_enums/named_arguments_anywhere/redirecting_constructor.dart.textual_outline_modelled.expect
@@ -0,0 +1,18 @@
+enum C {
+  a(1, 2, z: 3),
+  b(z: 3, 1, 2),
+  c(1, z: 3, 2),
+  d.named1(1, 2, 3),
+  e.named2(1, 2, 3),
+  f.named3(1, 2, 3),
+  ;
+
+  final String log;
+  const C(int x, int y, {int z = 42}) : this.log = "x=$x, y=$y, z=$z";
+  const C.named1(int x, int y, int z) : this(x, y, z: z);
+  const C.named2(int x, int y, int z) : this(x, z: z, y);
+  const C.named3(int x, int y, int z) : this(z: z, x, y);
+}
+
+expect(expected, actual) {}
+main() {}
diff --git a/pkg/front_end/testcases/enhanced_enums/qualified_names_with_no_type_arguments.dart.textual_outline.expect b/pkg/front_end/testcases/enhanced_enums/qualified_names_with_no_type_arguments.dart.textual_outline.expect
index bc9f7ff..e53cb1d 100644
--- a/pkg/front_end/testcases/enhanced_enums/qualified_names_with_no_type_arguments.dart.textual_outline.expect
+++ b/pkg/front_end/testcases/enhanced_enums/qualified_names_with_no_type_arguments.dart.textual_outline.expect
@@ -1,2 +1,7 @@
-enum E { a.b() ; const E.b(); }
+enum E {
+  a.b();
+
+  const E.b();
+}
+
 main() {}
diff --git a/pkg/front_end/testcases/enhanced_enums/qualified_names_with_no_type_arguments.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/enhanced_enums/qualified_names_with_no_type_arguments.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..e53cb1d
--- /dev/null
+++ b/pkg/front_end/testcases/enhanced_enums/qualified_names_with_no_type_arguments.dart.textual_outline_modelled.expect
@@ -0,0 +1,7 @@
+enum E {
+  a.b();
+
+  const E.b();
+}
+
+main() {}
diff --git a/pkg/front_end/testcases/enhanced_enums/redirecting_initializers.dart.textual_outline.expect b/pkg/front_end/testcases/enhanced_enums/redirecting_initializers.dart.textual_outline.expect
index 8246ad5..89a8e24 100644
--- a/pkg/front_end/testcases/enhanced_enums/redirecting_initializers.dart.textual_outline.expect
+++ b/pkg/front_end/testcases/enhanced_enums/redirecting_initializers.dart.textual_outline.expect
@@ -1,3 +1,19 @@
-enum E1 { one(1), two.named(2); final int foo; const E1(this.foo); const E1.named(int value) : this(value); }
-enum E2 { one(1), two.named(2); final int foo; const E2(this.foo); const E2.named(int value) : this(value, value); }
+enum E1 {
+  one(1),
+  two.named(2);
+
+  final int foo;
+  const E1(this.foo);
+  const E1.named(int value) : this(value);
+}
+
+enum E2 {
+  one(1),
+  two.named(2);
+
+  final int foo;
+  const E2(this.foo);
+  const E2.named(int value) : this(value, value);
+}
+
 main() {}
diff --git a/pkg/front_end/testcases/enhanced_enums/redirecting_initializers.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/enhanced_enums/redirecting_initializers.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..89a8e24
--- /dev/null
+++ b/pkg/front_end/testcases/enhanced_enums/redirecting_initializers.dart.textual_outline_modelled.expect
@@ -0,0 +1,19 @@
+enum E1 {
+  one(1),
+  two.named(2);
+
+  final int foo;
+  const E1(this.foo);
+  const E1.named(int value) : this(value);
+}
+
+enum E2 {
+  one(1),
+  two.named(2);
+
+  final int foo;
+  const E2(this.foo);
+  const E2.named(int value) : this(value, value);
+}
+
+main() {}
diff --git a/pkg/front_end/testcases/enhanced_enums/simple_fields.dart.textual_outline.expect b/pkg/front_end/testcases/enhanced_enums/simple_fields.dart.textual_outline.expect
index d11d9cd..0815587 100644
--- a/pkg/front_end/testcases/enhanced_enums/simple_fields.dart.textual_outline.expect
+++ b/pkg/front_end/testcases/enhanced_enums/simple_fields.dart.textual_outline.expect
@@ -1,3 +1,21 @@
-enum E1 { one(1), two.named(2); final int foo; const E1(this.foo); const E1.named(int value) : foo = value; }
-enum E2<X, Y> { one<int, String>(1, "one"), two.named("two", 2), three.named("three", "three"); final X foo; final Y bar; const E2(this.foo, this.bar); const E2.named(Y this.bar, X this.foo); }
+enum E1 {
+  one(1),
+  two.named(2);
+
+  final int foo;
+  const E1(this.foo);
+  const E1.named(int value) : foo = value;
+}
+
+enum E2<X, Y> {
+  one<int, String>(1, "one"),
+  two.named("two", 2),
+  three.named("three", "three");
+
+  final X foo;
+  final Y bar;
+  const E2(this.foo, this.bar);
+  const E2.named(Y this.bar, X this.foo);
+}
+
 main() {}
diff --git a/pkg/front_end/testcases/enhanced_enums/simple_fields.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/enhanced_enums/simple_fields.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..0815587
--- /dev/null
+++ b/pkg/front_end/testcases/enhanced_enums/simple_fields.dart.textual_outline_modelled.expect
@@ -0,0 +1,21 @@
+enum E1 {
+  one(1),
+  two.named(2);
+
+  final int foo;
+  const E1(this.foo);
+  const E1.named(int value) : foo = value;
+}
+
+enum E2<X, Y> {
+  one<int, String>(1, "one"),
+  two.named("two", 2),
+  three.named("three", "three");
+
+  final X foo;
+  final Y bar;
+  const E2(this.foo, this.bar);
+  const E2.named(Y this.bar, X this.foo);
+}
+
+main() {}
diff --git a/pkg/front_end/testcases/enhanced_enums/simple_interfaces.dart.textual_outline.expect b/pkg/front_end/testcases/enhanced_enums/simple_interfaces.dart.textual_outline.expect
index b33af83..0a18666 100644
--- a/pkg/front_end/testcases/enhanced_enums/simple_interfaces.dart.textual_outline.expect
+++ b/pkg/front_end/testcases/enhanced_enums/simple_interfaces.dart.textual_outline.expect
@@ -1,10 +1,30 @@
 abstract class I {
   void foo();
 }
-enum E1 implements I { one, two; void foo() {} }
+
+enum E1 implements I {
+  one,
+  two;
+
+  void foo() {}
+}
+
 enum E2 implements I { one, two }
-enum E3 implements I? { one, two; void foo() {} }
-enum E4 { one, two; void foo() {} }
+
+enum E3 implements I? {
+  one,
+  two;
+
+  void foo() {}
+}
+
+enum E4 {
+  one,
+  two;
+
+  void foo() {}
+}
+
 bar(I i) {}
 test(E1 e1, E2 e2, E3 e3, E4 e4) {}
 main() {}
diff --git a/pkg/front_end/testcases/enhanced_enums/simple_interfaces.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/enhanced_enums/simple_interfaces.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..8fe40d6
--- /dev/null
+++ b/pkg/front_end/testcases/enhanced_enums/simple_interfaces.dart.textual_outline_modelled.expect
@@ -0,0 +1,31 @@
+abstract class I {
+  void foo();
+}
+
+bar(I i) {}
+
+enum E1 implements I {
+  one,
+  two;
+
+  void foo() {}
+}
+
+enum E2 implements I { one, two }
+
+enum E3 implements I? {
+  one,
+  two;
+
+  void foo() {}
+}
+
+enum E4 {
+  one,
+  two;
+
+  void foo() {}
+}
+
+main() {}
+test(E1 e1, E2 e2, E3 e3, E4 e4) {}
diff --git a/pkg/front_end/testcases/enhanced_enums/simple_mixins.dart.textual_outline.expect b/pkg/front_end/testcases/enhanced_enums/simple_mixins.dart.textual_outline.expect
index 8e3abd8..a428d0b 100644
--- a/pkg/front_end/testcases/enhanced_enums/simple_mixins.dart.textual_outline.expect
+++ b/pkg/front_end/testcases/enhanced_enums/simple_mixins.dart.textual_outline.expect
@@ -1,15 +1,21 @@
 class A {
   String get foo => "foo";
 }
+
 class B {
   int bar() => 42;
 }
+
 mixin M {
   void set callOnAssignment(void Function() f) {}
 }
+
 enum E1 with A { one, two }
+
 enum E2 with A, B { one, two }
+
 enum E3 with M { one, two }
+
 expectEquals(x, y) {}
 expectThrows(void Function() f) {}
 void throwOnCall() {}
diff --git a/pkg/front_end/testcases/enhanced_enums/simple_mixins.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/enhanced_enums/simple_mixins.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..bd0fbf1
--- /dev/null
+++ b/pkg/front_end/testcases/enhanced_enums/simple_mixins.dart.textual_outline_modelled.expect
@@ -0,0 +1,21 @@
+class A {
+  String get foo => "foo";
+}
+
+class B {
+  int bar() => 42;
+}
+
+enum E1 with A { one, two }
+
+enum E2 with A, B { one, two }
+
+enum E3 with M { one, two }
+
+expectEquals(x, y) {}
+expectThrows(void Function() f) {}
+main() {}
+mixin M {
+  void set callOnAssignment(void Function() f) {}
+}
+void throwOnCall() {}
diff --git a/pkg/front_end/testcases/enhanced_enums/super_parameters/malformed_constructors.dart.textual_outline.expect b/pkg/front_end/testcases/enhanced_enums/super_parameters/malformed_constructors.dart.textual_outline.expect
index 4aac745..47d7784 100644
--- a/pkg/front_end/testcases/enhanced_enums/super_parameters/malformed_constructors.dart.textual_outline.expect
+++ b/pkg/front_end/testcases/enhanced_enums/super_parameters/malformed_constructors.dart.textual_outline.expect
@@ -1,3 +1,16 @@
-enum E1 { element; E1(); E1.named(); }
-enum E2 { one.named1(), two.named2(); const E2.named1() : super(); const E2.named2() : super(42, "42"); }
+enum E1 {
+  element;
+
+  E1();
+  E1.named();
+}
+
+enum E2 {
+  one.named1(),
+  two.named2();
+
+  const E2.named1() : super();
+  const E2.named2() : super(42, "42");
+}
+
 main() {}
diff --git a/pkg/front_end/testcases/enhanced_enums/super_parameters/malformed_constructors.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/enhanced_enums/super_parameters/malformed_constructors.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..47d7784
--- /dev/null
+++ b/pkg/front_end/testcases/enhanced_enums/super_parameters/malformed_constructors.dart.textual_outline_modelled.expect
@@ -0,0 +1,16 @@
+enum E1 {
+  element;
+
+  E1();
+  E1.named();
+}
+
+enum E2 {
+  one.named1(),
+  two.named2();
+
+  const E2.named1() : super();
+  const E2.named2() : super(42, "42");
+}
+
+main() {}
diff --git a/pkg/front_end/testcases/enhanced_enums/supertype_resolved_before_checking.dart.textual_outline.expect b/pkg/front_end/testcases/enhanced_enums/supertype_resolved_before_checking.dart.textual_outline.expect
index 5874d3e..998e815 100644
--- a/pkg/front_end/testcases/enhanced_enums/supertype_resolved_before_checking.dart.textual_outline.expect
+++ b/pkg/front_end/testcases/enhanced_enums/supertype_resolved_before_checking.dart.textual_outline.expect
@@ -1,6 +1,12 @@
 mixin GM<T> on Enum {}
 mixin M on Object {}
+
 abstract class I {}
+
 abstract class GI<T> {}
-enum E<S extends num, T extends num> with GM<T>, M implements I, GI<S> { element }
+
+enum E<S extends num, T extends num> with GM<T>, M implements I, GI<S> {
+  element
+}
+
 main() {}
diff --git a/pkg/front_end/testcases/enhanced_enums/supertype_resolved_before_checking.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/enhanced_enums/supertype_resolved_before_checking.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..9a1883e
--- /dev/null
+++ b/pkg/front_end/testcases/enhanced_enums/supertype_resolved_before_checking.dart.textual_outline_modelled.expect
@@ -0,0 +1,11 @@
+abstract class GI<T> {}
+
+abstract class I {}
+
+enum E<S extends num, T extends num> with GM<T>, M implements I, GI<S> {
+  element
+}
+
+main() {}
+mixin GM<T> on Enum {}
+mixin M on Object {}
diff --git a/pkg/front_end/testcases/general/annotation_on_enum_values.dart.textual_outline.expect b/pkg/front_end/testcases/general/annotation_on_enum_values.dart.textual_outline.expect
index 42c4aa9..6b1018f 100644
--- a/pkg/front_end/testcases/general/annotation_on_enum_values.dart.textual_outline.expect
+++ b/pkg/front_end/testcases/general/annotation_on_enum_values.dart.textual_outline.expect
@@ -12,4 +12,5 @@
   baz,
   cafebabe,
 }
+
 main() {}
diff --git a/pkg/front_end/testcases/general/annotation_on_enum_values.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/general/annotation_on_enum_values.dart.textual_outline_modelled.expect
index 1866609..1b22ef3 100644
--- a/pkg/front_end/testcases/general/annotation_on_enum_values.dart.textual_outline_modelled.expect
+++ b/pkg/front_end/testcases/general/annotation_on_enum_values.dart.textual_outline_modelled.expect
@@ -4,6 +4,7 @@
 }
 
 const int hest = 42;
+
 enum Foo {
   @hest
   bar,
@@ -11,4 +12,5 @@
   baz,
   cafebabe,
 }
+
 main() {}
diff --git a/pkg/front_end/testcases/general/enum_names_from_core.dart.textual_outline.expect b/pkg/front_end/testcases/general/enum_names_from_core.dart.textual_outline.expect
index ba503dc..8ced954 100644
--- a/pkg/front_end/testcases/general/enum_names_from_core.dart.textual_outline.expect
+++ b/pkg/front_end/testcases/general/enum_names_from_core.dart.textual_outline.expect
@@ -15,4 +15,5 @@
   _Enum,
   List,
 }
+
 main() {}
diff --git a/pkg/front_end/testcases/general/enum_names_from_core.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/general/enum_names_from_core.dart.textual_outline_modelled.expect
index 361bcb3..63ae580 100644
--- a/pkg/front_end/testcases/general/enum_names_from_core.dart.textual_outline_modelled.expect
+++ b/pkg/front_end/testcases/general/enum_names_from_core.dart.textual_outline_modelled.expect
@@ -15,4 +15,5 @@
   _Enum,
   List,
 }
+
 main() {}
diff --git a/pkg/front_end/testcases/general/instantiate_enum/main.dart.textual_outline.expect b/pkg/front_end/testcases/general/instantiate_enum/main.dart.textual_outline.expect
index 9e362fc..f5cfa60 100644
--- a/pkg/front_end/testcases/general/instantiate_enum/main.dart.textual_outline.expect
+++ b/pkg/front_end/testcases/general/instantiate_enum/main.dart.textual_outline.expect
@@ -1,6 +1,7 @@
 import 'main_lib.dart';
 
 enum Enum1 { a, b, c }
+
 typedef Alias1 = Enum1;
 test() {}
 main() {}
diff --git a/pkg/front_end/testcases/general/instantiate_enum/main.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/general/instantiate_enum/main.dart.textual_outline_modelled.expect
index 596d8b2..5082198 100644
--- a/pkg/front_end/testcases/general/instantiate_enum/main.dart.textual_outline_modelled.expect
+++ b/pkg/front_end/testcases/general/instantiate_enum/main.dart.textual_outline_modelled.expect
@@ -1,6 +1,7 @@
 import 'main_lib.dart';
 
 enum Enum1 { a, b, c }
+
 main() {}
 test() {}
 typedef Alias1 = Enum1;
diff --git a/pkg/front_end/testcases/general/metadata_enum.dart.textual_outline.expect b/pkg/front_end/testcases/general/metadata_enum.dart.textual_outline.expect
index 4e0154a..fcf0e3c 100644
--- a/pkg/front_end/testcases/general/metadata_enum.dart.textual_outline.expect
+++ b/pkg/front_end/testcases/general/metadata_enum.dart.textual_outline.expect
@@ -1,5 +1,7 @@
 // @dart = 2.9
 const a = null;
+
 @a
 enum E { E1, E2, E3 }
+
 main() {}
diff --git a/pkg/front_end/testcases/general/metadata_enum.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/general/metadata_enum.dart.textual_outline_modelled.expect
index 4e0154a..fcf0e3c 100644
--- a/pkg/front_end/testcases/general/metadata_enum.dart.textual_outline_modelled.expect
+++ b/pkg/front_end/testcases/general/metadata_enum.dart.textual_outline_modelled.expect
@@ -1,5 +1,7 @@
 // @dart = 2.9
 const a = null;
+
 @a
 enum E { E1, E2, E3 }
+
 main() {}
diff --git a/pkg/front_end/testcases/inference/inferred_type_is_enum.dart.textual_outline.expect b/pkg/front_end/testcases/inference/inferred_type_is_enum.dart.textual_outline.expect
index 7e8eab6..d228da5 100644
--- a/pkg/front_end/testcases/inference/inferred_type_is_enum.dart.textual_outline.expect
+++ b/pkg/front_end/testcases/inference/inferred_type_is_enum.dart.textual_outline.expect
@@ -2,5 +2,6 @@
 library test;
 
 enum E { v1 }
+
 final x = E.v1;
 main() {}
diff --git a/pkg/front_end/testcases/inference/inferred_type_is_enum.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/inference/inferred_type_is_enum.dart.textual_outline_modelled.expect
index 7e8eab6..d228da5 100644
--- a/pkg/front_end/testcases/inference/inferred_type_is_enum.dart.textual_outline_modelled.expect
+++ b/pkg/front_end/testcases/inference/inferred_type_is_enum.dart.textual_outline_modelled.expect
@@ -2,5 +2,6 @@
 library test;
 
 enum E { v1 }
+
 final x = E.v1;
 main() {}
diff --git a/pkg/front_end/testcases/inference/inferred_type_is_enum_values.dart.textual_outline.expect b/pkg/front_end/testcases/inference/inferred_type_is_enum_values.dart.textual_outline.expect
index 429c184..f7c5643 100644
--- a/pkg/front_end/testcases/inference/inferred_type_is_enum_values.dart.textual_outline.expect
+++ b/pkg/front_end/testcases/inference/inferred_type_is_enum_values.dart.textual_outline.expect
@@ -2,5 +2,6 @@
 library test;
 
 enum E { v1 }
+
 final x = E.values;
 main() {}
diff --git a/pkg/front_end/testcases/inference/inferred_type_is_enum_values.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/inference/inferred_type_is_enum_values.dart.textual_outline_modelled.expect
index 429c184..f7c5643 100644
--- a/pkg/front_end/testcases/inference/inferred_type_is_enum_values.dart.textual_outline_modelled.expect
+++ b/pkg/front_end/testcases/inference/inferred_type_is_enum_values.dart.textual_outline_modelled.expect
@@ -2,5 +2,6 @@
 library test;
 
 enum E { v1 }
+
 final x = E.values;
 main() {}
diff --git a/pkg/front_end/testcases/nnbd/return_null.dart.textual_outline.expect b/pkg/front_end/testcases/nnbd/return_null.dart.textual_outline.expect
index 0823c8f..9ff88d2 100644
--- a/pkg/front_end/testcases/nnbd/return_null.dart.textual_outline.expect
+++ b/pkg/front_end/testcases/nnbd/return_null.dart.textual_outline.expect
@@ -12,7 +12,9 @@
 Future<int?> returnAsync7() async {}
 Iterable yieldSync() sync* {}
 Stream yieldAsync() async* {}
+
 enum Enum { a, b }
+
 Enum caseReturn1(Enum e) {}
 Enum caseReturn2(Enum e) {}
 localFunctions() {}
diff --git a/pkg/front_end/testcases/nnbd/return_null.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/nnbd/return_null.dart.textual_outline_modelled.expect
index cc610a6..becfa0f 100644
--- a/pkg/front_end/testcases/nnbd/return_null.dart.textual_outline_modelled.expect
+++ b/pkg/front_end/testcases/nnbd/return_null.dart.textual_outline_modelled.expect
@@ -13,7 +13,9 @@
 String returnExplicit() {}
 String returnImplicit() {}
 String returnMixed(bool b) {}
+
 enum Enum { a, b }
+
 localFunctions() {}
 main() {}
 returnAsync5() async {}
diff --git a/pkg/front_end/testcases/nnbd/switch_nullable_enum.dart.textual_outline.expect b/pkg/front_end/testcases/nnbd/switch_nullable_enum.dart.textual_outline.expect
index acc9973..6644830 100644
--- a/pkg/front_end/testcases/nnbd/switch_nullable_enum.dart.textual_outline.expect
+++ b/pkg/front_end/testcases/nnbd/switch_nullable_enum.dart.textual_outline.expect
@@ -1,4 +1,5 @@
 enum Enum { e1, e2 }
+
 int method1(Enum? e) {}
 int method2(Enum? e) {}
 int method3(Enum? e) {}
diff --git a/pkg/front_end/testcases/nnbd/switch_nullable_enum.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/nnbd/switch_nullable_enum.dart.textual_outline_modelled.expect
index a18d6e9..78ea1cb 100644
--- a/pkg/front_end/testcases/nnbd/switch_nullable_enum.dart.textual_outline_modelled.expect
+++ b/pkg/front_end/testcases/nnbd/switch_nullable_enum.dart.textual_outline_modelled.expect
@@ -1,4 +1,5 @@
 enum Enum { e1, e2 }
+
 expect(expected, actual) {}
 int method1(Enum? e) {}
 int method2(Enum? e) {}
diff --git a/pkg/front_end/testcases/rasta/enum.dart.textual_outline.expect b/pkg/front_end/testcases/rasta/enum.dart.textual_outline.expect
index c10a31d..08d5765 100644
--- a/pkg/front_end/testcases/rasta/enum.dart.textual_outline.expect
+++ b/pkg/front_end/testcases/rasta/enum.dart.textual_outline.expect
@@ -3,4 +3,5 @@
   ec1,
   ec2,
 }
+
 main() {}
diff --git a/pkg/front_end/testcases/rasta/enum.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/rasta/enum.dart.textual_outline_modelled.expect
index c10a31d..08d5765 100644
--- a/pkg/front_end/testcases/rasta/enum.dart.textual_outline_modelled.expect
+++ b/pkg/front_end/testcases/rasta/enum.dart.textual_outline_modelled.expect
@@ -3,4 +3,5 @@
   ec1,
   ec2,
 }
+
 main() {}
diff --git a/pkg/front_end/testcases/static_field_lowering/enum.dart.textual_outline.expect b/pkg/front_end/testcases/static_field_lowering/enum.dart.textual_outline.expect
index b42a46f..2af2679 100644
--- a/pkg/front_end/testcases/static_field_lowering/enum.dart.textual_outline.expect
+++ b/pkg/front_end/testcases/static_field_lowering/enum.dart.textual_outline.expect
@@ -2,4 +2,5 @@
   a,
   b,
 }
+
 main() {}
diff --git a/pkg/front_end/testcases/static_field_lowering/enum.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/static_field_lowering/enum.dart.textual_outline_modelled.expect
index b42a46f..2af2679 100644
--- a/pkg/front_end/testcases/static_field_lowering/enum.dart.textual_outline_modelled.expect
+++ b/pkg/front_end/testcases/static_field_lowering/enum.dart.textual_outline_modelled.expect
@@ -2,4 +2,5 @@
   a,
   b,
 }
+
 main() {}
diff --git a/pkg/front_end/testcases/super_parameters/circular_dependency_inference.dart.textual_outline.expect b/pkg/front_end/testcases/super_parameters/circular_dependency_inference.dart.textual_outline.expect
index 94dbab2..51a454d 100644
--- a/pkg/front_end/testcases/super_parameters/circular_dependency_inference.dart.textual_outline.expect
+++ b/pkg/front_end/testcases/super_parameters/circular_dependency_inference.dart.textual_outline.expect
@@ -1,28 +1,36 @@
 B1 f1() => throw 42;
+
 class A1 {
   var foo = f1();
   A1(this.foo);
 }
+
 class B1 extends A1 {
   B1(super.foo) : super();
 }
+
 class A2 {
   var foo = B2.new;
   A2(this.foo);
 }
+
 class B2 extends A2 {
   B2(super.foo) : super();
 }
+
 class A3 {
   var foo = C3.new;
   A3();
   A3.initializeFoo(this.foo);
 }
+
 class B3 extends A3 {
   var bar = A3.initializeFoo;
   B3(this.bar) : super();
 }
+
 class C3 extends B3 {
   C3(super.bar) : super();
 }
+
 main() {}
diff --git a/pkg/front_end/testcases/super_parameters/circular_dependency_inference.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/super_parameters/circular_dependency_inference.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..310cf19
--- /dev/null
+++ b/pkg/front_end/testcases/super_parameters/circular_dependency_inference.dart.textual_outline_modelled.expect
@@ -0,0 +1,36 @@
+B1 f1() => throw 42;
+
+class A1 {
+  A1(this.foo);
+  var foo = f1();
+}
+
+class A2 {
+  A2(this.foo);
+  var foo = B2.new;
+}
+
+class A3 {
+  A3();
+  A3.initializeFoo(this.foo);
+  var foo = C3.new;
+}
+
+class B1 extends A1 {
+  B1(super.foo) : super();
+}
+
+class B2 extends A2 {
+  B2(super.foo) : super();
+}
+
+class B3 extends A3 {
+  B3(this.bar) : super();
+  var bar = A3.initializeFoo;
+}
+
+class C3 extends B3 {
+  C3(super.bar) : super();
+}
+
+main() {}
diff --git a/pkg/front_end/testcases/super_parameters/default_values.dart.textual_outline.expect b/pkg/front_end/testcases/super_parameters/default_values.dart.textual_outline.expect
index 9f3486c..9766c4d 100644
--- a/pkg/front_end/testcases/super_parameters/default_values.dart.textual_outline.expect
+++ b/pkg/front_end/testcases/super_parameters/default_values.dart.textual_outline.expect
@@ -2,97 +2,122 @@
   int s;
   S1([int x = 0]) : s = x - 1;
 }
+
 class C1 extends S1 {
   int c;
   C1([super.x]) : c = x + 1;
 }
+
 class S2 {
   int s;
   S2({int x = 0}) : s = x - 1;
 }
+
 class C2 extends S2 {
   int c;
   C2({super.x}) : c = x + 1;
 }
+
 class S3 {
   int s;
   S3([int x = 0]) : s = x - 1;
 }
+
 class C3 extends S3 {
   int c;
   C3([super.x = 42]) : c = x + 1;
 }
+
 class S4 {
   int s;
   S4({int x = 0}) : s = x - 1;
 }
+
 class C4 extends S4 {
   int c;
   C4({super.x = 42}) : c = x + 1;
 }
+
 class S5 {
   num a;
   S5([num x = 3.14]) : a = x - 1;
 }
+
 class C5 extends S5 {
   C5([int super.x]);
 }
+
 class S6 {
   num? a;
   S6([num? x = 3.14]) : a = x;
 }
+
 class C6 extends S6 {
   int? b;
   C6([int? super.x]);
 }
+
 class S7 {
   int s;
   S7([int x = 0]) : s = x - 1;
 }
+
 class C7 extends S7 {
   int c;
   C7([super.x]) : c = x + 1;
 }
+
 class CC7 extends C7 {
   int cc;
   CC7([super.x]) : cc = x * 1;
 }
+
 class S8 {
   int s;
   S8([int x = 0]) : s = x - 1;
 }
+
 class CC8 extends C8 {
   int cc;
   CC8([super.x]) : cc = x * 1;
 }
+
 class C8 extends S8 {
   int c;
   C8([super.x]) : c = x + 1;
 }
+
 class CC9 extends C9 {
   int cc;
   CC9([super.x]) : cc = x * 1;
 }
+
 class C9 extends S9 {
   int c;
   C9([super.x]) : c = x + 1;
 }
+
 class S9 {
   int s;
   S9([int x = 0]) : s = x - 1;
 }
+
 class Ap {
   Ap([num x = 3.14]);
 }
+
 class Bp extends Ap {
   Bp([int super.x]);
   Bp.req(int super.x);
 }
+
 class An {
   An({num x = 3.14});
 }
+
 class Bn extends An {
   Bn({int super.x});
   Bn.req({required int super.x});
 }
+
 main() {}
diff --git a/pkg/front_end/testcases/super_parameters/default_values.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/super_parameters/default_values.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..6b17d46
--- /dev/null
+++ b/pkg/front_end/testcases/super_parameters/default_values.dart.textual_outline_modelled.expect
@@ -0,0 +1,123 @@
+class An {
+  An({num x = 3.14});
+}
+
+class Ap {
+  Ap([num x = 3.14]);
+}
+
+class Bn extends An {
+  Bn({int super.x});
+  Bn.req({required int super.x});
+}
+
+class Bp extends Ap {
+  Bp([int super.x]);
+  Bp.req(int super.x);
+}
+
+class C1 extends S1 {
+  C1([super.x]) : c = x + 1;
+  int c;
+}
+
+class C2 extends S2 {
+  C2({super.x}) : c = x + 1;
+  int c;
+}
+
+class C3 extends S3 {
+  C3([super.x = 42]) : c = x + 1;
+  int c;
+}
+
+class C4 extends S4 {
+  C4({super.x = 42}) : c = x + 1;
+  int c;
+}
+
+class C5 extends S5 {
+  C5([int super.x]);
+}
+
+class C6 extends S6 {
+  C6([int? super.x]);
+  int? b;
+}
+
+class C7 extends S7 {
+  C7([super.x]) : c = x + 1;
+  int c;
+}
+
+class C8 extends S8 {
+  C8([super.x]) : c = x + 1;
+  int c;
+}
+
+class C9 extends S9 {
+  C9([super.x]) : c = x + 1;
+  int c;
+}
+
+class CC7 extends C7 {
+  CC7([super.x]) : cc = x * 1;
+  int cc;
+}
+
+class CC8 extends C8 {
+  CC8([super.x]) : cc = x * 1;
+  int cc;
+}
+
+class CC9 extends C9 {
+  CC9([super.x]) : cc = x * 1;
+  int cc;
+}
+
+class S1 {
+  S1([int x = 0]) : s = x - 1;
+  int s;
+}
+
+class S2 {
+  S2({int x = 0}) : s = x - 1;
+  int s;
+}
+
+class S3 {
+  S3([int x = 0]) : s = x - 1;
+  int s;
+}
+
+class S4 {
+  S4({int x = 0}) : s = x - 1;
+  int s;
+}
+
+class S5 {
+  S5([num x = 3.14]) : a = x - 1;
+  num a;
+}
+
+class S6 {
+  S6([num? x = 3.14]) : a = x;
+  num? a;
+}
+
+class S7 {
+  S7([int x = 0]) : s = x - 1;
+  int s;
+}
+
+class S8 {
+  S8([int x = 0]) : s = x - 1;
+  int s;
+}
+
+class S9 {
+  S9([int x = 0]) : s = x - 1;
+  int s;
+}
+
+main() {}
diff --git a/pkg/front_end/testcases/super_parameters/issue47951.dart.textual_outline.expect b/pkg/front_end/testcases/super_parameters/issue47951.dart.textual_outline.expect
index befb5f9..0f8b504 100644
--- a/pkg/front_end/testcases/super_parameters/issue47951.dart.textual_outline.expect
+++ b/pkg/front_end/testcases/super_parameters/issue47951.dart.textual_outline.expect
@@ -1,8 +1,10 @@
 class A {
   A(num a);
 }
+
 class B extends A {
   B.sub1(int super.a1);
   B.sub2(double super.a2);
 }
+
 main() {}
diff --git a/pkg/front_end/testcases/super_parameters/issue47951.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/super_parameters/issue47951.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..0f8b504
--- /dev/null
+++ b/pkg/front_end/testcases/super_parameters/issue47951.dart.textual_outline_modelled.expect
@@ -0,0 +1,10 @@
+class A {
+  A(num a);
+}
+
+class B extends A {
+  B.sub1(int super.a1);
+  B.sub2(double super.a2);
+}
+
+main() {}
diff --git a/pkg/front_end/testcases/super_parameters/issue48142.dart.textual_outline.expect b/pkg/front_end/testcases/super_parameters/issue48142.dart.textual_outline.expect
index d25be67..5a6498f 100644
--- a/pkg/front_end/testcases/super_parameters/issue48142.dart.textual_outline.expect
+++ b/pkg/front_end/testcases/super_parameters/issue48142.dart.textual_outline.expect
@@ -3,21 +3,52 @@
   int s2;
   S1(this.s1, [this.s2 = 42]);
 }
+
 class C1 extends S1 {
   int i1;
   int i2;
   C1(this.i1, super.s1, int x, [super.s2]) : this.i2 = x;
 }
+
 class S2 {
-  S2({String one = "1", bool two = false, int three = 3, double four = 4, num five = 3.14, List<String> six = const ["six"]});
+  S2(
+      {String one = "1",
+      bool two = false,
+      int three = 3,
+      double four = 4,
+      num five = 3.14,
+      List<String> six = const ["six"]});
 }
+
 class C21 extends S2 {
-  C21({dynamic foo, super.one, dynamic bar, dynamic baz, super.three, super.five});
+  C21(
+      {dynamic foo,
+      super.one,
+      dynamic bar,
+      dynamic baz,
+      super.three,
+      super.five});
 }
+
 class C22 extends S2 {
-  C22({dynamic foo, super.six, dynamic bar, dynamic baz, super.four, super.two});
+  C22(
+      {dynamic foo,
+      super.six,
+      dynamic bar,
+      dynamic baz,
+      super.four,
+      super.two});
 }
+
 class C23 extends S2 {
-  C23({super.three, dynamic foo, super.one, super.four, dynamic bar, super.two, dynamic baz});
+  C23(
+      {super.three,
+      dynamic foo,
+      super.one,
+      super.four,
+      dynamic bar,
+      super.two,
+      dynamic baz});
 }
+
 main() {}
diff --git a/pkg/front_end/testcases/super_parameters/issue48142.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/super_parameters/issue48142.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..d4a92de
--- /dev/null
+++ b/pkg/front_end/testcases/super_parameters/issue48142.dart.textual_outline_modelled.expect
@@ -0,0 +1,54 @@
+class C1 extends S1 {
+  C1(this.i1, super.s1, int x, [super.s2]) : this.i2 = x;
+  int i1;
+  int i2;
+}
+
+class C21 extends S2 {
+  C21(
+      {dynamic foo,
+      super.one,
+      dynamic bar,
+      dynamic baz,
+      super.three,
+      super.five});
+}
+
+class C22 extends S2 {
+  C22(
+      {dynamic foo,
+      super.six,
+      dynamic bar,
+      dynamic baz,
+      super.four,
+      super.two});
+}
+
+class C23 extends S2 {
+  C23(
+      {super.three,
+      dynamic foo,
+      super.one,
+      super.four,
+      dynamic bar,
+      super.two,
+      dynamic baz});
+}
+
+class S1 {
+  S1(this.s1, [this.s2 = 42]);
+  int s1;
+  int s2;
+}
+
+class S2 {
+  S2(
+      {String one = "1",
+      bool two = false,
+      int three = 3,
+      double four = 4,
+      num five = 3.14,
+      List<String> six = const ["six"]});
+}
+
+main() {}
diff --git a/pkg/front_end/testcases/super_parameters/issue48286.dart.textual_outline.expect b/pkg/front_end/testcases/super_parameters/issue48286.dart.textual_outline.expect
index 9eae54a..c769e7d 100644
--- a/pkg/front_end/testcases/super_parameters/issue48286.dart.textual_outline.expect
+++ b/pkg/front_end/testcases/super_parameters/issue48286.dart.textual_outline.expect
@@ -4,9 +4,11 @@
   S(this.n, this.t);
   S.named(this.t, this.n);
 }
+
 class C<T> extends S<T> {
   C.constr1(super.n, String s, super.t);
   C.constr2(int i, super.n, String s, super.t) : super();
   C.constr3(int i, super.t, String s, super.n) : super.named();
 }
+
 main() {}
diff --git a/pkg/front_end/testcases/super_parameters/issue48286.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/super_parameters/issue48286.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..b593fa1
--- /dev/null
+++ b/pkg/front_end/testcases/super_parameters/issue48286.dart.textual_outline_modelled.expect
@@ -0,0 +1,14 @@
+class C<T> extends S<T> {
+  C.constr1(super.n, String s, super.t);
+  C.constr2(int i, super.n, String s, super.t) : super();
+  C.constr3(int i, super.t, String s, super.n) : super.named();
+}
+
+class S<T> {
+  S(this.n, this.t);
+  S.named(this.t, this.n);
+  T t;
+  num n;
+}
+
+main() {}
diff --git a/pkg/front_end/testcases/super_parameters/simple.dart.textual_outline.expect b/pkg/front_end/testcases/super_parameters/simple.dart.textual_outline.expect
index f0bc3ea..91dee23 100644
--- a/pkg/front_end/testcases/super_parameters/simple.dart.textual_outline.expect
+++ b/pkg/front_end/testcases/super_parameters/simple.dart.textual_outline.expect
@@ -2,7 +2,9 @@
   final int foo;
   A(this.foo);
 }
+
 class B extends A {
   B(super.foo);
 }
+
 main() {}
diff --git a/pkg/front_end/testcases/super_parameters/simple.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/super_parameters/simple.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..ce8d868
--- /dev/null
+++ b/pkg/front_end/testcases/super_parameters/simple.dart.textual_outline_modelled.expect
@@ -0,0 +1,10 @@
+class A {
+  A(this.foo);
+  final int foo;
+}
+
+class B extends A {
+  B(super.foo);
+}
+
+main() {}
diff --git a/pkg/front_end/testcases/super_parameters/simple_inference.dart.textual_outline.expect b/pkg/front_end/testcases/super_parameters/simple_inference.dart.textual_outline.expect
index a194020..ebcc1b5 100644
--- a/pkg/front_end/testcases/super_parameters/simple_inference.dart.textual_outline.expect
+++ b/pkg/front_end/testcases/super_parameters/simple_inference.dart.textual_outline.expect
@@ -5,18 +5,22 @@
   A1.named2(int foo) : foo = foo;
   A1.named3({required int foo}) : foo = foo;
 }
+
 class B1 extends A1 {
   B1(super.foo);
   B1.named(super.foo) : super.named();
   B1.named2(super.foo) : super.named2();
   B1.named3({required super.foo}) : super.named3();
 }
+
 class A2 {
   final int foo;
   final String bar;
   A2({required int this.foo, required String this.bar});
 }
+
 class B2 extends A2 {
   B2({required super.bar, required super.foo});
 }
+
 main() {}
diff --git a/pkg/front_end/testcases/super_parameters/simple_inference.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/super_parameters/simple_inference.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..7b7faf4
--- /dev/null
+++ b/pkg/front_end/testcases/super_parameters/simple_inference.dart.textual_outline_modelled.expect
@@ -0,0 +1,26 @@
+class A1 {
+  A1(this.foo);
+  A1.named(this.foo);
+  A1.named2(int foo) : foo = foo;
+  A1.named3({required int foo}) : foo = foo;
+  final int foo;
+}
+
+class A2 {
+  A2({required int this.foo, required String this.bar});
+  final String bar;
+  final int foo;
+}
+
+class B1 extends A1 {
+  B1(super.foo);
+  B1.named(super.foo) : super.named();
+  B1.named2(super.foo) : super.named2();
+  B1.named3({required super.foo}) : super.named3();
+}
+
+class B2 extends A2 {
+  B2({required super.bar, required super.foo});
+}
+
+main() {}
diff --git a/pkg/front_end/testcases/super_parameters/simple_named_super_parameters.dart.textual_outline.expect b/pkg/front_end/testcases/super_parameters/simple_named_super_parameters.dart.textual_outline.expect
index 3c4243b..ff4395b 100644
--- a/pkg/front_end/testcases/super_parameters/simple_named_super_parameters.dart.textual_outline.expect
+++ b/pkg/front_end/testcases/super_parameters/simple_named_super_parameters.dart.textual_outline.expect
@@ -2,22 +2,28 @@
   final int foo;
   A1({required this.foo});
 }
+
 class B1 extends A1 {
   B1({required super.foo}) : super();
 }
+
 class C1 extends A1 {
   C1({required super.foo}) : super(foo: foo);
 }
+
 class A2 {
   final int foo;
   final String bar;
   A2({required this.foo, required this.bar});
 }
+
 class B2 extends A2 {
   B2() : super(foo: 42, bar: "bar", baz: false);
 }
+
 class C2 extends A2 {
   C2({required super.foo}) : super();
   C2.other({required super.foo}) : super(bar: 'bar');
 }
+
 main() {}
diff --git a/pkg/front_end/testcases/super_parameters/simple_named_super_parameters.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/super_parameters/simple_named_super_parameters.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..4ce72d0
--- /dev/null
+++ b/pkg/front_end/testcases/super_parameters/simple_named_super_parameters.dart.textual_outline_modelled.expect
@@ -0,0 +1,29 @@
+class A1 {
+  A1({required this.foo});
+  final int foo;
+}
+
+class A2 {
+  A2({required this.foo, required this.bar});
+  final String bar;
+  final int foo;
+}
+
+class B1 extends A1 {
+  B1({required super.foo}) : super();
+}
+
+class B2 extends A2 {
+  B2() : super(foo: 42, bar: "bar", baz: false);
+}
+
+class C1 extends A1 {
+  C1({required super.foo}) : super(foo: foo);
+}
+
+class C2 extends A2 {
+  C2({required super.foo}) : super();
+  C2.other({required super.foo}) : super(bar: 'bar');
+}
+
+main() {}
diff --git a/pkg/front_end/testcases/super_parameters/simple_positional_super_parameters.dart.textual_outline.expect b/pkg/front_end/testcases/super_parameters/simple_positional_super_parameters.dart.textual_outline.expect
index a6fc5bc..2d8c920 100644
--- a/pkg/front_end/testcases/super_parameters/simple_positional_super_parameters.dart.textual_outline.expect
+++ b/pkg/front_end/testcases/super_parameters/simple_positional_super_parameters.dart.textual_outline.expect
@@ -2,21 +2,27 @@
   final int foo;
   A1(this.foo);
 }
+
 class B1 extends A1 {
   B1(super.foo) : super();
 }
+
 class C1 extends A1 {
   C1(super.foo) : super(42);
 }
+
 class A2 {
   final int foo;
   final String bar;
   A2(this.foo, this.bar);
 }
+
 class B2 extends A2 {
   B2() : super(0, 1, 2);
 }
+
 class C2 extends A2 {
   C2(super.foo) : super();
 }
+
 main() {}
diff --git a/pkg/front_end/testcases/super_parameters/simple_positional_super_parameters.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/super_parameters/simple_positional_super_parameters.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..0602b3a
--- /dev/null
+++ b/pkg/front_end/testcases/super_parameters/simple_positional_super_parameters.dart.textual_outline_modelled.expect
@@ -0,0 +1,28 @@
+class A1 {
+  A1(this.foo);
+  final int foo;
+}
+
+class A2 {
+  A2(this.foo, this.bar);
+  final String bar;
+  final int foo;
+}
+
+class B1 extends A1 {
+  B1(super.foo) : super();
+}
+
+class B2 extends A2 {
+  B2() : super(0, 1, 2);
+}
+
+class C1 extends A1 {
+  C1(super.foo) : super(42);
+}
+
+class C2 extends A2 {
+  C2(super.foo) : super();
+}
+
+main() {}
diff --git a/pkg/front_end/testcases/super_parameters/super_parameters_with_types_and_default_values.dart.textual_outline.expect b/pkg/front_end/testcases/super_parameters/super_parameters_with_types_and_default_values.dart.textual_outline.expect
index 7acd1b7..d71530b 100644
--- a/pkg/front_end/testcases/super_parameters/super_parameters_with_types_and_default_values.dart.textual_outline.expect
+++ b/pkg/front_end/testcases/super_parameters/super_parameters_with_types_and_default_values.dart.textual_outline.expect
@@ -3,8 +3,10 @@
   int s2;
   S([this.s1 = 1, this.s2 = 2]);
 }
+
 class C extends S {
   int c1;
   C(this.c1, [int super.s1, int x = 0, int super.s2]);
 }
+
 main() {}
diff --git a/pkg/front_end/testcases/super_parameters/super_parameters_with_types_and_default_values.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/super_parameters/super_parameters_with_types_and_default_values.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..4d4ec1e
--- /dev/null
+++ b/pkg/front_end/testcases/super_parameters/super_parameters_with_types_and_default_values.dart.textual_outline_modelled.expect
@@ -0,0 +1,12 @@
+class C extends S {
+  C(this.c1, [int super.s1, int x = 0, int super.s2]);
+  int c1;
+}
+
+class S {
+  S([this.s1 = 1, this.s2 = 2]);
+  int s1;
+  int s2;
+}
+
+main() {}
diff --git a/pkg/front_end/testcases/super_parameters/synthesized_super_constructor_with_parameters.dart.textual_outline.expect b/pkg/front_end/testcases/super_parameters/synthesized_super_constructor_with_parameters.dart.textual_outline.expect
index ed0e4f7..570dcce 100644
--- a/pkg/front_end/testcases/super_parameters/synthesized_super_constructor_with_parameters.dart.textual_outline.expect
+++ b/pkg/front_end/testcases/super_parameters/synthesized_super_constructor_with_parameters.dart.textual_outline.expect
@@ -2,53 +2,75 @@
   final int a;
   A1(this.a);
 }
+
 class B1 {}
+
 class C1 = A1 with B1;
+
 class D1 extends C1 {
   D1(super.a);
 }
+
 class A2 {
   final int a;
   A2({this.a = 0});
 }
+
 class B2 {}
+
 class C2 = A2 with B2;
+
 class D2 extends C2 {
   D2({super.a});
 }
+
 class A3 {
   final int a;
   A3([this.a = 0]);
 }
+
 class B3 {}
+
 class C3 = A3 with B3;
+
 class D3 extends C3 {
   D3([super.a]);
 }
+
 class D4 extends C4 {
   D4([super.foo]);
 }
+
 class C4 = A4 with B4;
+
 class B4 {}
+
 class A4 extends AA4 {
   A4([super.foo]);
 }
+
 class AA4 {
   final int foo;
   AA4([this.foo = 42]);
 }
+
 class D5 extends C5c {
   D5([super.foo]);
 }
+
 class C5c = C5b with B5;
 class C5b = C5a with B5;
 class C5a = A5 with B5;
+
 class B5 {}
+
 class A5 extends AA5 {
   A5([super.foo]);
 }
+
 class AA5 {
   final int foo;
   AA5([this.foo = 42]);
 }
+
 main() {}
diff --git a/pkg/front_end/testcases/super_parameters/synthesized_super_constructor_with_parameters.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/super_parameters/synthesized_super_constructor_with_parameters.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..a0dfff2
--- /dev/null
+++ b/pkg/front_end/testcases/super_parameters/synthesized_super_constructor_with_parameters.dart.textual_outline_modelled.expect
@@ -0,0 +1,72 @@
+class A1 {
+  A1(this.a);
+  final int a;
+}
+
+class A2 {
+  A2({this.a = 0});
+  final int a;
+}
+
+class A3 {
+  A3([this.a = 0]);
+  final int a;
+}
+
+class A4 extends AA4 {
+  A4([super.foo]);
+}
+
+class A5 extends AA5 {
+  A5([super.foo]);
+}
+
+class AA4 {
+  AA4([this.foo = 42]);
+  final int foo;
+}
+
+class AA5 {
+  AA5([this.foo = 42]);
+  final int foo;
+}
+
+class B1 {}
+
+class B2 {}
+
+class B3 {}
+
+class B4 {}
+
+class B5 {}
+
+class C1 = A1 with B1;
+class C2 = A2 with B2;
+class C3 = A3 with B3;
+class C4 = A4 with B4;
+class C5a = A5 with B5;
+class C5b = C5a with B5;
+class C5c = C5b with B5;
+
+class D1 extends C1 {
+  D1(super.a);
+}
+
+class D2 extends C2 {
+  D2({super.a});
+}
+
+class D3 extends C3 {
+  D3([super.a]);
+}
+
+class D4 extends C4 {
+  D4([super.foo]);
+}
+
+class D5 extends C5c {
+  D5([super.foo]);
+}
+
+main() {}
diff --git a/pkg/front_end/testcases/super_parameters/type_alias_in_supertype.dart.textual_outline.expect b/pkg/front_end/testcases/super_parameters/type_alias_in_supertype.dart.textual_outline.expect
index 1e4deb1..0903aa2 100644
--- a/pkg/front_end/testcases/super_parameters/type_alias_in_supertype.dart.textual_outline.expect
+++ b/pkg/front_end/testcases/super_parameters/type_alias_in_supertype.dart.textual_outline.expect
@@ -2,44 +2,56 @@
   final String foo;
   A1(this.foo);
 }
+
 typedef TA1 = A1;
 typedef TTA1 = TA1;
 typedef TTTA1 = TTA1;
 typedef TTTTA1 = TTTA1;
+
 class D1 extends TTTTA1 {
   D1(super.foo);
 }
+
 class A2 {
   final String foo;
   A2({this.foo = "bar"});
 }
+
 typedef TA2 = A2;
 typedef TTA2 = TA2;
 typedef TTTA2 = TTA2;
 typedef TTTTA2 = TTTA2;
+
 class D2 extends TTTTA2 {
   D2({super.foo});
 }
+
 class A3 {
   final String foo;
   A3([this.foo = "bar"]);
 }
+
 typedef TA3 = A3;
 typedef TTA3 = TA3;
 typedef TTTA3 = TTA3;
 typedef TTTTA3 = TTTA3;
+
 class D3 extends TTTTA3 {
   D3([super.foo]);
 }
+
 class D4 extends TTTTA4 {
   D4([super.foo]);
 }
+
 typedef TTTTA4 = TTTA4;
 typedef TTTA4 = TTA4;
 typedef TTA4 = TA4;
 typedef TA4 = A4;
+
 class A4 {
   final String foo;
   A4([this.foo = "bar"]);
 }
+
 main() {}
diff --git a/pkg/front_end/testcases/super_parameters/type_alias_in_supertype.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/super_parameters/type_alias_in_supertype.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..095c390
--- /dev/null
+++ b/pkg/front_end/testcases/super_parameters/type_alias_in_supertype.dart.textual_outline_modelled.expect
@@ -0,0 +1,53 @@
+class A1 {
+  A1(this.foo);
+  final String foo;
+}
+
+class A2 {
+  A2({this.foo = "bar"});
+  final String foo;
+}
+
+class A3 {
+  A3([this.foo = "bar"]);
+  final String foo;
+}
+
+class A4 {
+  A4([this.foo = "bar"]);
+  final String foo;
+}
+
+class D1 extends TTTTA1 {
+  D1(super.foo);
+}
+
+class D2 extends TTTTA2 {
+  D2({super.foo});
+}
+
+class D3 extends TTTTA3 {
+  D3([super.foo]);
+}
+
+class D4 extends TTTTA4 {
+  D4([super.foo]);
+}
+
+main() {}
+typedef TA1 = A1;
+typedef TA2 = A2;
+typedef TA3 = A3;
+typedef TA4 = A4;
+typedef TTA1 = TA1;
+typedef TTA2 = TA2;
+typedef TTA3 = TA3;
+typedef TTA4 = TA4;
+typedef TTTA1 = TTA1;
+typedef TTTA2 = TTA2;
+typedef TTTA3 = TTA3;
+typedef TTTA4 = TTA4;
+typedef TTTTA1 = TTTA1;
+typedef TTTTA2 = TTTA2;
+typedef TTTTA3 = TTTA3;
+typedef TTTTA4 = TTTA4;
diff --git a/pkg/front_end/testcases/super_parameters/typed_super_parameters.dart.textual_outline.expect b/pkg/front_end/testcases/super_parameters/typed_super_parameters.dart.textual_outline.expect
index f29b981..82f686f 100644
--- a/pkg/front_end/testcases/super_parameters/typed_super_parameters.dart.textual_outline.expect
+++ b/pkg/front_end/testcases/super_parameters/typed_super_parameters.dart.textual_outline.expect
@@ -2,35 +2,45 @@
   final int foo;
   A1(int this.foo);
 }
+
 class B1 extends A1 {
   B1(int super.foo);
 }
+
 class A2 {
   final int Function(int) foo;
   A2(int Function(int) this.foo);
 }
+
 class B2 extends A2 {
   B2(int Function(int) super.foo);
 }
+
 class A3 {
   final int Function(int) foo;
   A3(int this.foo(int));
 }
+
 class B3 extends A3 {
   B3(int super.foo(int));
 }
+
 class A4 {
   final void Function() Function(void Function()) foo;
   A4(void Function() this.foo(void Function()));
 }
+
 class B4 extends A4 {
   B4(void Function() super.foo(void Function()));
 }
+
 class A5 {
   final void Function() Function(void Function()) foo;
   A5(void Function() Function(void Function()) this.foo);
 }
+
 class B5 extends A5 {
   B5(void Function() Function(void Function()) super.foo);
 }
+
 main() {}
diff --git a/pkg/front_end/testcases/super_parameters/typed_super_parameters.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/super_parameters/typed_super_parameters.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..cf41b18
--- /dev/null
+++ b/pkg/front_end/testcases/super_parameters/typed_super_parameters.dart.textual_outline_modelled.expect
@@ -0,0 +1,46 @@
+class A1 {
+  A1(int this.foo);
+  final int foo;
+}
+
+class A2 {
+  A2(int Function(int) this.foo);
+  final int Function(int) foo;
+}
+
+class A3 {
+  A3(int this.foo(int));
+  final int Function(int) foo;
+}
+
+class A4 {
+  A4(void Function() this.foo(void Function()));
+  final void Function() Function(void Function()) foo;
+}
+
+class A5 {
+  A5(void Function() Function(void Function()) this.foo);
+  final void Function() Function(void Function()) foo;
+}
+
+class B1 extends A1 {
+  B1(int super.foo);
+}
+
+class B2 extends A2 {
+  B2(int Function(int) super.foo);
+}
+
+class B3 extends A3 {
+  B3(int super.foo(int));
+}
+
+class B4 extends A4 {
+  B4(void Function() super.foo(void Function()));
+}
+
+class B5 extends A5 {
+  B5(void Function() Function(void Function()) super.foo);
+}
+
+main() {}
diff --git a/pkg/front_end/testcases/textual_outline.status b/pkg/front_end/testcases/textual_outline.status
index e5d43b6..6b47db9 100644
--- a/pkg/front_end/testcases/textual_outline.status
+++ b/pkg/front_end/testcases/textual_outline.status
@@ -28,30 +28,8 @@
 constructor_tearoffs/new_as_selector: FormatterCrash
 dart2js/late_fields: FormatterCrash
 dart2js/late_statics: FormatterCrash
-enhanced_enums/conflicting_elements: FormatterCrash
-enhanced_enums/constructor_calls: FormatterCrash
-enhanced_enums/constructor_not_found: FormatterCrash
-enhanced_enums/declared_values: FormatterCrash
 enhanced_enums/entries_with_type_arguments: FormatterCrash
-enhanced_enums/enum_as_supertype: FormatterCrash
-enhanced_enums/inference_in_constructor_parameters: FormatterCrash
-enhanced_enums/instantiated_generic_enum_types: FormatterCrash
-enhanced_enums/issue48084: FormatterCrash
-enhanced_enums/issue48181: FormatterCrash
-enhanced_enums/issue48232: FormatterCrash
-enhanced_enums/issue48303: FormatterCrash
-enhanced_enums/malformed_constructors: FormatterCrash
-enhanced_enums/members: FormatterCrash
-enhanced_enums/named_arguments: FormatterCrash
-enhanced_enums/named_arguments_anywhere/redirecting_constructor: FormatterCrash
-enhanced_enums/qualified_names_with_no_type_arguments: FormatterCrash
 enhanced_enums/recovery_in_elements: FormatterCrash
-enhanced_enums/redirecting_initializers: FormatterCrash
-enhanced_enums/simple_fields: FormatterCrash
-enhanced_enums/simple_interfaces: FormatterCrash
-enhanced_enums/simple_mixins: FormatterCrash
-enhanced_enums/super_parameters/malformed_constructors: FormatterCrash
-enhanced_enums/supertype_resolved_before_checking: FormatterCrash
 extension_types/basic_show: FormatterCrash
 extension_types/call_not_get: FormatterCrash
 extension_types/keyword_in_show_hide_element: FormatterCrash
@@ -231,22 +209,8 @@
 regress/issue_39091_1: FormatterCrash
 regress/issue_41265.crash: Crash
 regress/issue_41265.crash: FormatterCrash
-super_parameters/circular_dependency_inference: FormatterCrash
-super_parameters/default_values: FormatterCrash
 super_parameters/issue47741: FormatterCrash
 super_parameters/issue47922: FormatterCrash
-super_parameters/issue47951: FormatterCrash
-super_parameters/issue48142: FormatterCrash
-super_parameters/issue48286: FormatterCrash
-super_parameters/simple: FormatterCrash
-super_parameters/simple_inference: FormatterCrash
-super_parameters/simple_named_super_parameters: FormatterCrash
-super_parameters/simple_positional_super_parameters: FormatterCrash
-super_parameters/super_parameters_with_types_and_default_values: FormatterCrash
-super_parameters/synthesized_super_constructor_with_parameters: FormatterCrash
-super_parameters/type_alias_in_supertype: FormatterCrash
-super_parameters/typed_super_parameter: FormatterCrash
-super_parameters/typed_super_parameters: FormatterCrash
 triple_shift/invalid_operator: FormatterCrash
 variance/class_type_parameter_modifier: FormatterCrash
 variance/generic_covariance_sound_variance: FormatterCrash
diff --git a/runtime/vm/compiler/backend/flow_graph.h b/runtime/vm/compiler/backend/flow_graph.h
index 93c832a..cc0d964 100644
--- a/runtime/vm/compiler/backend/flow_graph.h
+++ b/runtime/vm/compiler/backend/flow_graph.h
@@ -616,7 +616,6 @@
   // DiscoverBlocks computes parent_ and assigned_vars_ which are then used
   // if/when computing SSA.
   GrowableArray<intptr_t> parent_;
-  GrowableArray<BitVector*> assigned_vars_;
 
   intptr_t current_ssa_temp_index_;
   intptr_t max_block_id_;
diff --git a/runtime/vm/compiler/backend/il.h b/runtime/vm/compiler/backend/il.h
index 58b4a50..809c16c 100644
--- a/runtime/vm/compiler/backend/il.h
+++ b/runtime/vm/compiler/backend/il.h
@@ -182,7 +182,6 @@
 
  private:
   friend class FlowGraphPrinter;
-  friend class FlowGraphDeserializer;  // For setting reaching_type_ directly.
 
   Definition* definition_;
   Value* previous_use_;
@@ -1347,13 +1346,14 @@
 class TemplateInstruction
     : public CSETrait<Instruction, PureInstruction>::Base {
  public:
+  using BaseClass = typename CSETrait<Instruction, PureInstruction>::Base;
+
   explicit TemplateInstruction(intptr_t deopt_id = DeoptId::kNone)
-      : CSETrait<Instruction, PureInstruction>::Base(deopt_id), inputs_() {}
+      : BaseClass(deopt_id), inputs_() {}
 
   TemplateInstruction(const InstructionSource& source,
                       intptr_t deopt_id = DeoptId::kNone)
-      : CSETrait<Instruction, PureInstruction>::Base(source, deopt_id),
-        inputs_() {}
+      : BaseClass(source, deopt_id), inputs_() {}
 
   virtual intptr_t InputCount() const { return N; }
   virtual Value* InputAt(intptr_t i) const { return inputs_[i]; }
@@ -1616,14 +1616,8 @@
       : Instruction(deopt_id),
         block_id_(block_id),
         try_index_(try_index),
-        preorder_number_(-1),
-        postorder_number_(-1),
         stack_depth_(stack_depth),
-        dominator_(nullptr),
-        dominated_blocks_(1),
-        last_instruction_(NULL),
-        parallel_move_(nullptr),
-        loop_info_(nullptr) {}
+        dominated_blocks_(1) {}
 
   // Perform a depth first search to find OSR entry and
   // link it to the given graph entry.
@@ -1632,8 +1626,6 @@
                              BitVector* block_marks);
 
  private:
-  friend class FlowGraphDeserializer;  // Access to AddPredecessor().
-
   virtual void RawSetInputAt(intptr_t i, Value* value) { UNREACHABLE(); }
 
   virtual void ClearPredecessors() = 0;
@@ -1643,25 +1635,26 @@
 
   intptr_t block_id_;
   intptr_t try_index_;
-  intptr_t preorder_number_;
-  intptr_t postorder_number_;
+  intptr_t preorder_number_ = -1;
+  intptr_t postorder_number_ = -1;
   // Expected stack depth on entry (for stack-based IR only).
   intptr_t stack_depth_;
   // Starting and ending lifetime positions for this block.  Used by
   // the linear scan register allocator.
-  intptr_t start_pos_;
-  intptr_t end_pos_;
-  BlockEntryInstr* dominator_;  // Immediate dominator, NULL for graph entry.
+  intptr_t start_pos_ = -1;
+  intptr_t end_pos_ = -1;
+  // Immediate dominator, nullptr for graph entry.
+  BlockEntryInstr* dominator_ = nullptr;
   // TODO(fschneider): Optimize the case of one child to save space.
   GrowableArray<BlockEntryInstr*> dominated_blocks_;
-  Instruction* last_instruction_;
+  Instruction* last_instruction_ = nullptr;
 
   // Parallel move that will be used by linear scan register allocator to
   // connect live ranges at the start of the block.
-  ParallelMoveInstr* parallel_move_;
+  ParallelMoveInstr* parallel_move_ = nullptr;
 
   // Closest enveloping loop in loop hierarchy (nullptr at nesting depth 0).
-  LoopInfo* loop_info_;
+  LoopInfo* loop_info_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(BlockEntryInstr);
 };
@@ -1851,8 +1844,6 @@
   PRINT_TO_SUPPORT
 
  private:
-  friend class FlowGraphDeserializer;  // For the constructor with deopt_id arg.
-
   GraphEntryInstr(const ParsedFunction& parsed_function,
                   intptr_t osr_id,
                   intptr_t deopt_id);
@@ -2523,12 +2514,13 @@
           template <typename Impure, typename Pure> class CSETrait = NoCSE>
 class TemplateDefinition : public CSETrait<Definition, PureDefinition>::Base {
  public:
+  using BaseClass = typename CSETrait<Definition, PureDefinition>::Base;
+
   explicit TemplateDefinition(intptr_t deopt_id = DeoptId::kNone)
-      : CSETrait<Definition, PureDefinition>::Base(deopt_id), inputs_() {}
+      : BaseClass(deopt_id), inputs_() {}
   TemplateDefinition(const InstructionSource& source,
                      intptr_t deopt_id = DeoptId::kNone)
-      : CSETrait<Definition, PureDefinition>::Base(source, deopt_id),
-        inputs_() {}
+      : BaseClass(source, deopt_id), inputs_() {}
 
   virtual intptr_t InputCount() const { return N; }
   virtual Value* InputAt(intptr_t i) const { return inputs_[i]; }
@@ -2551,7 +2543,6 @@
       : block_(block),
         inputs_(num_inputs),
         representation_(kTagged),
-        reaching_defs_(NULL),
         is_alive_(false),
         is_receiver_(kUnknownReceiver) {
     for (intptr_t i = 0; i < num_inputs; ++i) {
@@ -2642,7 +2633,7 @@
   JoinEntryInstr* block_;
   GrowableArray<Value*> inputs_;
   Representation representation_;
-  BitVector* reaching_defs_;
+  BitVector* reaching_defs_ = nullptr;
   bool is_alive_;
   int8_t is_receiver_;
 
@@ -2958,10 +2949,9 @@
 //
 // This lowlevel instruction is non-inlinable since it makes assumptons about
 // the frame.  This is asserted via `inliner.cc::CalleeGraphValidator`.
-class TailCallInstr : public Instruction {
+class TailCallInstr : public TemplateInstruction<1, Throws, Pure> {
  public:
-  TailCallInstr(const Code& code, Value* arg_desc)
-      : code_(code), arg_desc_(NULL) {
+  TailCallInstr(const Code& code, Value* arg_desc) : code_(code) {
     SetInputAt(0, arg_desc);
   }
 
@@ -2969,19 +2959,8 @@
 
   const Code& code() const { return code_; }
 
-  virtual intptr_t InputCount() const { return 1; }
-  virtual Value* InputAt(intptr_t i) const {
-    ASSERT(i == 0);
-    return arg_desc_;
-  }
-  virtual void RawSetInputAt(intptr_t i, Value* value) {
-    ASSERT(i == 0);
-    arg_desc_ = value;
-  }
-
   // Two tailcalls can be canonicalized into one instruction if both have the
   // same destination.
-  virtual bool AllowsCSE() const { return true; }
   virtual bool AttributesEqual(const Instruction& other) const {
     return &other.AsTailCall()->code() == &code();
   }
@@ -2989,14 +2968,14 @@
   // Since no code after this instruction will be executed, there will be no
   // side-effects for the following code.
   virtual bool HasUnknownSideEffects() const { return false; }
-  virtual bool MayThrow() const { return true; }
   virtual bool ComputeCanDeoptimize() const { return false; }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   const Code& code_;
-  Value* arg_desc_;
+
+  DISALLOW_COPY_AND_ASSIGN(TailCallInstr);
 };
 
 class PushArgumentInstr : public TemplateDefinition<1, NoThrow> {
@@ -5370,8 +5349,6 @@
 
   DECLARE_INSTRUCTION(AllocateHandle)
 
-  virtual intptr_t InputCount() const { return 1; }
-  virtual Value* InputAt(intptr_t i) const { return inputs_[i]; }
   virtual Representation RequiredInputRepresentation(intptr_t idx) const;
   virtual Representation representation() const { return kUnboxedIntPtr; }
   virtual bool ComputeCanDeoptimize() const { return false; }
@@ -5393,8 +5370,6 @@
 
   DECLARE_INSTRUCTION(RawStoreField)
 
-  virtual intptr_t InputCount() const { return 2; }
-  virtual Value* InputAt(intptr_t i) const { return inputs_[i]; }
   virtual Representation RequiredInputRepresentation(intptr_t idx) const;
   virtual bool ComputeCanDeoptimize() const { return false; }
   virtual bool HasUnknownSideEffects() const { return false; }
@@ -9742,7 +9717,6 @@
  private:
   friend class ShallowIterator;
   friend class compiler::BlockBuilder;  // For Environment constructor.
-  friend class FlowGraphDeserializer;   // For constructor and deopt_id_.
 
   class LazyDeoptPruningBits : public BitField<uintptr_t, uintptr_t, 0, 8> {};
   class LazyDeoptToBeforeDeoptId
diff --git a/runtime/vm/compiler/backend/range_analysis.h b/runtime/vm/compiler/backend/range_analysis.h
index aa247c7..aa1f6b9 100644
--- a/runtime/vm/compiler/backend/range_analysis.h
+++ b/runtime/vm/compiler/backend/range_analysis.h
@@ -302,8 +302,6 @@
   int64_t SmiLowerBound() const { return LowerBound(kRangeBoundarySmi); }
 
  private:
-  friend class FlowGraphDeserializer;  // For setting fields directly.
-
   RangeBoundary(Kind kind, int64_t value, int64_t offset)
       : kind_(kind), value_(value), offset_(offset) {}
 
@@ -539,8 +537,6 @@
                        Range* result);
 
  private:
-  friend class FlowGraphDeserializer;  // For setting min_/max_ directly.
-
   RangeBoundary min_;
   RangeBoundary max_;
 
diff --git a/runtime/vm/compiler/backend/slot.h b/runtime/vm/compiler/backend/slot.h
index 514c7ee..ab82fe2 100644
--- a/runtime/vm/compiler/backend/slot.h
+++ b/runtime/vm/compiler/backend/slot.h
@@ -343,8 +343,6 @@
   Representation UnboxedRepresentation() const;
 
  private:
-  friend class FlowGraphDeserializer;  // For GetNativeSlot.
-
   Slot(Kind kind,
        int8_t bits,
        ClassIdTagType cid,
diff --git a/tests/language/enum/enhanced_enums_basic_test.dart b/tests/language/enum/enhanced_enums_basic_test.dart
index 2b29521..be97c45 100644
--- a/tests/language/enum/enhanced_enums_basic_test.dart
+++ b/tests/language/enum/enhanced_enums_basic_test.dart
@@ -104,8 +104,8 @@
   Expect.equals(0, EnumAll.v1.instanceMethod());
   Expect.identical(EnumAll.v4, EnumAll.v3 ^ EnumAll.v2);
 
-  Expect.equals("EnumAll.v1:EnumMixin<num>:ObjectMixin:this",
-      EnumAll.v1.thisAndSuper());
+  Expect.equals(
+      "EnumAll.v1:EnumMixin<num>:ObjectMixin:this", EnumAll.v1.thisAndSuper());
 
   // Which can reference type parameters.
   Expect.isTrue(EnumAll.v2.test(2)); // does `is T` with `T` being `int`.
@@ -157,13 +157,18 @@
 // Also if using type parameters, mixins or interfaces.
 // It only matters whether there is something after the values.
 enum EnumNoSemicolon<T extends num> with ObjectMixin implements Interface {
-  v1, v2, v3
+  v1,
+  v2,
+  v3
 }
 
-
 // Allows semicolon after values, even when not needed.
 // Without trailing comma.
-enum EnumPlainSemicolon { v1, v2, v3; }
+enum EnumPlainSemicolon {
+  v1,
+  v2,
+  v3;
+}
 
 // With trailing comma.
 enum EnumPlainTrailingCommaSemicolon {
@@ -202,6 +207,7 @@
   static late var sLateVarInit = v3;
   static EnumAll? sVar;
   static EnumAll sVarInit = v3;
+
   /// Static getters, setters and methods
   static EnumAll<int, int> get staticGetSet => v3;
   static set staticGetSet(EnumAll<int, int> _) {}
@@ -210,10 +216,13 @@
   // Constructors.
   // Generative, non-redirecting, unnamed.
   const EnumAll({T? y})
-      : constructor = "unnamed", this.x = 0 as S, y = y ?? (0 as T);
+      : constructor = "unnamed",
+        this.x = 0 as S,
+        y = y ?? (0 as T);
   // Generative, non-redirecting, named.
   const EnumAll.named(this.x, {T? y, String? constructor})
-      : constructor = constructor ?? "named", y = y ?? (0 as T);
+      : constructor = constructor ?? "named",
+        y = y ?? (0 as T);
   // Generative, redirecting.
   const EnumAll.renamed(S x, {T? y})
       : this.named(x, y: y, constructor: "renamed");
@@ -266,6 +275,7 @@
     Expect.fail("Unreachable");
     return "not";
   }
+
   String get extension => "extension";
 }
 
@@ -282,6 +292,7 @@
 
 enum NewNamedConstructor {
   v1;
+
   const NewNamedConstructor.new();
 }
 
@@ -301,13 +312,16 @@
   v1<int>(1),
   v2<num>(1),
   v3<num>(1);
+
   final T value;
   const Canonical(this.value);
 }
 
 // Both `toString` and `index` are inherited from superclass.
 enum OverrideEnum {
-  v1, v2;
+  v1,
+  v2;
+
   // Cannot override index
   int get superIndex => super.index;
   String toString() => "FakeString";
@@ -318,6 +332,7 @@
 enum SelfRefEnum {
   e1(null),
   e2(e1);
+
   final SelfRefEnum? previous;
   const SelfRefEnum(this.previous);
 }
@@ -343,9 +358,7 @@
   String toString() => "${super.toString()}:EnumMixin<$T>";
 }
 
-abstract class Interface {
-
-}
+abstract class Interface {}
 
 abstract class GenericInterface<T> {
   // Implemented by mixins.
diff --git a/tests/language/enum/enhanced_enums_subtype_error_test.dart b/tests/language/enum/enhanced_enums_subtype_error_test.dart
index ae0be18..728c227 100644
--- a/tests/language/enum/enhanced_enums_subtype_error_test.dart
+++ b/tests/language/enum/enhanced_enums_subtype_error_test.dart
@@ -150,7 +150,8 @@
   // [analyzer] COMPILE_TIME_ERROR.IMPLEMENTS_NON_CLASS
 }
 
-abstract class MixesInEnum with MyEnum { // It's not a mixin!
+// It's not a mixin!
+abstract class MixesInEnum with MyEnum {
   //           ^
   // [cfe] 'MyEnum' is an enum and can't be extended or implemented.
   // [cfe] Can't use 'MyEnum' as a mixin because it has constructors.
diff --git a/tests/language/enum/enum_test.dart b/tests/language/enum/enum_test.dart
index 4deb861..9678587 100644
--- a/tests/language/enum/enum_test.dart
+++ b/tests/language/enum/enum_test.dart
@@ -5,13 +5,18 @@
 import 'package:expect/expect.dart';
 
 enum Enum1 { _ }
+
 enum Enum2 { A }
+
 enum Enum3 { B, C }
+
 enum Enum4 {
   D,
   E,
 }
+
 enum Enum5 { F, G, H }
+
 enum _Enum6 { I, _J }
 
 enum _IsNot { IsNot }
diff --git a/tests/language/enum/is_keyword_runtime_test.dart b/tests/language/enum/is_keyword_runtime_test.dart
index 2e9a471..3f24d63 100644
--- a/tests/language/enum/is_keyword_runtime_test.dart
+++ b/tests/language/enum/is_keyword_runtime_test.dart
@@ -8,6 +8,4 @@
 // Test that `enum` is considered a keyword and therefore invalid as the name of
 // declarations.
 
-main() {
-
-}
+main() {}
diff --git a/tests/language/enum/private_runtime_1_test.dart b/tests/language/enum/private_runtime_1_test.dart
index 34af126..27b4b74 100644
--- a/tests/language/enum/private_runtime_1_test.dart
+++ b/tests/language/enum/private_runtime_1_test.dart
@@ -21,5 +21,4 @@
 main() {
   Expect.equals('Enum1._A,Enum1._B', Enum1.values.join(','));
   Expect.equals('Enum2._A,Enum2._B', Enum2.values.join(','));
-
 }
diff --git a/tests/language/enum/private_runtime_test.dart b/tests/language/enum/private_runtime_test.dart
index adc8d7a..e479dfd 100644
--- a/tests/language/enum/private_runtime_test.dart
+++ b/tests/language/enum/private_runtime_test.dart
@@ -20,6 +20,4 @@
 
 main() {
   Expect.equals('Enum1._A,Enum1._B', Enum1.values.join(','));
-
-
 }
diff --git a/tests/language/named_arguments_anywhere/all_kinds_test.dart b/tests/language/named_arguments_anywhere/all_kinds_test.dart
index 004796e..059f3e6 100644
--- a/tests/language/named_arguments_anywhere/all_kinds_test.dart
+++ b/tests/language/named_arguments_anywhere/all_kinds_test.dart
@@ -216,8 +216,8 @@
         z: evaluate(false), w: evaluate(3.14));
   });
   runAndCheckEvaluationOrder([1, false, "2", 3.14], () {
-    a.property(evaluate(1),
-        z: evaluate(false), evaluate("2"), w: evaluate(3.14));
+    a.property(
+        evaluate(1), z: evaluate(false), evaluate("2"), w: evaluate(3.14));
   });
   runAndCheckEvaluationOrder([false, 1, "2", 3.14], () {
     a.property(
@@ -228,8 +228,8 @@
         w: evaluate(3.14), evaluate(1), evaluate("2"), z: evaluate(false));
   });
   runAndCheckEvaluationOrder([1, 3.14, "2", false], () {
-    a.property(evaluate(1),
-        w: evaluate(3.14), evaluate("2"), z: evaluate(false));
+    a.property(
+        evaluate(1), w: evaluate(3.14), evaluate("2"), z: evaluate(false));
   });
   runAndCheckEvaluationOrder([1, 3.14, "2"], () {
     a.property(evaluate(1), w: evaluate(3.14), evaluate("2"));
@@ -306,8 +306,8 @@
         z: evaluate(false), w: evaluate(3.14));
   });
   runAndCheckEvaluationOrder([1, false, "2", 3.14], () {
-    A.redirFactory(evaluate(1),
-        z: evaluate(false), evaluate("2"), w: evaluate(3.14));
+    A.redirFactory(
+        evaluate(1), z: evaluate(false), evaluate("2"), w: evaluate(3.14));
   });
   runAndCheckEvaluationOrder([false, 1, "2", 3.14], () {
     A.redirFactory(
@@ -318,8 +318,8 @@
         w: evaluate(3.14), evaluate(1), evaluate("2"), z: evaluate(false));
   });
   runAndCheckEvaluationOrder([1, 3.14, "2", false], () {
-    A.redirFactory(evaluate(1),
-        w: evaluate(3.14), evaluate("2"), z: evaluate(false));
+    A.redirFactory(
+        evaluate(1), w: evaluate(3.14), evaluate("2"), z: evaluate(false));
   });
   runAndCheckEvaluationOrder([1, 3.14, "2"], () {
     A.redirFactory(evaluate(1), w: evaluate(3.14), evaluate("2"));
@@ -373,8 +373,8 @@
       : super(evaluate(1), evaluate("2"),
             z: evaluate(false), w: evaluate(3.14));
   Test.super2()
-      : super(evaluate(1),
-            z: evaluate(false), evaluate("2"), w: evaluate(3.14));
+      : super(
+            evaluate(1), z: evaluate(false), evaluate("2"), w: evaluate(3.14));
   Test.super3()
       : super(
             z: evaluate(false), evaluate(1), evaluate("2"), w: evaluate(3.14));
@@ -382,8 +382,8 @@
       : super(
             w: evaluate(3.14), evaluate(1), evaluate("2"), z: evaluate(false));
   Test.super5()
-      : super(evaluate(1),
-            w: evaluate(3.14), evaluate("2"), z: evaluate(false));
+      : super(
+            evaluate(1), w: evaluate(3.14), evaluate("2"), z: evaluate(false));
   Test.super6() : super(evaluate(1), w: evaluate(3.14), evaluate("2"));
 
   test() {
@@ -392,8 +392,8 @@
           z: evaluate(false), w: evaluate(3.14));
     });
     runAndCheckEvaluationOrder([1, false, "2", 3.14], () {
-      super.bar(evaluate(1),
-          z: evaluate(false), evaluate("2"), w: evaluate(3.14));
+      super.bar(
+          evaluate(1), z: evaluate(false), evaluate("2"), w: evaluate(3.14));
     });
     runAndCheckEvaluationOrder([false, 1, "2", 3.14], () {
       super.bar(
@@ -404,8 +404,8 @@
           w: evaluate(3.14), evaluate(1), evaluate("2"), z: evaluate(false));
     });
     runAndCheckEvaluationOrder([1, 3.14, "2", false], () {
-      super.bar(evaluate(1),
-          w: evaluate(3.14), evaluate("2"), z: evaluate(false));
+      super.bar(
+          evaluate(1), w: evaluate(3.14), evaluate("2"), z: evaluate(false));
     });
     runAndCheckEvaluationOrder([1, 3.14, "2"], () {
       super.bar(evaluate(1), w: evaluate(3.14), evaluate("2"));
diff --git a/tests/language_2/enum/enum_test.dart b/tests/language_2/enum/enum_test.dart
index 73b3db6..4cb22a1 100644
--- a/tests/language_2/enum/enum_test.dart
+++ b/tests/language_2/enum/enum_test.dart
@@ -7,13 +7,18 @@
 import 'package:expect/expect.dart';
 
 enum Enum1 { _ }
+
 enum Enum2 { A }
+
 enum Enum3 { B, C }
+
 enum Enum4 {
   D,
   E,
 }
+
 enum Enum5 { F, G, H }
+
 enum _Enum6 { I, _J }
 
 enum _IsNot { IsNot }
diff --git a/tests/language_2/enum/is_keyword_runtime_test.dart b/tests/language_2/enum/is_keyword_runtime_test.dart
index 8ea644f..4c8c400 100644
--- a/tests/language_2/enum/is_keyword_runtime_test.dart
+++ b/tests/language_2/enum/is_keyword_runtime_test.dart
@@ -10,6 +10,4 @@
 // Test that `enum` is considered a keyword and therefore invalid as the name of
 // declarations.
 
-main() {
-
-}
+main() {}
diff --git a/tests/language_2/enum/private_runtime_1_test.dart b/tests/language_2/enum/private_runtime_1_test.dart
index b2fbfee..9234818 100644
--- a/tests/language_2/enum/private_runtime_1_test.dart
+++ b/tests/language_2/enum/private_runtime_1_test.dart
@@ -23,5 +23,4 @@
 main() {
   Expect.equals('Enum1._A,Enum1._B', Enum1.values.join(','));
   Expect.equals('Enum2._A,Enum2._B', Enum2.values.join(','));
-
 }
diff --git a/tests/language_2/enum/private_runtime_test.dart b/tests/language_2/enum/private_runtime_test.dart
index ad44d80..ea9c19a 100644
--- a/tests/language_2/enum/private_runtime_test.dart
+++ b/tests/language_2/enum/private_runtime_test.dart
@@ -22,6 +22,4 @@
 
 main() {
   Expect.equals('Enum1._A,Enum1._B', Enum1.values.join(','));
-
-
 }
diff --git a/tools/VERSION b/tools/VERSION
index f2bbd92..16ef2ea 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 17
 PATCH 0
-PRERELEASE 174
+PRERELEASE 175
 PRERELEASE_PATCH 0
\ No newline at end of file