diff --git a/pkg/analysis_server/lib/src/lsp/client_configuration.dart b/pkg/analysis_server/lib/src/lsp/client_configuration.dart
index 83b987b..c7497dd 100644
--- a/pkg/analysis_server/lib/src/lsp/client_configuration.dart
+++ b/pkg/analysis_server/lib/src/lsp/client_configuration.dart
@@ -165,6 +165,18 @@
       _fallback?.enableSdkFormatter ??
       true;
 
+  /// Whether to include Snippets in code completion results.
+  bool get enableSnippets =>
+      // TODO(dantup): Change this setting to `enableSnippets`
+      //    and default to `true`
+      //    and remove `initializeWithSnippetSupportAndPreviewFlag` from tests
+      //    once all snippets are implemented and VS Code has shipped a
+      //    version that maps `enableServerSnippets` to `enableSnippets` in
+      //    middleware to avoid dupes.
+      _settings['previewEnableSnippets'] as bool? ??
+      _fallback?.enableSnippets ??
+      false;
+
   /// The line length used when formatting documents.
   ///
   /// If null, the formatters default will be used.
diff --git a/pkg/analysis_server/lib/src/lsp/handlers/handler_completion.dart b/pkg/analysis_server/lib/src/lsp/handlers/handler_completion.dart
index 6338b96..a91f9fd 100644
--- a/pkg/analysis_server/lib/src/lsp/handlers/handler_completion.dart
+++ b/pkg/analysis_server/lib/src/lsp/handlers/handler_completion.dart
@@ -21,7 +21,9 @@
 import 'package:analysis_server/src/services/completion/yaml/fix_data_generator.dart';
 import 'package:analysis_server/src/services/completion/yaml/pubspec_generator.dart';
 import 'package:analysis_server/src/services/completion/yaml/yaml_completion_generator.dart';
+import 'package:analysis_server/src/services/snippets/dart/snippet_manager.dart';
 import 'package:analyzer/dart/analysis/results.dart';
+import 'package:analyzer/dart/analysis/session.dart';
 import 'package:analyzer/dart/ast/ast.dart' as ast;
 import 'package:analyzer/source/line_info.dart';
 import 'package:analyzer/src/services/available_declarations.dart';
@@ -178,6 +180,31 @@
   String _createImportedSymbolKey(String name, Uri declaringUri) =>
       '$name/$declaringUri';
 
+  Future<List<CompletionItem>> _getDartSnippetItems({
+    required LspClientCapabilities clientCapabilities,
+    required ResolvedUnitResult unit,
+    required int offset,
+    required LineInfo lineInfo,
+  }) async {
+    final request = DartSnippetRequest(
+      unit: unit,
+      offset: offset,
+    );
+    final snippetManager = DartSnippetManager();
+    final snippets = await snippetManager.computeSnippets(request);
+
+    return snippets
+        .map((snippet) => snippetToCompletionItem(
+              server,
+              clientCapabilities,
+              unit.path,
+              lineInfo,
+              toPosition(lineInfo.getLocation(offset)),
+              snippet,
+            ))
+        .toList();
+  }
+
   Future<ErrorOr<CompletionList>> _getPluginResults(
     LspClientCapabilities capabilities,
     LineInfo lineInfo,
@@ -420,6 +447,18 @@
             });
           }
 
+          // Add in any snippets.
+          final snippetsEnabled =
+              server.clientConfiguration.forResource(unit.path).enableSnippets;
+          if (capabilities.completionSnippets && snippetsEnabled) {
+            results.addAll(await _getDartSnippetItems(
+              clientCapabilities: capabilities,
+              unit: unit,
+              offset: offset,
+              lineInfo: unit.lineInfo,
+            ));
+          }
+
           // Perform fuzzy matching based on the identifier in front of the caret to
           // reduce the size of the payload.
           final fuzzyPattern = completionRequest.targetPrefix;
@@ -435,6 +474,8 @@
               CompletionList(isIncomplete: false, items: matchingResults));
         } on AbortCompletion {
           return success(CompletionList(isIncomplete: false, items: []));
+        } on InconsistentAnalysisException {
+          return success(CompletionList(isIncomplete: false, items: []));
         }
       },
     );
diff --git a/pkg/analysis_server/lib/src/lsp/mapping.dart b/pkg/analysis_server/lib/src/lsp/mapping.dart
index 817937e..fec47e8 100644
--- a/pkg/analysis_server/lib/src/lsp/mapping.dart
+++ b/pkg/analysis_server/lib/src/lsp/mapping.dart
@@ -22,6 +22,7 @@
 import 'package:analysis_server/src/lsp/source_edits.dart';
 import 'package:analysis_server/src/protocol_server.dart' as server
     hide AnalysisError;
+import 'package:analysis_server/src/services/snippets/dart/snippet_manager.dart';
 import 'package:analyzer/dart/analysis/results.dart' as server;
 import 'package:analyzer/error/error.dart' as server;
 import 'package:analyzer/source/line_info.dart' as server;
@@ -890,6 +891,35 @@
   );
 }
 
+/// Creates a SnippetTextEdit for a set of edits using Linked Edit Groups.
+///
+/// Edit groups offsets are based on the entire content being modified after all
+/// edits, so [editOffset] must to take into account both the offset of the edit
+/// _and_ any delta from edits prior to this one in the file.
+///
+/// [selectionOffset] is also absolute and assumes [edit.replacement] will be
+/// inserted at [editOffset].
+lsp.SnippetTextEdit snippetTextEditFromEditGroups(
+  String filePath,
+  server.LineInfo lineInfo,
+  server.SourceEdit edit, {
+  required List<server.LinkedEditGroup> editGroups,
+  required int editOffset,
+  required int? selectionOffset,
+}) {
+  return lsp.SnippetTextEdit(
+    insertTextFormat: lsp.InsertTextFormat.Snippet,
+    range: toRange(lineInfo, edit.offset, edit.length),
+    newText: buildSnippetStringForEditGroups(
+      edit.replacement,
+      filePath: filePath,
+      editGroups: editGroups,
+      editOffset: editOffset,
+      selectionOffset: selectionOffset,
+    ),
+  );
+}
+
 /// Creates a SnippetTextEdit for an edit with a selection placeholder.
 ///
 /// [selectionOffset] is relative to (and therefore must be within) the edit.
@@ -909,6 +939,76 @@
   );
 }
 
+lsp.CompletionItem snippetToCompletionItem(
+  lsp.LspAnalysisServer server,
+  LspClientCapabilities capabilities,
+  String file,
+  LineInfo lineInfo,
+  Position position,
+  Snippet snippet,
+) {
+  assert(capabilities.completionSnippets);
+
+  final formats = capabilities.completionDocumentationFormats;
+  final documentation = snippet.documentation;
+  final supportsAsIsInsertMode =
+      capabilities.completionInsertTextModes.contains(InsertTextMode.asIs);
+  final changes = snippet.change;
+
+  // We must only get one change for this file to be able to apply snippets.
+  final thisFilesChange = changes.edits.singleWhere((e) => e.file == file);
+  final otherFilesChanges = changes.edits.where((e) => e.file != file).toList();
+
+  // If this completion involves editing other files, we'll need to build
+  // a command that the client will call to apply those edits later, because
+  // LSP Completions can only provide simple edits for the current file.
+  Command? command;
+  if (otherFilesChanges.isNotEmpty) {
+    final workspaceEdit = createPlainWorkspaceEdit(server, otherFilesChanges);
+    command = Command(
+        title: 'Add import',
+        command: Commands.sendWorkspaceEdit,
+        arguments: [workspaceEdit]);
+  }
+
+  /// Convert the changes to TextEdits using snippet tokens for linked edit
+  /// groups.
+  final mainFileEdits = toSnippetTextEdits(
+    file,
+    thisFilesChange,
+    changes.linkedEditGroups,
+    lineInfo,
+    selectionOffset:
+        changes.selection?.file == file ? changes.selection?.offset : null,
+  );
+
+  // For LSP, we need to provide the main edit and other edits separately. The
+  // main edit must include the location that completion was invoked. If we
+  // fail to find exactly one, this is an error.
+  final mainEdit = mainFileEdits
+      .singleWhere((edit) => edit.range.start.line == position.line);
+  final nonMainEdits = mainFileEdits.where((edit) => edit != mainEdit).toList();
+
+  return lsp.CompletionItem(
+    label: snippet.label,
+    filterText: snippet.prefix,
+    kind: lsp.CompletionItemKind.Snippet,
+    command: command,
+    documentation: documentation != null
+        ? asStringOrMarkupContent(formats, documentation)
+        : null,
+    // Force snippets to be sorted at the bottom of the list.
+    // TODO(dantup): Consider if we can rank these better. Client-side
+    //   snippets have always been forced to the bottom partly because they
+    //   show up in more places than wanted.
+    sortText: 'zzz${snippet.prefix}',
+    insertTextFormat: lsp.InsertTextFormat.Snippet,
+    insertTextMode: supportsAsIsInsertMode ? InsertTextMode.asIs : null,
+    textEdit: Either2<TextEdit, InsertReplaceEdit>.t1(mainEdit),
+    additionalTextEdits: nonMainEdits,
+  );
+}
+
 lsp.CompletionItemKind? suggestionKindToCompletionItemKind(
   Set<lsp.CompletionItemKind> supportedCompletionKinds,
   server.CompletionSuggestionKind kind,
@@ -1372,6 +1472,36 @@
   );
 }
 
+List<lsp.SnippetTextEdit> toSnippetTextEdits(
+  String filePath,
+  server.SourceFileEdit change,
+  List<server.LinkedEditGroup> editGroups,
+  LineInfo lineInfo, {
+  required int? selectionOffset,
+}) {
+  final snippetEdits = <lsp.SnippetTextEdit>[];
+
+  // Edit groups offsets are based on after the edits are applied, so we
+  // must track the offset delta to ensure we track the offset within the
+  // edits. This also requires the edits are sorted earliest-to-latest.
+  var offsetDelta = 0;
+  change.edits.sortBy<num>((edit) => edit.offset);
+  for (final edit in change.edits) {
+    snippetEdits.add(snippetTextEditFromEditGroups(
+      filePath,
+      lineInfo,
+      edit,
+      editGroups: editGroups,
+      editOffset: edit.offset + offsetDelta,
+      selectionOffset: selectionOffset,
+    ));
+
+    offsetDelta += edit.replacement.length - edit.length;
+  }
+
+  return snippetEdits;
+}
+
 ErrorOr<server.SourceRange> toSourceRange(
     server.LineInfo lineInfo, Range range) {
   // If there is a range, convert to offsets because that's what
diff --git a/pkg/analysis_server/lib/src/lsp/snippets.dart b/pkg/analysis_server/lib/src/lsp/snippets.dart
index 6f59d8e..e88dcaa 100644
--- a/pkg/analysis_server/lib/src/lsp/snippets.dart
+++ b/pkg/analysis_server/lib/src/lsp/snippets.dart
@@ -4,32 +4,113 @@
 
 import 'dart:math' as math;
 
+import 'package:analysis_server/src/protocol_server.dart' as server
+    hide AnalysisError;
 import 'package:collection/collection.dart';
 
+/// Builds an LSP snippet string using the supplied edit groups.
+///
+/// [editGroups] are provided as absolute positions, where the edit will be
+/// made starting at [editOffset].
+///
+/// [selectionOffset] is also absolute and assumes [text] will be
+/// inserted at [editOffset].
+String buildSnippetStringForEditGroups(
+  String text, {
+  required String filePath,
+  required List<server.LinkedEditGroup> editGroups,
+  required int editOffset,
+  int? selectionOffset,
+}) =>
+    _buildSnippetString(
+      text,
+      filePath: filePath,
+      editGroups: editGroups,
+      editGroupsOffset: editOffset,
+      selectionOffset:
+          selectionOffset != null ? selectionOffset - editOffset : null,
+    );
+
 /// Builds an LSP snippet string with supplied ranges as tab stops.
 ///
 /// [tabStopOffsetLengthPairs] are relative to the supplied text.
 String buildSnippetStringWithTabStops(
   String text,
   List<int>? tabStopOffsetLengthPairs,
-) {
+) =>
+    _buildSnippetString(
+      text,
+      filePath: null,
+      tabStopOffsetLengthPairs: tabStopOffsetLengthPairs,
+    );
+
+/// Builds an LSP snippet string with supplied ranges as tab stops.
+///
+/// [tabStopOffsetLengthPairs] are relative to the supplied text.
+///
+/// [selectionOffset]/[selectionLength] form a tab stop that is always "number 0"
+/// which is the final tab stop.
+///
+/// [editGroups] are provided as absolute positions, where [text] is known to
+/// start at [editGroupsOffset] in the final document.
+String _buildSnippetString(
+  String text, {
+  required String? filePath,
+  List<int>? tabStopOffsetLengthPairs,
+  int? selectionOffset,
+  int? selectionLength,
+  List<server.LinkedEditGroup>? editGroups,
+  int editGroupsOffset = 0,
+}) {
   tabStopOffsetLengthPairs ??= const [];
+  editGroups ??= const [];
   assert(tabStopOffsetLengthPairs.length % 2 == 0);
 
-  // Convert selection/tab stops/edit groups all into a common format
-  // (`SnippetPlaceholder`) so they can be handled in a single pass through
+  /// Helper to create a [SnippetPlaceholder] for each position in a linked
+  /// edit group.
+  Iterable<SnippetPlaceholder> convertEditGroup(
+    int index,
+    server.LinkedEditGroup editGroup,
+  ) {
+    final validPositions = editGroup.positions.where((p) => p.file == filePath);
+    // Create a placeholder for each position in the group.
+    return validPositions.map(
+      (position) => SnippetPlaceholder(
+        // Make the position relative to the supplied text.
+        position.offset - editGroupsOffset,
+        editGroup.length,
+        suggestions: editGroup.suggestions
+            .map((suggestion) => suggestion.value)
+            .toList(),
+        // Use the index as an ID to keep all related positions together (so
+        // the remain "linked").
+        linkedGroupId: index,
+      ),
+    );
+  }
+
+  // Convert selection/tab stops/edit groups all into the same format
+  // (`_SnippetPlaceholder`) so they can be handled in a single pass through
   // the text.
   final placeholders = [
+    // Selection.
+    if (selectionOffset != null)
+      SnippetPlaceholder(selectionOffset, selectionLength ?? 0, isFinal: true),
+
     // Tab stops.
     for (var i = 0; i < tabStopOffsetLengthPairs.length - 1; i += 2)
       SnippetPlaceholder(
         tabStopOffsetLengthPairs[i],
         tabStopOffsetLengthPairs[i + 1],
-        // If there's only a single tab stop, mark
+        // If there's only a single tab stop (and no selection/editGroups), mark
         // it as the final stop so it exit "snippet mode" when tabbed to.
-        isFinal: tabStopOffsetLengthPairs.length == 2,
+        isFinal: selectionOffset == null &&
+            editGroups.isEmpty &&
+            tabStopOffsetLengthPairs.length == 2,
       ),
-    // TODO(dantup): Add edit group/selection support.
+
+    // Linked edit groups.
+    ...editGroups.expandIndexed(convertEditGroup),
   ];
 
   // Remove any groups outside of the range (it's possible the edit groups apply
diff --git a/pkg/analysis_server/lib/src/services/correction/assist.dart b/pkg/analysis_server/lib/src/services/correction/assist.dart
index 3f8be5c..0e0b1c9 100644
--- a/pkg/analysis_server/lib/src/services/correction/assist.dart
+++ b/pkg/analysis_server/lib/src/services/correction/assist.dart
@@ -56,6 +56,11 @@
     30,
     'Assign value to new local variable',
   );
+  static const CONVERT_CLASS_TO_ENUM = AssistKind(
+    'dart.assist.convert.classToEnum',
+    30,
+    'Convert class to an enum',
+  );
   static const CONVERT_CLASS_TO_MIXIN = AssistKind(
     'dart.assist.convert.classToMixin',
     30,
diff --git a/pkg/analysis_server/lib/src/services/correction/assist_internal.dart b/pkg/analysis_server/lib/src/services/correction/assist_internal.dart
index 3cbb3f8..70835d5 100644
--- a/pkg/analysis_server/lib/src/services/correction/assist_internal.dart
+++ b/pkg/analysis_server/lib/src/services/correction/assist_internal.dart
@@ -12,6 +12,7 @@
 import 'package:analysis_server/src/services/correction/dart/add_type_annotation.dart';
 import 'package:analysis_server/src/services/correction/dart/assign_to_local_variable.dart';
 import 'package:analysis_server/src/services/correction/dart/convert_add_all_to_spread.dart';
+import 'package:analysis_server/src/services/correction/dart/convert_class_to_enum.dart';
 import 'package:analysis_server/src/services/correction/dart/convert_class_to_mixin.dart';
 import 'package:analysis_server/src/services/correction/dart/convert_conditional_expression_to_if_element.dart';
 import 'package:analysis_server/src/services/correction/dart/convert_documentation_into_block.dart';
@@ -91,6 +92,7 @@
     AddTypeAnnotation.newInstanceBulkFixable,
     AssignToLocalVariable.newInstance,
     ConvertAddAllToSpread.newInstance,
+    ConvertClassToEnum.newInstance,
     ConvertClassToMixin.newInstance,
     ConvertConditionalExpressionToIfElement.newInstance,
     ConvertDocumentationIntoBlock.newInstance,
diff --git a/pkg/analysis_server/lib/src/services/correction/dart/convert_class_to_enum.dart b/pkg/analysis_server/lib/src/services/correction/dart/convert_class_to_enum.dart
new file mode 100644
index 0000000..978a6f5
--- /dev/null
+++ b/pkg/analysis_server/lib/src/services/correction/dart/convert_class_to_enum.dart
@@ -0,0 +1,768 @@
+// Copyright (c) 2022, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:analysis_server/src/services/correction/assist.dart';
+import 'package:analysis_server/src/services/correction/dart/abstract_producer.dart';
+import 'package:analysis_server/src/services/correction/util.dart';
+import 'package:analysis_server/src/utilities/extensions/range_factory.dart';
+import 'package:analyzer/dart/analysis/features.dart';
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/token.dart';
+import 'package:analyzer/dart/ast/visitor.dart';
+import 'package:analyzer/dart/constant/value.dart';
+import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/dart/element/type.dart';
+import 'package:analyzer_plugin/utilities/assist/assist.dart';
+import 'package:analyzer_plugin/utilities/change_builder/change_builder_core.dart';
+import 'package:analyzer_plugin/utilities/change_builder/change_builder_dart.dart';
+import 'package:analyzer_plugin/utilities/range_factory.dart';
+import 'package:collection/collection.dart';
+
+class ConvertClassToEnum extends CorrectionProducer {
+  @override
+  AssistKind get assistKind => DartAssistKind.CONVERT_CLASS_TO_ENUM;
+
+  @override
+  Future<void> compute(ChangeBuilder builder) async {
+    if (!libraryElement.featureSet.isEnabled(Feature.enhanced_enums)) {
+      // If the library doesn't support enhanced_enums then the class can't be
+      // converted.
+      return;
+    }
+    if (libraryElement.units.length > 1) {
+      // If the library has any part files, then the class can't be converted
+      // because we don't currently have a performant way to access the ASTs for
+      // the parts to check for invocations of the constructors or subclasses of
+      // the class.
+      return;
+    }
+    var node = this.node;
+    if (node is! SimpleIdentifier) {
+      return;
+    }
+    var parent = node.parent;
+    if (parent is ClassDeclaration && parent.name == node) {
+      var description = _EnumDescription.fromClass(parent);
+      if (description != null) {
+        await builder.addDartFileEdit(file, (builder) {
+          description.applyChanges(builder, utils);
+        });
+      }
+    }
+  }
+
+  /// Return an instance of this class. Used as a tear-off in `AssistProcessor`.
+  static ConvertClassToEnum newInstance() => ConvertClassToEnum();
+}
+
+/// A superclass for the [_EnumVisitor] and [_NonEnumVisitor].
+class _BaseVisitor extends RecursiveAstVisitor<void> {
+  /// The element representing the enum declaration that's being visited.
+  final ClassElement classElement;
+
+  _BaseVisitor(this.classElement);
+
+  /// Return `true` if the given [node] is an invocation of a constructor from
+  /// the class being converted.
+  bool invokesEnumConstructor(InstanceCreationExpression node) {
+    var constructorElement = node.constructorName.staticElement;
+    return constructorElement?.enclosingElement == classElement;
+  }
+}
+
+/// An exception thrown by the visitors if a condition is found that prevents
+/// the class from being converted.
+class _CannotConvertException implements Exception {
+  final String message;
+
+  _CannotConvertException(this.message);
+}
+
+/// A representation of a static field in the class being converted that will be
+/// replaced by an enum constant.
+class _ConstantField extends _Field {
+  /// The element representing the constructor used to initialize the field.
+  ConstructorElement constructorElement;
+
+  /// The invocation of the constructor.
+  final InstanceCreationExpression instanceCreation;
+
+  /// The value of the index field.
+  final int indexValue;
+
+  _ConstantField(
+      FieldElement element,
+      VariableDeclaration declaration,
+      VariableDeclarationList declarationList,
+      FieldDeclaration fieldDeclaration,
+      this.instanceCreation,
+      this.constructorElement,
+      this.indexValue)
+      : super(element, declaration, declarationList, fieldDeclaration);
+}
+
+/// Information about a single constructor in the class being converted.
+class _Constructor {
+  /// The declaration of the constructor.
+  final ConstructorDeclaration declaration;
+
+  /// The element representing the constructor.
+  final ConstructorElement element;
+
+  _Constructor(this.declaration, this.element);
+}
+
+/// Information about the constructors in the class being converted.
+class _Constructors {
+  /// A map from elements to constructors.
+  final Map<ConstructorElement, _Constructor> byElement = {};
+
+  _Constructors();
+
+  /// Return the constructors in this collection.
+  Iterable<_Constructor> get constructors => byElement.values;
+
+  /// Add the given [constructor] to this collection.
+  void add(_Constructor constructor) {
+    byElement[constructor.element] = constructor;
+  }
+
+  /// Return the constructor with the given [element].
+  _Constructor? forElement(ConstructorElement element) {
+    return byElement[element];
+  }
+}
+
+/// A description of how to convert the class to an enum.
+class _EnumDescription {
+  /// The class declaration being converted.
+  final ClassDeclaration classDeclaration;
+
+  /// A map from constructor declarations to information about the parameter
+  /// corresponding to the index field. The map is `null` if there is no index
+  /// field.
+  final Map<_Constructor, _Parameter>? constructorMap;
+
+  /// A list of the declarations to be converted into enum constants.
+  final _Fields fields;
+
+  /// A list of the indexes of members that need to be deleted.
+  final List<int> membersToDelete;
+
+  _EnumDescription({
+    required this.classDeclaration,
+    required this.constructorMap,
+    required this.fields,
+    required this.membersToDelete,
+  });
+
+  /// Return the offset immediately following the opening brace for the class
+  /// body.
+  int get bodyOffset => classDeclaration.leftBracket.end;
+
+  /// Use the [builder] and correction [utils] to apply the change necessary to
+  /// convert the class to an enum.
+  void applyChanges(DartFileEditBuilder builder, CorrectionUtils utils) {
+    // Replace the keyword.
+    builder.addSimpleReplacement(
+        range.token(classDeclaration.classKeyword), 'enum');
+
+    // Remove the extends clause if there is one.
+    final extendsClause = classDeclaration.extendsClause;
+    if (extendsClause != null) {
+      var followingToken = extendsClause.endToken.next!;
+      builder.addDeletion(range.startStart(extendsClause, followingToken));
+    }
+
+    // Compute the declarations of the enum constants and delete the fields
+    // being converted.
+    var members = classDeclaration.members;
+    var indent = utils.getIndent(1);
+    var constantsBuffer = StringBuffer();
+    var fieldsToConvert = fields.fieldsToConvert;
+    fieldsToConvert
+        .sort((first, second) => first.indexValue.compareTo(second.indexValue));
+    for (var field in fieldsToConvert) {
+      // Compute the declaration of the corresponding enum constant.
+      if (constantsBuffer.isNotEmpty) {
+        constantsBuffer.write(',\n$indent');
+      }
+      constantsBuffer.write(field.name);
+      var invocation = field.instanceCreation;
+      var constructorNameNode = invocation.constructorName;
+      var invokedConstructorElement = field.constructorElement;
+      var invokedConstructor = constructorMap?.keys.firstWhere(
+          (constructor) => constructor.element == invokedConstructorElement);
+      var parameterData = constructorMap?[invokedConstructor];
+      var typeArguments = constructorNameNode.type.typeArguments;
+      if (typeArguments != null) {
+        constantsBuffer.write(utils.getNodeText(typeArguments));
+      }
+      var constructorName = constructorNameNode.name?.name;
+      if (constructorName != null) {
+        constantsBuffer.write('.$constructorName');
+      }
+      var argumentList = invocation.argumentList;
+      var arguments = argumentList.arguments;
+      var argumentCount = arguments.length - (parameterData == null ? 0 : 1);
+      if (argumentCount == 0) {
+        if (typeArguments != null || constructorName != null) {
+          constantsBuffer.write('()');
+        }
+      } else if (parameterData == null) {
+        constantsBuffer.write(utils.getNodeText(argumentList));
+      } else {
+        constantsBuffer.write('(');
+        var index = parameterData.index;
+        var last = arguments.length - 1;
+        if (index == 0) {
+          var offset = arguments[1].offset;
+          var length = arguments[last].end - offset;
+          constantsBuffer.write(utils.getText(offset, length));
+        } else if (index == last) {
+          var offset = arguments[0].offset;
+          int length;
+          if (arguments[last].endToken.next?.type == TokenType.COMMA) {
+            length = arguments[last].offset - offset;
+          } else {
+            length = arguments[last - 1].end - offset;
+          }
+          constantsBuffer.write(utils.getText(offset, length));
+        } else {
+          var offset = arguments[0].offset;
+          var length = arguments[index].offset - offset;
+          constantsBuffer.write(utils.getText(offset, length));
+
+          offset = arguments[index + 1].offset;
+          length = argumentList.endToken.offset - offset;
+          constantsBuffer.write(utils.getText(offset, length));
+        }
+        constantsBuffer.write(')');
+      }
+
+      // Delete the static field that was converted to an enum constant.
+      _deleteField(builder, field, members);
+    }
+
+    // Remove the index field.
+    var indexField = fields.indexField;
+    if (indexField != null) {
+      _deleteField(builder, indexField, members);
+    }
+
+    // Update the constructors.
+    var removedConstructor = _removeUnnamedConstructor();
+    _transformConstructors(builder, removedConstructor);
+
+    // Special case replacing all of the members.
+    if (membersToDelete.length == members.length) {
+      builder.addSimpleReplacement(range.startEnd(members.first, members.last),
+          constantsBuffer.toString());
+      return;
+    }
+
+    // Insert the declarations of the enum constants.
+    var semicolon = ';';
+    var prefix = '${utils.endOfLine}$indent';
+    var suffix = '$semicolon${utils.endOfLine}';
+    builder.addSimpleInsertion(bodyOffset, '$prefix$constantsBuffer$suffix');
+
+    // Delete any members that are no longer needed.
+    membersToDelete.sort();
+    for (var range in range.nodesInList(members, membersToDelete)) {
+      builder.addDeletion(range);
+    }
+  }
+
+  /// Use the [builder] to delete the [field].
+  void _deleteField(DartFileEditBuilder builder, _Field field,
+      NodeList<ClassMember> members) {
+    var variableList = field.declarationList;
+    if (variableList.variables.length == 1) {
+      membersToDelete.add(members.indexOf(field.fieldDeclaration));
+    } else {
+      builder.addDeletion(
+          range.nodeInList(variableList.variables, field.declaration));
+    }
+  }
+
+  /// If the unnamed constructor is the only constructor, and if it has no
+  /// parameters other than potentially the index field, then remove it.
+  ConstructorDeclaration? _removeUnnamedConstructor() {
+    var members = classDeclaration.members;
+    var constructors = members.whereType<ConstructorDeclaration>().toList();
+    if (constructors.length != 1) {
+      return null;
+    }
+    var constructor = constructors[0];
+    var name = constructor.name?.name;
+    if (name != null && name != 'new') {
+      return null;
+    }
+    var parameters = constructor.parameters.parameters;
+    // If there's only one constructor, then there can only be one entry in the
+    // constructor map.
+    var parameterData = constructorMap?.entries.first.value;
+    // `parameterData` should only be `null` if there is no index field.
+    var updatedParameterCount =
+        parameters.length - (parameterData == null ? 0 : 1);
+    if (updatedParameterCount != 0) {
+      return null;
+    }
+    membersToDelete.add(members.indexOf(constructor));
+    return constructor;
+  }
+
+  /// Transform the used constructors by removing the parameter corresponding to
+  /// the index field.
+  void _transformConstructors(
+      DartFileEditBuilder builder, ConstructorDeclaration? removedConstructor) {
+    final constructorMap = this.constructorMap;
+    if (constructorMap == null) {
+      return;
+    }
+    for (var constructor in constructorMap.keys) {
+      if (constructor.declaration != removedConstructor) {
+        var parameterData = constructorMap[constructor];
+        if (parameterData != null) {
+          var parameters = constructor.declaration.parameters.parameters;
+          builder.addDeletion(
+              range.nodeInList(parameters, parameters[parameterData.index]));
+        }
+      }
+    }
+  }
+
+  /// If the given [node] can be converted into an enum, then return a
+  /// description of the conversion work to be done. Otherwise, return `null`.
+  static _EnumDescription? fromClass(ClassDeclaration node) {
+    // The class must be a concrete class.
+    var classElement = node.declaredElement;
+    if (classElement == null || classElement.isAbstract) {
+      return null;
+    }
+
+    // The class must be a subclass of Object, whether implicitly or explicitly.
+    var extendsClause = node.extendsClause;
+    if (extendsClause != null &&
+        extendsClause.superclass.type?.isDartCoreObject == false) {
+      return null;
+    }
+
+    // The class must either be private or must only have private constructors.
+    var constructors = _validateConstructors(node, classElement);
+    if (constructors == null) {
+      return null;
+    }
+
+    // The class must not override either `==` or `hashCode`.
+    if (!_validateMethods(node)) {
+      return null;
+    }
+
+    // There must be at least one static field that can be converted into an
+    // enum constant.
+    //
+    // The instance fields must all be final.
+    var fields = _validateFields(node, classElement);
+    if (fields == null || fields.fieldsToConvert.isEmpty) {
+      return null;
+    }
+
+    var visitor = _EnumVisitor(classElement, fields.fieldsToConvert);
+    try {
+      node.accept(visitor);
+    } on _CannotConvertException {
+      return null;
+    }
+
+    // Within the defining library,
+    // - there can't be any subclasses of the class to be converted,
+    // - there can't be any invocations of any constructor from that class.
+    try {
+      node.root.accept(_NonEnumVisitor(classElement));
+    } on _CannotConvertException {
+      return null;
+    }
+
+    var usedConstructors = _computeUsedConstructors(constructors, fields);
+    var constructorMap = _indexFieldData(usedConstructors, fields);
+    if (fields.indexField != null && constructorMap == null) {
+      return null;
+    }
+
+    var membersToDelete = <int>[];
+    return _EnumDescription(
+      classDeclaration: node,
+      constructorMap: constructorMap,
+      fields: fields,
+      membersToDelete: membersToDelete,
+    );
+  }
+
+  /// Return the subset of [constructors] that are invoked by the [fields] to be
+  /// converted.
+  static _Constructors _computeUsedConstructors(
+      _Constructors constructors, _Fields fields) {
+    var usedElements = <ConstructorElement>{};
+    for (var field in fields.fieldsToConvert) {
+      usedElements.add(field.constructorElement);
+    }
+    var usedConstructors = _Constructors();
+    for (var element in usedElements) {
+      var constructor = constructors.forElement(element);
+      if (constructor != null) {
+        usedConstructors.add(constructor);
+      }
+    }
+    return usedConstructors;
+  }
+
+  /// If the index field can be removed, return a map describing the changes
+  /// that need to be made to both the constructors and the invocations of those
+  /// constructors. Otherwise, return `null`.
+  static Map<_Constructor, _Parameter>? _indexFieldData(
+      _Constructors usedConstructors, _Fields fields) {
+    var indexField = fields.indexField;
+    if (indexField == null) {
+      return null;
+    }
+    // Ensure that the index field has a corresponding field formal initializer
+    // in each of the used constructors.
+    var constructorMap = <_Constructor, _Parameter>{};
+    for (var constructor in usedConstructors.constructors) {
+      var parameterData = _indexParameter(constructor, indexField);
+      if (parameterData == null) {
+        return null;
+      }
+      constructorMap[constructor] = parameterData;
+    }
+
+    var fieldsToConvert = fields.fieldsToConvert;
+    var values = <int>{};
+    for (var field in fieldsToConvert) {
+      var constructorElement = field.constructorElement;
+      var constructor = usedConstructors.forElement(constructorElement);
+      if (constructor == null) {
+        // We should never reach this point.
+        return null;
+      }
+      var parameterData = constructorMap[constructor];
+      if (parameterData == null) {
+        // We should never reach this point.
+        return null;
+      }
+      var arguments = field.instanceCreation.argumentList.arguments;
+      var argument = parameterData.getArgument(arguments);
+      if (argument is! IntegerLiteral) {
+        return null;
+      }
+      var value = argument.value;
+      if (value == null) {
+        return null;
+      }
+      if (!values.add(value)) {
+        // Duplicate value.
+        return null;
+      }
+    }
+    var sortedValues = values.toList()..sort();
+    if (sortedValues.length == fieldsToConvert.length &&
+        sortedValues.first == 0 &&
+        sortedValues.last == fieldsToConvert.length - 1) {
+      return constructorMap;
+    }
+    return null;
+  }
+
+  static _Parameter? _indexParameter(
+      _Constructor constructor, _Field? indexField) {
+    if (indexField == null) {
+      return null;
+    }
+    var parameters = constructor.declaration.parameters.parameters;
+    var indexFieldElement = indexField.element;
+    for (var i = 0; i < parameters.length; i++) {
+      var element = parameters[i].declaredElement;
+      if (element is FieldFormalParameterElement) {
+        if (element.field == indexFieldElement) {
+          if (element.isPositional) {
+            return _Parameter(i, element);
+          } else {
+            return _Parameter(i, element);
+          }
+        }
+      }
+    }
+    return null;
+  }
+
+  /// Return a representation of all of the constructors declared by the
+  /// [classDeclaration], or `null` if the class can't be converted.
+  ///
+  /// The [classElement] must be the element declared by the [classDeclaration].
+  static _Constructors? _validateConstructors(
+      ClassDeclaration classDeclaration, ClassElement classElement) {
+    var constructors = _Constructors();
+    for (var member in classDeclaration.members) {
+      if (member is ConstructorDeclaration) {
+        var constructor = member.declaredElement;
+        if (constructor is ConstructorElement) {
+          if (!classElement.isPrivate && !constructor.isPrivate) {
+            // Public constructor in public enum.
+            return null;
+          } else if (constructor.isFactory) {
+            // Factory constructor.
+            return null;
+          } else if (!constructor.isConst) {
+            // Non-const constructor.
+            return null;
+          }
+          constructors.add(_Constructor(member, constructor));
+        } else {
+          // Not resolved.
+          return null;
+        }
+      }
+    }
+    return constructors;
+  }
+
+  /// Return a representation of all of the constructors declared by the
+  /// [classDeclaration], or `null` if the class can't be converted.
+  ///
+  /// The [classElement] must be the element declared by the [classDeclaration].
+  static _Fields? _validateFields(
+      ClassDeclaration classDeclaration, ClassElement classElement) {
+    var potentialFieldsToConvert = <DartObject, List<_ConstantField>>{};
+    _Field? indexField;
+
+    for (var member in classDeclaration.members) {
+      if (member is FieldDeclaration) {
+        var fieldList = member.fields;
+        var fields = fieldList.variables;
+        if (member.isStatic) {
+          for (var field in fields) {
+            var fieldElement = field.declaredElement;
+            if (fieldElement is FieldElement) {
+              var fieldType = fieldElement.type;
+              // The field can be converted to be an enum constant if it
+              // - is a const field,
+              // - has a type equal to the type of the class, and
+              // - is initialized by an instance creation expression defined in this
+              //   class.
+              if (fieldElement.isConst &&
+                  fieldType is InterfaceType &&
+                  fieldType.element == classElement) {
+                var initializer = field.initializer;
+                if (initializer is InstanceCreationExpression) {
+                  var constructorElement =
+                      initializer.constructorName.staticElement;
+                  if (constructorElement != null &&
+                      constructorElement.enclosingElement == classElement) {
+                    var fieldValue = fieldElement.computeConstantValue();
+                    if (fieldValue != null) {
+                      if (fieldList.variables.length != 1) {
+                        // Too many constants in the field declaration.
+                        return null;
+                      }
+                      potentialFieldsToConvert
+                          .putIfAbsent(fieldValue, () => [])
+                          .add(_ConstantField(
+                              fieldElement,
+                              field,
+                              fieldList,
+                              member,
+                              initializer,
+                              constructorElement,
+                              fieldValue.getField('index')?.toIntValue() ??
+                                  -1));
+                    }
+                  }
+                }
+              }
+            }
+          }
+        } else {
+          for (var field in fields) {
+            if (!field.isFinal) {
+              // Non-final instance field.
+              return null;
+            }
+            var fieldElement = field.declaredElement;
+            if (fieldElement is FieldElement) {
+              var fieldType = fieldElement.type;
+              if (fieldElement.name == 'index' && fieldType.isDartCoreInt) {
+                indexField = _Field(fieldElement, field, fieldList, member);
+              }
+            }
+          }
+        }
+      }
+    }
+
+    var fieldsToConvert = <_ConstantField>[];
+    for (var list in potentialFieldsToConvert.values) {
+      if (list.length == 1) {
+        fieldsToConvert.add(list[0]);
+      } else {
+        // TODO(brianwilkerson) We could potentially handle the case where
+        //  there's only one non-deprecated field in the list. We'd need to
+        //  change the return type for this method so that we could return two
+        //  lists: the list of fields to convert and the list of fields whose
+        //  initializer needs to be updated to refer to the constant.
+        return null;
+      }
+    }
+    return _Fields(fieldsToConvert, indexField);
+  }
+
+  /// Return `true` if the [classDeclaration] does not contain any methods that
+  /// prevent it from being converted.
+  static bool _validateMethods(ClassDeclaration classDeclaration) {
+    for (var member in classDeclaration.members) {
+      if (member is MethodDeclaration) {
+        if (member.name.name == '==' || member.name.name == 'hashCode') {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+}
+
+/// A visitor used to visit the class being converted. This visitor throws an
+/// exception if a constructor for the class is invoked anywhere other than the
+/// top-level expression of an initializer for one of the fields being converted.
+class _EnumVisitor extends _BaseVisitor {
+  /// The declarations of the fields that are to be converted.
+  final List<VariableDeclaration> fieldsToConvert;
+
+  /// A flag indicating whether we are currently visiting the children of a
+  /// field declaration that will be converted to be a constant.
+  bool inConstantDeclaration = false;
+
+  /// Initialize a newly created visitor to visit the class declaration
+  /// corresponding to the given [classElement].
+  _EnumVisitor(ClassElement classElement, List<_ConstantField> fieldsToConvert)
+      : fieldsToConvert =
+            fieldsToConvert.map((field) => field.declaration).toList(),
+        super(classElement);
+
+  @override
+  void visitInstanceCreationExpression(InstanceCreationExpression node) {
+    if (!inConstantDeclaration) {
+      if (invokesEnumConstructor(node)) {
+        throw _CannotConvertException(
+            'Constructor used outside constant initializer');
+      }
+    }
+    inConstantDeclaration = false;
+    super.visitInstanceCreationExpression(node);
+  }
+
+  @override
+  void visitVariableDeclaration(VariableDeclaration node) {
+    if (fieldsToConvert.contains(node)) {
+      inConstantDeclaration = true;
+    }
+    super.visitVariableDeclaration(node);
+    inConstantDeclaration = false;
+  }
+}
+
+/// A representation of a field of interest in the class being converted.
+class _Field {
+  /// The element representing the field.
+  final FieldElement element;
+
+  /// The declaration of the field.
+  final VariableDeclaration declaration;
+
+  /// The list containing the [declaration]
+  final VariableDeclarationList declarationList;
+
+  /// The field declaration containing the [declarationList].
+  final FieldDeclaration fieldDeclaration;
+
+  _Field(this.element, this.declaration, this.declarationList,
+      this.fieldDeclaration);
+
+  /// Return the name of the field.
+  String get name => declaration.name.name;
+}
+
+/// A representation of all the fields of interest in the class being converted.
+class _Fields {
+  /// The fields to be converted into enum constants.
+  List<_ConstantField> fieldsToConvert;
+
+  /// The index field, or `null` if there is no index field.
+  _Field? indexField;
+
+  _Fields(this.fieldsToConvert, this.indexField);
+}
+
+/// A visitor that visits everything in the library other than the class being
+/// converted. This visitor throws an exception if the class can't be converted
+/// because
+/// - there is a subclass of the class, or
+/// - there is an invocation of one of the constructors of the class.
+class _NonEnumVisitor extends _BaseVisitor {
+  /// Initialize a newly created visitor to visit everything except the class
+  /// declaration corresponding to the given [classElement].
+  _NonEnumVisitor(ClassElement classElement) : super(classElement);
+
+  @override
+  void visitClassDeclaration(ClassDeclaration node) {
+    var element = node.declaredElement;
+    if (element == null) {
+      throw _CannotConvertException('Unresolved');
+    }
+    if (element != classElement) {
+      if (element.supertype?.element == classElement) {
+        throw _CannotConvertException('Class is extended');
+      } else if (element.interfaces
+          .map((e) => e.element)
+          .contains(classElement)) {
+        throw _CannotConvertException('Class is implemented');
+      } else if (element.mixins.map((e) => e.element).contains(classElement)) {
+        // This case won't occur unless there's an error in the source code, but
+        // it's easier to check for the condition than it is to check for the
+        // diagnostic.
+        throw _CannotConvertException('Class is mixed in');
+      }
+      super.visitClassDeclaration(node);
+    }
+  }
+
+  @override
+  void visitInstanceCreationExpression(InstanceCreationExpression node) {
+    if (invokesEnumConstructor(node)) {
+      throw _CannotConvertException(
+          'Constructor used outside class being converted');
+    }
+    super.visitInstanceCreationExpression(node);
+  }
+}
+
+/// An object used to access information about a specific parameter, including
+/// its index in the parameter list as well as any associated argument in an
+/// argument list.
+class _Parameter {
+  /// The index of this parameter in the enclosing constructor's parameter list.
+  final int index;
+
+  /// The element associated with the parameter.
+  final ParameterElement element;
+
+  _Parameter(this.index, this.element);
+
+  /// Return the expression representing the argument associated with this
+  /// parameter, or `null` if there is no such argument.
+  Expression? getArgument(NodeList<Expression> arguments) {
+    return arguments.firstWhereOrNull(
+        (argument) => argument.staticParameterElement == element);
+  }
+}
diff --git a/pkg/analysis_server/lib/src/services/snippets/dart/flutter_snippet_producers.dart b/pkg/analysis_server/lib/src/services/snippets/dart/flutter_snippet_producers.dart
new file mode 100644
index 0000000..6222f82
--- /dev/null
+++ b/pkg/analysis_server/lib/src/services/snippets/dart/flutter_snippet_producers.dart
@@ -0,0 +1,160 @@
+// Copyright (c) 2022, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:analysis_server/src/services/snippets/dart/snippet_manager.dart';
+import 'package:analysis_server/src/utilities/flutter.dart';
+import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/dart/element/nullability_suffix.dart';
+import 'package:analyzer/dart/element/type.dart';
+import 'package:analyzer/src/dart/analysis/session_helper.dart';
+import 'package:analyzer_plugin/utilities/change_builder/change_builder_core.dart';
+import 'package:meta/meta.dart';
+
+abstract class FlutterSnippetProducer extends SnippetProducer {
+  final flutter = Flutter.instance;
+  final AnalysisSessionHelper sessionHelper;
+
+  late ClassElement? classWidget;
+
+  FlutterSnippetProducer(DartSnippetRequest request)
+      : sessionHelper = AnalysisSessionHelper(request.analysisSession),
+        super(request);
+
+  @override
+  @mustCallSuper
+  Future<bool> isValid() async {
+    classWidget = await _getClass('Widget');
+
+    return classWidget != null;
+  }
+
+  Future<ClassElement?> _getClass(String name) =>
+      sessionHelper.getClass(flutter.widgetsUri, name);
+
+  DartType _getType(
+    ClassElement classElement, [
+    NullabilitySuffix nullabilitySuffix = NullabilitySuffix.none,
+  ]) =>
+      classElement.instantiate(
+        typeArguments: const [],
+        nullabilitySuffix: nullabilitySuffix,
+      );
+}
+
+/// Contributes snippets useful in Flutter applications, such as creating
+/// Flutter widget classes.
+class FlutterStatelessWidgetSnippetProducer extends FlutterSnippetProducer {
+  static const prefix = 'stless';
+  static const label = 'Flutter Stateless Widget';
+
+  late ClassElement? classStatelessWidget;
+  late ClassElement? classBuildContext;
+  late ClassElement? classKey;
+
+  FlutterStatelessWidgetSnippetProducer(DartSnippetRequest request)
+      : super(request);
+
+  @override
+  Future<Snippet> compute() async {
+    final builder = ChangeBuilder(session: request.analysisSession);
+
+    // Checked by isValid().
+    final classStatelessWidget = this.classStatelessWidget!;
+    final classWidget = this.classWidget!;
+    final classBuildContext = this.classBuildContext!;
+    final classKey = this.classKey!;
+
+    // Only include `?` for nulable types like Key? if in a null-safe library.
+    final nullableSuffix = request.unit.libraryElement.isNonNullableByDefault
+        ? NullabilitySuffix.question
+        : NullabilitySuffix.none;
+
+    final className = 'MyWidget';
+    await builder.addDartFileEdit(request.filePath, (builder) {
+      builder.addReplacement(request.replacementRange, (builder) {
+        builder.writeClassDeclaration(
+          className,
+          nameGroupName: 'name',
+          superclass: _getType(classStatelessWidget),
+          membersWriter: () {
+            // Add the constructor.
+            builder.write('  ');
+            builder.writeConstructorDeclaration(
+              className,
+              classNameGroupName: 'name',
+              isConst: true,
+              parameterWriter: () {
+                builder.write('{');
+                builder.writeParameter(
+                  'key',
+                  type: _getType(classKey, nullableSuffix),
+                );
+                builder.write('}');
+              },
+              initializerWriter: () => builder.write('super(key: key)'),
+            );
+            builder.writeln();
+            builder.writeln();
+
+            // Add the build method.
+            builder.writeln('  @override');
+            builder.write('  ');
+            builder.writeFunctionDeclaration(
+              'build',
+              returnType: _getType(classWidget),
+              parameterWriter: () {
+                builder.writeParameter(
+                  'context',
+                  type: _getType(classBuildContext),
+                );
+              },
+              bodyWriter: () {
+                builder.writeln('{');
+                builder.write('    ');
+                builder.selectHere();
+                builder.writeln('');
+                builder.writeln('  }');
+              },
+            );
+          },
+        );
+      });
+    });
+
+    return Snippet(
+      prefix,
+      label,
+      'Insert a StatelessWidget',
+      builder.sourceChange,
+    );
+  }
+
+  @override
+  Future<bool> isValid() async {
+    if (!await super.isValid()) {
+      return false;
+    }
+
+    classStatelessWidget = await _getClass('StatelessWidget');
+    if (classStatelessWidget == null) {
+      return false;
+    }
+
+    classBuildContext = await _getClass('BuildContext');
+    if (classBuildContext == null) {
+      return false;
+    }
+
+    classKey = await _getClass('Key');
+    if (classKey == null) {
+      return false;
+    }
+
+    return true;
+  }
+
+  static FlutterStatelessWidgetSnippetProducer newInstance(
+          DartSnippetRequest request) =>
+      FlutterStatelessWidgetSnippetProducer(request);
+}
diff --git a/pkg/analysis_server/lib/src/services/snippets/dart/snippet_manager.dart b/pkg/analysis_server/lib/src/services/snippets/dart/snippet_manager.dart
new file mode 100644
index 0000000..6895873
--- /dev/null
+++ b/pkg/analysis_server/lib/src/services/snippets/dart/snippet_manager.dart
@@ -0,0 +1,186 @@
+// Copyright (c) 2022, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:analysis_server/src/protocol_server.dart';
+import 'package:analysis_server/src/provisional/completion/completion_core.dart';
+import 'package:analysis_server/src/services/snippets/dart/flutter_snippet_producers.dart';
+import 'package:analyzer/dart/analysis/results.dart';
+import 'package:analyzer/dart/analysis/session.dart';
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/token.dart';
+import 'package:analyzer/file_system/file_system.dart';
+import 'package:analyzer/source/source_range.dart';
+import 'package:analyzer/src/util/file_paths.dart' as file_paths;
+import 'package:analyzer_plugin/src/utilities/completion/completion_target.dart';
+
+typedef SnippetProducerGenerator = SnippetProducer Function(DartSnippetRequest);
+
+/// [DartSnippetManager] determines if a snippet request is Dart specific
+/// and forwards those requests to all Snippet Producers that return `true` from
+/// their `isValid()` method.
+class DartSnippetManager {
+  final producerGenerators =
+      const <SnippetContext, List<SnippetProducerGenerator>>{
+    SnippetContext.atTopLevel: [
+      FlutterStatelessWidgetSnippetProducer.newInstance,
+    ]
+  };
+
+  Future<List<Snippet>> computeSnippets(
+    DartSnippetRequest request,
+  ) async {
+    var pathContext = request.resourceProvider.pathContext;
+    if (!file_paths.isDart(pathContext, request.filePath)) {
+      return const [];
+    }
+
+    try {
+      final snippets = <Snippet>[];
+      final generators = producerGenerators[request.context];
+      if (generators == null) {
+        return snippets;
+      }
+      for (final generator in generators) {
+        final producer = generator(request);
+        if (await producer.isValid()) {
+          snippets.add(await producer.compute());
+        }
+      }
+      return snippets;
+    } on InconsistentAnalysisException {
+      // The state of the code being analyzed has changed, so results are likely
+      // to be inconsistent. Just abort the operation.
+      throw AbortCompletion();
+    }
+  }
+}
+
+/// The information about a request for a list of snippets within a Dart file.
+class DartSnippetRequest {
+  /// The resolved unit for the file that snippets are being requested for.
+  final ResolvedUnitResult unit;
+
+  /// The path of the file snippets are being requested for.
+  final String filePath;
+
+  /// The offset within the source at which snippets are being
+  /// requested for.
+  final int offset;
+
+  /// The context in which the snippet request is being made.
+  late final SnippetContext context;
+
+  /// The source range that represents the region of text that should be
+  /// replaced if the snippet is selected.
+  late final SourceRange replacementRange;
+
+  DartSnippetRequest({
+    required this.unit,
+    required this.offset,
+  }) : filePath = unit.path {
+    final target = CompletionTarget.forOffset(unit.unit, offset);
+    context = _getContext(target);
+    replacementRange = target.computeReplacementRange(offset);
+  }
+
+  /// The analysis session that produced the elements of the request.
+  AnalysisSession get analysisSession => unit.session;
+
+  /// The resource provider associated with this request.
+  ResourceProvider get resourceProvider => analysisSession.resourceProvider;
+
+  static SnippetContext _getContext(CompletionTarget target) {
+    final entity = target.entity;
+    if (entity is Token) {
+      final tokenType = (entity.beforeSynthetic ?? entity).type;
+
+      if (tokenType == TokenType.MULTI_LINE_COMMENT ||
+          tokenType == TokenType.SINGLE_LINE_COMMENT) {
+        return SnippetContext.inComment;
+      }
+
+      if (tokenType == TokenType.STRING ||
+          tokenType == TokenType.STRING_INTERPOLATION_EXPRESSION ||
+          tokenType == TokenType.STRING_INTERPOLATION_IDENTIFIER) {
+        return SnippetContext.inString;
+      }
+    }
+
+    AstNode? node = target.containingNode;
+    while (node != null) {
+      if (node is Comment) {
+        return SnippetContext.inComment;
+      }
+
+      if (node is StringLiteral) {
+        return SnippetContext.inString;
+      }
+
+      if (node is Block) {
+        return SnippetContext.inBlock;
+      }
+
+      if (node is Statement || node is Expression || node is Annotation) {
+        return SnippetContext.inExpressionOrStatement;
+      }
+
+      if (node is BlockFunctionBody) {
+        return SnippetContext.inBlock;
+      }
+
+      if (node is ClassOrMixinDeclaration || node is ExtensionDeclaration) {
+        return SnippetContext.inClass;
+      }
+
+      node = node.parent;
+    }
+
+    return SnippetContext.atTopLevel;
+  }
+}
+
+class Snippet {
+  /// The text the user will type to use this snippet.
+  final String prefix;
+
+  /// The label/title of this snippet.
+  final String label;
+
+  /// A description of/documentation for the snippet.
+  final String? documentation;
+
+  /// The source changes to be made to insert this snippet.
+  final SourceChange change;
+
+  Snippet(
+    this.prefix,
+    this.label,
+    this.documentation,
+    this.change,
+  );
+}
+
+/// The context in which a snippet request was made.
+///
+/// This is used to filter the available snippets (for example preventing
+/// snippets that create classes showing up when inside an existing class or
+/// function body).
+enum SnippetContext {
+  atTopLevel,
+  inClass,
+  inBlock,
+  inExpressionOrStatement,
+  inComment,
+  inString,
+}
+
+abstract class SnippetProducer {
+  final DartSnippetRequest request;
+
+  SnippetProducer(this.request);
+
+  Future<Snippet> compute();
+
+  Future<bool> isValid();
+}
diff --git a/pkg/analysis_server/lib/src/utilities/extensions/range_factory.dart b/pkg/analysis_server/lib/src/utilities/extensions/range_factory.dart
index 95c5384..eedc3c7 100644
--- a/pkg/analysis_server/lib/src/utilities/extensions/range_factory.dart
+++ b/pkg/analysis_server/lib/src/utilities/extensions/range_factory.dart
@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import 'package:_fe_analyzer_shared/src/scanner/token.dart';
+import 'package:analysis_server/src/utilities/index_range.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/source/line_info.dart';
 import 'package:analyzer/source/source_range.dart';
@@ -67,6 +68,30 @@
     }
   }
 
+  /// Return a list of the ranges that cover all of the elements in the [list]
+  /// whose index is in the list of [indexes].
+  List<SourceRange> nodesInList<T extends AstNode>(
+      NodeList<T> list, List<int> indexes) {
+    var ranges = <SourceRange>[];
+    var indexRanges = IndexRange.contiguousSubRanges(indexes);
+    if (indexRanges.length == 1) {
+      var indexRange = indexRanges[0];
+      if (indexRange.lower == 0 && indexRange.upper == list.length - 1) {
+        ranges.add(startEnd(list[indexRange.lower], list[indexRange.upper]));
+        return ranges;
+      }
+    }
+    for (var indexRange in indexRanges) {
+      if (indexRange.lower == 0) {
+        ranges.add(
+            startStart(list[indexRange.lower], list[indexRange.upper + 1]));
+      } else {
+        ranges.add(endEnd(list[indexRange.lower - 1], list[indexRange.upper]));
+      }
+    }
+    return ranges;
+  }
+
   /// Return a source range that covers the given [node] with any leading and
   /// trailing comments.
   ///
diff --git a/pkg/analysis_server/lib/src/utilities/index_range.dart b/pkg/analysis_server/lib/src/utilities/index_range.dart
new file mode 100644
index 0000000..648ec02
--- /dev/null
+++ b/pkg/analysis_server/lib/src/utilities/index_range.dart
@@ -0,0 +1,42 @@
+// Copyright (c) 2022, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/// A range of indexes within a list.
+class IndexRange {
+  /// The index of the first element in the range.
+  final int lower;
+
+  /// The index of the last element in the range. This will be the same as the
+  /// [lower] if there is a single element in the range.
+  final int upper;
+
+  /// Initialize a newly created range.
+  IndexRange(this.lower, this.upper);
+
+  /// Return the number of indices in this range.
+  int get count => upper - lower + 1;
+
+  @override
+  String toString() => '[$lower..$upper]';
+
+  static List<IndexRange> contiguousSubRanges(List<int> indexes) {
+    var ranges = <IndexRange>[];
+    if (indexes.isEmpty) {
+      return ranges;
+    }
+    var lower = indexes[0];
+    var previous = lower;
+    for (var index = 1; index < indexes.length; index++) {
+      var current = indexes[index];
+      if (current == previous + 1) {
+        previous = current;
+      } else {
+        ranges.add(IndexRange(lower, previous));
+        lower = previous = current;
+      }
+    }
+    ranges.add(IndexRange(lower, previous));
+    return ranges;
+  }
+}
diff --git a/pkg/analysis_server/test/lsp/code_actions_fixes_test.dart b/pkg/analysis_server/test/lsp/code_actions_fixes_test.dart
index 925b13b..9a541dc 100644
--- a/pkg/analysis_server/test/lsp/code_actions_fixes_test.dart
+++ b/pkg/analysis_server/test/lsp/code_actions_fixes_test.dart
@@ -341,7 +341,7 @@
   }
 
   Future<void> test_outsideRoot() async {
-    final otherFilePath = '/home/otherProject/foo.dart';
+    final otherFilePath = convertPath('/home/otherProject/foo.dart');
     final otherFileUri = Uri.file(otherFilePath);
     newFile(otherFilePath, content: 'bad code to create error');
     await initialize(
diff --git a/pkg/analysis_server/test/lsp/completion_dart_test.dart b/pkg/analysis_server/test/lsp/completion_dart_test.dart
index 1f749a6..5588ee9 100644
--- a/pkg/analysis_server/test/lsp/completion_dart_test.dart
+++ b/pkg/analysis_server/test/lsp/completion_dart_test.dart
@@ -5,6 +5,7 @@
 import 'package:analysis_server/lsp_protocol/protocol_generated.dart';
 import 'package:analysis_server/src/lsp/constants.dart';
 import 'package:analysis_server/src/services/linter/lint_names.dart';
+import 'package:analysis_server/src/services/snippets/dart/flutter_snippet_producers.dart';
 import 'package:analyzer_plugin/protocol/protocol_common.dart' as plugin;
 import 'package:analyzer_plugin/protocol/protocol_generated.dart' as plugin;
 import 'package:collection/collection.dart';
@@ -19,6 +20,9 @@
 void main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(CompletionTest);
+    defineReflectiveTests(DartSnippetCompletionTest);
+    defineReflectiveTests(FlutterSnippetCompletionTest);
+    defineReflectiveTests(FlutterSnippetCompletionWithNullSafetyTest);
     defineReflectiveTests(CompletionTestWithNullSafetyTest);
   });
 }
@@ -2363,3 +2367,246 @@
     expect(completion.detail, '(int? a, [int b = 1]) → String?');
   }
 }
+
+@reflectiveTest
+class DartSnippetCompletionTest extends SnippetCompletionTest {
+  Future<void> test_snippets_disabled() async {
+    final content = '^';
+
+    // Advertise support (this is done by the editor), but with the user
+    // preference disabled.
+    await provideConfig(
+      () => initialize(
+        textDocumentCapabilities: withCompletionItemSnippetSupport(
+            emptyTextDocumentClientCapabilities),
+        workspaceCapabilities:
+            withConfigurationSupport(emptyWorkspaceClientCapabilities),
+      ),
+      {'enableSnippets': true},
+    );
+
+    await expectNoSnippet(
+      content,
+      FlutterStatelessWidgetSnippetProducer.prefix,
+    );
+  }
+
+  Future<void>
+      test_snippets_flutterStateless_notAvailable_notFlutterProject() async {
+    final content = '''
+class A {}
+
+stle^
+
+class B {}
+''';
+
+    await initializeWithSnippetSupportAndPreviewFlag();
+    await expectNoSnippet(
+      content,
+      FlutterStatelessWidgetSnippetProducer.prefix,
+    );
+  }
+
+  Future<void> test_snippets_notSupported() async {
+    final content = '^';
+
+    // If we don't send support for Snippet CompletionItem kinds, we don't
+    // expect any snippets at all.
+    await initialize();
+    await openFile(mainFileUri, withoutMarkers(content));
+    final res = await getCompletion(mainFileUri, positionFromMarker(content));
+    expect(res.any((c) => c.kind == CompletionItemKind.Snippet), isFalse);
+  }
+}
+
+@reflectiveTest
+class FlutterSnippetCompletionTest extends SnippetCompletionTest {
+  /// Nullability suffix expected in this test class.
+  ///
+  /// Used to allow all tests to be run in both modes without having to
+  /// duplicate all tests ([FlutterSnippetCompletionWithNullSafetyTest]
+  /// overrides this).
+  String get questionSuffix => '';
+
+  @override
+  void setUp() {
+    super.setUp();
+    writePackageConfig(
+      projectFolderPath,
+      flutter: true,
+    );
+  }
+
+  Future<void> test_snippets_flutterStateless() async {
+    final content = '''
+import 'package:flutter/widgets.dart';
+
+class A {}
+
+stle^
+
+class B {}
+''';
+
+    await initializeWithSnippetSupportAndPreviewFlag();
+    final updated = await expectAndApplySnippet(
+      content,
+      prefix: FlutterStatelessWidgetSnippetProducer.prefix,
+      label: FlutterStatelessWidgetSnippetProducer.label,
+    );
+
+    expect(updated, '''
+import 'package:flutter/widgets.dart';
+
+class A {}
+
+class \${1:MyWidget} extends StatelessWidget {
+  const \${1:MyWidget}({Key$questionSuffix key}) : super(key: key);
+
+  @override
+  Widget build(BuildContext context) {
+    \$0
+  }
+}
+
+class B {}
+''');
+  }
+
+  Future<void> test_snippets_flutterStateless_addsImports() async {
+    final content = '''
+class A {}
+
+stle^
+
+class B {}
+''';
+
+    await initializeWithSnippetSupportAndPreviewFlag();
+    final updated = await expectAndApplySnippet(
+      content,
+      prefix: FlutterStatelessWidgetSnippetProducer.prefix,
+      label: FlutterStatelessWidgetSnippetProducer.label,
+    );
+
+    expect(updated, '''
+import 'package:flutter/src/foundation/key.dart';
+import 'package:flutter/src/widgets/framework.dart';
+
+class A {}
+
+class \${1:MyWidget} extends StatelessWidget {
+  const \${1:MyWidget}({Key$questionSuffix key}) : super(key: key);
+
+  @override
+  Widget build(BuildContext context) {
+    \$0
+  }
+}
+
+class B {}
+''');
+  }
+
+  Future<void> test_snippets_flutterStateless_notAvailable_notTopLevel() async {
+    final content = '''
+class A {
+
+  stle^
+
+}
+''';
+
+    await initializeWithSnippetSupportAndPreviewFlag();
+    await expectNoSnippet(
+      content,
+      FlutterStatelessWidgetSnippetProducer.prefix,
+    );
+  }
+}
+
+@reflectiveTest
+class FlutterSnippetCompletionWithNullSafetyTest
+    extends FlutterSnippetCompletionTest {
+  @override
+  String get questionSuffix => '?';
+
+  @override
+  String get testPackageLanguageVersion => latestLanguageVersion;
+}
+
+abstract class SnippetCompletionTest extends AbstractLspAnalysisServerTest
+    with CompletionTestMixin {
+  /// Expect that there is a snippet for [prefix] at [position] with the label
+  /// [label] and return the results of applying it to [content].
+  Future<String> expectAndApplySnippet(
+    String content, {
+    required String prefix,
+    required String label,
+  }) async {
+    final snippet = await expectSnippet(
+      content,
+      prefix: prefix,
+      label: label,
+    );
+
+    // Also apply the edit and check that it went in the right place with the
+    // correct formatting. Edit groups will just appear in the raw textmate
+    // snippet syntax here, as we don't do any special handling of them (and
+    // assume what's coded here is correct, and that the client will correctly
+    // interpret them).
+    final updated = applyTextEdits(
+      withoutMarkers(content),
+      [toTextEdit(snippet.textEdit!)]
+          .followedBy(snippet.additionalTextEdits!)
+          .toList(),
+    );
+    return updated;
+  }
+
+  /// Expect that there is no snippet for [prefix] at the position of `^` within
+  /// [content].
+  Future<void> expectNoSnippet(
+    String content,
+    String prefix,
+  ) async {
+    await openFile(mainFileUri, withoutMarkers(content));
+    final res = await getCompletion(mainFileUri, positionFromMarker(content));
+    final hasSnippet = res.any((c) => c.filterText == prefix);
+    expect(hasSnippet, isFalse);
+  }
+
+  /// Expect that there is a snippet for [prefix] with the label [label] at
+  /// [position] in [content].
+  Future<CompletionItem> expectSnippet(
+    String content, {
+    required String prefix,
+    required String label,
+  }) async {
+    await openFile(mainFileUri, withoutMarkers(content));
+    final res = await getCompletion(mainFileUri, positionFromMarker(content));
+    final item = res.singleWhere(
+      (c) => c.filterText == prefix && c.label == label,
+    );
+    expect(item.insertTextFormat, InsertTextFormat.Snippet);
+    expect(item.insertText, isNull);
+    expect(item.textEdit, isNotNull);
+    return item;
+  }
+
+  Future<void> initializeWithSnippetSupport() => initialize(
+        textDocumentCapabilities: withCompletionItemSnippetSupport(
+            emptyTextDocumentClientCapabilities),
+      );
+
+  Future<void> initializeWithSnippetSupportAndPreviewFlag() => provideConfig(
+        () => initialize(
+          textDocumentCapabilities: withCompletionItemSnippetSupport(
+              emptyTextDocumentClientCapabilities),
+          workspaceCapabilities:
+              withConfigurationSupport(emptyWorkspaceClientCapabilities),
+        ),
+        {'previewEnableSnippets': true},
+      );
+}
diff --git a/pkg/analysis_server/test/lsp/snippets_test.dart b/pkg/analysis_server/test/lsp/snippets_test.dart
index ba25212..a126c9b 100644
--- a/pkg/analysis_server/test/lsp/snippets_test.dart
+++ b/pkg/analysis_server/test/lsp/snippets_test.dart
@@ -4,6 +4,7 @@
 
 import 'package:analysis_server/src/lsp/snippets.dart' as lsp;
 import 'package:analysis_server/src/lsp/snippets.dart';
+import 'package:analysis_server/src/protocol_server.dart' as server;
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
@@ -129,6 +130,146 @@
 
 @reflectiveTest
 class SnippetsTest {
+  /// Paths aren't used for anything except filtering edit groups positions
+  /// so the specific values are not important.
+  final mainPath = '/home/test.dart';
+  final otherPath = '/home/other.dart';
+
+  Future<void> test_editGroups_choices() async {
+    var result = lsp.buildSnippetStringForEditGroups(
+      r'''
+var a = 1;
+''',
+      filePath: mainPath,
+      editOffset: 0,
+      editGroups: [
+        server.LinkedEditGroup(
+          [_pos(4)],
+          1,
+          [
+            _suggestion('aaa'),
+            _suggestion(r'bbb${},|'), // test for escaping
+            _suggestion('ccc'),
+          ],
+        ),
+      ],
+    );
+    expect(result, equals(r'''
+var ${1|a,aaa,bbb\${\}\,\|,ccc|} = 1;
+'''));
+  }
+
+  Future<void> test_editGroups_emptyGroup() async {
+    var result = lsp.buildSnippetStringForEditGroups(
+      r'''
+class  {
+  ();
+}
+''',
+      filePath: mainPath,
+      editOffset: 0,
+      editGroups: [
+        server.LinkedEditGroup(
+          [
+            _pos(6),
+            _pos(11),
+          ],
+          0,
+          [],
+        ),
+      ],
+    );
+    expect(result, equals(r'''
+class $1 {
+  $1();
+}
+'''));
+  }
+
+  Future<void> test_editGroups_positionsInOtherFiles() async {
+    var result = lsp.buildSnippetStringForEditGroups(
+      r'''
+class A {
+  A();
+}
+''',
+      filePath: mainPath,
+      editOffset: 0,
+      editGroups: [
+        server.LinkedEditGroup(
+          [
+            _pos(6),
+            _pos(10, otherPath), // Should not be included.
+            _pos(12),
+          ],
+          1,
+          [],
+        ),
+      ],
+    );
+    expect(result, equals(r'''
+class ${1:A} {
+  ${1:A}();
+}
+'''));
+  }
+
+  Future<void> test_editGroups_simpleGroup() async {
+    var result = lsp.buildSnippetStringForEditGroups(
+      r'''
+class A {
+  A();
+}
+''',
+      filePath: mainPath,
+      editOffset: 0,
+      editGroups: [
+        server.LinkedEditGroup(
+          [
+            _pos(6),
+            _pos(12),
+          ],
+          1,
+          [],
+        ),
+      ],
+    );
+    expect(result, equals(r'''
+class ${1:A} {
+  ${1:A}();
+}
+'''));
+  }
+
+  Future<void> test_editGroups_withOffset() async {
+    var result = lsp.buildSnippetStringForEditGroups(
+      r'''
+class A {
+  A();
+}
+''',
+      filePath: mainPath,
+      // This means the edit will be inserted at offset 100, so all linked edit
+      // offsets will be 100 more than in the supplied text.
+      editOffset: 100,
+      editGroups: [
+        server.LinkedEditGroup(
+          [
+            _pos(100 + 6),
+            _pos(100 + 12),
+          ],
+          1,
+          [],
+        ),
+      ],
+    );
+    expect(result, equals(r'''
+class ${1:A} {
+  ${1:A}();
+}
+'''));
+  }
+
   Future<void> test_tabStops_contains() async {
     var result = lsp.buildSnippetStringWithTabStops('a, b, c', [3, 1]);
     expect(result, equals(r'a, ${0:b}, c'));
@@ -165,4 +306,13 @@
     var result = lsp.buildSnippetStringWithTabStops('a, b', [0, 1]);
     expect(result, equals(r'${0:a}, b'));
   }
+
+  server.Position _pos(int offset, [String? path]) =>
+      server.Position(path ?? mainPath, offset);
+
+  server.LinkedEditSuggestion _suggestion(String text) =>
+      server.LinkedEditSuggestion(
+        text,
+        server.LinkedEditSuggestionKind.TYPE, // We don't use type.
+      );
 }
diff --git a/pkg/analysis_server/test/services/snippets/dart/flutter_snippet_producers_test.dart b/pkg/analysis_server/test/services/snippets/dart/flutter_snippet_producers_test.dart
new file mode 100644
index 0000000..1b9449c
--- /dev/null
+++ b/pkg/analysis_server/test/services/snippets/dart/flutter_snippet_producers_test.dart
@@ -0,0 +1,120 @@
+// Copyright (c) 2022, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:analysis_server/src/services/snippets/dart/flutter_snippet_producers.dart';
+import 'package:analysis_server/src/services/snippets/dart/snippet_manager.dart';
+import 'package:test/test.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import '../../../abstract_single_unit.dart';
+import 'test_support.dart';
+
+void main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(FlutterStatelessWidgetSnippetProducerTest);
+  });
+}
+
+class FlutterSnippetProducerTest extends AbstractSingleUnitTest {
+  Future<void> expectNotValidSnippet(
+    SnippetProducerGenerator generator,
+    String code,
+  ) async {
+    await resolveTestCode(withoutMarkers(code));
+    final request = DartSnippetRequest(
+      unit: testAnalysisResult,
+      offset: offsetFromMarker(code),
+    );
+
+    final producer = generator(request);
+    expect(await producer.isValid(), isFalse);
+  }
+
+  Future<Snippet> expectValidSnippet(
+      SnippetProducerGenerator generator, String code) async {
+    await resolveTestCode(withoutMarkers(code));
+    final request = DartSnippetRequest(
+      unit: testAnalysisResult,
+      offset: offsetFromMarker(code),
+    );
+
+    final producer = generator(request);
+    expect(await producer.isValid(), isTrue);
+    return producer.compute();
+  }
+}
+
+@reflectiveTest
+class FlutterStatelessWidgetSnippetProducerTest
+    extends FlutterSnippetProducerTest {
+  Future<void> test_notValid_notFlutterProject() async {
+    writeTestPackageConfig();
+
+    await expectNotValidSnippet(
+      FlutterStatelessWidgetSnippetProducer.newInstance,
+      '^',
+    );
+  }
+
+  Future<void> test_notValid_notTopLevel() async {
+    writeTestPackageConfig();
+
+    await expectNotValidSnippet(
+      FlutterStatelessWidgetSnippetProducer.newInstance,
+      'class A { ^ }',
+    );
+  }
+
+  Future<void> test_valid() async {
+    writeTestPackageConfig(flutter: true);
+
+    final snippet = await expectValidSnippet(
+      FlutterStatelessWidgetSnippetProducer.newInstance,
+      '^',
+    );
+    expect(snippet.prefix, 'stless');
+    expect(snippet.label, 'Flutter Stateless Widget');
+    expect(snippet.change.toJson(), {
+      'message': '',
+      'edits': [
+        {
+          'file': testFile,
+          'fileStamp': 0,
+          'edits': [
+            {
+              'offset': 0,
+              'length': 0,
+              'replacement':
+                  'import \'package:flutter/src/foundation/key.dart\';\n'
+                      'import \'package:flutter/src/widgets/framework.dart\';\n'
+            },
+            {
+              'offset': 0,
+              'length': 0,
+              'replacement': 'class MyWidget extends StatelessWidget {\n'
+                  '  const MyWidget({Key? key}) : super(key: key);\n'
+                  '\n'
+                  '  @override\n'
+                  '  Widget build(BuildContext context) {\n'
+                  '    \n'
+                  '  }\n'
+                  '}'
+            }
+          ]
+        }
+      ],
+      'linkedEditGroups': [
+        {
+          'positions': [
+            {'file': testFile, 'offset': 109},
+            {'file': testFile, 'offset': 152}
+          ],
+          'length': 8,
+          'suggestions': []
+        }
+      ],
+      'selection': {'file': testFile, 'offset': 248}
+    });
+  }
+}
diff --git a/pkg/analysis_server/test/services/snippets/dart/snippet_manager_test.dart b/pkg/analysis_server/test/services/snippets/dart/snippet_manager_test.dart
new file mode 100644
index 0000000..622d84f
--- /dev/null
+++ b/pkg/analysis_server/test/services/snippets/dart/snippet_manager_test.dart
@@ -0,0 +1,116 @@
+// Copyright (c) 2022, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:analysis_server/src/services/snippets/dart/snippet_manager.dart';
+import 'package:analyzer_plugin/protocol/protocol_common.dart';
+import 'package:test/test.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import '../../../abstract_single_unit.dart';
+
+void main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(SnippetManagerTest);
+  });
+}
+
+@reflectiveTest
+class SnippetManagerTest extends AbstractSingleUnitTest {
+  Future<void> test_notValidProducers() async {
+    await resolveTestCode('');
+    final request = DartSnippetRequest(
+      unit: testAnalysisResult,
+      offset: 0,
+    );
+
+    final manager = _TestDartSnippetManager({
+      SnippetContext.atTopLevel: [_NotValidSnippetProducer.newInstance],
+    });
+    final results = await manager.computeSnippets(request);
+    expect(results, isEmpty);
+  }
+
+  Future<void> test_onlyCreatesForContext() async {
+    await resolveTestCode('');
+    final request = DartSnippetRequest(
+      unit: testAnalysisResult,
+      offset: 0,
+    );
+
+    final manager = _TestDartSnippetManager({
+      SnippetContext.atTopLevel: [_ValidSnippetProducer.newInstance],
+      SnippetContext.inClass: [
+        (context) => throw 'Tried to create producer for wrong context',
+      ]
+    });
+    final results = await manager.computeSnippets(request);
+    expect(results, hasLength(1));
+  }
+
+  Future<void> test_validProducers() async {
+    await resolveTestCode('');
+    final request = DartSnippetRequest(
+      unit: testAnalysisResult,
+      offset: 0,
+    );
+
+    final manager = _TestDartSnippetManager({
+      SnippetContext.atTopLevel: [_ValidSnippetProducer.newInstance],
+    });
+    final results = await manager.computeSnippets(request);
+    expect(results, hasLength(1));
+    final snippet = results.single;
+    expect(snippet.prefix, 'mysnip');
+    expect(snippet.label, 'My Test Snippet');
+  }
+}
+
+/// A snippet producer that always returns `false` from [isValid] and throws
+/// if [compute] is called.
+class _NotValidSnippetProducer extends SnippetProducer {
+  _NotValidSnippetProducer(DartSnippetRequest request) : super(request);
+
+  @override
+  Future<Snippet> compute() {
+    throw UnsupportedError(
+      'compute should not be called for a producer '
+      'that returned false from isValid',
+    );
+  }
+
+  @override
+  Future<bool> isValid() async => false;
+
+  static _NotValidSnippetProducer newInstance(DartSnippetRequest request) =>
+      _NotValidSnippetProducer(request);
+}
+
+class _TestDartSnippetManager extends DartSnippetManager {
+  @override
+  final Map<SnippetContext, List<SnippetProducerGenerator>> producerGenerators;
+
+  _TestDartSnippetManager(this.producerGenerators);
+}
+
+/// A snippet producer that always returns `true` from [isValid] and a simple
+/// snippet from [compute].
+class _ValidSnippetProducer extends SnippetProducer {
+  _ValidSnippetProducer(DartSnippetRequest request) : super(request);
+
+  @override
+  Future<Snippet> compute() async {
+    return Snippet(
+      'mysnip',
+      'My Test Snippet',
+      'This is a test snippet',
+      SourceChange('message'),
+    );
+  }
+
+  @override
+  Future<bool> isValid() async => true;
+
+  static _ValidSnippetProducer newInstance(DartSnippetRequest request) =>
+      _ValidSnippetProducer(request);
+}
diff --git a/pkg/analysis_server/test/services/snippets/dart/snippet_request_test.dart b/pkg/analysis_server/test/services/snippets/dart/snippet_request_test.dart
new file mode 100644
index 0000000..fd6a240
--- /dev/null
+++ b/pkg/analysis_server/test/services/snippets/dart/snippet_request_test.dart
@@ -0,0 +1,495 @@
+// Copyright (c) 2022, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:analysis_server/src/services/snippets/dart/snippet_manager.dart';
+import 'package:analyzer/src/test_utilities/platform.dart';
+import 'package:test/test.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import '../../../abstract_single_unit.dart';
+import 'test_support.dart';
+
+void main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(SnippetRequestTest);
+  });
+}
+
+@reflectiveTest
+class SnippetRequestTest extends AbstractSingleUnitTest {
+  SnippetRequestTest() {
+    verifyNoTestUnitErrors = false;
+  }
+
+  Future<void> test_expression_constructor() async {
+    await testRequest(r'''
+final a = new [[^]]
+''', SnippetContext.inExpressionOrStatement);
+  }
+
+  Future<void> test_expression_constructorName() async {
+    await testRequest(r'''
+class A {
+  A.foo();
+}
+final a = new A.[[fo^]]
+''', SnippetContext.inExpressionOrStatement);
+  }
+
+  Future<void> test_inAnnotation() async {
+    await testRequest(r'''
+@[[depre^]]
+class A {}
+''', SnippetContext.inExpressionOrStatement);
+  }
+
+  Future<void> test_inBlock_forBody() async {
+    await testRequest(r'''
+foo() {
+  for (var i = 0; i < 10; i++) {
+    [[^]]
+  }
+}
+''', SnippetContext.inBlock);
+  }
+
+  Future<void> test_inClass_atEnd() async {
+    await testRequest(r'''
+class A {
+  foo() {}
+
+  [[^]]
+}
+''', SnippetContext.inClass);
+  }
+
+  Future<void> test_inClass_atEnd_partialIdentifier() async {
+    await testRequest(r'''
+class A {
+  foo() {}
+
+  [[mysnip^]]
+}
+''', SnippetContext.inClass);
+  }
+
+  Future<void> test_inClass_atStart() async {
+    await testRequest(r'''
+class A {
+  [[^]]
+
+  foo() {}
+}
+''', SnippetContext.inClass);
+  }
+
+  Future<void> test_inClass_atStart_partialIdentifier() async {
+    await testRequest(r'''
+class A {
+  [[mysnip^]]
+
+  foo() {}
+}
+''', SnippetContext.inClass);
+  }
+
+  Future<void> test_inClass_betweenMembers() async {
+    await testRequest(r'''
+class A {
+  foo() {}
+
+  [[^]]
+
+  bar() {}
+}
+''', SnippetContext.inClass);
+  }
+
+  Future<void> test_inClass_betweenMembers_partialIdentifier() async {
+    await testRequest(r'''
+class A {
+  foo() {}
+
+  [[mysnip^]]
+
+  bar() {}
+}
+''', SnippetContext.inClass);
+  }
+
+  Future<void> test_inClass_empty() async {
+    await testRequest(r'''
+class A {
+  [[^]]
+}
+''', SnippetContext.inClass);
+  }
+
+  Future<void> test_inClass_empty_partialIdentifier() async {
+    await testRequest(r'''
+class A {
+  [[mysnip^]]
+}
+''', SnippetContext.inClass);
+  }
+
+  Future<void> test_inComment_dartDoc() async {
+    await testRequest(r'''
+/// [[^]]
+class A {}
+''', SnippetContext.inComment);
+  }
+
+  Future<void> test_inComment_dartDoc_reference_member() async {
+    await testRequest(r'''
+class A {
+  /// [ [[A^]] ]
+  foo() {}
+}
+''', SnippetContext.inComment);
+  }
+
+  Future<void> test_inComment_dartDoc_reference_topLevel() async {
+    await testRequest(r'''
+/// [ [[A^]] ]
+class A {}
+''', SnippetContext.inComment);
+  }
+
+  Future<void> test_inComment_multiline_member() async {
+    await testRequest(r'''
+class A {
+  /*
+   * [[^]]
+   */
+  foo() {}
+}
+''', SnippetContext.inComment);
+  }
+
+  Future<void> test_inComment_multiline_topLevel() async {
+    await testRequest(r'''
+/*
+ * [[^]]
+ */
+class A {}
+''', SnippetContext.inComment);
+  }
+
+  Future<void> test_inComment_singleLine_member() async {
+    await testRequest(r'''
+class A {
+  // [[^]]
+  foo () {}
+}
+''', SnippetContext.inComment);
+  }
+
+  Future<void> test_inComment_singleLine_topLevel() async {
+    await testRequest(r'''
+// [[^]]
+class A {}
+''', SnippetContext.inComment);
+  }
+
+  Future<void> test_inExpression_functionCall() async {
+    await testRequest(r'''
+foo() {
+  print([[^]]
+}
+''', SnippetContext.inExpressionOrStatement);
+  }
+
+  Future<void> test_inExtension() async {
+    await testRequest(r'''
+extension on Object {
+  [[^]]
+}
+''', SnippetContext.inClass);
+  }
+
+  Future<void> test_inFunction_atEnd() async {
+    await testRequest(r'''
+foo() {
+  var a = 1;
+  [[^]]
+}
+''', SnippetContext.inBlock);
+  }
+
+  Future<void> test_inFunction_atEnd_partialIdentifier() async {
+    await testRequest(r'''
+foo() {
+  var a = 1;
+  [[mysnip^]]
+}
+''', SnippetContext.inBlock);
+  }
+
+  Future<void> test_inFunction_atStart() async {
+    await testRequest(r'''
+foo() {
+  [[^]]
+  var a = 1;
+}
+''', SnippetContext.inBlock);
+  }
+
+  Future<void> test_inFunction_atStart_partialIdentifier() async {
+    await testRequest(r'''
+foo() {
+  [[mysnip^]]
+  var a = 1;
+}
+''', SnippetContext.inBlock);
+  }
+
+  Future<void> test_inFunction_betweenStatements() async {
+    await testRequest(r'''
+foo() {
+  var a = 1;
+  [[^]]
+  var b = 1;
+}
+''', SnippetContext.inBlock);
+  }
+
+  Future<void> test_inFunction_betweenStatements_partialIdentifier() async {
+    await testRequest(r'''
+foo() {
+  var a = 1;
+  [[mysnip^]]
+  var b = 1;
+}
+''', SnippetContext.inBlock);
+  }
+
+  Future<void> test_inFunction_empty() async {
+    await testRequest(r'''
+foo() {
+  [[^]]
+}
+''', SnippetContext.inBlock);
+  }
+
+  Future<void> test_inFunction_empty_partialIdentifier() async {
+    await testRequest(r'''
+foo() {
+  [[mysnip^]]
+}
+''', SnippetContext.inBlock);
+  }
+
+  Future<void> test_inMethod_atEnd() async {
+    await testRequest(r'''
+class A {
+  foo() {
+    var a = 1;
+    [[^]]
+  }
+}
+''', SnippetContext.inBlock);
+  }
+
+  Future<void> test_inMethod_atEnd_partialIdentifier() async {
+    await testRequest(r'''
+class A {
+  foo() {
+    var a = 1;
+    [[mysnip^]]
+  }
+}
+''', SnippetContext.inBlock);
+  }
+
+  Future<void> test_inMethod_atStart() async {
+    await testRequest(r'''
+class A {
+  foo() {
+    [[^]]
+    var a = 1;
+  }
+}
+''', SnippetContext.inBlock);
+  }
+
+  Future<void> test_inMethod_atStart_partialIdentifier() async {
+    await testRequest(r'''
+class A {
+  foo() {
+    [[mysnip^]]
+    var a = 1;
+  }
+}
+''', SnippetContext.inBlock);
+  }
+
+  Future<void> test_inMethod_betweenStatements() async {
+    await testRequest(r'''
+class A {
+  foo() {
+    var a = 1;
+    [[^]]
+    var b = 1;
+  }
+}
+''', SnippetContext.inBlock);
+  }
+
+  Future<void> test_inMethod_betweenStatements_partialIdentifier() async {
+    await testRequest(r'''
+class A {
+  foo() {
+    var a = 1;
+    [[mysnip^]]
+    var b = 1;
+  }
+}
+''', SnippetContext.inBlock);
+  }
+
+  Future<void> test_inMethod_empty() async {
+    await testRequest(r'''
+class A {
+  foo() {
+    [[^]]
+  }
+}
+''', SnippetContext.inBlock);
+  }
+
+  Future<void> test_inMethod_empty_partialIdentifier() async {
+    await testRequest(r'''
+class A {
+  foo() {
+    [[mysnip^]]
+  }
+}
+''', SnippetContext.inBlock);
+  }
+
+  Future<void> test_inMixin() async {
+    await testRequest(r'''
+mixin A {
+  [[^]]
+}
+''', SnippetContext.inClass);
+  }
+
+  Future<void> test_inStatement_forCondition() async {
+    await testRequest(r'''
+foo() {
+  for (var i = [[^]]
+}
+''', SnippetContext.inExpressionOrStatement);
+  }
+
+  Future<void> test_inStatement_variableDeclaration() async {
+    await testRequest(r'''
+foo() {
+  var a = [[^]]
+}
+''', SnippetContext.inExpressionOrStatement);
+  }
+
+  Future<void> test_inString() async {
+    await testRequest(r'''
+const a = '[[^]]';
+''', SnippetContext.inString);
+  }
+
+  Future<void> test_inString_raw() async {
+    await testRequest(r'''
+const a = r'[[^]]';
+''', SnippetContext.inString);
+  }
+
+  Future<void> test_inString_unterminated() async {
+    await testRequest(r'''
+const a = r'[[^]]
+''', SnippetContext.inString);
+  }
+
+  Future<void> test_topLevel_atEnd() async {
+    await testRequest(r'''
+class A {}
+
+[[^]]
+''', SnippetContext.atTopLevel);
+  }
+
+  Future<void> test_topLevel_atEnd_partialIdentifier() async {
+    await testRequest(r'''
+class A {}
+
+[[mysnip^]]
+''', SnippetContext.atTopLevel);
+  }
+
+  Future<void> test_topLevel_atStart() async {
+    await testRequest(r'''
+[[^]]
+
+class A {}
+''', SnippetContext.atTopLevel);
+  }
+
+  Future<void> test_topLevel_atStart_partialIdentifier() async {
+    await testRequest(r'''
+[[mysnip^]]
+
+class A {}
+''', SnippetContext.atTopLevel);
+  }
+
+  Future<void> test_topLevel_betweenClasses() async {
+    await testRequest(r'''
+class A {}
+
+[[^]]
+
+class B {}
+''', SnippetContext.atTopLevel);
+  }
+
+  Future<void> test_topLevel_betweenClasses_partialIdentifier() async {
+    await testRequest(r'''
+class A {}
+
+[[mysnip^]]
+
+class B {}
+''', SnippetContext.atTopLevel);
+  }
+
+  Future<void> test_topLevel_empty() async {
+    await testRequest('[[^]]', SnippetContext.atTopLevel);
+  }
+
+  Future<void> test_topLevel_empty_partialIdentifier() async {
+    await testRequest('[[mysnip^]]', SnippetContext.atTopLevel);
+  }
+
+  /// Checks that [code] produces a context of [expectedContext] where the
+  /// character '^' in [code] represents the supplied offset and the range
+  /// surrounded `[[` by brackets `]]` is the expected replacement range.
+  ///
+  /// `^`, `[[` and `]]` will be removed from the code before resolving.
+  Future<void> testRequest(String code, SnippetContext expectedContext) async {
+    code = normalizeNewlinesForPlatform(code);
+    final offset = offsetFromMarker(code);
+    final expectedReplacementRange = rangeFromMarkers(code);
+    await resolveTestCode(withoutMarkers(code));
+
+    final request = DartSnippetRequest(
+      unit: testAnalysisResult,
+      offset: offset,
+    );
+
+    expect(request.filePath, testFile);
+    expect(request.offset, offset);
+    expect(request.context, expectedContext);
+    expect(request.replacementRange, expectedReplacementRange);
+  }
+}
diff --git a/pkg/analysis_server/test/services/snippets/dart/test_all.dart b/pkg/analysis_server/test/services/snippets/dart/test_all.dart
new file mode 100644
index 0000000..907e05a
--- /dev/null
+++ b/pkg/analysis_server/test/services/snippets/dart/test_all.dart
@@ -0,0 +1,17 @@
+// Copyright (c) 2014, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import 'flutter_snippet_producers_test.dart' as flutter_snippet_producers;
+import 'snippet_manager_test.dart' as snippet_manager;
+import 'snippet_request_test.dart' as snippet_request;
+
+void main() {
+  defineReflectiveSuite(() {
+    flutter_snippet_producers.main();
+    snippet_manager.main();
+    snippet_request.main();
+  }, name: 'dart');
+}
diff --git a/pkg/analysis_server/test/services/snippets/dart/test_support.dart b/pkg/analysis_server/test/services/snippets/dart/test_support.dart
new file mode 100644
index 0000000..9f2d740
--- /dev/null
+++ b/pkg/analysis_server/test/services/snippets/dart/test_support.dart
@@ -0,0 +1,30 @@
+// Copyright (c) 2022, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:analyzer/source/source_range.dart';
+import 'package:test/test.dart';
+
+int offsetFromMarker(String code) {
+  final offset = withoutRangeMarkers(code).indexOf('^');
+  expect(offset, isNot(-1));
+  return offset;
+}
+
+SourceRange rangeFromMarkers(String code) {
+  code = _withoutPositionMarker(code);
+  final start = code.indexOf('[[');
+  final end = code.indexOf(']]');
+  expect(start, isNot(-1));
+  expect(end, isNot(-1));
+  final endAdjusted = end - 2; // Account for the [[ before this marker
+  return SourceRange(start, endAdjusted - start);
+}
+
+String withoutMarkers(String code) =>
+    withoutRangeMarkers(_withoutPositionMarker(code));
+
+String withoutRangeMarkers(String code) =>
+    code.replaceAll('[[', '').replaceAll(']]', '');
+
+String _withoutPositionMarker(String code) => code.replaceAll('^', '');
diff --git a/pkg/analysis_server/test/services/snippets/test_all.dart b/pkg/analysis_server/test/services/snippets/test_all.dart
new file mode 100644
index 0000000..899f5ae
--- /dev/null
+++ b/pkg/analysis_server/test/services/snippets/test_all.dart
@@ -0,0 +1,13 @@
+// Copyright (c) 2022, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import 'dart/test_all.dart' as dart_all;
+
+void main() {
+  defineReflectiveSuite(() {
+    dart_all.main();
+  }, name: 'snippets');
+}
diff --git a/pkg/analysis_server/test/services/test_all.dart b/pkg/analysis_server/test/services/test_all.dart
index 954023d..a6feeba 100644
--- a/pkg/analysis_server/test/services/test_all.dart
+++ b/pkg/analysis_server/test/services/test_all.dart
@@ -9,6 +9,7 @@
 import 'linter/test_all.dart' as linter_all;
 import 'refactoring/test_all.dart' as refactoring_all;
 import 'search/test_all.dart' as search_all;
+import 'snippets/test_all.dart' as snippets_all;
 
 void main() {
   defineReflectiveSuite(() {
@@ -17,5 +18,6 @@
     linter_all.main();
     refactoring_all.main();
     search_all.main();
+    snippets_all.main();
   });
 }
diff --git a/pkg/analysis_server/test/src/services/correction/assist/convert_class_to_enum_test.dart b/pkg/analysis_server/test/src/services/correction/assist/convert_class_to_enum_test.dart
new file mode 100644
index 0000000..931cc73
--- /dev/null
+++ b/pkg/analysis_server/test/src/services/correction/assist/convert_class_to_enum_test.dart
@@ -0,0 +1,516 @@
+// Copyright (c) 2022, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:analysis_server/src/services/correction/assist.dart';
+import 'package:analyzer_plugin/utilities/assist/assist.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import 'assist_processor.dart';
+
+void main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(ConvertClassToEnumTest);
+  });
+}
+
+@reflectiveTest
+class ConvertClassToEnumTest extends AssistProcessorTest {
+  @override
+  AssistKind get kind => DartAssistKind.CONVERT_CLASS_TO_ENUM;
+
+  Future<void> test_extends_object_privateClass() async {
+    await resolveTestCode('''
+class _E extends Object {
+  static const _E c = _E();
+
+  const _E();
+}
+''');
+    await assertHasAssistAt('E extends', '''
+enum _E {
+  c
+}
+''');
+  }
+
+  Future<void> test_extends_object_publicClass() async {
+    await resolveTestCode('''
+class E extends Object {
+  static const E c = E._();
+
+  const E._();
+}
+''');
+    await assertHasAssistAt('E extends', '''
+enum E {
+  c._();
+
+  const E._();
+}
+''');
+  }
+
+  Future<void> test_index_namedIndex_first_privateClass() async {
+    await resolveTestCode('''
+class _E {
+  static const _E c0 = _E(0, 'a');
+  static const _E c1 = _E(1, 'b');
+
+  final int index;
+
+  final String code;
+
+  const _E(this.index, this.code);
+}
+''');
+    await assertHasAssistAt('E {', '''
+enum _E {
+  c0('a'),
+  c1('b');
+
+  final String code;
+
+  const _E(this.code);
+}
+''');
+  }
+
+  Future<void> test_index_namedIndex_last_privateClass() async {
+    await resolveTestCode('''
+class _E {
+  static const _E c0 = _E('a', 0);
+  static const _E c1 = _E('b', 1);
+
+  final String code;
+
+  final int index;
+
+  const _E(this.code, this.index);
+}
+''');
+    await assertHasAssistAt('E {', '''
+enum _E {
+  c0('a'),
+  c1('b');
+
+  final String code;
+
+  const _E(this.code);
+}
+''');
+  }
+
+  Future<void> test_index_namedIndex_middle_privateClass() async {
+    await resolveTestCode('''
+class _E {
+  static const _E c0 = _E('a', 0, 'b');
+  static const _E c1 = _E('c', 1, 'd');
+
+  final String first;
+
+  final int index;
+
+  final String last;
+
+  const _E(this.first, this.index, this.last);
+}
+''');
+    await assertHasAssistAt('E {', '''
+enum _E {
+  c0('a', 'b'),
+  c1('c', 'd');
+
+  final String first;
+
+  final String last;
+
+  const _E(this.first, this.last);
+}
+''');
+  }
+
+  Future<void> test_index_namedIndex_only_outOfOrder() async {
+    await resolveTestCode('''
+class _E {
+  static const _E c0 = _E(1);
+  static const _E c1 = _E(0);
+
+  final int index;
+
+  const _E(this.index);
+}
+''');
+    await assertHasAssistAt('E {', '''
+enum _E {
+  c1,
+  c0
+}
+''');
+  }
+
+  Future<void> test_index_namedIndex_only_privateClass() async {
+    await resolveTestCode('''
+class _E {
+  static const _E c0 = _E(0);
+  static const _E c1 = _E(1);
+
+  final int index;
+
+  const _E(this.index);
+}
+''');
+    await assertHasAssistAt('E {', '''
+enum _E {
+  c0,
+  c1
+}
+''');
+  }
+
+  Future<void> test_index_namedIndex_only_publicClass() async {
+    await resolveTestCode('''
+class E {
+  static const E c0 = E._(0);
+  static const E c1 = E._(1);
+
+  final int index;
+
+  const E._(this.index);
+}
+''');
+    await assertHasAssistAt('E {', '''
+enum E {
+  c0._(),
+  c1._();
+
+  const E._();
+}
+''');
+  }
+
+  Future<void> test_index_notNamedIndex_privateClass() async {
+    await resolveTestCode('''
+class _E {
+  static const _E c0 = _E(0);
+  static const _E c1 = _E(1);
+
+  final int value;
+
+  const _E(this.value);
+}
+''');
+    await assertHasAssistAt('E {', '''
+enum _E {
+  c0(0),
+  c1(1);
+
+  final int value;
+
+  const _E(this.value);
+}
+''');
+  }
+
+  Future<void> test_index_notNamedIndex_publicClass() async {
+    await resolveTestCode('''
+class E {
+  static const E c0 = E._(0);
+  static const E c1 = E._(1);
+
+  final int value;
+
+  const E._(this.value);
+}
+''');
+    await assertHasAssistAt('E {', '''
+enum E {
+  c0._(0),
+  c1._(1);
+
+  final int value;
+
+  const E._(this.value);
+}
+''');
+  }
+
+  Future<void> test_invalid_abstractClass() async {
+    await resolveTestCode('''
+abstract class E {}
+''');
+    await assertNoAssistAt('E {');
+  }
+
+  Future<void> test_invalid_constructorUsedInConstructor() async {
+    await resolveTestCode('''
+class _E {
+  static const _E c = _E();
+
+  // ignore: unused_element
+  const _E({_E e = const _E()});
+}
+''');
+    await assertNoAssistAt('E {');
+  }
+
+  Future<void> test_invalid_constructorUsedOutsideClass() async {
+    await resolveTestCode('''
+class _E {
+  static const _E c = _E();
+
+  const _E();
+}
+_E get e => _E();
+''');
+    await assertNoAssistAt('E {');
+  }
+
+  Future<void> test_invalid_extended() async {
+    await resolveTestCode('''
+class _E {
+  static const _E c = _E();
+
+  const _E();
+}
+class F extends _E  {}
+''');
+    await assertNoAssistAt('E {');
+  }
+
+  Future<void> test_invalid_extends_notObject() async {
+    await resolveTestCode('''
+class E extends C {
+  static const E c = E._();
+
+  const E._();
+}
+class C {
+  const C();
+}
+''');
+    await assertNoAssistAt('E extends');
+  }
+
+  Future<void> test_invalid_hasPart() async {
+    // Change this test if the assist becomes able to look for references to the
+    // class and its constructors in part files.
+    newFile('$testPackageLibPath/a.dart', content: '''
+part of 'test.dart';
+''');
+    await resolveTestCode('''
+part 'a.dart';
+
+class E {
+  static const E c = E._();
+
+  const E._();
+}
+''');
+    await assertNoAssistAt('E {');
+  }
+
+  Future<void> test_invalid_implemented() async {
+    await resolveTestCode('''
+class _E {
+  static const _E c = _E();
+
+  const _E();
+}
+class F implements _E  {}
+''');
+    await assertNoAssistAt('E {');
+  }
+
+  Future<void> test_invalid_indexFieldNotSequential() async {
+    await resolveTestCode('''
+class _E {
+  static const _E c0 = _E(0);
+  static const _E c1 = _E(3);
+
+  final int index;
+
+  const _E(this.index);
+}
+''');
+    await assertNoAssistAt('E {');
+  }
+
+  Future<void> test_invalid_multipleConstantsInSameFieldDeclaration() async {
+    // Change this test if support is added to cover cases where multiple
+    // constants are defined in a single field declaration.
+    await resolveTestCode('''
+class _E {
+  static const _E c0 = _E('a'), c1 = _E('b');
+
+  final String s;
+
+  const _E(this.s);
+}
+''');
+    await assertNoAssistAt('E {');
+  }
+
+  Future<void> test_invalid_nonConstConstructor() async {
+    await resolveTestCode('''
+class _E {
+  static _E c = _E();
+
+  _E();
+}
+''');
+    await assertNoAssistAt('E {');
+  }
+
+  Future<void> test_invalid_overrides_equal() async {
+    await resolveTestCode('''
+class _E {
+  static const _E c = _E();
+
+  const _E();
+
+  @override
+  int get hashCode => 0;
+}
+''');
+    await assertNoAssistAt('E {');
+  }
+
+  Future<void> test_invalid_overrides_hashCode() async {
+    await resolveTestCode('''
+class _E {
+  static const _E c = _E();
+
+  const _E();
+
+  @override
+  bool operator ==(Object other) => true;
+}
+''');
+    await assertNoAssistAt('E {');
+  }
+
+  Future<void> test_minimal_privateClass() async {
+    await resolveTestCode('''
+class _E {
+  static const _E c = _E();
+
+  const _E();
+}
+''');
+    await assertHasAssistAt('E {', '''
+enum _E {
+  c
+}
+''');
+  }
+
+  Future<void> test_minimal_publicClass() async {
+    await resolveTestCode('''
+class E {
+  static const E c = E._();
+
+  const E._();
+}
+''');
+    await assertHasAssistAt('E {', '''
+enum E {
+  c._();
+
+  const E._();
+}
+''');
+  }
+
+  Future<void> test_noIndex_int_privateClass() async {
+    await resolveTestCode('''
+class _E {
+  static const _E c0 = _E(2);
+  static const _E c1 = _E(4);
+
+  final int count;
+
+  const _E(this.count);
+}
+''');
+    await assertHasAssistAt('E {', '''
+enum _E {
+  c0(2),
+  c1(4);
+
+  final int count;
+
+  const _E(this.count);
+}
+''');
+  }
+
+  Future<void> test_noIndex_int_publicClass() async {
+    await resolveTestCode('''
+class E {
+  static const E c0 = E._(2);
+  static const E c1 = E._(4);
+
+  final int count;
+
+  const E._(this.count);
+}
+''');
+    await assertHasAssistAt('E {', '''
+enum E {
+  c0._(2),
+  c1._(4);
+
+  final int count;
+
+  const E._(this.count);
+}
+''');
+  }
+
+  Future<void> test_noIndex_notInt_privateClass() async {
+    await resolveTestCode('''
+class _E {
+  static const _E c0 = _E('c0');
+  static const _E c1 = _E('c1');
+
+  final String name;
+
+  const _E(this.name);
+}
+''');
+    await assertHasAssistAt('E {', '''
+enum _E {
+  c0('c0'),
+  c1('c1');
+
+  final String name;
+
+  const _E(this.name);
+}
+''');
+  }
+
+  Future<void> test_noIndex_notInt_publicClass() async {
+    await resolveTestCode('''
+class E {
+  static const E c0 = E._('c0');
+  static const E c1 = E._('c1');
+
+  final String name;
+
+  const E._(this.name);
+}
+''');
+    await assertHasAssistAt('E {', '''
+enum E {
+  c0._('c0'),
+  c1._('c1');
+
+  final String name;
+
+  const E._(this.name);
+}
+''');
+  }
+}
diff --git a/pkg/analysis_server/test/src/services/correction/assist/test_all.dart b/pkg/analysis_server/test/src/services/correction/assist/test_all.dart
index e61b6f7..2c05865 100644
--- a/pkg/analysis_server/test/src/services/correction/assist/test_all.dart
+++ b/pkg/analysis_server/test/src/services/correction/assist/test_all.dart
@@ -9,6 +9,7 @@
 import 'add_return_type_test.dart' as add_return_type;
 import 'add_type_annotation_test.dart' as add_type_annotation;
 import 'assign_to_local_variable_test.dart' as assign_to_local_variable;
+import 'convert_class_to_enum_test.dart' as convert_class_to_enum;
 import 'convert_class_to_mixin_test.dart' as convert_class_to_mixin;
 import 'convert_documentation_into_block_test.dart'
     as convert_documentation_into_block;
@@ -97,6 +98,7 @@
     add_return_type.main();
     add_type_annotation.main();
     assign_to_local_variable.main();
+    convert_class_to_enum.main();
     convert_class_to_mixin.main();
     convert_documentation_into_block.main();
     convert_documentation_into_line.main();
diff --git a/pkg/analyzer/lib/src/dart/ast/ast.dart b/pkg/analyzer/lib/src/dart/ast/ast.dart
index 29f3b33..9e07497 100644
--- a/pkg/analyzer/lib/src/dart/ast/ast.dart
+++ b/pkg/analyzer/lib/src/dart/ast/ast.dart
@@ -44,16 +44,17 @@
   Token get beginToken => _strings.beginToken!;
 
   @override
-  Iterable<SyntacticEntity> get childEntities =>
-      ChildEntities()..addAll(_strings);
-
-  @override
   Token get endToken => _strings.endToken!;
 
   @override
   NodeListImpl<StringLiteral> get strings => _strings;
 
   @override
+  ChildEntities get _childEntities {
+    return ChildEntities()..addNodeList('strings', strings);
+  }
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitAdjacentStrings(this);
 
   @override
@@ -126,17 +127,11 @@
     ]..sort(AstNode.LEXICAL_ORDER);
   }
 
-  /// Return a holder of child entities that subclasses can add to.
+  @override
   ChildEntities get _childEntities {
-    ChildEntities result = ChildEntities();
-    if (_commentIsBeforeAnnotations()) {
-      result
-        ..add(_comment)
-        ..addAll(_metadata);
-    } else {
-      result.addAll(sortedCommentAndAnnotations);
-    }
-    return result;
+    return ChildEntities()
+      ..addNode('documentationComment', documentationComment)
+      ..addNodeList('metadata', metadata);
   }
 
   @override
@@ -237,15 +232,6 @@
   Token get beginToken => atSign;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(atSign)
-    ..add(_name)
-    ..add(_typeArguments)
-    ..add(period)
-    ..add(_constructorName)
-    ..add(_arguments);
-
-  @override
   SimpleIdentifierImpl? get constructorName => _constructorName;
 
   set constructorName(SimpleIdentifier? name) {
@@ -296,6 +282,17 @@
   }
 
   @override
+  ChildEntities get _childEntities {
+    return ChildEntities()
+      ..addToken('atSign', atSign)
+      ..addNode('name', name)
+      ..addNode('typeArguments', typeArguments)
+      ..addToken('period', period)
+      ..addNode('constructorName', constructorName)
+      ..addNode('arguments', arguments);
+  }
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitAnnotation(this);
 
   @override
@@ -349,13 +346,6 @@
   @override
   Token get beginToken => leftParenthesis;
 
-  @override
-  // TODO(paulberry): Add commas.
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(leftParenthesis)
-    ..addAll(_arguments)
-    ..add(rightParenthesis);
-
   List<ParameterElement?>? get correspondingStaticParameters =>
       _correspondingStaticParameters;
 
@@ -371,6 +361,13 @@
   Token get endToken => rightParenthesis;
 
   @override
+  // TODO(paulberry): Add commas.
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('leftParenthesis', leftParenthesis)
+    ..addNodeList('arguments', arguments)
+    ..addToken('rightParenthesis', rightParenthesis);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitArgumentList(this);
 
   @override
@@ -429,12 +426,6 @@
   Token get beginToken => _expression.beginToken;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(_expression)
-    ..add(asOperator)
-    ..add(_type);
-
-  @override
   Token get endToken => _type.endToken;
 
   @override
@@ -455,6 +446,12 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addNode('expression', expression)
+    ..addToken('asOperator', asOperator)
+    ..addNode('type', type);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitAsExpression(this);
 
   @override
@@ -500,15 +497,6 @@
   Token get beginToken => assertKeyword;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(assertKeyword)
-    ..add(leftParenthesis)
-    ..add(_condition)
-    ..add(comma)
-    ..add(_message)
-    ..add(rightParenthesis);
-
-  @override
   ExpressionImpl get condition => _condition;
 
   set condition(Expression condition) {
@@ -526,6 +514,15 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('assertKeyword', assertKeyword)
+    ..addToken('leftParenthesis', leftParenthesis)
+    ..addNode('condition', condition)
+    ..addToken('comma', comma)
+    ..addNode('message', message)
+    ..addToken('rightParenthesis', rightParenthesis);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitAssertInitializer(this);
 
   @override
@@ -573,16 +570,6 @@
   Token get beginToken => assertKeyword;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(assertKeyword)
-    ..add(leftParenthesis)
-    ..add(_condition)
-    ..add(comma)
-    ..add(_message)
-    ..add(rightParenthesis)
-    ..add(semicolon);
-
-  @override
   ExpressionImpl get condition => _condition;
 
   set condition(Expression condition) {
@@ -600,6 +587,16 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('assertKeyword', assertKeyword)
+    ..addToken('leftParenthesis', leftParenthesis)
+    ..addNode('condition', condition)
+    ..addToken('comma', comma)
+    ..addNode('message', message)
+    ..addToken('rightParenthesis', rightParenthesis)
+    ..addToken('semicolon', semicolon);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitAssertStatement(this);
 
   @override
@@ -644,12 +641,6 @@
   Token get beginToken => _leftHandSide.beginToken;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(_leftHandSide)
-    ..add(operator)
-    ..add(_rightHandSide);
-
-  @override
   Token get endToken => _rightHandSide.endToken;
 
   @override
@@ -670,6 +661,12 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addNode('leftHandSide', leftHandSide)
+    ..addToken('operator', operator)
+    ..addNode('rightHandSide', rightHandSide);
+
+  @override
   AstNode? get _nullShortingExtensionCandidate => parent;
 
   /// If the AST structure has been resolved, and the function being invoked is
@@ -724,6 +721,10 @@
   Map<String, Object>? _propertyMap;
 
   @override
+  Iterable<SyntacticEntity> get childEntities =>
+      _childEntities.syntacticEntities;
+
+  @override
   int get end => offset + length;
 
   @override
@@ -736,6 +737,11 @@
     return endToken.offset + endToken.length - beginToken.offset;
   }
 
+  /// Return properties (tokens and nodes) of this node, with names, in the
+  /// order in which these entities should normally appear, not necessary in
+  /// the order they really are (because of recovery).
+  Iterable<ChildEntity> get namedChildEntities => _childEntities.entities;
+
   @override
   int get offset {
     final beginToken = this.beginToken;
@@ -756,6 +762,8 @@
     return root;
   }
 
+  ChildEntities get _childEntities => ChildEntities();
+
   void detachFromParent() {
     _parent = null;
   }
@@ -845,11 +853,6 @@
   }
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(awaitKeyword)
-    ..add(_expression);
-
-  @override
   Token get endToken => _expression.endToken;
 
   @override
@@ -863,6 +866,11 @@
   Precedence get precedence => Precedence.prefix;
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('awaitKeyword', awaitKeyword)
+    ..addNode('expression', expression);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitAwaitExpression(this);
 
   @override
@@ -905,12 +913,6 @@
   Token get beginToken => _leftOperand.beginToken;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(_leftOperand)
-    ..add(operator)
-    ..add(_rightOperand);
-
-  @override
   Token get endToken => _rightOperand.endToken;
 
   @override
@@ -931,6 +933,12 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addNode('leftOperand', leftOperand)
+    ..addToken('operator', operator)
+    ..addNode('rightOperand', rightOperand);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitBinaryExpression(this);
 
   @override
@@ -983,12 +991,6 @@
   }
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(keyword)
-    ..add(star)
-    ..add(_block);
-
-  @override
   Token get endToken => _block.endToken;
 
   @override
@@ -1001,6 +1003,12 @@
   bool get isSynchronous => keyword?.lexeme != Keyword.ASYNC.lexeme;
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('keyword', keyword)
+    ..addToken('star', star)
+    ..addNode('block', block);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitBlockFunctionBody(this);
 
   @override
@@ -1038,18 +1046,18 @@
   Token get beginToken => leftBracket;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(leftBracket)
-    ..addAll(_statements)
-    ..add(rightBracket);
-
-  @override
   Token get endToken => rightBracket;
 
   @override
   NodeListImpl<Statement> get statements => _statements;
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('leftBracket', leftBracket)
+    ..addNodeList('statements', statements)
+    ..addToken('rightBracket', rightBracket);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitBlock(this);
 
   @override
@@ -1078,15 +1086,16 @@
   Token get beginToken => literal;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()..add(literal);
-
-  @override
   Token get endToken => literal;
 
   @override
   bool get isSynthetic => literal.isSynthetic;
 
   @override
+  ChildEntities get _childEntities =>
+      ChildEntities()..addToken('literal', literal);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitBooleanLiteral(this);
 
   @override
@@ -1131,12 +1140,6 @@
   Token get beginToken => breakKeyword;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(breakKeyword)
-    ..add(_label)
-    ..add(semicolon);
-
-  @override
   Token get endToken => semicolon;
 
   @override
@@ -1147,6 +1150,12 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('breakKeyword', breakKeyword)
+    ..addNode('label', label)
+    ..addToken('semicolon', semicolon);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitBreakStatement(this);
 
   @override
@@ -1192,11 +1201,6 @@
   NodeListImpl<Expression> get cascadeSections => _cascadeSections;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(_target)
-    ..addAll(_cascadeSections);
-
-  @override
   Token get endToken => _cascadeSections.endToken!;
 
   @override
@@ -1215,6 +1219,11 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addNode('target', target)
+    ..addNodeList('cascadeSections', cascadeSections);
+
+  @override
   AstNode? get _nullShortingExtensionCandidate => null;
 
   @override
@@ -1316,18 +1325,6 @@
   }
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(onKeyword)
-    ..add(_exceptionType)
-    ..add(catchKeyword)
-    ..add(leftParenthesis)
-    ..add(_exceptionParameter)
-    ..add(comma)
-    ..add(_stackTraceParameter)
-    ..add(rightParenthesis)
-    ..add(_body);
-
-  @override
   Token get endToken => _body.endToken;
 
   @override
@@ -1352,6 +1349,18 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('onKeyword', onKeyword)
+    ..addNode('exceptionType', exceptionType)
+    ..addToken('catchKeyword', catchKeyword)
+    ..addToken('leftParenthesis', leftParenthesis)
+    ..addNode('exceptionParameter', exceptionParameter)
+    ..addToken('comma', comma)
+    ..addNode('stackTraceParameter', stackTraceParameter)
+    ..addToken('rightParenthesis', rightParenthesis)
+    ..addNode('body', body);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitCatchClause(this);
 
   @override
@@ -1364,28 +1373,81 @@
 }
 
 /// Helper class to allow iteration of child entities of an AST node.
-class ChildEntities
-    with IterableMixin<SyntacticEntity>
-    implements Iterable<SyntacticEntity> {
+class ChildEntities {
   /// The list of child entities to be iterated over.
-  final List<SyntacticEntity> _entities = [];
+  final List<ChildEntity> entities = [];
 
-  @override
-  Iterator<SyntacticEntity> get iterator => _entities.iterator;
+  List<SyntacticEntity> get syntacticEntities {
+    var result = <SyntacticEntity>[];
+    for (var entity in entities) {
+      var entityValue = entity.value;
+      if (entityValue is SyntacticEntity) {
+        result.add(entityValue);
+      } else if (entityValue is List<Object>) {
+        for (var element in entityValue) {
+          if (element is SyntacticEntity) {
+            result.add(element);
+          }
+        }
+      }
+    }
 
-  /// Add an AST node or token as the next child entity, if it is not `null`.
-  void add(SyntacticEntity? entity) {
-    if (entity != null) {
-      _entities.add(entity);
+    var needsSorting = false;
+    int? lastOffset;
+    for (var entity in result) {
+      if (lastOffset != null && lastOffset > entity.offset) {
+        needsSorting = true;
+        break;
+      }
+      lastOffset = entity.offset;
+    }
+
+    if (needsSorting) {
+      result.sort((a, b) => a.offset - b.offset);
+    }
+
+    return result;
+  }
+
+  void addAll(ChildEntities other) {
+    entities.addAll(other.entities);
+  }
+
+  void addNode(String name, AstNode? value) {
+    if (value != null) {
+      entities.add(
+        ChildEntity(name, value),
+      );
     }
   }
 
-  /// Add the given items as the next child entities, if [items] is not `null`.
-  void addAll(Iterable<SyntacticEntity>? items) {
-    if (items != null) {
-      _entities.addAll(items);
+  void addNodeList(String name, List<AstNode> value) {
+    entities.add(
+      ChildEntity(name, value),
+    );
+  }
+
+  void addToken(String name, Token? value) {
+    if (value != null) {
+      entities.add(
+        ChildEntity(name, value),
+      );
     }
   }
+
+  void addTokenList(String name, List<Token> value) {
+    entities.add(
+      ChildEntity(name, value),
+    );
+  }
+}
+
+/// A named child of an [AstNode], usually a token, node, or a list of nodes.
+class ChildEntity {
+  final String name;
+  final Object value;
+
+  ChildEntity(this.name, this.value);
 }
 
 /// The declaration of a class.
@@ -1455,22 +1517,6 @@
   }
 
   @override
-  Iterable<SyntacticEntity> get childEntities => super._childEntities
-    ..add(abstractKeyword)
-    ..add(macroKeyword)
-    ..add(augmentKeyword)
-    ..add(classKeyword)
-    ..add(_name)
-    ..add(_typeParameters)
-    ..add(_extendsClause)
-    ..add(_withClause)
-    ..add(_implementsClause)
-    ..add(_nativeClause)
-    ..add(leftBracket)
-    ..addAll(members)
-    ..add(rightBracket);
-
-  @override
   ClassElement? get declaredElement => _name.staticElement as ClassElement?;
 
   @override
@@ -1503,6 +1549,22 @@
   }
 
   @override
+  ChildEntities get _childEntities => super._childEntities
+    ..addToken('abstractKeyword', abstractKeyword)
+    ..addToken('macroKeyword', macroKeyword)
+    ..addToken('augmentKeyword', augmentKeyword)
+    ..addToken('classKeyword', classKeyword)
+    ..addNode('name', name)
+    ..addNode('typeParameters', typeParameters)
+    ..addNode('extendsClause', extendsClause)
+    ..addNode('withClause', withClause)
+    ..addNode('implementsClause', implementsClause)
+    ..addNode('nativeClause', nativeClause)
+    ..addToken('leftBracket', leftBracket)
+    ..addNodeList('members', members)
+    ..addToken('rightBracket', rightBracket);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitClassDeclaration(this);
 
   @override
@@ -1710,20 +1772,6 @@
   }
 
   @override
-  Iterable<SyntacticEntity> get childEntities => super._childEntities
-    ..add(typedefKeyword)
-    ..add(_name)
-    ..add(_typeParameters)
-    ..add(equals)
-    ..add(abstractKeyword)
-    ..add(macroKeyword)
-    ..add(augmentKeyword)
-    ..add(_superclass)
-    ..add(_withClause)
-    ..add(_implementsClause)
-    ..add(semicolon);
-
-  @override
   ClassElement? get declaredElement => _name.staticElement as ClassElement?;
 
   @override
@@ -1768,6 +1816,20 @@
   }
 
   @override
+  ChildEntities get _childEntities => super._childEntities
+    ..addToken('typedefKeyword', typedefKeyword)
+    ..addNode('name', name)
+    ..addNode('typeParameters', typeParameters)
+    ..addToken('equals', equals)
+    ..addToken('abstractKeyword', abstractKeyword)
+    ..addToken('macroKeyword', macroKeyword)
+    ..addToken('augmentKeyword', augmentKeyword)
+    ..addNode('superclass', superclass)
+    ..addNode('withClause', withClause)
+    ..addNode('implementsClause', implementsClause)
+    ..addToken('semicolon', semicolon);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitClassTypeAlias(this);
 
   @override
@@ -1848,10 +1910,6 @@
   Token get beginToken => tokens[0];
 
   @override
-  Iterable<SyntacticEntity> get childEntities =>
-      ChildEntities()..addAll(tokens);
-
-  @override
   Token get endToken => tokens[tokens.length - 1];
 
   @override
@@ -1867,6 +1925,10 @@
   NodeListImpl<CommentReference> get references => _references;
 
   @override
+  ChildEntities get _childEntities =>
+      ChildEntities()..addTokenList('tokens', tokens);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitComment(this);
 
   @override
@@ -1920,11 +1982,6 @@
   Token get beginToken => newKeyword ?? _expression.beginToken;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(newKeyword)
-    ..add(_expression);
-
-  @override
   Token get endToken => _expression.endToken;
 
   @override
@@ -1944,6 +2001,11 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('newKeyword', newKeyword)
+    ..addNode('expression', expression);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitCommentReference(this);
 
   @override
@@ -2048,19 +2110,6 @@
   }
 
   @override
-  Iterable<SyntacticEntity> get childEntities {
-    ChildEntities result = ChildEntities()..add(_scriptTag);
-    if (_directivesAreBeforeDeclarations) {
-      result
-        ..addAll(_directives)
-        ..addAll(_declarations);
-    } else {
-      result.addAll(sortedDirectivesAndDeclarations);
-    }
-    return result;
-  }
-
-  @override
   NodeListImpl<CompilationUnitMember> get declarations => _declarations;
 
   @override
@@ -2111,6 +2160,14 @@
     ]..sort(AstNode.LEXICAL_ORDER);
   }
 
+  @override
+  ChildEntities get _childEntities {
+    return ChildEntities()
+      ..addNode('scriptTag', scriptTag)
+      ..addNodeList('directives', directives)
+      ..addNodeList('declarations', declarations);
+  }
+
   /// Return `true` if all of the directives are lexically before any
   /// declarations.
   bool get _directivesAreBeforeDeclarations {
@@ -2211,14 +2268,6 @@
   Token get beginToken => _condition.beginToken;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(_condition)
-    ..add(question)
-    ..add(_thenExpression)
-    ..add(colon)
-    ..add(_elseExpression);
-
-  @override
   ExpressionImpl get condition => _condition;
 
   set condition(Expression expression) {
@@ -2246,6 +2295,14 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addNode('condition', condition)
+    ..addToken('question', question)
+    ..addNode('thenExpression', thenExpression)
+    ..addToken('colon', colon)
+    ..addNode('elseExpression', elseExpression);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) =>
       visitor.visitConditionalExpression(this);
 
@@ -2300,16 +2357,6 @@
   Token get beginToken => ifKeyword;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(ifKeyword)
-    ..add(leftParenthesis)
-    ..add(_name)
-    ..add(equalToken)
-    ..add(_value)
-    ..add(rightParenthesis)
-    ..add(_uri);
-
-  @override
   Token get endToken => _uri.endToken;
 
   @override
@@ -2334,6 +2381,16 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('ifKeyword', ifKeyword)
+    ..addToken('leftParenthesis', leftParenthesis)
+    ..addNode('name', name)
+    ..addToken('equalToken', equalToken)
+    ..addNode('value', value)
+    ..addToken('rightParenthesis', rightParenthesis)
+    ..addNode('uri', uri);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitConfiguration(this);
 
   @override
@@ -2478,20 +2535,6 @@
   }
 
   @override
-  Iterable<SyntacticEntity> get childEntities => super._childEntities
-    ..add(externalKeyword)
-    ..add(constKeyword)
-    ..add(factoryKeyword)
-    ..add(_returnType)
-    ..add(period)
-    ..add(_name)
-    ..add(_parameters)
-    ..add(separator)
-    ..addAll(initializers)
-    ..add(_redirectedConstructor)
-    ..add(_body);
-
-  @override
   Token get endToken {
     return _body.endToken;
   }
@@ -2536,6 +2579,20 @@
   }
 
   @override
+  ChildEntities get _childEntities => super._childEntities
+    ..addToken('externalKeyword', externalKeyword)
+    ..addToken('constKeyword', constKeyword)
+    ..addToken('factoryKeyword', factoryKeyword)
+    ..addNode('returnType', returnType)
+    ..addToken('period', period)
+    ..addNode('name', name)
+    ..addNode('parameters', parameters)
+    ..addToken('separator', separator)
+    ..addNodeList('initializers', initializers)
+    ..addNode('redirectedConstructor', redirectedConstructor)
+    ..addNode('body', body);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) =>
       visitor.visitConstructorDeclaration(this);
 
@@ -2594,14 +2651,6 @@
   }
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(thisKeyword)
-    ..add(period)
-    ..add(_fieldName)
-    ..add(equals)
-    ..add(_expression);
-
-  @override
   Token get endToken => _expression.endToken;
 
   @override
@@ -2619,6 +2668,14 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('thisKeyword', thisKeyword)
+    ..addToken('period', period)
+    ..addNode('fieldName', fieldName)
+    ..addToken('equals', equals)
+    ..addNode('expression', expression);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) =>
       visitor.visitConstructorFieldInitializer(this);
 
@@ -2672,12 +2729,6 @@
   Token get beginToken => _type.beginToken;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(_type)
-    ..add(period)
-    ..add(_name);
-
-  @override
   Token get endToken {
     if (_name != null) {
       return _name!.endToken;
@@ -2704,6 +2755,12 @@
   NamedTypeImpl get type2 => _type;
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addNode('type', type)
+    ..addToken('period', period)
+    ..addNode('name', name);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitConstructorName(this);
 
   @override
@@ -2731,10 +2788,6 @@
   Token get beginToken => constructorName.beginToken;
 
   @override
-  Iterable<SyntacticEntity> get childEntities =>
-      ChildEntities()..add(constructorName);
-
-  @override
   ConstructorNameImpl get constructorName => _constructorName;
 
   set constructorName(ConstructorNameImpl value) {
@@ -2748,6 +2801,10 @@
   Precedence get precedence => Precedence.postfix;
 
   @override
+  ChildEntities get _childEntities =>
+      ChildEntities()..addNode('constructorName', constructorName);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) =>
       visitor.visitConstructorReference(this);
 
@@ -2776,12 +2833,12 @@
   Token get beginToken => period;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(period)
-    ..add(name);
+  Token get endToken => name.token;
 
   @override
-  Token get endToken => name.token;
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('period', period)
+    ..addNode('name', name);
 
   @override
   E? accept<E>(AstVisitor<E> visitor) {
@@ -2827,12 +2884,6 @@
   Token get beginToken => continueKeyword;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(continueKeyword)
-    ..add(_label)
-    ..add(semicolon);
-
-  @override
   Token get endToken => semicolon;
 
   @override
@@ -2843,6 +2894,12 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('continueKeyword', continueKeyword)
+    ..addNode('label', label)
+    ..addToken('semicolon', semicolon);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitContinueStatement(this);
 
   @override
@@ -2892,12 +2949,6 @@
   }
 
   @override
-  Iterable<SyntacticEntity> get childEntities => super._childEntities
-    ..add(keyword)
-    ..add(_type)
-    ..add(_identifier);
-
-  @override
   LocalVariableElement? get declaredElement {
     return _identifier.staticElement as LocalVariableElement;
   }
@@ -2931,6 +2982,12 @@
   }
 
   @override
+  ChildEntities get _childEntities => super._childEntities
+    ..addToken('keyword', keyword)
+    ..addNode('type', type)
+    ..addNode('identifier', identifier);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitDeclaredIdentifier(this);
 
   @override
@@ -2996,12 +3053,6 @@
   Token get beginToken => _parameter.beginToken;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(_parameter)
-    ..add(separator)
-    ..add(_defaultValue);
-
-  @override
   Token? get covariantKeyword => null;
 
   @override
@@ -3045,6 +3096,12 @@
   Token? get requiredKeyword => null;
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addNode('parameter', parameter)
+    ..addToken('separator', separator)
+    ..addNode('defaultValue', defaultValue);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) =>
       visitor.visitDefaultFormalParameter(this);
 
@@ -3138,16 +3195,6 @@
   }
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(doKeyword)
-    ..add(_body)
-    ..add(whileKeyword)
-    ..add(leftParenthesis)
-    ..add(_condition)
-    ..add(rightParenthesis)
-    ..add(semicolon);
-
-  @override
   ExpressionImpl get condition => _condition;
 
   set condition(Expression expression) {
@@ -3158,6 +3205,16 @@
   Token get endToken => semicolon;
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('doKeyword', doKeyword)
+    ..addNode('body', body)
+    ..addToken('whileKeyword', whileKeyword)
+    ..addToken('leftParenthesis', leftParenthesis)
+    ..addNode('condition', condition)
+    ..addToken('rightParenthesis', rightParenthesis)
+    ..addToken('semicolon', semicolon);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitDoStatement(this);
 
   @override
@@ -3184,17 +3241,17 @@
   Token get beginToken => _components.beginToken!;
 
   @override
-  // TODO(paulberry): add "." tokens.
-  Iterable<SyntacticEntity> get childEntities =>
-      ChildEntities()..addAll(_components);
-
-  @override
   NodeListImpl<SimpleIdentifier> get components => _components;
 
   @override
   Token get endToken => _components.endToken!;
 
   @override
+  // TODO(paulberry): add "." tokens.
+  ChildEntities get _childEntities =>
+      ChildEntities()..addNodeList('components', components);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitDottedName(this);
 
   @override
@@ -3227,10 +3284,11 @@
   Token get beginToken => literal;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()..add(literal);
+  Token get endToken => literal;
 
   @override
-  Token get endToken => literal;
+  ChildEntities get _childEntities =>
+      ChildEntities()..addToken('literal', literal);
 
   @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitDoubleLiteral(this);
@@ -3260,11 +3318,11 @@
   Token get beginToken => semicolon;
 
   @override
-  Iterable<SyntacticEntity> get childEntities =>
-      ChildEntities()..add(semicolon);
+  Token get endToken => semicolon;
 
   @override
-  Token get endToken => semicolon;
+  ChildEntities get _childEntities =>
+      ChildEntities()..addToken('semicolon', semicolon);
 
   @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitEmptyFunctionBody(this);
@@ -3295,16 +3353,16 @@
   Token get beginToken => semicolon;
 
   @override
-  Iterable<SyntacticEntity> get childEntities =>
-      ChildEntities()..add(semicolon);
-
-  @override
   Token get endToken => semicolon;
 
   @override
   bool get isSynthetic => semicolon.isSynthetic;
 
   @override
+  ChildEntities get _childEntities =>
+      ChildEntities()..addToken('semicolon', semicolon);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitEmptyStatement(this);
 
   @override
@@ -3339,13 +3397,13 @@
       (typeArguments ?? constructorSelector ?? argumentList).beginToken;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(typeArguments)
-    ..add(constructorSelector)
-    ..add(argumentList);
+  Token get endToken => argumentList.endToken;
 
   @override
-  Token get endToken => argumentList.endToken;
+  ChildEntities get _childEntities => ChildEntities()
+    ..addNode('typeArguments', typeArguments)
+    ..addNode('constructorSelector', constructorSelector)
+    ..addNode('argumentList', argumentList);
 
   @override
   E? accept<E>(AstVisitor<E> visitor) {
@@ -3387,11 +3445,6 @@
   }
 
   @override
-  Iterable<SyntacticEntity> get childEntities => super._childEntities
-    ..add(_name)
-    ..add(arguments);
-
-  @override
   FieldElement get declaredElement => _name.staticElement as FieldElement;
 
   @override
@@ -3408,6 +3461,11 @@
   }
 
   @override
+  ChildEntities get _childEntities => super._childEntities
+    ..addNode('name', name)
+    ..addNode('arguments', arguments);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) =>
       visitor.visitEnumConstantDeclaration(this);
 
@@ -3486,19 +3544,6 @@
   }
 
   @override
-  // TODO(brianwilkerson) Add commas?
-  Iterable<SyntacticEntity> get childEntities => super._childEntities
-    ..add(enumKeyword)
-    ..add(_name)
-    ..add(_typeParameters)
-    ..add(_withClause)
-    ..add(_implementsClause)
-    ..add(leftBracket)
-    ..addAll(_constants)
-    ..addAll(_members)
-    ..add(rightBracket);
-
-  @override
   NodeListImpl<EnumConstantDeclaration> get constants => _constants;
 
   @override
@@ -3536,6 +3581,19 @@
   }
 
   @override
+  // TODO(brianwilkerson) Add commas?
+  ChildEntities get _childEntities => super._childEntities
+    ..addToken('enumKeyword', enumKeyword)
+    ..addNode('name', name)
+    ..addNode('typeParameters', typeParameters)
+    ..addNode('withClause', withClause)
+    ..addNode('implementsClause', implementsClause)
+    ..addToken('leftBracket', leftBracket)
+    ..addNodeList('constants', constants)
+    ..addNodeList('members', members)
+    ..addToken('rightBracket', rightBracket);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitEnumDeclaration(this);
 
   @override
@@ -3581,13 +3639,6 @@
             combinators, semicolon);
 
   @override
-  Iterable<SyntacticEntity> get childEntities => super._childEntities
-    ..add(keyword)
-    ..add(_uri)
-    ..addAll(combinators)
-    ..add(semicolon);
-
-  @override
   ExportElement? get element => super.element as ExportElement?;
 
   @override
@@ -3596,6 +3647,13 @@
   }
 
   @override
+  ChildEntities get _childEntities => super._childEntities
+    ..addToken('keyword', keyword)
+    ..addNode('uri', uri)
+    ..addNodeList('combinators', combinators)
+    ..addToken('semicolon', semicolon);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitExportDirective(this);
 
   @override
@@ -3654,14 +3712,6 @@
   }
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(keyword)
-    ..add(star)
-    ..add(functionDefinition)
-    ..add(_expression)
-    ..add(semicolon);
-
-  @override
   Token get endToken {
     if (semicolon != null) {
       return semicolon!;
@@ -3686,6 +3736,14 @@
   bool get isSynchronous => keyword?.lexeme != Keyword.ASYNC.lexeme;
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('keyword', keyword)
+    ..addToken('star', star)
+    ..addToken('functionDefinition', functionDefinition)
+    ..addNode('expression', expression)
+    ..addToken('semicolon', semicolon);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) =>
       visitor.visitExpressionFunctionBody(this);
 
@@ -3817,11 +3875,6 @@
   Token get beginToken => _expression.beginToken;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(_expression)
-    ..add(semicolon);
-
-  @override
   Token get endToken {
     if (semicolon != null) {
       return semicolon!;
@@ -3841,6 +3894,11 @@
       _expression.isSynthetic && (semicolon == null || semicolon!.isSynthetic);
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addNode('expression', expression)
+    ..addToken('semicolon', semicolon);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitExpressionStatement(this);
 
   @override
@@ -3870,11 +3928,6 @@
   Token get beginToken => extendsKeyword;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(extendsKeyword)
-    ..add(_superclass);
-
-  @override
   Token get endToken => _superclass.endToken;
 
   @override
@@ -3889,6 +3942,11 @@
   NamedTypeImpl get superclass2 => _superclass;
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('extendsKeyword', extendsKeyword)
+    ..addNode('superclass', superclass);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitExtendsClause(this);
 
   @override
@@ -3967,17 +4025,6 @@
   }
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(extensionKeyword)
-    ..add(name)
-    ..add(typeParameters)
-    ..add(onKeyword)
-    ..add(extendedType)
-    ..add(leftBracket)
-    ..addAll(members)
-    ..add(rightBracket);
-
-  @override
   ExtensionElement? get declaredElement => _declaredElement;
 
   /// Set the element declared by this declaration to the given [element].
@@ -4030,6 +4077,17 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('extensionKeyword', extensionKeyword)
+    ..addNode('name', name)
+    ..addNode('typeParameters', typeParameters)
+    ..addToken('onKeyword', onKeyword)
+    ..addNode('extendedType', extendedType)
+    ..addToken('leftBracket', leftBracket)
+    ..addNodeList('members', members)
+    ..addToken('rightBracket', rightBracket);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) =>
       visitor.visitExtensionDeclaration(this);
 
@@ -4085,12 +4143,6 @@
   Token get beginToken => _extensionName.beginToken;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(_extensionName)
-    ..add(_typeArguments)
-    ..add(_argumentList);
-
-  @override
   Token get endToken => _argumentList.endToken;
 
   @override
@@ -4123,6 +4175,12 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addNode('extensionName', extensionName)
+    ..addNode('typeArguments', typeArguments)
+    ..addNode('argumentList', argumentList);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) {
     return visitor.visitExtensionOverride(this);
   }
@@ -4180,12 +4238,6 @@
   }
 
   @override
-  Iterable<SyntacticEntity> get childEntities => super._childEntities
-    ..add(staticKeyword)
-    ..add(_fieldList)
-    ..add(semicolon);
-
-  @override
   Element? get declaredElement => null;
 
   @override
@@ -4209,6 +4261,12 @@
   bool get isStatic => staticKeyword != null;
 
   @override
+  ChildEntities get _childEntities => super._childEntities
+    ..addToken('staticKeyword', staticKeyword)
+    ..addNode('fields', fields)
+    ..addToken('semicolon', semicolon);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitFieldDeclaration(this);
 
   @override
@@ -4299,15 +4357,6 @@
   }
 
   @override
-  Iterable<SyntacticEntity> get childEntities => super._childEntities
-    ..add(keyword)
-    ..add(_type)
-    ..add(thisKeyword)
-    ..add(period)
-    ..add(identifier)
-    ..add(_parameters);
-
-  @override
   Token get endToken {
     return question ?? _parameters?.endToken ?? identifier.endToken;
   }
@@ -4343,6 +4392,15 @@
   }
 
   @override
+  ChildEntities get _childEntities => super._childEntities
+    ..addToken('keyword', keyword)
+    ..addNode('type', type)
+    ..addToken('thisKeyword', thisKeyword)
+    ..addToken('period', period)
+    ..addNode('identifier', identifier)
+    ..addNode('parameters', parameters);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) =>
       visitor.visitFieldFormalParameter(this);
 
@@ -4375,11 +4433,6 @@
   Token get beginToken => inKeyword;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(inKeyword)
-    ..add(_iterable);
-
-  @override
   Token get endToken => _iterable.endToken;
 
   @override
@@ -4390,6 +4443,11 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('inKeyword', inKeyword)
+    ..addNode('iterable', iterable);
+
+  @override
   void visitChildren(AstVisitor visitor) {
     _iterable.accept(visitor);
   }
@@ -4412,11 +4470,6 @@
   Token get beginToken => _loopVariable.beginToken;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(_loopVariable)
-    ..addAll(super.childEntities);
-
-  @override
   DeclaredIdentifierImpl get loopVariable => _loopVariable;
 
   set loopVariable(DeclaredIdentifier variable) {
@@ -4424,6 +4477,11 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addNode('loopVariable', loopVariable)
+    ..addAll(super._childEntities);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) =>
       visitor.visitForEachPartsWithDeclaration(this);
 
@@ -4451,11 +4509,6 @@
   Token get beginToken => _identifier.beginToken;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(_identifier)
-    ..addAll(super.childEntities);
-
-  @override
   SimpleIdentifierImpl get identifier => _identifier;
 
   set identifier(SimpleIdentifier identifier) {
@@ -4463,6 +4516,11 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addNode('identifier', identifier)
+    ..addAll(super._childEntities);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) =>
       visitor.visitForEachPartsWithIdentifier(this);
 
@@ -4509,15 +4567,6 @@
   }
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(awaitKeyword)
-    ..add(forKeyword)
-    ..add(leftParenthesis)
-    ..add(_forLoopParts)
-    ..add(rightParenthesis)
-    ..add(_body);
-
-  @override
   Token get endToken => _body.endToken;
 
   @override
@@ -4528,6 +4577,15 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('awaitKeyword', awaitKeyword)
+    ..addToken('forKeyword', forKeyword)
+    ..addToken('leftParenthesis', leftParenthesis)
+    ..addNode('forLoopParts', forLoopParts)
+    ..addToken('rightParenthesis', rightParenthesis)
+    ..addNode('body', body);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitForElement(this);
 
   @override
@@ -4670,25 +4728,6 @@
   Token get beginToken => leftParenthesis;
 
   @override
-  Iterable<SyntacticEntity> get childEntities {
-    // TODO(paulberry): include commas.
-    ChildEntities result = ChildEntities()..add(leftParenthesis);
-    bool leftDelimiterNeeded = leftDelimiter != null;
-    int length = _parameters.length;
-    for (int i = 0; i < length; i++) {
-      FormalParameter parameter = _parameters[i];
-      if (leftDelimiterNeeded && leftDelimiter!.offset < parameter.offset) {
-        result.add(leftDelimiter);
-        leftDelimiterNeeded = false;
-      }
-      result.add(parameter);
-    }
-    return result
-      ..add(rightDelimiter)
-      ..add(rightParenthesis);
-  }
-
-  @override
   Token get endToken => rightParenthesis;
 
   @override
@@ -4705,6 +4744,25 @@
   NodeListImpl<FormalParameter> get parameters => _parameters;
 
   @override
+  ChildEntities get _childEntities {
+    // TODO(paulberry): include commas.
+    var result = ChildEntities()..addToken('leftParenthesis', leftParenthesis);
+    bool leftDelimiterNeeded = leftDelimiter != null;
+    int length = _parameters.length;
+    for (int i = 0; i < length; i++) {
+      FormalParameter parameter = _parameters[i];
+      if (leftDelimiterNeeded && leftDelimiter!.offset < parameter.offset) {
+        result..addToken('leftDelimiter', leftDelimiter);
+        leftDelimiterNeeded = false;
+      }
+      result..addNode('parameter', parameter);
+    }
+    return result
+      ..addToken('rightDelimiter', rightDelimiter)
+      ..addToken('rightParenthesis', rightParenthesis);
+  }
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitFormalParameterList(this);
 
   @override
@@ -4741,13 +4799,6 @@
   Token get beginToken => leftSeparator;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(leftSeparator)
-    ..add(_condition)
-    ..add(rightSeparator)
-    ..addAll(_updaters);
-
-  @override
   ExpressionImpl? get condition => _condition;
 
   set condition(Expression? expression) {
@@ -4761,6 +4812,13 @@
   NodeListImpl<Expression> get updaters => _updaters;
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('leftSeparator', leftSeparator)
+    ..addNode('condition', condition)
+    ..addToken('rightSeparator', rightSeparator)
+    ..addNodeList('updaters', updaters);
+
+  @override
   void visitChildren(AstVisitor visitor) {
     _condition?.accept(visitor);
     _updaters.accept(visitor);
@@ -4791,11 +4849,6 @@
   Token get beginToken => _variableList.beginToken;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(_variableList)
-    ..addAll(super.childEntities);
-
-  @override
   VariableDeclarationListImpl get variables => _variableList;
 
   set variables(VariableDeclarationList? variableList) {
@@ -4804,6 +4857,11 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addNode('variables', variables)
+    ..addAll(super._childEntities);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) =>
       visitor.visitForPartsWithDeclarations(this);
 
@@ -4838,11 +4896,6 @@
   Token get beginToken => initialization?.beginToken ?? super.beginToken;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(_initialization)
-    ..addAll(super.childEntities);
-
-  @override
   ExpressionImpl? get initialization => _initialization;
 
   set initialization(Expression? initialization) {
@@ -4850,6 +4903,11 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addNode('initialization', initialization)
+    ..addAll(super._childEntities);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) =>
       visitor.visitForPartsWithExpression(this);
 
@@ -4896,15 +4954,6 @@
   }
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(awaitKeyword)
-    ..add(forKeyword)
-    ..add(leftParenthesis)
-    ..add(_forLoopParts)
-    ..add(rightParenthesis)
-    ..add(_body);
-
-  @override
   Token get endToken => _body.endToken;
 
   @override
@@ -4915,6 +4964,15 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('awaitKeyword', awaitKeyword)
+    ..addToken('forKeyword', forKeyword)
+    ..addToken('leftParenthesis', leftParenthesis)
+    ..addNode('forLoopParts', forLoopParts)
+    ..addToken('rightParenthesis', rightParenthesis)
+    ..addNode('body', body);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitForStatement(this);
 
   @override
@@ -5027,14 +5085,6 @@
   }
 
   @override
-  Iterable<SyntacticEntity> get childEntities => super._childEntities
-    ..add(externalKeyword)
-    ..add(_returnType)
-    ..add(propertyKeyword)
-    ..add(_name)
-    ..add(_functionExpression);
-
-  @override
   ExecutableElement? get declaredElement =>
       _name.staticElement as ExecutableElement?;
 
@@ -5071,6 +5121,14 @@
   }
 
   @override
+  ChildEntities get _childEntities => super._childEntities
+    ..addToken('externalKeyword', externalKeyword)
+    ..addNode('returnType', returnType)
+    ..addToken('propertyKeyword', propertyKeyword)
+    ..addNode('name', name)
+    ..addNode('functionExpression', functionExpression);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitFunctionDeclaration(this);
 
   @override
@@ -5097,10 +5155,6 @@
   Token get beginToken => _functionDeclaration.beginToken;
 
   @override
-  Iterable<SyntacticEntity> get childEntities =>
-      ChildEntities()..add(_functionDeclaration);
-
-  @override
   Token get endToken => _functionDeclaration.endToken;
 
   @override
@@ -5112,6 +5166,10 @@
   }
 
   @override
+  ChildEntities get _childEntities =>
+      ChildEntities()..addNode('functionDeclaration', functionDeclaration);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) =>
       visitor.visitFunctionDeclarationStatement(this);
 
@@ -5171,12 +5229,6 @@
   }
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(_typeParameters)
-    ..add(_parameters)
-    ..add(_body);
-
-  @override
   Token get endToken {
     return _body.endToken;
   }
@@ -5199,6 +5251,12 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addNode('typeParameters', typeParameters)
+    ..addNode('parameters', parameters)
+    ..addNode('body', body);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitFunctionExpression(this);
 
   @override
@@ -5239,11 +5297,6 @@
   Token get beginToken => _function.beginToken;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(_function)
-    ..add(_argumentList);
-
-  @override
   Token get endToken => _argumentList.endToken;
 
   @override
@@ -5257,6 +5310,11 @@
   Precedence get precedence => Precedence.postfix;
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addNode('function', function)
+    ..addNode('argumentList', argumentList);
+
+  @override
   AstNode? get _nullShortingExtensionCandidate => parent;
 
   @override
@@ -5295,11 +5353,6 @@
   Token get beginToken => function.beginToken;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(function)
-    ..add(typeArguments);
-
-  @override
   Token get endToken => typeArguments?.endToken ?? function.endToken;
 
   @override
@@ -5321,6 +5374,11 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addNode('function', function)
+    ..addNode('typeArguments', typeArguments);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitFunctionReference(this);
 
   @override
@@ -5370,15 +5428,6 @@
   }
 
   @override
-  Iterable<SyntacticEntity> get childEntities => super._childEntities
-    ..add(typedefKeyword)
-    ..add(_returnType)
-    ..add(_name)
-    ..add(_typeParameters)
-    ..add(_parameters)
-    ..add(semicolon);
-
-  @override
   TypeAliasElement? get declaredElement =>
       _name.staticElement as TypeAliasElement?;
 
@@ -5404,6 +5453,15 @@
   }
 
   @override
+  ChildEntities get _childEntities => super._childEntities
+    ..addToken('typedefKeyword', typedefKeyword)
+    ..addNode('returnType', returnType)
+    ..addNode('name', name)
+    ..addNode('typeParameters', typeParameters)
+    ..addNode('parameters', parameters)
+    ..addToken('semicolon', semicolon);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitFunctionTypeAlias(this);
 
   @override
@@ -5474,12 +5532,6 @@
   }
 
   @override
-  Iterable<SyntacticEntity> get childEntities => super._childEntities
-    ..add(_returnType)
-    ..add(identifier)
-    ..add(parameters);
-
-  @override
   Token get endToken => question ?? _parameters.endToken;
 
   @override
@@ -5513,6 +5565,12 @@
   }
 
   @override
+  ChildEntities get _childEntities => super._childEntities
+    ..addNode('returnType', returnType)
+    ..addNode('identifier', identifier)
+    ..addNode('parameters', parameters);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) =>
       visitor.visitFunctionTypedFormalParameter(this);
 
@@ -5593,14 +5651,6 @@
   Token get beginToken => _returnType?.beginToken ?? functionKeyword;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(_returnType)
-    ..add(functionKeyword)
-    ..add(_typeParameters)
-    ..add(_parameters)
-    ..add(question);
-
-  @override
   Token get endToken => question ?? _parameters.endToken;
 
   @override
@@ -5629,6 +5679,14 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addNode('returnType', returnType)
+    ..addToken('functionKeyword', functionKeyword)
+    ..addNode('typeParameters', typeParameters)
+    ..addNode('parameters', parameters)
+    ..addToken('question', question);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) {
     return visitor.visitGenericFunctionType(this);
   }
@@ -5676,15 +5734,6 @@
   }
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..addAll(metadata)
-    ..add(typedefKeyword)
-    ..add(name)
-    ..add(_typeParameters)
-    ..add(equals)
-    ..add(_type);
-
-  @override
   Element? get declaredElement => name.staticElement;
 
   /// The type of function being defined by the alias.
@@ -5718,6 +5767,15 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addNodeList('metadata', metadata)
+    ..addToken('typedefKeyword', typedefKeyword)
+    ..addNode('name', name)
+    ..addNode('typeParameters', typeParameters)
+    ..addToken('equals', equals)
+    ..addNode('type', type);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) {
     return visitor.visitGenericTypeAlias(this);
   }
@@ -5752,17 +5810,17 @@
   Token get beginToken => hideKeyword;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(hideKeyword)
-    ..addAll(elements);
-
-  @override
   NodeListImpl<ShowHideClauseElement> get elements => _elements;
 
   @override
   Token get endToken => _elements.endToken!;
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('hideKeyword', hideKeyword)
+    ..addNodeList('elements', elements);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitHideClause(this);
 
   @override
@@ -5787,17 +5845,17 @@
   }
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(keyword)
-    ..addAll(_hiddenNames);
-
-  @override
   Token get endToken => _hiddenNames.endToken!;
 
   @override
   NodeListImpl<SimpleIdentifier> get hiddenNames => _hiddenNames;
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('keyword', keyword)
+    ..addNodeList('hiddenNames', hiddenNames);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitHideCombinator(this);
 
   @override
@@ -5858,16 +5916,6 @@
   Token get beginToken => ifKeyword;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(ifKeyword)
-    ..add(leftParenthesis)
-    ..add(_condition)
-    ..add(rightParenthesis)
-    ..add(_thenElement)
-    ..add(elseKeyword)
-    ..add(_elseElement);
-
-  @override
   ExpressionImpl get condition => _condition;
 
   set condition(Expression condition) {
@@ -5892,6 +5940,16 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('ifKeyword', ifKeyword)
+    ..addToken('leftParenthesis', leftParenthesis)
+    ..addNode('condition', condition)
+    ..addToken('rightParenthesis', rightParenthesis)
+    ..addNode('thenElement', thenElement)
+    ..addToken('elseKeyword', elseKeyword)
+    ..addNode('elseElement', elseElement);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitIfElement(this);
 
   @override
@@ -5954,16 +6012,6 @@
   Token get beginToken => ifKeyword;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(ifKeyword)
-    ..add(leftParenthesis)
-    ..add(_condition)
-    ..add(rightParenthesis)
-    ..add(_thenStatement)
-    ..add(elseKeyword)
-    ..add(_elseStatement);
-
-  @override
   ExpressionImpl get condition => _condition;
 
   set condition(Expression condition) {
@@ -5993,6 +6041,16 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('ifKeyword', ifKeyword)
+    ..addToken('leftParenthesis', leftParenthesis)
+    ..addNode('condition', condition)
+    ..addToken('rightParenthesis', rightParenthesis)
+    ..addNode('thenStatement', thenStatement)
+    ..addToken('elseKeyword', elseKeyword)
+    ..addNode('elseStatement', elseStatement);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitIfStatement(this);
 
   @override
@@ -6024,12 +6082,6 @@
   Token get beginToken => implementsKeyword;
 
   @override
-  // TODO(paulberry): add commas.
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(implementsKeyword)
-    ..addAll(interfaces);
-
-  @override
   Token get endToken => _interfaces.endToken!;
 
   @override
@@ -6040,6 +6092,12 @@
   NodeListImpl<NamedType> get interfaces2 => _interfaces;
 
   @override
+  // TODO(paulberry): add commas.
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('implementsKeyword', implementsKeyword)
+    ..addNodeList('interfaces', interfaces);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitImplementsClause(this);
 
   @override
@@ -6074,11 +6132,6 @@
   Token get beginToken => expression.beginToken;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(expression)
-    ..add(typeArguments);
-
-  @override
   Token get endToken => typeArguments?.endToken ?? expression.endToken;
 
   @override
@@ -6100,6 +6153,11 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addNode('expression', expression)
+    ..addNode('typeArguments', typeArguments);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) {
     return visitor.visitImplicitCallReference(this);
   }
@@ -6157,16 +6215,6 @@
   }
 
   @override
-  Iterable<SyntacticEntity> get childEntities => super._childEntities
-    ..add(keyword)
-    ..add(_uri)
-    ..add(deferredKeyword)
-    ..add(asKeyword)
-    ..add(_prefix)
-    ..addAll(combinators)
-    ..add(semicolon);
-
-  @override
   ImportElement? get element => super.element as ImportElement?;
 
   @override
@@ -6182,6 +6230,16 @@
   }
 
   @override
+  ChildEntities get _childEntities => super._childEntities
+    ..addToken('keyword', keyword)
+    ..addNode('uri', uri)
+    ..addToken('deferredKeyword', deferredKeyword)
+    ..addToken('asKeyword', asKeyword)
+    ..addNode('prefix', prefix)
+    ..addNodeList('combinators', combinators)
+    ..addToken('semicolon', semicolon);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitImportDirective(this);
 
   @override
@@ -6249,14 +6307,6 @@
   }
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(_target)
-    ..add(period)
-    ..add(leftBracket)
-    ..add(_index)
-    ..add(rightBracket);
-
-  @override
   Token get endToken => rightBracket;
 
   @override
@@ -6314,6 +6364,14 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addNode('target', target)
+    ..addToken('period', period)
+    ..addToken('leftBracket', leftBracket)
+    ..addNode('index', index)
+    ..addToken('rightBracket', rightBracket);
+
+  @override
   AstNode get _nullShortingExtensionCandidate => parent!;
 
   /// If the AST structure has been resolved, and the function being invoked is
@@ -6428,13 +6486,6 @@
   Token get beginToken => keyword ?? _constructorName.beginToken;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(keyword)
-    ..add(_constructorName)
-    ..add(_typeArguments)
-    ..add(_argumentList);
-
-  @override
   ConstructorNameImpl get constructorName => _constructorName;
 
   set constructorName(ConstructorName name) {
@@ -6474,6 +6525,13 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('keyword', keyword)
+    ..addNode('constructorName', constructorName)
+    ..addNode('typeArguments', typeArguments)
+    ..addNode('argumentList', argumentList);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) =>
       visitor.visitInstanceCreationExpression(this);
 
@@ -6513,9 +6571,6 @@
   Token get beginToken => literal;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()..add(literal);
-
-  @override
   Token get endToken => literal;
 
   /// Returns whether this literal's [parent] is a [PrefixExpression] of unary
@@ -6531,6 +6586,10 @@
   }
 
   @override
+  ChildEntities get _childEntities =>
+      ChildEntities()..addToken('literal', literal);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitIntegerLiteral(this);
 
   @override
@@ -6631,12 +6690,6 @@
   Token get beginToken => leftBracket;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(leftBracket)
-    ..add(_expression)
-    ..add(rightBracket);
-
-  @override
   Token get endToken => rightBracket ?? _expression.endToken;
 
   @override
@@ -6647,6 +6700,12 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('leftBracket', leftBracket)
+    ..addNode('expression', expression)
+    ..addToken('rightBracket', rightBracket);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) =>
       visitor.visitInterpolationExpression(this);
 
@@ -6678,9 +6737,6 @@
   Token get beginToken => contents;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()..add(contents);
-
-  @override
   int get contentsEnd => offset + _lexemeHelper.end;
 
   @override
@@ -6692,6 +6748,10 @@
   @override
   StringInterpolation get parent => super.parent as StringInterpolation;
 
+  @override
+  ChildEntities get _childEntities =>
+      ChildEntities()..addToken('contents', contents);
+
   StringLexemeHelper get _lexemeHelper {
     String lexeme = contents.lexeme;
     return StringLexemeHelper(lexeme, identical(this, parent.elements.first),
@@ -6774,13 +6834,6 @@
   Token get beginToken => _expression.beginToken;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(_expression)
-    ..add(isOperator)
-    ..add(notOperator)
-    ..add(_type);
-
-  @override
   Token get endToken => _type.endToken;
 
   @override
@@ -6801,6 +6854,13 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addNode('expression', expression)
+    ..addToken('isOperator', isOperator)
+    ..addToken('notOperator', notOperator)
+    ..addNode('type', type);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitIsExpression(this);
 
   @override
@@ -6836,11 +6896,6 @@
   }
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..addAll(_labels)
-    ..add(_statement);
-
-  @override
   Token get endToken => _statement.endToken;
 
   @override
@@ -6857,6 +6912,11 @@
   StatementImpl get unlabeled => _statement.unlabeled;
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addNodeList('labels', labels)
+    ..addNode('statement', statement);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitLabeledStatement(this);
 
   @override
@@ -6887,11 +6947,6 @@
   Token get beginToken => _label.beginToken;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(_label)
-    ..add(colon);
-
-  @override
   Token get endToken => colon;
 
   @override
@@ -6902,6 +6957,11 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addNode('label', label)
+    ..addToken('colon', colon);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitLabel(this);
 
   @override
@@ -6936,12 +6996,6 @@
   }
 
   @override
-  Iterable<SyntacticEntity> get childEntities => super._childEntities
-    ..add(libraryKeyword)
-    ..add(_name)
-    ..add(semicolon);
-
-  @override
   Token get endToken => semicolon;
 
   @override
@@ -6958,6 +7012,12 @@
   }
 
   @override
+  ChildEntities get _childEntities => super._childEntities
+    ..addToken('libraryKeyword', libraryKeyword)
+    ..addNode('name', name)
+    ..addToken('semicolon', semicolon);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitLibraryDirective(this);
 
   @override
@@ -6985,11 +7045,6 @@
   Token get beginToken => _components.beginToken!;
 
   @override
-  // TODO(paulberry): add "." tokens.
-  Iterable<SyntacticEntity> get childEntities =>
-      ChildEntities()..addAll(_components);
-
-  @override
   NodeListImpl<SimpleIdentifier> get components => _components;
 
   @override
@@ -7019,6 +7074,11 @@
   Element? get staticElement => null;
 
   @override
+  // TODO(paulberry): add "." tokens.
+  ChildEntities get _childEntities =>
+      ChildEntities()..addNodeList('components', components);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitLibraryIdentifier(this);
 
   @override
@@ -7077,19 +7137,19 @@
   }
 
   @override
-  // TODO(paulberry): add commas.
-  Iterable<SyntacticEntity> get childEntities => super._childEntities
-    ..add(leftBracket)
-    ..addAll(_elements)
-    ..add(rightBracket);
-
-  @override
   NodeListImpl<CollectionElement> get elements => _elements;
 
   @override
   Token get endToken => rightBracket;
 
   @override
+  // TODO(paulberry): add commas.
+  ChildEntities get _childEntities => super._childEntities
+    ..addToken('leftBracket', leftBracket)
+    ..addNodeList('elements', elements)
+    ..addToken('rightBracket', rightBracket);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitListLiteral(this);
 
   @override
@@ -7153,12 +7213,6 @@
   Token get beginToken => _key.beginToken;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(_key)
-    ..add(separator)
-    ..add(_value);
-
-  @override
   Token get endToken => _value.endToken;
 
   @override
@@ -7176,6 +7230,12 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addNode('key', key)
+    ..addToken('separator', separator)
+    ..addNode('value', value);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitMapLiteralEntry(this);
 
   @override
@@ -7278,17 +7338,6 @@
     _body = _becomeParentOf(functionBody as FunctionBodyImpl);
   }
 
-  @override
-  Iterable<SyntacticEntity> get childEntities => super._childEntities
-    ..add(externalKeyword)
-    ..add(modifierKeyword)
-    ..add(_returnType)
-    ..add(propertyKeyword)
-    ..add(operatorKeyword)
-    ..add(_name)
-    ..add(_parameters)
-    ..add(_body);
-
   /// Return the element associated with this method, or `null` if the AST
   /// structure has not been resolved. The element can either be a
   /// [MethodElement], if this represents the declaration of a normal method, or
@@ -7357,6 +7406,17 @@
   }
 
   @override
+  ChildEntities get _childEntities => super._childEntities
+    ..addToken('externalKeyword', externalKeyword)
+    ..addToken('modifierKeyword', modifierKeyword)
+    ..addNode('returnType', returnType)
+    ..addToken('propertyKeyword', propertyKeyword)
+    ..addToken('operatorKeyword', operatorKeyword)
+    ..addNode('name', name)
+    ..addNode('parameters', parameters)
+    ..addNode('body', body);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitMethodDeclaration(this);
 
   @override
@@ -7419,13 +7479,6 @@
   }
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(_target)
-    ..add(operator)
-    ..add(_methodName)
-    ..add(_argumentList);
-
-  @override
   Token get endToken => _argumentList.endToken;
 
   @override
@@ -7501,6 +7554,13 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addNode('target', target)
+    ..addToken('operator', operator)
+    ..addNode('methodName', methodName)
+    ..addNode('argumentList', argumentList);
+
+  @override
   AstNode? get _nullShortingExtensionCandidate => parent;
 
   @override
@@ -7556,17 +7616,6 @@
   }
 
   @override
-  Iterable<SyntacticEntity> get childEntities => super._childEntities
-    ..add(mixinKeyword)
-    ..add(_name)
-    ..add(_typeParameters)
-    ..add(_onClause)
-    ..add(_implementsClause)
-    ..add(leftBracket)
-    ..addAll(members)
-    ..add(rightBracket);
-
-  @override
   ClassElement? get declaredElement => _name.staticElement as ClassElement?;
 
   @override
@@ -7591,6 +7640,17 @@
   TypeParameterListImpl? get typeParameters => _typeParameters;
 
   @override
+  ChildEntities get _childEntities => super._childEntities
+    ..addToken('mixinKeyword', mixinKeyword)
+    ..addNode('name', name)
+    ..addNode('typeParameters', typeParameters)
+    ..addNode('onClause', onClause)
+    ..addNode('implementsClause', implementsClause)
+    ..addToken('leftBracket', leftBracket)
+    ..addNodeList('members', members)
+    ..addToken('rightBracket', rightBracket);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitMixinDeclaration(this);
 
   @override
@@ -7649,11 +7709,6 @@
   Token get beginToken => _name.beginToken;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(_name)
-    ..add(_expression);
-
-  @override
   ParameterElement? get element {
     var element = _name.label.staticElement;
     if (element is ParameterElement) {
@@ -7683,6 +7738,11 @@
   Precedence get precedence => Precedence.none;
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addNode('name', name)
+    ..addNode('expression', expression);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitNamedExpression(this);
 
   @override
@@ -7724,12 +7784,6 @@
   Token get beginToken => _name.beginToken;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(_name)
-    ..add(_typeArguments)
-    ..add(question);
-
-  @override
   Token get endToken => question ?? _typeArguments?.endToken ?? _name.endToken;
 
   @override
@@ -7759,6 +7813,12 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addNode('name', name)
+    ..addNode('typeArguments', typeArguments)
+    ..addToken('question', question);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitNamedType(this);
 
   @override
@@ -7850,11 +7910,6 @@
   Token get beginToken => nativeKeyword;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(nativeKeyword)
-    ..add(_name);
-
-  @override
   Token get endToken {
     return _name?.endToken ?? nativeKeyword;
   }
@@ -7867,6 +7922,11 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('nativeKeyword', nativeKeyword)
+    ..addNode('name', name);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitNativeClause(this);
 
   @override
@@ -7905,12 +7965,6 @@
   Token get beginToken => nativeKeyword;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(nativeKeyword)
-    ..add(_stringLiteral)
-    ..add(semicolon);
-
-  @override
   Token get endToken => semicolon;
 
   @override
@@ -7921,6 +7975,12 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('nativeKeyword', nativeKeyword)
+    ..addNode('stringLiteral', stringLiteral)
+    ..addToken('semicolon', semicolon);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitNativeFunctionBody(this);
 
   @override
@@ -8123,19 +8183,13 @@
     ]..sort(AstNode.LEXICAL_ORDER);
   }
 
+  @override
   ChildEntities get _childEntities {
-    ChildEntities result = ChildEntities();
-    if (_commentIsBeforeAnnotations()) {
-      result
-        ..add(_comment)
-        ..addAll(_metadata);
-    } else {
-      result.addAll(sortedCommentAndAnnotations);
-    }
-    result
-      ..add(requiredKeyword)
-      ..add(covariantKeyword);
-    return result;
+    return ChildEntities()
+      ..addNode('documentationComment', documentationComment)
+      ..addNodeList('metadata', metadata)
+      ..addToken('requiredKeyword', requiredKeyword)
+      ..addToken('covariantKeyword', covariantKeyword);
   }
 
   @override
@@ -8182,10 +8236,11 @@
   Token get beginToken => literal;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()..add(literal);
+  Token get endToken => literal;
 
   @override
-  Token get endToken => literal;
+  ChildEntities get _childEntities =>
+      ChildEntities()..addToken('literal', literal);
 
   @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitNullLiteral(this);
@@ -8243,12 +8298,6 @@
   Token get beginToken => onKeyword;
 
   @override
-  // TODO(paulberry): add commas.
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(onKeyword)
-    ..addAll(superclassConstraints);
-
-  @override
   Token get endToken => _superclassConstraints.endToken!;
 
   @override
@@ -8259,6 +8308,12 @@
   NodeListImpl<NamedType> get superclassConstraints2 => _superclassConstraints;
 
   @override
+  // TODO(paulberry): add commas.
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('onKeyword', onKeyword)
+    ..addNodeList('superclassConstraints', superclassConstraints);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitOnClause(this);
 
   @override
@@ -8294,12 +8349,6 @@
   Token get beginToken => leftParenthesis;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(leftParenthesis)
-    ..add(_expression)
-    ..add(rightParenthesis);
-
-  @override
   Token get endToken => rightParenthesis;
 
   @override
@@ -8324,6 +8373,12 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('leftParenthesis', leftParenthesis)
+    ..addNode('expression', expression)
+    ..addToken('rightParenthesis', rightParenthesis);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) =>
       visitor.visitParenthesizedExpression(this);
 
@@ -8354,12 +8409,6 @@
       : super(comment, metadata, partUri);
 
   @override
-  Iterable<SyntacticEntity> get childEntities => super._childEntities
-    ..add(partKeyword)
-    ..add(_uri)
-    ..add(semicolon);
-
-  @override
   Token get endToken => semicolon;
 
   @override
@@ -8372,6 +8421,12 @@
   CompilationUnitElement? get uriElement => element as CompilationUnitElement?;
 
   @override
+  ChildEntities get _childEntities => super._childEntities
+    ..addToken('partKeyword', partKeyword)
+    ..addNode('uri', uri)
+    ..addToken('semicolon', semicolon);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitPartDirective(this);
 }
 
@@ -8417,14 +8472,6 @@
   }
 
   @override
-  Iterable<SyntacticEntity> get childEntities => super._childEntities
-    ..add(partKeyword)
-    ..add(ofKeyword)
-    ..add(_uri)
-    ..add(_libraryName)
-    ..add(semicolon);
-
-  @override
   Token get endToken => semicolon;
 
   @override
@@ -8448,6 +8495,14 @@
   }
 
   @override
+  ChildEntities get _childEntities => super._childEntities
+    ..addToken('partKeyword', partKeyword)
+    ..addToken('ofKeyword', ofKeyword)
+    ..addNode('uri', uri)
+    ..addNode('libraryName', libraryName)
+    ..addToken('semicolon', semicolon);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitPartOfDirective(this);
 
   @override
@@ -8487,11 +8542,6 @@
   Token get beginToken => _operand.beginToken;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(_operand)
-    ..add(operator);
-
-  @override
   Token get endToken => operator;
 
   @override
@@ -8505,6 +8555,11 @@
   Precedence get precedence => Precedence.postfix;
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addNode('operand', operand)
+    ..addToken('operator', operator);
+
+  @override
   AstNode? get _nullShortingExtensionCandidate => parent;
 
   /// If the AST structure has been resolved, and the function being invoked is
@@ -8561,12 +8616,6 @@
   Token get beginToken => _prefix.beginToken;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(_prefix)
-    ..add(period)
-    ..add(_identifier);
-
-  @override
   Token get endToken => _identifier.endToken;
 
   @override
@@ -8609,6 +8658,12 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addNode('prefix', prefix)
+    ..addToken('period', period)
+    ..addNode('identifier', identifier);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitPrefixedIdentifier(this);
 
   @override
@@ -8647,11 +8702,6 @@
   Token get beginToken => operator;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(operator)
-    ..add(_operand);
-
-  @override
   Token get endToken => _operand.endToken;
 
   @override
@@ -8665,6 +8715,11 @@
   Precedence get precedence => Precedence.prefix;
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('operator', operator)
+    ..addNode('operand', operand);
+
+  @override
   AstNode? get _nullShortingExtensionCandidate => parent;
 
   /// If the AST structure has been resolved, and the function being invoked is
@@ -8731,12 +8786,6 @@
   }
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(_target)
-    ..add(operator)
-    ..add(_propertyName);
-
-  @override
   Token get endToken => _propertyName.endToken;
 
   @override
@@ -8794,6 +8843,12 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addNode('target', target)
+    ..addToken('operator', operator)
+    ..addNode('propertyName', propertyName);
+
+  @override
   AstNode? get _nullShortingExtensionCandidate => parent;
 
   @override
@@ -8859,13 +8914,6 @@
   Token get beginToken => thisKeyword;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(thisKeyword)
-    ..add(period)
-    ..add(_constructorName)
-    ..add(_argumentList);
-
-  @override
   SimpleIdentifierImpl? get constructorName => _constructorName;
 
   set constructorName(SimpleIdentifier? identifier) {
@@ -8876,6 +8924,13 @@
   Token get endToken => _argumentList.endToken;
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('thisKeyword', thisKeyword)
+    ..addToken('period', period)
+    ..addNode('constructorName', constructorName)
+    ..addNode('argumentList', argumentList);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) =>
       visitor.visitRedirectingConstructorInvocation(this);
 
@@ -8903,16 +8958,16 @@
   Token get beginToken => rethrowKeyword;
 
   @override
-  Iterable<SyntacticEntity> get childEntities =>
-      ChildEntities()..add(rethrowKeyword);
-
-  @override
   Token get endToken => rethrowKeyword;
 
   @override
   Precedence get precedence => Precedence.assignment;
 
   @override
+  ChildEntities get _childEntities =>
+      ChildEntities()..addToken('rethrowKeyword', rethrowKeyword);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitRethrowExpression(this);
 
   @override
@@ -8948,12 +9003,6 @@
   Token get beginToken => returnKeyword;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(returnKeyword)
-    ..add(_expression)
-    ..add(semicolon);
-
-  @override
   Token get endToken => semicolon;
 
   @override
@@ -8964,6 +9013,12 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('returnKeyword', returnKeyword)
+    ..addNode('expression', expression)
+    ..addToken('semicolon', semicolon);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitReturnStatement(this);
 
   @override
@@ -8989,11 +9044,11 @@
   Token get beginToken => scriptTag;
 
   @override
-  Iterable<SyntacticEntity> get childEntities =>
-      ChildEntities()..add(scriptTag);
+  Token get endToken => scriptTag;
 
   @override
-  Token get endToken => scriptTag;
+  ChildEntities get _childEntities =>
+      ChildEntities()..addToken('scriptTag', scriptTag);
 
   @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitScriptTag(this);
@@ -9054,13 +9109,6 @@
   }
 
   @override
-  // TODO(paulberry): add commas.
-  Iterable<SyntacticEntity> get childEntities => super._childEntities
-    ..add(leftBracket)
-    ..addAll(elements)
-    ..add(rightBracket);
-
-  @override
   NodeListImpl<CollectionElement> get elements => _elements;
 
   @override
@@ -9073,6 +9121,13 @@
   bool get isSet => _resolvedKind == _SetOrMapKind.set;
 
   @override
+  // TODO(paulberry): add commas.
+  ChildEntities get _childEntities => super._childEntities
+    ..addToken('leftBracket', leftBracket)
+    ..addNodeList('elements', elements)
+    ..addToken('rightBracket', rightBracket);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitSetOrMapLiteral(this);
 
   void becomeMap() {
@@ -9119,17 +9174,17 @@
   Token get beginToken => showKeyword;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(showKeyword)
-    ..addAll(elements);
-
-  @override
   NodeListImpl<ShowHideClauseElement> get elements => _elements;
 
   @override
   Token get endToken => _elements.endToken!;
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('showKeyword', showKeyword)
+    ..addNodeList('elements', elements);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitShowClause(this);
 
   @override
@@ -9155,18 +9210,18 @@
   }
 
   @override
-  // TODO(paulberry): add commas.
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(keyword)
-    ..addAll(_shownNames);
-
-  @override
   Token get endToken => _shownNames.endToken!;
 
   @override
   NodeListImpl<SimpleIdentifier> get shownNames => _shownNames;
 
   @override
+  // TODO(paulberry): add commas.
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('keyword', keyword)
+    ..addNodeList('shownNames', shownNames);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitShowCombinator(this);
 
   @override
@@ -9199,11 +9254,12 @@
   Token get beginToken => modifier ?? name.beginToken;
 
   @override
-  Iterable<SyntacticEntity> get childEntities =>
-      ChildEntities()..addAll([if (modifier != null) modifier!, name]);
+  Token get endToken => name.endToken;
 
   @override
-  Token get endToken => name.endToken;
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('modifier', modifier)
+    ..addNode('name', name);
 
   @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitShowHideElement(this);
@@ -9270,12 +9326,6 @@
   }
 
   @override
-  Iterable<SyntacticEntity> get childEntities => super._childEntities
-    ..add(keyword)
-    ..add(_type)
-    ..add(identifier);
-
-  @override
   Token get endToken => identifier?.endToken ?? type!.endToken;
 
   @override
@@ -9292,6 +9342,12 @@
   }
 
   @override
+  ChildEntities get _childEntities => super._childEntities
+    ..addToken('keyword', keyword)
+    ..addNode('type', type)
+    ..addNode('identifier', identifier);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) =>
       visitor.visitSimpleFormalParameter(this);
 
@@ -9350,9 +9406,6 @@
   Token get beginToken => token;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()..add(token);
-
-  @override
   Token get endToken => token;
 
   @override
@@ -9416,6 +9469,9 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()..addToken('token', token);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitSimpleIdentifier(this);
 
   @override
@@ -9551,9 +9607,6 @@
   Token get beginToken => literal;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()..add(literal);
-
-  @override
   int get contentsEnd => offset + _helper.end;
 
   @override
@@ -9574,6 +9627,10 @@
   @override
   bool get isSynthetic => literal.isSynthetic;
 
+  @override
+  ChildEntities get _childEntities =>
+      ChildEntities()..addToken('literal', literal);
+
   StringLexemeHelper get _helper {
     return StringLexemeHelper(literal.lexeme, true, true);
   }
@@ -9615,11 +9672,6 @@
   Token get beginToken => spreadOperator;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(spreadOperator)
-    ..add(_expression);
-
-  @override
   Token get endToken => _expression.endToken;
 
   @override
@@ -9634,6 +9686,11 @@
       spreadOperator.type == TokenType.PERIOD_PERIOD_PERIOD_QUESTION;
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('spreadOperator', spreadOperator)
+    ..addNode('expression', expression);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) {
     return visitor.visitSpreadElement(this);
   }
@@ -9705,10 +9762,6 @@
   Token get beginToken => _elements.beginToken!;
 
   @override
-  Iterable<SyntacticEntity> get childEntities =>
-      ChildEntities()..addAll(_elements);
-
-  @override
   int get contentsEnd {
     var element = _elements.last as InterpolationString;
     return element.contentsEnd;
@@ -9744,6 +9797,10 @@
   InterpolationStringImpl get lastString =>
       elements.last as InterpolationStringImpl;
 
+  @override
+  ChildEntities get _childEntities =>
+      ChildEntities()..addNodeList('elements', elements);
+
   StringLexemeHelper get _firstHelper {
     var lastString = _elements.first as InterpolationString;
     String lexeme = lastString.contents.lexeme;
@@ -9927,13 +9984,6 @@
   Token get beginToken => superKeyword;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(superKeyword)
-    ..add(period)
-    ..add(_constructorName)
-    ..add(_argumentList);
-
-  @override
   SimpleIdentifierImpl? get constructorName => _constructorName;
 
   set constructorName(SimpleIdentifier? identifier) {
@@ -9944,6 +9994,13 @@
   Token get endToken => _argumentList.endToken;
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('superKeyword', superKeyword)
+    ..addToken('period', period)
+    ..addNode('constructorName', constructorName)
+    ..addNode('argumentList', argumentList);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) =>
       visitor.visitSuperConstructorInvocation(this);
 
@@ -9970,16 +10027,16 @@
   Token get beginToken => superKeyword;
 
   @override
-  Iterable<SyntacticEntity> get childEntities =>
-      ChildEntities()..add(superKeyword);
-
-  @override
   Token get endToken => superKeyword;
 
   @override
   Precedence get precedence => Precedence.primary;
 
   @override
+  ChildEntities get _childEntities =>
+      ChildEntities()..addToken('superKeyword', superKeyword);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitSuperExpression(this);
 
   @override
@@ -10069,15 +10126,6 @@
   }
 
   @override
-  Iterable<SyntacticEntity> get childEntities => super._childEntities
-    ..add(keyword)
-    ..add(_type)
-    ..add(superKeyword)
-    ..add(period)
-    ..add(identifier)
-    ..add(_parameters);
-
-  @override
   Token get endToken {
     return question ?? _parameters?.endToken ?? identifier.endToken;
   }
@@ -10113,6 +10161,15 @@
   }
 
   @override
+  ChildEntities get _childEntities => super._childEntities
+    ..addToken('keyword', keyword)
+    ..addNode('type', type)
+    ..addToken('superKeyword', superKeyword)
+    ..addToken('period', period)
+    ..addNode('identifier', identifier)
+    ..addNode('parameters', parameters);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) =>
       visitor.visitSuperFormalParameter(this);
 
@@ -10143,14 +10200,6 @@
   }
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..addAll(labels)
-    ..add(keyword)
-    ..add(_expression)
-    ..add(colon)
-    ..addAll(statements);
-
-  @override
   ExpressionImpl get expression => _expression;
 
   set expression(Expression expression) {
@@ -10158,6 +10207,14 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addNodeList('labels', labels)
+    ..addToken('keyword', keyword)
+    ..addNode('expression', expression)
+    ..addToken('colon', colon)
+    ..addNodeList('statements', statements);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitSwitchCase(this);
 
   @override
@@ -10180,11 +10237,11 @@
       : super(labels, keyword, colon, statements);
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..addAll(labels)
-    ..add(keyword)
-    ..add(colon)
-    ..addAll(statements);
+  ChildEntities get _childEntities => ChildEntities()
+    ..addNodeList('labels', labels)
+    ..addToken('keyword', keyword)
+    ..addToken('colon', colon)
+    ..addNodeList('statements', statements);
 
   @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitSwitchDefault(this);
@@ -10297,16 +10354,6 @@
   Token get beginToken => switchKeyword;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(switchKeyword)
-    ..add(leftParenthesis)
-    ..add(_expression)
-    ..add(rightParenthesis)
-    ..add(leftBracket)
-    ..addAll(_members)
-    ..add(rightBracket);
-
-  @override
   Token get endToken => rightBracket;
 
   @override
@@ -10320,6 +10367,16 @@
   NodeListImpl<SwitchMember> get members => _members;
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('switchKeyword', switchKeyword)
+    ..addToken('leftParenthesis', leftParenthesis)
+    ..addNode('expression', expression)
+    ..addToken('rightParenthesis', rightParenthesis)
+    ..addToken('leftBracket', leftBracket)
+    ..addNodeList('members', members)
+    ..addToken('rightBracket', rightBracket);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitSwitchStatement(this);
 
   @override
@@ -10349,13 +10406,13 @@
   Token get beginToken => poundSign;
 
   @override
-  // TODO(paulberry): add "." tokens.
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(poundSign)
-    ..addAll(components);
+  Token get endToken => components[components.length - 1];
 
   @override
-  Token get endToken => components[components.length - 1];
+  // TODO(paulberry): add "." tokens.
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('poundSign', poundSign)
+    ..addTokenList('components', components);
 
   @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitSymbolLiteral(this);
@@ -10382,16 +10439,16 @@
   Token get beginToken => thisKeyword;
 
   @override
-  Iterable<SyntacticEntity> get childEntities =>
-      ChildEntities()..add(thisKeyword);
-
-  @override
   Token get endToken => thisKeyword;
 
   @override
   Precedence get precedence => Precedence.primary;
 
   @override
+  ChildEntities get _childEntities =>
+      ChildEntities()..addToken('thisKeyword', thisKeyword);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitThisExpression(this);
 
   @override
@@ -10421,11 +10478,6 @@
   Token get beginToken => throwKeyword;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(throwKeyword)
-    ..add(_expression);
-
-  @override
   Token get endToken {
     return _expression.endToken;
   }
@@ -10441,6 +10493,11 @@
   Precedence get precedence => Precedence.assignment;
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('throwKeyword', throwKeyword)
+    ..addNode('expression', expression);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitThrowExpression(this);
 
   @override
@@ -10480,11 +10537,6 @@
   }
 
   @override
-  Iterable<SyntacticEntity> get childEntities => super._childEntities
-    ..add(_variableList)
-    ..add(semicolon);
-
-  @override
   Element? get declaredElement => null;
 
   @override
@@ -10502,6 +10554,11 @@
   }
 
   @override
+  ChildEntities get _childEntities => super._childEntities
+    ..addNode('variables', variables)
+    ..addToken('semicolon', semicolon);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) =>
       visitor.visitTopLevelVariableDeclaration(this);
 
@@ -10563,14 +10620,6 @@
   NodeListImpl<CatchClause> get catchClauses => _catchClauses;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(tryKeyword)
-    ..add(_body)
-    ..addAll(_catchClauses)
-    ..add(finallyKeyword)
-    ..add(_finallyBlock);
-
-  @override
   Token get endToken {
     if (_finallyBlock != null) {
       return _finallyBlock!.endToken;
@@ -10590,6 +10639,14 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('tryKeyword', tryKeyword)
+    ..addNode('body', body)
+    ..addNodeList('catchClauses', catchClauses)
+    ..addToken('finallyKeyword', finallyKeyword)
+    ..addNode('finallyBlock', finallyBlock);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitTryStatement(this);
 
   @override
@@ -10669,14 +10726,14 @@
   Token get beginToken => leftBracket;
 
   @override
-  // TODO(paulberry): Add commas.
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(leftBracket)
-    ..addAll(_arguments)
-    ..add(rightBracket);
+  Token get endToken => rightBracket;
 
   @override
-  Token get endToken => rightBracket;
+  // TODO(paulberry): Add commas.
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('leftBracket', leftBracket)
+    ..addNodeList('arguments', arguments)
+    ..addToken('rightBracket', rightBracket);
 
   @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitTypeArgumentList(this);
@@ -10721,9 +10778,10 @@
     _typeArguments = _becomeParentOf(typeArguments as TypeArgumentListImpl?);
   }
 
+  @override
   ChildEntities get _childEntities => ChildEntities()
-    ..add(constKeyword)
-    ..add(_typeArguments);
+    ..addToken('constKeyword', constKeyword)
+    ..addNode('typeArguments', typeArguments);
 
   @override
   void visitChildren(AstVisitor visitor) {
@@ -10753,10 +10811,6 @@
   Token get beginToken => _typeName.beginToken;
 
   @override
-  Iterable<SyntacticEntity> get childEntities =>
-      ChildEntities()..add(_typeName);
-
-  @override
   Token get endToken => _typeName.endToken;
 
   @override
@@ -10772,6 +10826,9 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()..addNode('type', type);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitTypeLiteral(this);
 
   @override
@@ -10822,12 +10879,6 @@
   }
 
   @override
-  Iterable<SyntacticEntity> get childEntities => super._childEntities
-    ..add(_name)
-    ..add(extendsKeyword)
-    ..add(_bound);
-
-  @override
   TypeParameterElement? get declaredElement =>
       _name.staticElement as TypeParameterElement?;
 
@@ -10850,6 +10901,12 @@
   }
 
   @override
+  ChildEntities get _childEntities => super._childEntities
+    ..addNode('name', name)
+    ..addToken('extendsKeyword', extendsKeyword)
+    ..addNode('bound', bound);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitTypeParameter(this);
 
   @override
@@ -10886,18 +10943,18 @@
   Token get beginToken => leftBracket;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(leftBracket)
-    ..addAll(_typeParameters)
-    ..add(rightBracket);
-
-  @override
   Token get endToken => rightBracket;
 
   @override
   NodeListImpl<TypeParameter> get typeParameters => _typeParameters;
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('leftBracket', leftBracket)
+    ..addNodeList('typeParameters', typeParameters)
+    ..addToken('rightBracket', rightBracket);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitTypeParameterList(this);
 
   @override
@@ -11031,12 +11088,6 @@
   }
 
   @override
-  Iterable<SyntacticEntity> get childEntities => super._childEntities
-    ..add(_name)
-    ..add(equals)
-    ..add(_initializer);
-
-  @override
   VariableElement? get declaredElement =>
       _name.staticElement as VariableElement?;
 
@@ -11099,6 +11150,12 @@
   }
 
   @override
+  ChildEntities get _childEntities => super._childEntities
+    ..addNode('name', name)
+    ..addToken('equals', equals)
+    ..addNode('initializer', initializer);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitVariableDeclaration(this);
 
   @override
@@ -11156,13 +11213,6 @@
   }
 
   @override
-  // TODO(paulberry): include commas.
-  Iterable<SyntacticEntity> get childEntities => super._childEntities
-    ..add(keyword)
-    ..add(_type)
-    ..addAll(_variables);
-
-  @override
   Token get endToken => _variables.endToken!;
 
   @override
@@ -11192,6 +11242,13 @@
   NodeListImpl<VariableDeclaration> get variables => _variables;
 
   @override
+  // TODO(paulberry): include commas.
+  ChildEntities get _childEntities => super._childEntities
+    ..addToken('keyword', keyword)
+    ..addNode('type', type)
+    ..addNodeList('variables', variables);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) =>
       visitor.visitVariableDeclarationList(this);
 
@@ -11226,11 +11283,6 @@
   Token get beginToken => _variableList.beginToken;
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(_variableList)
-    ..add(semicolon);
-
-  @override
   Token get endToken => semicolon;
 
   @override
@@ -11241,6 +11293,11 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addNode('variables', variables)
+    ..addToken('semicolon', semicolon);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) =>
       visitor.visitVariableDeclarationStatement(this);
 
@@ -11291,14 +11348,6 @@
   }
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(whileKeyword)
-    ..add(leftParenthesis)
-    ..add(_condition)
-    ..add(rightParenthesis)
-    ..add(_body);
-
-  @override
   ExpressionImpl get condition => _condition;
 
   set condition(Expression expression) {
@@ -11309,6 +11358,14 @@
   Token get endToken => _body.endToken;
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('whileKeyword', whileKeyword)
+    ..addToken('leftParenthesis', leftParenthesis)
+    ..addNode('condition', condition)
+    ..addToken('rightParenthesis', rightParenthesis)
+    ..addNode('body', body);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitWhileStatement(this);
 
   @override
@@ -11339,12 +11396,6 @@
   Token get beginToken => withKeyword;
 
   @override
-  // TODO(paulberry): add commas.
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(withKeyword)
-    ..addAll(_mixinTypes);
-
-  @override
   Token get endToken => _mixinTypes.endToken!;
 
   @override
@@ -11355,6 +11406,12 @@
   NodeListImpl<NamedType> get mixinTypes2 => _mixinTypes;
 
   @override
+  // TODO(paulberry): add commas.
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('withKeyword', withKeyword)
+    ..addNodeList('mixinTypes', mixinTypes);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitWithClause(this);
 
   @override
@@ -11396,13 +11453,6 @@
   }
 
   @override
-  Iterable<SyntacticEntity> get childEntities => ChildEntities()
-    ..add(yieldKeyword)
-    ..add(star)
-    ..add(_expression)
-    ..add(semicolon);
-
-  @override
   Token get endToken {
     return semicolon;
   }
@@ -11415,6 +11465,13 @@
   }
 
   @override
+  ChildEntities get _childEntities => ChildEntities()
+    ..addToken('yieldKeyword', yieldKeyword)
+    ..addToken('star', star)
+    ..addNode('expression', expression)
+    ..addToken('semicolon', semicolon);
+
+  @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitYieldStatement(this);
 
   @override
diff --git a/pkg/analyzer/lib/src/error/required_parameters_verifier.dart b/pkg/analyzer/lib/src/error/required_parameters_verifier.dart
index c5d9146..0e553d3 100644
--- a/pkg/analyzer/lib/src/error/required_parameters_verifier.dart
+++ b/pkg/analyzer/lib/src/error/required_parameters_verifier.dart
@@ -20,9 +20,9 @@
   @override
   void visitEnumConstantDeclaration(EnumConstantDeclaration node) {
     _check(
-      node.constructorElement?.parameters,
-      node.arguments?.argumentList.arguments ?? <Expression>[],
-      node.name,
+      parameters: node.constructorElement?.parameters,
+      arguments: node.arguments?.argumentList.arguments ?? <Expression>[],
+      errorNode: node.name,
     );
   }
 
@@ -31,9 +31,9 @@
     var type = node.staticInvokeType;
     if (type is FunctionType) {
       _check(
-        type.parameters,
-        node.argumentList.arguments,
-        node,
+        parameters: type.parameters,
+        arguments: node.argumentList.arguments,
+        errorNode: node,
       );
     }
   }
@@ -41,9 +41,9 @@
   @override
   void visitInstanceCreationExpression(InstanceCreationExpression node) {
     _check(
-      node.constructorName.staticElement?.parameters,
-      node.argumentList.arguments,
-      node.constructorName,
+      parameters: node.constructorName.staticElement?.parameters,
+      arguments: node.argumentList.arguments,
+      errorNode: node.constructorName,
     );
   }
 
@@ -52,16 +52,19 @@
     if (node.methodName.name == FunctionElement.CALL_METHOD_NAME) {
       var targetType = node.realTarget?.staticType;
       if (targetType is FunctionType) {
-        _check(targetType.parameters, node.argumentList.arguments,
-            node.argumentList);
+        _check(
+          parameters: targetType.parameters,
+          arguments: node.argumentList.arguments,
+          errorNode: node.argumentList,
+        );
         return;
       }
     }
 
     _check(
-      _executableElement(node.methodName.staticElement)?.parameters,
-      node.argumentList.arguments,
-      node.methodName,
+      parameters: _executableElement(node.methodName.staticElement)?.parameters,
+      arguments: node.argumentList.arguments,
+      errorNode: node.methodName,
     );
   }
 
@@ -69,26 +72,31 @@
   void visitRedirectingConstructorInvocation(
       RedirectingConstructorInvocation node) {
     _check(
-      _executableElement(node.staticElement)?.parameters,
-      node.argumentList.arguments,
-      node,
+      parameters: _executableElement(node.staticElement)?.parameters,
+      arguments: node.argumentList.arguments,
+      errorNode: node,
     );
   }
 
   @override
-  void visitSuperConstructorInvocation(SuperConstructorInvocation node) {
+  void visitSuperConstructorInvocation(
+    SuperConstructorInvocation node, {
+    ConstructorElement? enclosingConstructor,
+  }) {
     _check(
-      _executableElement(node.staticElement)?.parameters,
-      node.argumentList.arguments,
-      node,
+      parameters: _executableElement(node.staticElement)?.parameters,
+      enclosingConstructor: enclosingConstructor,
+      arguments: node.argumentList.arguments,
+      errorNode: node,
     );
   }
 
-  void _check(
-    List<ParameterElement>? parameters,
-    List<Expression> arguments,
-    AstNode node,
-  ) {
+  void _check({
+    required List<ParameterElement>? parameters,
+    ConstructorElement? enclosingConstructor,
+    required List<Expression> arguments,
+    required AstNode errorNode,
+  }) {
     if (parameters == null) {
       return;
     }
@@ -96,10 +104,11 @@
     for (ParameterElement parameter in parameters) {
       if (parameter.isRequiredNamed) {
         String parameterName = parameter.name;
-        if (!_containsNamedExpression(arguments, parameterName)) {
+        if (!_containsNamedExpression(
+            enclosingConstructor, arguments, parameterName)) {
           _errorReporter.reportErrorForNode(
             CompileTimeErrorCode.MISSING_REQUIRED_ARGUMENT,
-            node,
+            errorNode,
             [parameterName],
           );
         }
@@ -108,18 +117,19 @@
         var annotation = _requiredAnnotation(parameter);
         if (annotation != null) {
           String parameterName = parameter.name;
-          if (!_containsNamedExpression(arguments, parameterName)) {
+          if (!_containsNamedExpression(
+              enclosingConstructor, arguments, parameterName)) {
             var reason = annotation.reason;
             if (reason != null) {
               _errorReporter.reportErrorForNode(
                 HintCode.MISSING_REQUIRED_PARAM_WITH_DETAILS,
-                node,
+                errorNode,
                 [parameterName, reason],
               );
             } else {
               _errorReporter.reportErrorForNode(
                 HintCode.MISSING_REQUIRED_PARAM,
-                node,
+                errorNode,
                 [parameterName],
               );
             }
@@ -130,6 +140,7 @@
   }
 
   static bool _containsNamedExpression(
+    ConstructorElement? enclosingConstructor,
     List<Expression> arguments,
     String name,
   ) {
@@ -141,6 +152,12 @@
         }
       }
     }
+
+    if (enclosingConstructor != null) {
+      return enclosingConstructor.parameters.any((e) =>
+          e is SuperFormalParameterElement && e.isNamed && e.name == name);
+    }
+
     return false;
   }
 
diff --git a/pkg/analyzer/lib/src/generated/error_verifier.dart b/pkg/analyzer/lib/src/generated/error_verifier.dart
index 83d50a2..f516e46 100644
--- a/pkg/analyzer/lib/src/generated/error_verifier.dart
+++ b/pkg/analyzer/lib/src/generated/error_verifier.dart
@@ -1159,7 +1159,10 @@
 
   @override
   void visitSuperConstructorInvocation(SuperConstructorInvocation node) {
-    _requiredParametersVerifier.visitSuperConstructorInvocation(node);
+    _requiredParametersVerifier.visitSuperConstructorInvocation(
+      node,
+      enclosingConstructor: _enclosingExecutable.element.ifTypeOrNull(),
+    );
     _isInConstructorInitializer = true;
     try {
       super.visitSuperConstructorInvocation(node);
@@ -5280,3 +5283,11 @@
     }
   }
 }
+
+extension on Object? {
+  /// If the target is [T], return it, otherwise `null`.
+  T? ifTypeOrNull<T>() {
+    final self = this;
+    return self is T ? self : null;
+  }
+}
diff --git a/pkg/analyzer/test/src/diagnostics/getter_not_subtype_setter_types_test.dart b/pkg/analyzer/test/src/diagnostics/getter_not_subtype_setter_types_test.dart
index ac4c1f3..f20aedb 100644
--- a/pkg/analyzer/test/src/diagnostics/getter_not_subtype_setter_types_test.dart
+++ b/pkg/analyzer/test/src/diagnostics/getter_not_subtype_setter_types_test.dart
@@ -235,19 +235,51 @@
     ]);
   }
 
-  test_enum_instance() async {
+  test_enum_instance_mixinGetter_mixinSetter() async {
     await assertErrorsInCode('''
-enum E {
-  v;
+mixin M1 {
   num get foo => 0;
+}
+
+mixin M2 {
   set foo(int v) {}
 }
+
+enum E with M1, M2 {
+  v
+}
 ''', [
-      error(CompileTimeErrorCode.GETTER_NOT_SUBTYPE_SETTER_TYPES, 24, 3),
+      error(CompileTimeErrorCode.GETTER_NOT_SUBTYPE_SETTER_TYPES, 73, 1),
     ]);
   }
 
-  test_enum_instance_field() async {
+  test_enum_instance_mixinGetter_thisSetter() async {
+    await assertErrorsInCode('''
+mixin M {
+  num get foo => 0;
+}
+
+enum E with M {
+  v;
+  set foo(int v) {}
+}
+''', [
+      error(CompileTimeErrorCode.GETTER_NOT_SUBTYPE_SETTER_TYPES, 60, 3),
+    ]);
+  }
+
+  test_enum_instance_superGetter_thisSetter_index() async {
+    await assertErrorsInCode('''
+enum E {
+  v;
+  set index(String _) {}
+}
+''', [
+      error(CompileTimeErrorCode.GETTER_NOT_SUBTYPE_SETTER_TYPES, 20, 5),
+    ]);
+  }
+
+  test_enum_instance_thisField_thisSetter() async {
     await assertErrorsInCode('''
 enum E {
   v;
@@ -259,6 +291,18 @@
     ]);
   }
 
+  test_enum_instance_thisGetter_thisSetter() async {
+    await assertErrorsInCode('''
+enum E {
+  v;
+  num get foo => 0;
+  set foo(int v) {}
+}
+''', [
+      error(CompileTimeErrorCode.GETTER_NOT_SUBTYPE_SETTER_TYPES, 24, 3),
+    ]);
+  }
+
   test_enum_static() async {
     await assertErrorsInCode('''
 enum E {
diff --git a/pkg/analyzer/test/src/diagnostics/missing_required_param_test.dart b/pkg/analyzer/test/src/diagnostics/missing_required_param_test.dart
index c70450c..e066e13 100644
--- a/pkg/analyzer/test/src/diagnostics/missing_required_param_test.dart
+++ b/pkg/analyzer/test/src/diagnostics/missing_required_param_test.dart
@@ -101,6 +101,18 @@
     ]);
   }
 
+  test_constructor_superFormalParameter() async {
+    await assertNoErrorsInCode(r'''
+class A {
+  A({required int a});
+}
+
+class B extends A {
+  B({required super.a}) : super();
+}
+''');
+  }
+
   test_enumConstant_withArguments() async {
     await assertErrorsInCode(r'''
 enum E {
diff --git a/runtime/vm/compiler/asm_intrinsifier_arm.cc b/runtime/vm/compiler/asm_intrinsifier_arm.cc
index 7702c24..3b6b707 100644
--- a/runtime/vm/compiler/asm_intrinsifier_arm.cc
+++ b/runtime/vm/compiler/asm_intrinsifier_arm.cc
@@ -26,41 +26,6 @@
 
 #define __ assembler->
 
-// Allocate a GrowableObjectArray:: using the backing array specified.
-// On stack: type argument (+1), data (+0).
-void AsmIntrinsifier::GrowableArray_Allocate(Assembler* assembler,
-                                             Label* normal_ir_body) {
-  // The newly allocated object is returned in R0.
-  const intptr_t kTypeArgumentsOffset = 1 * target::kWordSize;
-  const intptr_t kArrayOffset = 0 * target::kWordSize;
-
-  // Try allocating in new space.
-  const Class& cls = GrowableObjectArrayClass();
-  __ TryAllocate(cls, normal_ir_body, Assembler::kFarJump, R0, R1);
-
-  // Store backing array object in growable array object.
-  __ ldr(R1, Address(SP, kArrayOffset));  // Data argument.
-  // R0 is new, no barrier needed.
-  __ StoreIntoObjectNoBarrier(
-      R0, FieldAddress(R0, target::GrowableObjectArray::data_offset()), R1);
-
-  // R0: new growable array object start as a tagged pointer.
-  // Store the type argument field in the growable array object.
-  __ ldr(R1, Address(SP, kTypeArgumentsOffset));  // Type argument.
-  __ StoreIntoObjectNoBarrier(
-      R0,
-      FieldAddress(R0, target::GrowableObjectArray::type_arguments_offset()),
-      R1);
-
-  // Set the length field in the growable array object to 0.
-  __ LoadImmediate(R1, 0);
-  __ StoreIntoObjectNoBarrier(
-      R0, FieldAddress(R0, target::GrowableObjectArray::length_offset()), R1);
-  __ Ret();  // Returns the newly allocated object in R0.
-
-  __ Bind(normal_ir_body);
-}
-
 // Loads args from stack into R0 and R1
 // Tests if they are smis, jumps to label not_smi if not.
 static void TestBothArgumentsSmis(Assembler* assembler, Label* not_smi) {
diff --git a/runtime/vm/compiler/asm_intrinsifier_arm64.cc b/runtime/vm/compiler/asm_intrinsifier_arm64.cc
index 429099c..eb5cacc 100644
--- a/runtime/vm/compiler/asm_intrinsifier_arm64.cc
+++ b/runtime/vm/compiler/asm_intrinsifier_arm64.cc
@@ -26,40 +26,6 @@
 
 #define __ assembler->
 
-// Allocate a GrowableObjectArray:: using the backing array specified.
-// On stack: type argument (+1), data (+0).
-void AsmIntrinsifier::GrowableArray_Allocate(Assembler* assembler,
-                                             Label* normal_ir_body) {
-  // The newly allocated object is returned in R0.
-  const intptr_t kTypeArgumentsOffset = 1 * target::kWordSize;
-  const intptr_t kArrayOffset = 0 * target::kWordSize;
-
-  // Try allocating in new space.
-  const Class& cls = GrowableObjectArrayClass();
-  __ TryAllocate(cls, normal_ir_body, Assembler::kFarJump, R0, R1);
-
-  // Store backing array object in growable array object.
-  __ ldr(R1, Address(SP, kArrayOffset));  // Data argument.
-  // R0 is new, no barrier needed.
-  __ StoreCompressedIntoObjectNoBarrier(
-      R0, FieldAddress(R0, target::GrowableObjectArray::data_offset()), R1);
-
-  // R0: new growable array object start as a tagged pointer.
-  // Store the type argument field in the growable array object.
-  __ ldr(R1, Address(SP, kTypeArgumentsOffset));  // Type argument.
-  __ StoreCompressedIntoObjectNoBarrier(
-      R0,
-      FieldAddress(R0, target::GrowableObjectArray::type_arguments_offset()),
-      R1);
-
-  // Set the length field in the growable array object to 0.
-  __ StoreCompressedIntoObjectNoBarrier(
-      R0, FieldAddress(R0, target::GrowableObjectArray::length_offset()), ZR);
-  __ ret();  // Returns the newly allocated object in R0.
-
-  __ Bind(normal_ir_body);
-}
-
 // Loads args from stack into R0 and R1
 // Tests if they are smis, jumps to label not_smi if not.
 static void TestBothArgumentsSmis(Assembler* assembler, Label* not_smi) {
diff --git a/runtime/vm/compiler/asm_intrinsifier_ia32.cc b/runtime/vm/compiler/asm_intrinsifier_ia32.cc
index 7d264aa7..815a2e0 100644
--- a/runtime/vm/compiler/asm_intrinsifier_ia32.cc
+++ b/runtime/vm/compiler/asm_intrinsifier_ia32.cc
@@ -31,42 +31,6 @@
 
 #define __ assembler->
 
-// Allocate a GrowableObjectArray:: using the backing array specified.
-// On stack: type argument (+2), data (+1), return-address (+0).
-void AsmIntrinsifier::GrowableArray_Allocate(Assembler* assembler,
-                                             Label* normal_ir_body) {
-  // This snippet of inlined code uses the following registers:
-  // EAX, EBX
-  // and the newly allocated object is returned in EAX.
-  const intptr_t kTypeArgumentsOffset = 2 * target::kWordSize;
-
-  const intptr_t kArrayOffset = 1 * target::kWordSize;
-
-  // Try allocating in new space.
-  const Class& cls = GrowableObjectArrayClass();
-  __ TryAllocate(cls, normal_ir_body, Assembler::kNearJump, EAX, EBX);
-
-  // Store backing array object in growable array object.
-  __ movl(EBX, Address(ESP, kArrayOffset));  // data argument.
-  // EAX is new, no barrier needed.
-  __ StoreIntoObjectNoBarrier(
-      EAX, FieldAddress(EAX, target::GrowableObjectArray::data_offset()), EBX);
-
-  // EAX: new growable array object start as a tagged pointer.
-  // Store the type argument field in the growable array object.
-  __ movl(EBX, Address(ESP, kTypeArgumentsOffset));  // type argument.
-  __ StoreIntoObjectNoBarrier(
-      EAX,
-      FieldAddress(EAX, target::GrowableObjectArray::type_arguments_offset()),
-      EBX);
-
-  __ ZeroInitSmiField(
-      FieldAddress(EAX, target::GrowableObjectArray::length_offset()));
-  __ ret();  // returns the newly allocated object in EAX.
-
-  __ Bind(normal_ir_body);
-}
-
 // Tests if two top most arguments are smis, jumps to label not_smi if not.
 // Topmost argument is in EAX.
 static void TestBothArgumentsSmis(Assembler* assembler, Label* not_smi) {
diff --git a/runtime/vm/compiler/asm_intrinsifier_riscv.cc b/runtime/vm/compiler/asm_intrinsifier_riscv.cc
index 0e2da82..db03989 100644
--- a/runtime/vm/compiler/asm_intrinsifier_riscv.cc
+++ b/runtime/vm/compiler/asm_intrinsifier_riscv.cc
@@ -26,40 +26,6 @@
 
 #define __ assembler->
 
-// Allocate a GrowableObjectArray:: using the backing array specified.
-// On stack: type argument (+1), data (+0).
-void AsmIntrinsifier::GrowableArray_Allocate(Assembler* assembler,
-                                             Label* normal_ir_body) {
-  // The newly allocated object is returned in R0.
-  const intptr_t kTypeArgumentsOffset = 1 * target::kWordSize;
-  const intptr_t kArrayOffset = 0 * target::kWordSize;
-
-  // Try allocating in new space.
-  const Class& cls = GrowableObjectArrayClass();
-  __ TryAllocate(cls, normal_ir_body, Assembler::kFarJump, A0, A1);
-
-  // Store backing array object in growable array object.
-  __ lx(A1, Address(SP, kArrayOffset));  // Data argument.
-  // R0 is new, no barrier needed.
-  __ StoreCompressedIntoObjectNoBarrier(
-      A0, FieldAddress(A0, target::GrowableObjectArray::data_offset()), A1);
-
-  // R0: new growable array object start as a tagged pointer.
-  // Store the type argument field in the growable array object.
-  __ lx(A1, Address(SP, kTypeArgumentsOffset));  // Type argument.
-  __ StoreCompressedIntoObjectNoBarrier(
-      A0,
-      FieldAddress(A0, target::GrowableObjectArray::type_arguments_offset()),
-      A1);
-
-  // Set the length field in the growable array object to 0.
-  __ StoreCompressedIntoObjectNoBarrier(
-      A0, FieldAddress(A0, target::GrowableObjectArray::length_offset()), ZR);
-  __ ret();  // Returns the newly allocated object in A0.
-
-  __ Bind(normal_ir_body);
-}
-
 // Loads args from stack into A0 and A1
 // Tests if they are smis, jumps to label not_smi if not.
 static void TestBothArgumentsSmis(Assembler* assembler, Label* not_smi) {
diff --git a/runtime/vm/compiler/asm_intrinsifier_x64.cc b/runtime/vm/compiler/asm_intrinsifier_x64.cc
index 48bfe54..0a47313 100644
--- a/runtime/vm/compiler/asm_intrinsifier_x64.cc
+++ b/runtime/vm/compiler/asm_intrinsifier_x64.cc
@@ -26,42 +26,6 @@
 
 #define __ assembler->
 
-// Allocate a GrowableObjectArray using the backing array specified.
-// On stack: type argument (+2), data (+1), return-address (+0).
-void AsmIntrinsifier::GrowableArray_Allocate(Assembler* assembler,
-                                             Label* normal_ir_body) {
-  // This snippet of inlined code uses the following registers:
-  // RAX, RCX, R13
-  // and the newly allocated object is returned in RAX.
-  const intptr_t kTypeArgumentsOffset = 2 * target::kWordSize;
-  const intptr_t kArrayOffset = 1 * target::kWordSize;
-
-  // Try allocating in new space.
-  const Class& cls = GrowableObjectArrayClass();
-  __ TryAllocate(cls, normal_ir_body, Assembler::kFarJump, RAX, R13);
-
-  // Store backing array object in growable array object.
-  __ movq(RCX, Address(RSP, kArrayOffset));  // data argument.
-  // RAX is new, no barrier needed.
-  __ StoreCompressedIntoObjectNoBarrier(
-      RAX, FieldAddress(RAX, target::GrowableObjectArray::data_offset()), RCX);
-
-  // RAX: new growable array object start as a tagged pointer.
-  // Store the type argument field in the growable array object.
-  __ movq(RCX, Address(RSP, kTypeArgumentsOffset));  // type argument.
-  __ StoreCompressedIntoObjectNoBarrier(
-      RAX,
-      FieldAddress(RAX, target::GrowableObjectArray::type_arguments_offset()),
-      RCX);
-
-  // Set the length field in the growable array object to 0.
-  __ ZeroInitCompressedSmiField(
-      FieldAddress(RAX, target::GrowableObjectArray::length_offset()));
-  __ ret();  // returns the newly allocated object in RAX.
-
-  __ Bind(normal_ir_body);
-}
-
 // Tests if two top most arguments are smis, jumps to label not_smi if not.
 // Topmost argument is in RAX.
 static void TestBothArgumentsSmis(Assembler* assembler, Label* not_smi) {
diff --git a/runtime/vm/compiler/frontend/kernel_to_il.cc b/runtime/vm/compiler/frontend/kernel_to_il.cc
index 0311465..6fd0db2 100644
--- a/runtime/vm/compiler/frontend/kernel_to_il.cc
+++ b/runtime/vm/compiler/frontend/kernel_to_il.cc
@@ -877,6 +877,7 @@
     case MethodRecognizer::kByteDataViewTypedData:
     case MethodRecognizer::kTypedDataViewTypedData:
     case MethodRecognizer::kClassIDgetID:
+    case MethodRecognizer::kGrowableArrayAllocateWithData:
     case MethodRecognizer::kGrowableArrayCapacity:
     case MethodRecognizer::kListFactory:
     case MethodRecognizer::kObjectArrayAllocate:
@@ -1124,6 +1125,26 @@
       body += LoadLocal(parsed_function_->RawParameterVariable(0));
       body += LoadClassId();
       break;
+    case MethodRecognizer::kGrowableArrayAllocateWithData: {
+      ASSERT(function.IsFactory());
+      ASSERT_EQUAL(function.NumParameters(), 2);
+      const Class& cls =
+          Class::ZoneHandle(Z, compiler::GrowableObjectArrayClass().ptr());
+      body += LoadLocal(parsed_function_->RawParameterVariable(0));
+      body += AllocateObject(TokenPosition::kNoSource, cls, 1);
+      LocalVariable* object = MakeTemporary();
+      body += LoadLocal(object);
+      body += LoadLocal(parsed_function_->RawParameterVariable(1));
+      body += StoreNativeField(Slot::GrowableObjectArray_data(),
+                               StoreInstanceFieldInstr::Kind::kInitializing,
+                               kNoStoreBarrier);
+      body += LoadLocal(object);
+      body += IntConstant(0);
+      body += StoreNativeField(Slot::GrowableObjectArray_length(),
+                               StoreInstanceFieldInstr::Kind::kInitializing,
+                               kNoStoreBarrier);
+      break;
+    }
     case MethodRecognizer::kGrowableArrayCapacity:
       ASSERT_EQUAL(function.NumParameters(), 1);
       body += LoadLocal(parsed_function_->RawParameterVariable(0));
diff --git a/runtime/vm/compiler/recognized_methods_list.h b/runtime/vm/compiler/recognized_methods_list.h
index 6c67e4c..5d42253 100644
--- a/runtime/vm/compiler/recognized_methods_list.h
+++ b/runtime/vm/compiler/recognized_methods_list.h
@@ -18,6 +18,7 @@
   V(List, ., ListFactory, 0xbc820cf9)                                          \
   V(_List, ., ObjectArrayAllocate, 0xd693eee6)                                 \
   V(_List, []=, ObjectArraySetIndexed, 0xd7b48abc)                             \
+  V(_GrowableList, ._withData, GrowableArrayAllocateWithData, 0xa32d060b)      \
   V(_GrowableList, []=, GrowableArraySetIndexed, 0xd7b48abc)                   \
   V(_TypedList, _getInt8, ByteArrayBaseGetInt8, 0x1623dc34)                    \
   V(_TypedList, _getUint8, ByteArrayBaseGetUint8, 0x177ffe2a)                  \
@@ -274,7 +275,6 @@
   V(_Double, get:isNegative, Double_getIsNegative, 0xd4715091)                 \
   V(_Double, _mulFromInteger, Double_mulFromInteger, 0x0a50d2cf)               \
   V(_Double, .fromInteger, DoubleFromInteger, 0x7d0fd999)                      \
-  V(_GrowableList, ._withData, GrowableArray_Allocate, 0xa32d060b)             \
   V(_RegExp, _ExecuteMatch, RegExp_ExecuteMatch, 0x9911d549)                   \
   V(_RegExp, _ExecuteMatchSticky, RegExp_ExecuteMatchSticky, 0x91dd880f)       \
   V(Object, ==, ObjectEquals, 0x46587030)                                      \
diff --git a/runtime/vm/compiler/stub_code_compiler.cc b/runtime/vm/compiler/stub_code_compiler.cc
index b70a40e..199ae30 100644
--- a/runtime/vm/compiler/stub_code_compiler.cc
+++ b/runtime/vm/compiler/stub_code_compiler.cc
@@ -899,6 +899,43 @@
   __ Ret();
 }
 
+// Generates allocation stub for _GrowableList class.
+// This stub exists solely for performance reasons: default allocation
+// stub is slower as it doesn't use specialized inline allocation.
+void StubCodeCompiler::GenerateAllocateGrowableArrayStub(Assembler* assembler) {
+#if defined(TARGET_ARCH_IA32)
+  // This stub is not used on IA32 because IA32 version of
+  // StubCodeCompiler::GenerateAllocationStubForClass uses inline
+  // allocation. Also, AllocateObjectSlow stub is not generated on IA32.
+  __ Breakpoint();
+#else
+  const intptr_t instance_size = target::RoundedAllocationSize(
+      target::GrowableObjectArray::InstanceSize());
+
+  if (!FLAG_use_slow_path && FLAG_inline_alloc) {
+    Label slow_case;
+    __ Comment("Inline allocation of GrowableList");
+    __ TryAllocateObject(kGrowableObjectArrayCid, instance_size, &slow_case,
+                         Assembler::kNearJump, AllocateObjectABI::kResultReg,
+                         /*temp_reg=*/AllocateObjectABI::kTagsReg);
+    __ StoreIntoObjectNoBarrier(
+        AllocateObjectABI::kResultReg,
+        FieldAddress(AllocateObjectABI::kResultReg,
+                     target::GrowableObjectArray::type_arguments_offset()),
+        AllocateObjectABI::kTypeArgumentsReg);
+
+    __ Ret();
+    __ Bind(&slow_case);
+  }
+
+  const uword tags = target::MakeTagWordForNewSpaceObject(
+      kGrowableObjectArrayCid, instance_size);
+  __ LoadImmediate(AllocateObjectABI::kTagsReg, tags);
+  __ Jump(
+      Address(THR, target::Thread::allocate_object_slow_entry_point_offset()));
+#endif  // defined(TARGET_ARCH_IA32)
+}
+
 // The UnhandledException class lives in the VM isolate, so it cannot cache
 // an allocation stub for itself. Instead, we cache it in the stub code list.
 void StubCodeCompiler::GenerateAllocateUnhandledExceptionStub(
diff --git a/runtime/vm/compiler/stub_code_compiler_arm.cc b/runtime/vm/compiler/stub_code_compiler_arm.cc
index 5174ca8..a37565a 100644
--- a/runtime/vm/compiler/stub_code_compiler_arm.cc
+++ b/runtime/vm/compiler/stub_code_compiler_arm.cc
@@ -1728,7 +1728,7 @@
 
 static void GenerateAllocateObjectHelper(Assembler* assembler,
                                          bool is_cls_parameterized) {
-  const Register kTagsReg = R2;
+  const Register kTagsReg = AllocateObjectABI::kTagsReg;
 
   {
     Label slow_case;
@@ -1845,7 +1845,6 @@
 
 void StubCodeCompiler::GenerateAllocateObjectSlowStub(Assembler* assembler) {
   const Register kClsReg = R1;
-  const Register kTagsReg = R2;
 
   if (!FLAG_precompiled_mode) {
     __ ldr(CODE_REG,
@@ -1856,7 +1855,8 @@
   // calling into the runtime.
   __ EnterStubFrame();
 
-  __ ExtractClassIdFromTags(AllocateObjectABI::kResultReg, kTagsReg);
+  __ ExtractClassIdFromTags(AllocateObjectABI::kResultReg,
+                            AllocateObjectABI::kTagsReg);
   __ LoadClassById(kClsReg, AllocateObjectABI::kResultReg);
 
   __ LoadObject(AllocateObjectABI::kResultReg, NullObject());
@@ -1903,7 +1903,7 @@
   const uword tags =
       target::MakeTagWordForNewSpaceObject(cls_id, instance_size);
 
-  const Register kTagsReg = R2;
+  const Register kTagsReg = AllocateObjectABI::kTagsReg;
 
   __ LoadImmediate(kTagsReg, tags);
 
diff --git a/runtime/vm/compiler/stub_code_compiler_arm64.cc b/runtime/vm/compiler/stub_code_compiler_arm64.cc
index e5fe61f..6dc4dbe 100644
--- a/runtime/vm/compiler/stub_code_compiler_arm64.cc
+++ b/runtime/vm/compiler/stub_code_compiler_arm64.cc
@@ -1904,7 +1904,7 @@
 
 static void GenerateAllocateObjectHelper(Assembler* assembler,
                                          bool is_cls_parameterized) {
-  const Register kTagsReg = R2;
+  const Register kTagsReg = AllocateObjectABI::kTagsReg;
 
   {
     Label slow_case;
@@ -2014,20 +2014,19 @@
 }
 
 void StubCodeCompiler::GenerateAllocateObjectSlowStub(Assembler* assembler) {
-  const Register kTagsToClsIdReg = R2;
-
   if (!FLAG_precompiled_mode) {
     __ ldr(CODE_REG,
            Address(THR, target::Thread::call_to_runtime_stub_offset()));
   }
 
-  __ ExtractClassIdFromTags(kTagsToClsIdReg, kTagsToClsIdReg);
+  __ ExtractClassIdFromTags(AllocateObjectABI::kTagsReg,
+                            AllocateObjectABI::kTagsReg);
 
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   __ EnterStubFrame();
 
-  __ LoadClassById(R0, kTagsToClsIdReg);
+  __ LoadClassById(R0, AllocateObjectABI::kTagsReg);
   __ PushPair(R0, NULL_REG);  // Pushes result slot, then class object.
 
   // Should be Object::null() if class is non-parameterized.
@@ -2072,7 +2071,7 @@
       target::MakeTagWordForNewSpaceObject(cls_id, instance_size);
 
   // Note: Keep in sync with helper function.
-  const Register kTagsReg = R2;
+  const Register kTagsReg = AllocateObjectABI::kTagsReg;
 
   __ LoadImmediate(kTagsReg, tags);
 
diff --git a/runtime/vm/compiler/stub_code_compiler_riscv.cc b/runtime/vm/compiler/stub_code_compiler_riscv.cc
index c9f604b..14dd9f3 100644
--- a/runtime/vm/compiler/stub_code_compiler_riscv.cc
+++ b/runtime/vm/compiler/stub_code_compiler_riscv.cc
@@ -1831,7 +1831,7 @@
 
 static void GenerateAllocateObjectHelper(Assembler* assembler,
                                          bool is_cls_parameterized) {
-  const Register kTagsReg = T2;
+  const Register kTagsReg = AllocateObjectABI::kTagsReg;
 
   {
     Label slow_case;
@@ -1936,8 +1936,6 @@
 }
 
 void StubCodeCompiler::GenerateAllocateObjectSlowStub(Assembler* assembler) {
-  const Register kTagsToClsIdReg = T2;
-
   if (!FLAG_precompiled_mode) {
     __ lx(CODE_REG,
           Address(THR, target::Thread::call_to_runtime_stub_offset()));
@@ -1947,8 +1945,9 @@
   // calling into the runtime.
   __ EnterStubFrame();
 
-  __ ExtractClassIdFromTags(kTagsToClsIdReg, kTagsToClsIdReg);
-  __ LoadClassById(A0, kTagsToClsIdReg);
+  __ ExtractClassIdFromTags(AllocateObjectABI::kTagsReg,
+                            AllocateObjectABI::kTagsReg);
+  __ LoadClassById(A0, AllocateObjectABI::kTagsReg);
 
   __ subi(SP, SP, 3 * target::kWordSize);
   __ sx(ZR, Address(SP, 2 * target::kWordSize));  // Result slot.
@@ -1993,7 +1992,7 @@
       target::MakeTagWordForNewSpaceObject(cls_id, instance_size);
 
   // Note: Keep in sync with helper function.
-  const Register kTagsReg = T2;
+  const Register kTagsReg = AllocateObjectABI::kTagsReg;
   ASSERT(kTagsReg != AllocateObjectABI::kTypeArgumentsReg);
 
   __ LoadImmediate(kTagsReg, tags);
diff --git a/runtime/vm/compiler/stub_code_compiler_x64.cc b/runtime/vm/compiler/stub_code_compiler_x64.cc
index 5e3ba12..de42236 100644
--- a/runtime/vm/compiler/stub_code_compiler_x64.cc
+++ b/runtime/vm/compiler/stub_code_compiler_x64.cc
@@ -1938,7 +1938,7 @@
 static void GenerateAllocateObjectHelper(Assembler* assembler,
                                          bool is_cls_parameterized) {
   // Note: Keep in sync with calling function.
-  const Register kTagsReg = R8;
+  const Register kTagsReg = AllocateObjectABI::kTagsReg;
 
   {
     Label slow_case;
@@ -2049,14 +2049,13 @@
 }
 
 void StubCodeCompiler::GenerateAllocateObjectSlowStub(Assembler* assembler) {
-  const Register kTagsToClsIdReg = R8;
-
   if (!FLAG_precompiled_mode) {
     __ movq(CODE_REG,
             Address(THR, target::Thread::call_to_runtime_stub_offset()));
   }
 
-  __ ExtractClassIdFromTags(kTagsToClsIdReg, kTagsToClsIdReg);
+  __ ExtractClassIdFromTags(AllocateObjectABI::kTagsReg,
+                            AllocateObjectABI::kTagsReg);
 
   // Create a stub frame.
   // Ensure constant pool is allowed so we can e.g. load class object.
@@ -2067,7 +2066,7 @@
   __ pushq(AllocateObjectABI::kResultReg);
 
   // Push class of object to be allocated.
-  __ LoadClassById(AllocateObjectABI::kResultReg, kTagsToClsIdReg);
+  __ LoadClassById(AllocateObjectABI::kResultReg, AllocateObjectABI::kTagsReg);
   __ pushq(AllocateObjectABI::kResultReg);
 
   // Must be Object::null() if non-parameterized class.
@@ -2118,7 +2117,7 @@
   const uword tags =
       target::MakeTagWordForNewSpaceObject(cls_id, instance_size);
 
-  const Register kTagsReg = R8;
+  const Register kTagsReg = AllocateObjectABI::kTagsReg;
 
   __ movq(kTagsReg, Immediate(tags));
 
diff --git a/runtime/vm/constants_arm.h b/runtime/vm/constants_arm.h
index 94b214a..b7f2374 100644
--- a/runtime/vm/constants_arm.h
+++ b/runtime/vm/constants_arm.h
@@ -470,6 +470,7 @@
 struct AllocateObjectABI {
   static const Register kResultReg = R0;
   static const Register kTypeArgumentsReg = R3;
+  static const Register kTagsReg = R2;
 };
 
 // ABI for AllocateClosureStub.
diff --git a/runtime/vm/constants_arm64.h b/runtime/vm/constants_arm64.h
index 9e4213d..b2f4e6e 100644
--- a/runtime/vm/constants_arm64.h
+++ b/runtime/vm/constants_arm64.h
@@ -309,6 +309,7 @@
 struct AllocateObjectABI {
   static const Register kResultReg = R0;
   static const Register kTypeArgumentsReg = R1;
+  static const Register kTagsReg = R2;
 };
 
 // ABI for AllocateClosureStub.
diff --git a/runtime/vm/constants_ia32.h b/runtime/vm/constants_ia32.h
index bac9dd5..d06f97f 100644
--- a/runtime/vm/constants_ia32.h
+++ b/runtime/vm/constants_ia32.h
@@ -206,6 +206,7 @@
 struct AllocateObjectABI {
   static const Register kResultReg = EAX;
   static const Register kTypeArgumentsReg = EDX;
+  static const Register kTagsReg = kNoRegister;  // Not used.
 };
 
 // ABI for Allocate{Mint,Double,Float32x4,Float64x2}Stub.
diff --git a/runtime/vm/constants_riscv.h b/runtime/vm/constants_riscv.h
index d04317b..a03694c 100644
--- a/runtime/vm/constants_riscv.h
+++ b/runtime/vm/constants_riscv.h
@@ -326,6 +326,7 @@
 struct AllocateObjectABI {
   static constexpr Register kResultReg = A0;
   static constexpr Register kTypeArgumentsReg = T1;
+  static const Register kTagsReg = T2;
 };
 
 // ABI for AllocateClosureStub.
diff --git a/runtime/vm/constants_x64.h b/runtime/vm/constants_x64.h
index 2bc9444..aae0a4c 100644
--- a/runtime/vm/constants_x64.h
+++ b/runtime/vm/constants_x64.h
@@ -281,6 +281,7 @@
 struct AllocateObjectABI {
   static const Register kResultReg = RAX;
   static const Register kTypeArgumentsReg = RDX;
+  static const Register kTagsReg = R8;
 };
 
 // ABI for AllocateClosureStub.
diff --git a/runtime/vm/object_store.h b/runtime/vm/object_store.h
index b8eaf21..88d7a2e 100644
--- a/runtime/vm/object_store.h
+++ b/runtime/vm/object_store.h
@@ -208,6 +208,7 @@
   RW(Code, allocate_float64x2_array_stub)                                      \
   RW(Code, allocate_closure_stub)                                              \
   RW(Code, allocate_context_stub)                                              \
+  RW(Code, allocate_growable_array_stub)                                       \
   RW(Code, allocate_object_stub)                                               \
   RW(Code, allocate_object_parametrized_stub)                                  \
   RW(Code, allocate_unhandled_exception_stub)                                  \
@@ -284,6 +285,7 @@
   DO(allocate_float64x2_array_stub, AllocateFloat64x2Array)                    \
   DO(allocate_closure_stub, AllocateClosure)                                   \
   DO(allocate_context_stub, AllocateContext)                                   \
+  DO(allocate_growable_array_stub, AllocateGrowableArray)                      \
   DO(allocate_object_stub, AllocateObject)                                     \
   DO(allocate_object_parametrized_stub, AllocateObjectParameterized)           \
   DO(allocate_unhandled_exception_stub, AllocateUnhandledException)            \
diff --git a/runtime/vm/stack_trace.cc b/runtime/vm/stack_trace.cc
index 0ef8b4d..9b665c2 100644
--- a/runtime/vm/stack_trace.cc
+++ b/runtime/vm/stack_trace.cc
@@ -75,7 +75,6 @@
       controller_subscription_class(Class::Handle(zone)),
       buffering_stream_subscription_class(Class::Handle(zone)),
       stream_iterator_class(Class::Handle(zone)),
-      async_then_wrapper_(Function::Handle(zone)),
       future_result_or_listeners_field(Field::Handle(zone)),
       callback_field(Field::Handle(zone)),
       future_listener_state_field(Field::Handle(zone)),
@@ -112,9 +111,6 @@
   stream_iterator_class =
       async_lib.LookupClassAllowPrivate(Symbols::_StreamIterator());
   ASSERT(!stream_iterator_class.IsNull());
-  async_then_wrapper_ =
-      async_lib.LookupFunctionAllowPrivate(Symbols::AsyncThenWrapperHelper());
-  ASSERT(!async_then_wrapper_.IsNull());
 
   // Look up fields:
   // - async:
diff --git a/runtime/vm/stack_trace.h b/runtime/vm/stack_trace.h
index 6893a7f..566a0a8 100644
--- a/runtime/vm/stack_trace.h
+++ b/runtime/vm/stack_trace.h
@@ -82,7 +82,6 @@
   Class& controller_subscription_class;
   Class& buffering_stream_subscription_class;
   Class& stream_iterator_class;
-  Function& async_then_wrapper_;
 
   Field& future_result_or_listeners_field;
   Field& callback_field;
diff --git a/runtime/vm/stub_code.cc b/runtime/vm/stub_code.cc
index 6303447..be40522 100644
--- a/runtime/vm/stub_code.cc
+++ b/runtime/vm/stub_code.cc
@@ -172,6 +172,10 @@
   switch (cls.id()) {
     case kArrayCid:
       return object_store->allocate_array_stub();
+#if !defined(TARGET_ARCH_IA32)
+    case kGrowableObjectArrayCid:
+      return object_store->allocate_growable_array_stub();
+#endif  // !defined(TARGET_ARCH_IA32)
     case kContextCid:
       return object_store->allocate_context_stub();
     case kUnhandledExceptionCid:
diff --git a/runtime/vm/stub_code_list.h b/runtime/vm/stub_code_list.h
index 778e08c..3607cbc 100644
--- a/runtime/vm/stub_code_list.h
+++ b/runtime/vm/stub_code_list.h
@@ -52,6 +52,7 @@
   V(AllocateMintSharedWithoutFPURegs)                                          \
   V(AllocateClosure)                                                           \
   V(AllocateContext)                                                           \
+  V(AllocateGrowableArray)                                                     \
   V(AllocateObject)                                                            \
   V(AllocateObjectParameterized)                                               \
   V(AllocateObjectSlow)                                                        \
diff --git a/runtime/vm/symbols.h b/runtime/vm/symbols.h
index 707df3d..7784041 100644
--- a/runtime/vm/symbols.h
+++ b/runtime/vm/symbols.h
@@ -31,7 +31,6 @@
   V(AsyncStarMoveNextHelper, "_asyncStarMoveNextHelper")                       \
   V(AwaitContextVar, ":await_ctx_var")                                         \
   V(AwaitJumpVar, ":await_jump_var")                                           \
-  V(AsyncThenWrapperHelper, "_asyncThenWrapperHelper")                         \
   V(Bool, "bool")                                                              \
   V(BooleanExpression, "boolean expression")                                   \
   V(BoundsCheckForPartialInstantiation, "_boundsCheckForPartialInstantiation") \
diff --git a/sdk/lib/_internal/vm/lib/growable_array.dart b/sdk/lib/_internal/vm/lib/growable_array.dart
index c6d9e46..2c47725 100644
--- a/sdk/lib/_internal/vm/lib/growable_array.dart
+++ b/sdk/lib/_internal/vm/lib/growable_array.dart
@@ -222,7 +222,7 @@
     return list;
   }
 
-  @pragma("vm:recognized", "asm-intrinsic")
+  @pragma("vm:recognized", "other")
   @pragma("vm:exact-result-type",
       <dynamic>[_GrowableList, "result-type-uses-passed-type-arguments"])
   @pragma("vm:external-name", "GrowableList_allocate")
diff --git a/tools/VERSION b/tools/VERSION
index e933701..aeefac4 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 17
 PATCH 0
-PRERELEASE 124
+PRERELEASE 125
 PRERELEASE_PATCH 0
\ No newline at end of file