diff --git a/pkg/analysis_server/lib/src/services/correction/fix/data_driven/element_matcher.dart b/pkg/analysis_server/lib/src/services/correction/fix/data_driven/element_matcher.dart
index 252ccf6..acceb63 100644
--- a/pkg/analysis_server/lib/src/services/correction/fix/data_driven/element_matcher.dart
+++ b/pkg/analysis_server/lib/src/services/correction/fix/data_driven/element_matcher.dart
@@ -144,12 +144,26 @@
   _MatcherBuilder(this.importedUris);
 
   void buildMatchersForNode(AstNode? node) {
-    var components = _componentsForNode(node);
-    if (components == null) {
-      return;
+    if (node is ArgumentList) {
+      _buildFromArgumentList(node);
+    } else if (node is BinaryExpression) {
+      _buildFromBinaryExpression(node);
+    } else if (node is ConstructorName) {
+      _buildFromConstructorName(node);
+    } else if (node is Literal) {
+      var parent = node.parent;
+      if (parent is ArgumentList) {
+        _buildFromArgumentList(parent);
+      }
+    } else if (node is NamedType) {
+      _buildFromNamedType(node);
+    } else if (node is PrefixedIdentifier) {
+      _buildFromPrefixedIdentifier(node);
+    } else if (node is SimpleIdentifier) {
+      _buildFromSimpleIdentifier(node);
+    } else if (node is TypeArgumentList) {
+      _buildFromTypeArgumentList(node);
     }
-    var kinds = _kindsForNode(node) ?? [];
-    _addMatcher(components: components, kinds: kinds);
   }
 
   void _addMatcher(
@@ -158,58 +172,311 @@
         importedUris: importedUris, components: components, kinds: kinds));
   }
 
-  /// Return the components of the path of the element associated with the given
-  /// [node]. The components are ordered from the most local to the most global.
-  /// For example, for a constructor this would be the name of the constructor
-  /// followed by the name of the class in which the constructor is declared
-  /// (with an empty string for the unnamed constructor).
-  static List<String>? _componentsForNode(AstNode? node) {
-    if (node is SimpleIdentifier) {
-      var parent = node.parent;
-      if (parent is Label && parent.parent is NamedExpression) {
-        // The parent of the named expression is an argument list. Because we
-        // don't represent parameters as elements, the element we need to match
-        // against is the invocation containing those arguments.
-        return _componentsFromParent(parent.parent!.parent!);
-      } else if (parent is NamedType && parent.parent is ConstructorName) {
-        return ['', node.name];
-      } else if (parent is MethodDeclaration && node == parent.name) {
-        return [node.name];
-      } else if ((parent is MethodInvocation &&
-              node == parent.methodName &&
-              !_isPrefix(parent.target)) ||
-          (parent is PrefixedIdentifier &&
-              node == parent.identifier &&
-              !_isPrefix(parent.prefix)) ||
-          (parent is PropertyAccess &&
-              node == parent.propertyName &&
-              !_isPrefix(parent.target))) {
-        return _componentsFromParent(node);
+  /// Build a matcher for the element being invoked.
+  void _buildFromArgumentList(ArgumentList node) {
+    var parent = node.parent;
+    if (parent is Annotation) {
+      _addMatcher(
+        components: [parent.constructorName?.name ?? '', parent.name.name],
+        kinds: [ElementKind.constructorKind],
+      );
+      // } else if (parent is ExtensionOverride) {
+      //   // TODO(brianwilkerson) Determine whether this branch can be reached.
+      //   _buildFromExtensionOverride(parent);
+    } else if (parent is FunctionExpressionInvocation) {
+      _buildFromFunctionExpressionInvocation(parent);
+    } else if (parent is InstanceCreationExpression) {
+      _buildFromInstanceCreationExpression(parent);
+    } else if (parent is MethodInvocation) {
+      _buildFromMethodInvocation(parent);
+    } else if (parent is RedirectingConstructorInvocation) {
+      var grandparent = parent.parent;
+      if (grandparent is ConstructorDeclaration) {
+        _addMatcher(
+          components: [
+            parent.constructorName?.name ?? '',
+            grandparent.returnType.name
+          ],
+          kinds: [ElementKind.constructorKind],
+        );
       }
-      return _componentsFromIdentifier(node);
-    } else if (node is PrefixedIdentifier) {
-      var parent = node.parent;
-      if (parent is NamedType && parent.parent is ConstructorName) {
-        return ['', node.identifier.name];
+    } else if (parent is SuperConstructorInvocation) {
+      var superclassName = parent.staticElement?.enclosingElement.name;
+      if (superclassName != null) {
+        _addMatcher(
+          components: [parent.constructorName?.name ?? '', superclassName],
+          kinds: [ElementKind.constructorKind],
+        );
       }
-      return [node.identifier.name];
-    } else if (node is ConstructorName) {
-      var constructorName = node.name;
-      if (constructorName != null) {
-        return [constructorName.name];
-      }
-    } else if (node is NamedType) {
-      return [node.name.name];
-    } else if (node is TypeArgumentList) {
-      return _componentsFromParent(node);
-    } else if (node is ArgumentList) {
-      return _componentsFromParent(node);
     }
-    var parent = node?.parent;
-    if (parent is ArgumentList) {
-      return _componentsFromParent(parent);
+  }
+
+  /// Build a matcher for the operator being invoked.
+  void _buildFromBinaryExpression(BinaryExpression node) {
+    // TODO(brianwilkerson) Implement this method in order to support changes to
+    //  operators.
+  }
+
+  /// Build a matcher for the constructor being referenced.
+  void _buildFromConstructorName(ConstructorName node) {
+    // TODO(brianwilkerson) Use the static element, if there is one, in order to
+    //  get a more exact matcher.
+    // TODO(brianwilkerson) Use 'new' for the name of the unnamed constructor.
+    var constructorName = node.name?.name ?? ''; // ?? 'new';
+    var className = node.type2.name.simpleName;
+    _addMatcher(
+      components: [constructorName, className],
+      kinds: const [ElementKind.constructorKind],
+    );
+    _addMatcher(
+      components: [className],
+      kinds: const [ElementKind.classKind],
+    );
+  }
+
+  /// Build a matcher for the extension.
+  void _buildFromExtensionOverride(ExtensionOverride node) {
+    _addMatcher(
+      components: [node.extensionName.name],
+      kinds: [ElementKind.extensionKind],
+    );
+  }
+
+  /// Build a matcher for the function being invoked.
+  void _buildFromFunctionExpressionInvocation(
+      FunctionExpressionInvocation node) {
+    // TODO(brianwilkerson) This case was missed in the original implementation
+    //  and there are no tests for it at this point, but it ought to be supported.
+  }
+
+  /// Build a matcher for the constructor being invoked.
+  void _buildFromInstanceCreationExpression(InstanceCreationExpression node) {
+    _buildFromConstructorName(node.constructorName);
+  }
+
+  /// Build a matcher for the method being declared.
+  void _buildFromMethodDeclaration(MethodDeclaration node) {
+    _addMatcher(
+      components: [node.name.name],
+      kinds: [ElementKind.methodKind],
+    );
+  }
+
+  /// Build a matcher for the method being invoked.
+  void _buildFromMethodInvocation(MethodInvocation node) {
+    // TODO(brianwilkerson) Use the static element, if there is one, in order to
+    //  get a more exact matcher.
+    // var element = node.methodName.staticElement;
+    // if (element != null) {
+    //   return _buildFromElement(element);
+    // }
+    var methodName = node.methodName;
+    var targetName = _nameOfTarget(node.realTarget);
+    if (targetName != null) {
+      // If there is a target, and we know the type of the target, then we know
+      // that a method is being invoked.
+      _addMatcher(
+        components: [methodName.name, targetName],
+        kinds: [
+          ElementKind.constructorKind,
+          ElementKind.methodKind,
+        ],
+      );
+    } else if (node.realTarget != null) {
+      // If there is a target, but we don't know the type of the target, then
+      // the target type might be undefined and this might have been either a
+      // method invocation, an invocation of a function returned by a getter, or
+      // a constructor invocation prior to the type having been deleted.
+      _addMatcher(
+        components: _componentsFromIdentifier(methodName),
+        kinds: [
+          ElementKind.constructorKind,
+          ElementKind.getterKind,
+          ElementKind.methodKind,
+        ],
+      );
+    } else {
+      // If there is no target, then this might have been either a method
+      // invocation, a function invocation (of either a function or a function
+      // returned from a getter), a constructor invocation, or an extension
+      // override. If it's a constructor, then the change might have been to the
+      // class rather than an individual constructor.
+      _addMatcher(
+        components: _componentsFromIdentifier(methodName),
+        kinds: [
+          ElementKind.classKind,
+          ElementKind.constructorKind,
+          ElementKind.extensionKind,
+          ElementKind.functionKind,
+          ElementKind.getterKind,
+          ElementKind.methodKind,
+        ],
+      );
     }
-    return null;
+  }
+
+  /// Build a matcher for the type.
+  void _buildFromNamedType(NamedType node) {
+    var parent = node.parent;
+    if (parent is ConstructorName) {
+      return _buildFromConstructorName(parent);
+    }
+    // TODO(brianwilkerson) Use the static element, if there is one, in order to
+    //  get a more exact matcher.
+    _addMatcher(
+      components: [node.name.simpleName],
+      kinds: const [
+        ElementKind.classKind,
+        ElementKind.enumKind,
+        ElementKind.mixinKind,
+        ElementKind.typedefKind
+      ],
+    );
+    // TODO(brianwilkerson) Determine whether we can ever get here as a result
+    //  of having a removed unnamed constructor.
+    // _addMatcher(
+    //   components: ['', node.name.name],
+    //   kinds: const [ElementKind.constructorKind],
+    // );
+  }
+
+  /// Build a matcher for the element represented by the prefixed identifier.
+  void _buildFromPrefixedIdentifier(PrefixedIdentifier node) {
+    var parent = node.parent;
+    if (parent is NamedType) {
+      return _buildFromNamedType(parent);
+    }
+    // TODO(brianwilkerson) Use the static element, if there is one, in order to
+    //  get a more exact matcher.
+    var prefix = node.prefix;
+    if (prefix.staticElement is PrefixElement) {
+      var parent = node.parent;
+      if ((parent is NamedType && parent.parent is! ConstructorName) ||
+          (parent is PropertyAccess && parent.target == node)) {
+        _addMatcher(components: [
+          node.identifier.name
+        ], kinds: const [
+          ElementKind.classKind,
+          ElementKind.enumKind,
+          ElementKind.extensionKind,
+          ElementKind.mixinKind,
+          ElementKind.typedefKind
+        ]);
+      }
+      _addMatcher(components: [
+        node.identifier.name
+      ], kinds: const [
+        // If the old class has been removed then this might have been a
+        // constructor invocation.
+        ElementKind.constructorKind,
+        ElementKind.functionKind, // tear-off
+        ElementKind.getterKind,
+        ElementKind.setterKind,
+        ElementKind.variableKind
+      ]);
+    }
+    // It looks like we're accessing a member, so try to figure out the
+    // name of the type defining the member.
+    var targetType = node.prefix.staticType;
+    if (targetType is InterfaceType) {
+      _addMatcher(
+        components: [node.identifier.name, targetType.element.name],
+        kinds: const [
+          ElementKind.constantKind,
+          ElementKind.fieldKind,
+          ElementKind.functionKind, // tear-off
+          ElementKind.getterKind,
+          ElementKind.methodKind, // tear-off
+          ElementKind.setterKind
+        ],
+      );
+    }
+    // It looks like we're accessing a member, but we don't know what kind of
+    // member, so we include all of the member kinds.
+    var container = node.prefix.staticElement;
+    if (container is ClassElement) {
+      _addMatcher(
+        components: [node.identifier.name, container.name],
+        kinds: const [
+          ElementKind.constantKind,
+          ElementKind.fieldKind,
+          ElementKind.functionKind, // tear-off
+          ElementKind.getterKind,
+          ElementKind.methodKind, // tear-off
+          ElementKind.setterKind
+        ],
+      );
+    }
+  }
+
+  /// Build a matcher for the property being accessed.
+  void _buildFromPropertyAccess(PropertyAccess node) {
+    // TODO(brianwilkerson) Use the static element, if there is one, in order to
+    //  get a more exact matcher.
+    var propertyName = node.propertyName;
+    var targetName = _nameOfTarget(node.realTarget);
+    List<String> components;
+    if (targetName != null) {
+      components = [propertyName.name, targetName];
+    } else {
+      components = _componentsFromIdentifier(propertyName);
+    }
+    _addMatcher(
+      components: components,
+      kinds: const [
+        ElementKind.constantKind,
+        ElementKind.fieldKind,
+        ElementKind.functionKind, // tear-off, prefixed
+        ElementKind.getterKind,
+        ElementKind.methodKind, // tear-off, prefixed
+        ElementKind.setterKind
+      ],
+    );
+  }
+
+  /// Build a matcher for the element referenced by the identifier.
+  void _buildFromSimpleIdentifier(SimpleIdentifier node) {
+    // TODO(brianwilkerson) Use the static element, if there is one, in order to
+    //  get a more exact matcher.
+    var parent = node.parent;
+    if (parent is Label && parent.parent is NamedExpression) {
+      // The parent of the named expression is an argument list. Because we
+      // don't represent parameters as elements, the element we need to match
+      // against is the invocation containing those arguments.
+      _buildFromArgumentList(parent.parent!.parent as ArgumentList);
+    } else if (parent is NamedType) {
+      _buildFromNamedType(parent);
+    } else if (parent is MethodDeclaration && node == parent.name) {
+      _buildFromMethodDeclaration(parent);
+    } else if (parent is MethodInvocation &&
+        node == parent.methodName &&
+        !_isPrefix(parent.target)) {
+      _buildFromMethodInvocation(parent);
+    } else if (parent is PrefixedIdentifier && node == parent.identifier) {
+      _buildFromPrefixedIdentifier(parent);
+    } else if (parent is PropertyAccess &&
+        node == parent.propertyName &&
+        !_isPrefix(parent.target)) {
+      _buildFromPropertyAccess(parent);
+    } else {
+      // TODO(brianwilkerson) See whether the list of kinds can be specified.
+      _addMatcher(components: [node.name], kinds: []);
+    }
+  }
+
+  /// Build a matcher for the element with which the type arguments are
+  /// associated.
+  void _buildFromTypeArgumentList(TypeArgumentList node) {
+    var parent = node.parent;
+    if (parent is ExtensionOverride) {
+      _buildFromExtensionOverride(parent);
+    } else if (parent is FunctionExpressionInvocation) {
+      _buildFromFunctionExpressionInvocation(parent);
+    } else if (parent is InstanceCreationExpression) {
+      _buildFromInstanceCreationExpression(parent);
+    } else if (parent is MethodInvocation) {
+      _buildFromMethodInvocation(parent);
+    }
   }
 
   /// Return the components associated with the [identifier] when there is no
@@ -236,162 +503,11 @@
     return [identifier.name];
   }
 
-  /// Return the components for the element associated with the given [node] by
-  /// looking at the parent of the [node].
-  static List<String>? _componentsFromParent(AstNode node) {
-    var parent = node.parent;
-    if (parent is ArgumentList) {
-      parent = parent.parent;
-    }
-    if (parent is Annotation) {
-      return [parent.constructorName?.name ?? '', parent.name.name];
-    } else if (parent is ExtensionOverride) {
-      return [parent.extensionName.name];
-    } else if (parent is InstanceCreationExpression) {
-      var constructorName = parent.constructorName;
-      return [
-        constructorName.name?.name ?? '',
-        constructorName.type2.name.name
-      ];
-    } else if (parent is MethodInvocation) {
-      var methodName = parent.methodName;
-      var targetName = _nameOfTarget(parent.realTarget);
-      if (targetName != null) {
-        return [methodName.name, targetName];
-      }
-      return _componentsFromIdentifier(methodName);
-    } else if (parent is PrefixedIdentifier) {
-      var identifier = parent.identifier;
-      var targetName = _nameOfTarget(parent.prefix);
-      if (targetName != null) {
-        return [identifier.name, targetName];
-      }
-      return _componentsFromIdentifier(identifier);
-    } else if (parent is PropertyAccess) {
-      var propertyName = parent.propertyName;
-      var targetName = _nameOfTarget(parent.realTarget);
-      if (targetName != null) {
-        return [propertyName.name, targetName];
-      }
-      return _componentsFromIdentifier(propertyName);
-    } else if (parent is RedirectingConstructorInvocation) {
-      var ancestor = parent.parent;
-      if (ancestor is ConstructorDeclaration) {
-        return [parent.constructorName?.name ?? '', ancestor.returnType.name];
-      }
-    } else if (parent is SuperConstructorInvocation) {
-      var ancestor = parent.parent;
-      if (ancestor is ConstructorDeclaration) {
-        return [parent.constructorName?.name ?? '', ancestor.returnType.name];
-      }
-    }
-    return null;
-  }
-
   /// Return `true` if the [node] is a prefix
   static bool _isPrefix(AstNode? node) {
     return node is SimpleIdentifier && node.staticElement is PrefixElement;
   }
 
-  /// Return the kinds of elements that could reasonably be referenced at the
-  /// location of the [node]. If [child] is not `null` then the [node] is a
-  /// parent of the [child].
-  static List<ElementKind>? _kindsForNode(AstNode? node, {AstNode? child}) {
-    if (node is ConstructorName) {
-      return const [ElementKind.constructorKind];
-    } else if (node is ExtensionOverride) {
-      return const [ElementKind.extensionKind];
-    } else if (node is InstanceCreationExpression) {
-      return const [ElementKind.constructorKind];
-    } else if (node is Label) {
-      var argumentList = node.parent?.parent;
-      return _kindsForNode(argumentList?.parent, child: argumentList);
-    } else if (node is MethodInvocation) {
-      assert(child != null);
-      if (node.target == child) {
-        return const [
-          ElementKind.classKind,
-          ElementKind.enumKind,
-          ElementKind.mixinKind
-        ];
-      }
-      var realTarget = node.realTarget;
-      if (realTarget != null && !_isPrefix(realTarget)) {
-        return const [ElementKind.constructorKind, ElementKind.methodKind];
-      }
-      return const [
-        ElementKind.classKind,
-        ElementKind.extensionKind,
-        ElementKind.functionKind,
-        ElementKind.methodKind
-      ];
-    } else if (node is NamedType) {
-      var parent = node.parent;
-      if (parent is ConstructorName && parent.name == null) {
-        return const [ElementKind.classKind, ElementKind.constructorKind];
-      }
-      return const [
-        ElementKind.classKind,
-//        ElementKind.constructorKind,
-        ElementKind.enumKind,
-        ElementKind.mixinKind,
-        ElementKind.typedefKind
-      ];
-    } else if (node is PrefixedIdentifier) {
-      var prefix = node.prefix;
-      if (prefix == child) {
-        return const [
-          ElementKind.classKind,
-          ElementKind.enumKind,
-          ElementKind.extensionKind,
-          ElementKind.mixinKind,
-          ElementKind.typedefKind
-        ];
-      } else if (prefix.staticElement is PrefixElement) {
-        var parent = node.parent;
-        if ((parent is NamedType && parent.parent is! ConstructorName) ||
-            (parent is PropertyAccess && parent.target == node)) {
-          return const [
-            ElementKind.classKind,
-            ElementKind.enumKind,
-            ElementKind.extensionKind,
-            ElementKind.mixinKind,
-            ElementKind.typedefKind
-          ];
-        }
-        return const [
-          // If the old class has been removed then this might have been a
-          // constructor invocation.
-          ElementKind.constructorKind,
-          ElementKind.functionKind, // tear-off
-          ElementKind.getterKind,
-          ElementKind.setterKind,
-          ElementKind.variableKind
-        ];
-      }
-      return const [
-        ElementKind.constantKind,
-        ElementKind.fieldKind,
-        ElementKind.functionKind, // tear-off
-        ElementKind.getterKind,
-        ElementKind.methodKind, // tear-off
-        ElementKind.setterKind
-      ];
-    } else if (node is PropertyAccess) {
-      return const [
-        ElementKind.constantKind,
-        ElementKind.fieldKind,
-        ElementKind.functionKind, // tear-off, prefixed
-        ElementKind.getterKind,
-        ElementKind.methodKind, // tear-off, prefixed
-        ElementKind.setterKind
-      ];
-    } else if (node is SimpleIdentifier) {
-      return _kindsForNode(node.parent, child: node);
-    }
-    return null;
-  }
-
   /// Return the name of the class associated with the given [target].
   static String? _nameOfTarget(Expression? target) {
     if (target is SimpleIdentifier) {
@@ -416,3 +532,14 @@
     return null;
   }
 }
+
+extension on Identifier {
+  String get simpleName {
+    var identifier = this;
+    if (identifier is PrefixedIdentifier) {
+      // The prefix isn't part of the name of the class.
+      return identifier.identifier.name;
+    }
+    return name;
+  }
+}
diff --git a/pkg/analysis_server/test/analysis/get_hover_test.dart b/pkg/analysis_server/test/analysis/get_hover_test.dart
index 980ec6e..6d19ce9 100644
--- a/pkg/analysis_server/test/analysis/get_hover_test.dart
+++ b/pkg/analysis_server/test/analysis/get_hover_test.dart
@@ -933,6 +933,54 @@
     expect(hover.elementKind, 'parameter');
   }
 
+  Future<void>
+      test_parameter_ofConstructor_optionalPositional_super_defaultValue_explicit() async {
+    addTestFile('''
+class A {
+  A([int a = 1]);
+}
+class B extends A {
+  B([super.a = 2]);
+}
+''');
+    var hover = await prepareHover('a = 2]');
+    // element
+    expect(hover.elementDescription, '[int a = 2]');
+    expect(hover.elementKind, 'parameter');
+  }
+
+  Future<void>
+      test_parameter_ofConstructor_optionalPositional_super_defaultValue_inherited() async {
+    addTestFile('''
+class A {
+  A([int a = 1]);
+}
+class B extends A {
+  B([super.a]);
+}
+''');
+    var hover = await prepareHover('a]');
+    // element
+    expect(hover.elementDescription, '[int a = 1]');
+    expect(hover.elementKind, 'parameter');
+  }
+
+  Future<void>
+      test_parameter_ofConstructor_optionalPositional_super_defaultValue_inherited2() async {
+    addTestFile('''
+class A {
+  A([num a = 1.2]);
+}
+class B extends A{
+  B([int super.a]);
+}
+''');
+    var hover = await prepareHover('a]');
+    // element
+    expect(hover.elementDescription, '[int a]');
+    expect(hover.elementKind, 'parameter');
+  }
+
   Future<void> test_parameter_reference_fieldFormal() async {
     addTestFile('''
 class A {
diff --git a/pkg/analysis_server/test/src/services/correction/fix/data_driven/add_type_parameter_test.dart b/pkg/analysis_server/test/src/services/correction/fix/data_driven/add_type_parameter_test.dart
index dff9c05..6839e8f 100644
--- a/pkg/analysis_server/test/src/services/correction/fix/data_driven/add_type_parameter_test.dart
+++ b/pkg/analysis_server/test/src/services/correction/fix/data_driven/add_type_parameter_test.dart
@@ -33,7 +33,7 @@
   void C() {}
 }
 ''');
-    setPackageData(_add(0, components: ['C', 'C']));
+    setPackageData(_add(0, components: ['C']));
     await resolveTestCode('''
 import '$importUri';
 
diff --git a/pkg/analysis_server/test/src/services/correction/fix/data_driven/element_matcher_test.dart b/pkg/analysis_server/test/src/services/correction/fix/data_driven/element_matcher_test.dart
index 716cd55..e7a0f03 100644
--- a/pkg/analysis_server/test/src/services/correction/fix/data_driven/element_matcher_test.dart
+++ b/pkg/analysis_server/test/src/services/correction/fix/data_driven/element_matcher_test.dart
@@ -54,8 +54,10 @@
   /// The kinds that are expected where an invocation is allowed.
   static List<ElementKind> invocationKinds = [
     ElementKind.classKind,
+    ElementKind.constructorKind,
     ElementKind.extensionKind,
     ElementKind.functionKind,
+    ElementKind.getterKind,
     ElementKind.methodKind,
   ];
 
@@ -109,7 +111,7 @@
   }
 }
 ''');
-    _assertMatcher('g;', expectedComponents: ['g', 'C']);
+    _assertMatcher('g;', expectedComponents: ['g']);
   }
 
   Future<void> test_getter_withoutTarget_unresolved() async {
@@ -149,17 +151,7 @@
   s.length;
 }
 ''');
-    // TODO(brianwilkerson) Several of these kinds don't seem to be appropriate,
-    //  so we might want to narrow down the list.
-    _assertMatcher('s', expectedComponents: [
-      's'
-    ], expectedKinds: [
-      ElementKind.classKind,
-      ElementKind.enumKind,
-      ElementKind.extensionKind,
-      ElementKind.mixinKind,
-      ElementKind.typedefKind,
-    ]);
+    _assertMatcher('s', expectedComponents: ['s'], expectedKinds: []);
   }
 
   Future<void> test_method_withoutTarget_resolved() async {
@@ -217,7 +209,7 @@
   }
 }
 ''');
-    _assertMatcher('s =', expectedComponents: ['s', 'C']);
+    _assertMatcher('s =', expectedComponents: ['s']);
   }
 
   Future<void> test_setter_withoutTarget_unresolved() async {
diff --git a/pkg/analyzer/lib/src/dart/element/element.dart b/pkg/analyzer/lib/src/dart/element/element.dart
index 6101710..b1d7dd6 100644
--- a/pkg/analyzer/lib/src/dart/element/element.dart
+++ b/pkg/analyzer/lib/src/dart/element/element.dart
@@ -130,6 +130,16 @@
   }
 
   @override
+  ConstructorElement? get unnamedConstructor {
+    for (ConstructorElement element in constructors) {
+      if (element.name.isEmpty) {
+        return element;
+      }
+    }
+    return null;
+  }
+
+  @override
   T? accept<T>(ElementVisitor<T> visitor) => visitor.visitClassElement(this);
 
   @override
@@ -778,16 +788,6 @@
   }
 
   @override
-  ConstructorElement? get unnamedConstructor {
-    for (ConstructorElement element in constructors) {
-      if (element.name.isEmpty) {
-        return element;
-      }
-    }
-    return null;
-  }
-
-  @override
   void appendTo(ElementDisplayStringBuilder builder) {
     builder.writeClassElement(this);
   }
@@ -1584,23 +1584,19 @@
 
   @override
   String? get defaultValueCode {
-    return constantInitializer?.toSource();
-  }
-
-  @override
-  bool get hasDefaultValue {
-    if (super.hasDefaultValue) {
-      return true;
-    }
-    return computeConstantValue() != null;
-  }
-
-  @override
-  DartObject? computeConstantValue() {
+    final constantInitializer = this.constantInitializer;
     if (constantInitializer != null) {
-      return super.computeConstantValue();
+      return constantInitializer.toSource();
     }
 
+    if (_superConstructorParameterDefaultValue != null) {
+      return superConstructorParameter?.defaultValueCode;
+    }
+
+    return null;
+  }
+
+  DartObject? get _superConstructorParameterDefaultValue {
     var superDefault = superConstructorParameter?.computeConstantValue();
     var superDefaultType = superDefault?.type;
     var libraryElement = library;
@@ -1612,6 +1608,15 @@
 
     return null;
   }
+
+  @override
+  DartObject? computeConstantValue() {
+    if (constantInitializer != null) {
+      return super.computeConstantValue();
+    }
+
+    return _superConstructorParameterDefaultValue;
+  }
 }
 
 /// The synthetic element representing the declaration of the type `dynamic`.
@@ -2768,9 +2773,6 @@
   }
 
   @override
-  ConstructorElement? get unnamedConstructor => null;
-
-  @override
   void appendTo(ElementDisplayStringBuilder builder) {
     builder.writeEnumElement(this);
   }
diff --git a/pkg/analyzer/lib/src/dart/element/extensions.dart b/pkg/analyzer/lib/src/dart/element/extensions.dart
index ad00f5e..decbd59 100644
--- a/pkg/analyzer/lib/src/dart/element/extensions.dart
+++ b/pkg/analyzer/lib/src/dart/element/extensions.dart
@@ -103,6 +103,12 @@
   }
 }
 
+extension ExecutableElementExtension on ExecutableElement {
+  bool get isEnumConstructor {
+    return this is ConstructorElement && enclosingElement is EnumElementImpl;
+  }
+}
+
 extension ParameterElementExtensions on ParameterElement {
   /// Return [ParameterElement] with the specified properties replaced.
   ParameterElement copyWith({
diff --git a/pkg/analyzer/lib/src/dart/resolver/resolution_visitor.dart b/pkg/analyzer/lib/src/dart/resolver/resolution_visitor.dart
index 0f6da71..7145bd0 100644
--- a/pkg/analyzer/lib/src/dart/resolver/resolution_visitor.dart
+++ b/pkg/analyzer/lib/src/dart/resolver/resolution_visitor.dart
@@ -394,6 +394,15 @@
 
     node.metadata.accept(this);
     _setElementAnnotations(node.metadata, element.metadata);
+
+    var arguments = node.arguments;
+    if (arguments != null) {
+      _withElementWalker(null, () {
+        _withElementHolder(ElementHolder(element), () {
+          arguments.accept(this);
+        });
+      });
+    }
   }
 
   @override
diff --git a/pkg/analyzer/lib/src/generated/declaration_resolver.dart b/pkg/analyzer/lib/src/generated/declaration_resolver.dart
index 650fde4..19b68b9 100644
--- a/pkg/analyzer/lib/src/generated/declaration_resolver.dart
+++ b/pkg/analyzer/lib/src/generated/declaration_resolver.dart
@@ -4,6 +4,7 @@
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/element.dart';
+import 'package:analyzer/src/dart/element/extensions.dart';
 
 /// Keeps track of the set of non-synthetic child elements of an element,
 /// yielding them one at a time in response to "get" method calls.
@@ -67,7 +68,9 @@
   ElementWalker.forExecutable(ExecutableElement element)
       : element = element,
         _functions = const <ExecutableElement>[],
-        _parameters = element.parameters,
+        _parameters = element.isEnumConstructor
+            ? element.parameters.skip(2).toList()
+            : element.parameters,
         _typeParameters = element.typeParameters;
 
   /// Creates an [ElementWalker] which walks the child elements of an extension
diff --git a/pkg/analyzer/lib/src/generated/resolver.dart b/pkg/analyzer/lib/src/generated/resolver.dart
index 1e84b07..d7284f2 100644
--- a/pkg/analyzer/lib/src/generated/resolver.dart
+++ b/pkg/analyzer/lib/src/generated/resolver.dart
@@ -1539,9 +1539,39 @@
 
   @override
   void visitEnumConstantDeclaration(EnumConstantDeclaration node) {
+    node as EnumConstantDeclarationImpl;
+
+    node.documentationComment?.accept(this);
     node.metadata.accept(this);
     checkUnreachableNode(node);
-    node.visitChildren(this);
+
+    var element = node.declaredElement as ConstFieldElementImpl;
+    var initializer = element.constantInitializer;
+    if (initializer is InstanceCreationExpression) {
+      var constructor = initializer.constructorName.staticElement;
+      node.constructorElement = constructor;
+      var arguments = node.arguments;
+      if (arguments != null) {
+        var argumentList = arguments.argumentList;
+        if (constructor != null) {
+          InferenceContext.setType(argumentList, constructor.type);
+          argumentList.correspondingStaticParameters =
+              ResolverVisitor.resolveArgumentsToParameters(
+            argumentList: argumentList,
+            parameters: constructor.parameters.skip(2).toList(),
+          );
+          for (var argument in argumentList.arguments) {
+            var parameter = argument.staticParameterElement;
+            if (parameter != null) {
+              InferenceContext.setType(argument, parameter.type);
+            }
+            argument.accept(this);
+          }
+        }
+        arguments.typeArguments?.accept(this);
+      }
+    }
+
     elementResolver.visitEnumConstantDeclaration(node);
   }
 
@@ -3039,6 +3069,7 @@
   void visitEnumMembersInScope(EnumDeclaration node) {
     node.documentationComment?.accept(this);
     node.constants.accept(this);
+    node.members.accept(this);
   }
 
   @override
diff --git a/pkg/analyzer/lib/src/summary2/element_builder.dart b/pkg/analyzer/lib/src/summary2/element_builder.dart
index 8bad34e..e201c44 100644
--- a/pkg/analyzer/lib/src/summary2/element_builder.dart
+++ b/pkg/analyzer/lib/src/summary2/element_builder.dart
@@ -268,6 +268,7 @@
             name: astFactory.simpleIdentifier(
               StringToken(TokenType.STRING, element.name, -1),
             ),
+            typeArguments: constant.arguments?.typeArguments,
           ),
           Tokens.period(),
           astFactory.simpleIdentifier(
diff --git a/pkg/analyzer/lib/src/summary2/informative_data.dart b/pkg/analyzer/lib/src/summary2/informative_data.dart
index 1ae0a1c..c7f58df 100644
--- a/pkg/analyzer/lib/src/summary2/informative_data.dart
+++ b/pkg/analyzer/lib/src/summary2/informative_data.dart
@@ -1299,7 +1299,7 @@
       _writeDocumentationComment(node);
       _writeOffsets(
         metadata: node.metadata,
-        enumConstantArguments: node.arguments?.argumentList,
+        enumConstantArguments: node.arguments,
       );
     }
 
@@ -1433,7 +1433,7 @@
     NodeList<ConstructorInitializer>? constructorInitializers,
     NodeList<EnumConstantDeclaration>? enumConstants,
     TypeAnnotation? aliasedType,
-    ArgumentList? enumConstantArguments,
+    EnumConstantArguments? enumConstantArguments,
   }) {
     var collector = _OffsetsCollector();
 
@@ -1485,7 +1485,8 @@
       addTypeParameters(aliasedType.typeParameters);
       addFormalParameters(aliasedType.parameters);
     }
-    enumConstantArguments?.arguments.accept(collector);
+    enumConstantArguments?.typeArguments?.accept(collector);
+    enumConstantArguments?.argumentList.arguments.accept(collector);
     sink.writeUint30List(collector.offsets);
   }
 
@@ -1662,14 +1663,7 @@
 
   void applyToConstantInitializer(Element element) {
     if (element is ConstFieldElementImpl && element.isEnumConstant) {
-      var initializer = element.constantInitializer;
-      if (initializer is InstanceCreationExpression) {
-        var arguments = initializer.argumentList.arguments;
-        // Skip synthetic `index` and `name` arguments.
-        for (var argument in arguments.skip(2)) {
-          argument.accept(this);
-        }
-      }
+      _applyToEnumConstantInitializer(element);
     } else if (element is ConstVariableElement) {
       element.constantInitializer?.accept(this);
     }
@@ -1744,6 +1738,18 @@
       element.nameOffset = identifier.offset;
     }
   }
+
+  void _applyToEnumConstantInitializer(ConstFieldElementImpl element) {
+    var initializer = element.constantInitializer;
+    if (initializer is InstanceCreationExpression) {
+      initializer.constructorName.type2.typeArguments?.accept(this);
+      var arguments = initializer.argumentList.arguments;
+      // Skip synthetic `index` and `name` arguments.
+      for (var argument in arguments.skip(2)) {
+        argument.accept(this);
+      }
+    }
+  }
 }
 
 abstract class _OffsetsAstVisitor extends RecursiveAstVisitor<void> {
diff --git a/pkg/analyzer/lib/src/test_utilities/find_element.dart b/pkg/analyzer/lib/src/test_utilities/find_element.dart
index 25dfccc..7159665 100644
--- a/pkg/analyzer/lib/src/test_utilities/find_element.dart
+++ b/pkg/analyzer/lib/src/test_utilities/find_element.dart
@@ -355,21 +355,34 @@
 
   ConstructorElement constructor(String name, {String? of}) {
     assert(name != '');
+
     ConstructorElement? result;
-    for (var class_ in unitElement.classes) {
-      if (of == null || class_.name == of) {
-        for (var constructor in class_.constructors) {
-          if (constructor.name == name) {
-            if (result != null) {
-              throw StateError('Not unique: $name');
-            }
-            result = constructor;
+
+    void findIn(List<ConstructorElement> constructors) {
+      for (var constructor in constructors) {
+        if (constructor.name == name) {
+          if (result != null) {
+            throw StateError('Not unique: $name');
           }
+          result = constructor;
         }
       }
     }
+
+    for (var class_ in unitElement.classes) {
+      if (of == null || class_.name == of) {
+        findIn(class_.constructors);
+      }
+    }
+
+    for (var enum_ in unitElement.enums) {
+      if (of == null || enum_.name == of) {
+        findIn(enum_.constructors);
+      }
+    }
+
     if (result != null) {
-      return result;
+      return result!;
     }
     throw StateError('Not found: $name');
   }
diff --git a/pkg/analyzer/test/src/dart/resolution/enum_test.dart b/pkg/analyzer/test/src/dart/resolution/enum_test.dart
index 1e71eb6..ca17f7c 100644
--- a/pkg/analyzer/test/src/dart/resolution/enum_test.dart
+++ b/pkg/analyzer/test/src/dart/resolution/enum_test.dart
@@ -15,9 +15,212 @@
 
 @reflectiveTest
 class EnumDriverResolutionTest extends PubPackageResolutionTest {
-  test_field() async {
+  test_constructor_argumentList_contextType() async {
+    await assertNoErrorsInCode(r'''
+enum E {
+  v([]);
+  E(List<int> a);
+}
+''');
+
+    assertType(findNode.listLiteral('[]'), 'List<int>');
+  }
+
+  test_constructor_argumentList_namedType() async {
+    await assertNoErrorsInCode(r'''
+enum E {
+  v(<void Function(double)>[]);
+  E(Object a);
+}
+''');
+
+    assertNamedType(
+      findNode.namedType('double'),
+      doubleElement,
+      'double',
+    );
+
+    assertType(
+      findNode.genericFunctionType('void Function'),
+      'void Function(double)',
+    );
+  }
+
+  test_constructor_generic_noTypeArguments_named() async {
     await assertNoErrorsInCode(r'''
 enum E<T> {
+  v.named(42);
+  E.named(T a);
+}
+''');
+
+    assertEnumConstant(
+      findNode.enumConstantDeclaration('v'),
+      element: findElement.field('v'),
+      constructorElement: elementMatcher(
+        findElement.constructor('named'),
+        substitution: {'T': 'int'},
+      ),
+    );
+
+    assertParameterElement(
+      findNode.integerLiteral('42'),
+      elementMatcher(
+        findElement.parameter('a'),
+        substitution: {'T': 'int'},
+      ),
+    );
+  }
+
+  test_constructor_generic_noTypeArguments_unnamed() async {
+    await assertNoErrorsInCode(r'''
+enum E<T> {
+  v(42);
+  E(T a);
+}
+''');
+
+    assertEnumConstant(
+      findNode.enumConstantDeclaration('v'),
+      element: findElement.field('v'),
+      constructorElement: elementMatcher(
+        findElement.enum_('E').unnamedConstructor,
+        substitution: {'T': 'int'},
+      ),
+    );
+
+    assertParameterElement(
+      findNode.integerLiteral('42'),
+      elementMatcher(
+        findElement.parameter('a'),
+        substitution: {'T': 'int'},
+      ),
+    );
+  }
+
+  test_constructor_generic_typeArguments_named() async {
+    await assertNoErrorsInCode(r'''
+enum E<T> {
+  v<double>.named(42);
+  E.named(T a);
+}
+''');
+
+    assertEnumConstant(
+      findNode.enumConstantDeclaration('v'),
+      element: findElement.field('v'),
+      constructorElement: elementMatcher(
+        findElement.constructor('named'),
+        substitution: {'T': 'double'},
+      ),
+    );
+
+    assertNamedType(
+      findNode.namedType('double'),
+      doubleElement,
+      'double',
+    );
+
+    assertParameterElement(
+      findNode.integerLiteral('42'),
+      elementMatcher(
+        findElement.parameter('a'),
+        substitution: {'T': 'double'},
+      ),
+    );
+  }
+
+  test_constructor_notGeneric_named() async {
+    await assertNoErrorsInCode(r'''
+enum E {
+  v.named(42);
+  E.named(int a);
+}
+''');
+
+    assertEnumConstant(
+      findNode.enumConstantDeclaration('v'),
+      element: findElement.field('v'),
+      constructorElement: findElement.constructor('named'),
+    );
+
+    assertParameterElement(
+      findNode.integerLiteral('42'),
+      findElement.parameter('a'),
+    );
+  }
+
+  test_constructor_notGeneric_unnamed() async {
+    await assertNoErrorsInCode(r'''
+enum E {
+  v(42);
+  E(int a);
+}
+''');
+
+    assertEnumConstant(
+      findNode.enumConstantDeclaration('v'),
+      element: findElement.field('v'),
+      constructorElement: findElement.enum_('E').unnamedConstructor,
+    );
+
+    assertParameterElement(
+      findNode.integerLiteral('42'),
+      findElement.parameter('a'),
+    );
+  }
+
+  test_constructor_notGeneric_unnamed_implicit() async {
+    await assertNoErrorsInCode(r'''
+enum E {
+  v
+}
+''');
+
+    assertEnumConstant(
+      findNode.enumConstantDeclaration('v'),
+      element: findElement.field('v'),
+      constructorElement: findElement.enum_('E').unnamedConstructor,
+    );
+  }
+
+  test_constructor_unresolved_named() async {
+    await assertNoErrorsInCode(r'''
+enum E {
+  v.named(42);
+  E(int a);
+}
+''');
+
+    assertEnumConstant(
+      findNode.enumConstantDeclaration('v'),
+      element: findElement.field('v'),
+      constructorElement: null,
+    );
+
+    assertParameterElement(findNode.integerLiteral('42'), null);
+  }
+
+  test_constructor_unresolved_unnamed() async {
+    await assertNoErrorsInCode(r'''
+enum E {
+  v(42);
+  E.named(int a);
+}
+''');
+
+    assertEnumConstant(
+      findNode.enumConstantDeclaration('v'),
+      element: findElement.field('v'),
+      constructorElement: null,
+    );
+
+    assertParameterElement(findNode.integerLiteral('42'), null);
+  }
+
+  test_field() async {
+    await assertNoErrorsInCode(r'''
+enum E {
   v;
   final foo = 42;
 }
@@ -88,7 +291,7 @@
 
   test_method_toString() async {
     await assertNoErrorsInCode(r'''
-enum E<T> {
+enum E {
   v;
   String toString() => 'E';
 }
diff --git a/pkg/analyzer/test/src/dart/resolution/index_expression_test.dart b/pkg/analyzer/test/src/dart/resolution/index_expression_test.dart
index c02261d..384b9be 100644
--- a/pkg/analyzer/test/src/dart/resolution/index_expression_test.dart
+++ b/pkg/analyzer/test/src/dart/resolution/index_expression_test.dart
@@ -122,7 +122,10 @@
     );
     assertParameterElement(
       indexExpression.index,
-      indexElement.parameters[0],
+      elementMatcher(
+        indexElement.parameters[0],
+        substitution: {'T': 'double'},
+      ),
     );
   }
 
@@ -230,7 +233,10 @@
     }
     assertParameterElement(
       indexExpression.index,
-      indexEqElement.parameters[0],
+      elementMatcher(
+        indexEqElement.parameters[0],
+        substitution: {'T': 'double'},
+      ),
     );
 
     var assignment = indexExpression.parent as AssignmentExpression;
@@ -426,7 +432,10 @@
     }
     assertParameterElement(
       indexExpression.index,
-      indexEqElement.parameters[0],
+      elementMatcher(
+        indexEqElement.parameters[0],
+        substitution: {'T': 'double'},
+      ),
     );
 
     var assignment = indexExpression.parent as AssignmentExpression;
@@ -444,7 +453,10 @@
     );
     assertParameterElement(
       assignment.rightHandSide,
-      indexEqElement.parameters[1],
+      elementMatcher(
+        indexEqElement.parameters[1],
+        substitution: {'T': 'double'},
+      ),
     );
   }
 
diff --git a/pkg/analyzer/test/src/dart/resolution/resolution.dart b/pkg/analyzer/test/src/dart/resolution/resolution.dart
index 35aaf17..e76b324 100644
--- a/pkg/analyzer/test/src/dart/resolution/resolution.dart
+++ b/pkg/analyzer/test/src/dart/resolution/resolution.dart
@@ -285,6 +285,15 @@
     expect(element.enclosingElement, expectedEnclosing);
   }
 
+  void assertEnumConstant(
+    EnumConstantDeclaration node, {
+    required FieldElement element,
+    required Object? constructorElement,
+  }) {
+    assertElement(node.declaredElement, element);
+    assertElement(node.constructorElement, constructorElement);
+  }
+
   Future<void> assertErrorsInCode(
       String code, List<ExpectedError> expectedErrors) async {
     addTestFile(code);
@@ -627,9 +636,9 @@
 
   void assertParameterElement(
     Expression expression,
-    ParameterElement expected,
+    Object? elementOrMatcher,
   ) {
-    expect(expression.staticParameterElement, expected);
+    assertElement(expression.staticParameterElement, elementOrMatcher);
   }
 
   void assertParameterElementType(FormalParameter node, String expected) {
diff --git a/pkg/analyzer/test/src/diagnostics/instantiate_enum_test.dart b/pkg/analyzer/test/src/diagnostics/instantiate_enum_test.dart
index 0fd804c..4fc7b70 100644
--- a/pkg/analyzer/test/src/diagnostics/instantiate_enum_test.dart
+++ b/pkg/analyzer/test/src/diagnostics/instantiate_enum_test.dart
@@ -22,7 +22,10 @@
   return const E();
 }
 ''', [
+      error(CompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH, 43, 9),
+      error(CompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH, 43, 9),
       error(CompileTimeErrorCode.INSTANTIATE_ENUM, 49, 1),
+      error(CompileTimeErrorCode.NOT_ENOUGH_POSITIONAL_ARGUMENTS, 50, 2),
     ]);
   }
 
@@ -34,6 +37,7 @@
 }
 ''', [
       error(CompileTimeErrorCode.INSTANTIATE_ENUM, 47, 1),
+      error(CompileTimeErrorCode.NOT_ENOUGH_POSITIONAL_ARGUMENTS, 48, 2),
     ]);
   }
 }
diff --git a/pkg/analyzer/test/src/summary/resynthesize_common.dart b/pkg/analyzer/test/src/summary/resynthesize_common.dart
index 3e35554..4d9cd96 100644
--- a/pkg/analyzer/test/src/summary/resynthesize_common.dart
+++ b/pkg/analyzer/test/src/summary/resynthesize_common.dart
@@ -17748,6 +17748,109 @@
 ''');
   }
 
+  test_enum_constant_typeArguments() async {
+    var library = await checkLibrary(r'''
+enum E<T> {
+  v<double>(42);
+  E(T a);
+}
+''');
+    checkElementText(library, r'''
+library
+  definingUnit
+    enums
+      enum E @5
+        typeParameters
+          covariant T @7
+            defaultType: dynamic
+        supertype: Enum
+        fields
+          static const enumConstant v @14
+            type: E<double>
+            constantInitializer
+              InstanceCreationExpression
+                argumentList: ArgumentList
+                  arguments
+                    IntegerLiteral
+                      literal: 0 @0
+                      staticType: int
+                    SimpleStringLiteral
+                      literal: 'v' @0
+                    IntegerLiteral
+                      literal: 42 @24
+                      staticType: double
+                  leftParenthesis: ( @0
+                  rightParenthesis: ) @0
+                constructorName: ConstructorName
+                  name: SimpleIdentifier
+                    staticElement: ConstructorMember
+                      base: self::@enum::E::@constructor::•
+                      substitution: {T: double}
+                    staticType: null
+                    token:  @-1
+                  period: . @0
+                  staticElement: ConstructorMember
+                    base: self::@enum::E::@constructor::•
+                    substitution: {T: double}
+                  type: NamedType
+                    name: SimpleIdentifier
+                      staticElement: self::@enum::E
+                      staticType: null
+                      token: E @-1
+                    type: E<double>
+                    typeArguments: TypeArgumentList
+                      arguments
+                        NamedType
+                          name: SimpleIdentifier
+                            staticElement: dart:core::@class::double
+                            staticType: null
+                            token: double @16
+                          type: double
+                      leftBracket: < @15
+                      rightBracket: > @22
+                staticType: E<double>
+          synthetic static const values @-1
+            type: List<E<dynamic>>
+            constantInitializer
+              ListLiteral
+                elements
+                  SimpleIdentifier
+                    staticElement: self::@enum::E::@getter::v
+                    staticType: E<double>
+                    token: v @-1
+                leftBracket: [ @0
+                rightBracket: ] @0
+                staticType: List<E<dynamic>>
+          synthetic final index @-1
+            type: int
+          synthetic final _name @-1
+            type: String
+        constructors
+          @31
+            parameters
+              requiredPositional final this.index @-1
+                type: int
+                field: self::@enum::E::@field::index
+              requiredPositional final this._name @-1
+                type: String
+                field: self::@enum::E::@field::_name
+              requiredPositional a @35
+                type: T
+        accessors
+          synthetic static get v @-1
+            returnType: E<double>
+          synthetic static get values @-1
+            returnType: List<E<dynamic>>
+          synthetic get index @-1
+            returnType: int
+          synthetic get _name @-1
+            returnType: String
+        methods
+          synthetic toString @-1
+            returnType: String
+''');
+  }
+
   test_enum_constant_underscore() async {
     var library = await checkLibrary('''
 enum E {
diff --git a/pkg/analyzer/test/verify_diagnostics_test.dart b/pkg/analyzer/test/verify_diagnostics_test.dart
index 873f700..84ce4b3 100644
--- a/pkg/analyzer/test/verify_diagnostics_test.dart
+++ b/pkg/analyzer/test/verify_diagnostics_test.dart
@@ -50,6 +50,8 @@
     // (such as `JSBool b;`), but that would complicate the example.
     'CompileTimeErrorCode.IMPORT_INTERNAL_LIBRARY',
     // Produces two diagnostics when it should only produce one.
+    'CompileTimeErrorCode.INSTANTIATE_ENUM',
+    // Produces two diagnostics when it should only produce one.
     'CompileTimeErrorCode.INVALID_URI',
     // Produces two diagnostics when it should only produce one.
     'CompileTimeErrorCode.INVALID_USE_OF_NULL_VALUE',
diff --git a/tools/VERSION b/tools/VERSION
index a4cf01a..5d43e34 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 17
 PATCH 0
-PRERELEASE 55
+PRERELEASE 56
 PRERELEASE_PATCH 0
\ No newline at end of file