diff --git a/pkg/analyzer/lib/src/dart/resolver/annotation_resolver.dart b/pkg/analyzer/lib/src/dart/resolver/annotation_resolver.dart
index 98fe2d9..46980c7 100644
--- a/pkg/analyzer/lib/src/dart/resolver/annotation_resolver.dart
+++ b/pkg/analyzer/lib/src/dart/resolver/annotation_resolver.dart
@@ -2,36 +2,25 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-import 'package:analyzer/dart/analysis/features.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/error/listener.dart';
 import 'package:analyzer/src/dart/ast/ast.dart';
-import 'package:analyzer/src/dart/ast/extensions.dart';
-import 'package:analyzer/src/dart/element/member.dart';
-import 'package:analyzer/src/dart/element/type.dart';
-import 'package:analyzer/src/dart/element/type_algebra.dart';
-import 'package:analyzer/src/dart/resolver/instance_creation_resolver_helper.dart';
 import 'package:analyzer/src/dart/resolver/invocation_inference_helper.dart';
+import 'package:analyzer/src/dart/resolver/invocation_inferrer.dart';
 import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 
-class AnnotationResolver with InstanceCreationResolverMixin {
+class AnnotationResolver {
   final ResolverVisitor _resolver;
 
   AnnotationResolver(this._resolver);
 
-  @override
-  ResolverVisitor get resolver => _resolver;
-
   LibraryElement get _definingLibrary => _resolver.definingLibrary;
 
   ErrorReporter get _errorReporter => _resolver.errorReporter;
 
-  bool get _genericMetadataIsEnabled =>
-      _definingLibrary.featureSet.isEnabled(Feature.generic_metadata);
-
   void resolve(
       AnnotationImpl node, List<WhyNotPromotedGetter> whyNotPromotedList) {
     node.typeArguments?.accept(_resolver);
@@ -116,137 +105,35 @@
     constructorElement = _resolver.toLegacyElement(constructorElement);
     constructorName?.staticElement = constructorElement;
     node.element = constructorElement;
+    var annotationInferrer =
+        AnnotationInferrer(constructorName: constructorName);
 
     if (constructorElement == null) {
       _errorReporter.reportErrorForNode(
         CompileTimeErrorCode.INVALID_ANNOTATION,
         node,
       );
-      _resolver.analyzeArgumentList(argumentList, null,
+      annotationInferrer.resolveInvocation(
+          resolver: _resolver,
+          node: node,
+          rawType: null,
+          contextType: null,
           whyNotPromotedList: whyNotPromotedList);
       return;
     }
 
-    // If no type parameters, the elements are correct.
-    if (typeParameters.isEmpty) {
-      var typeArgumentList = node.typeArguments;
-      if (typeArgumentList != null) {
-        _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS,
-          typeArgumentList,
-          [
-            typeDisplayName,
-            typeParameters.length,
-            typeArgumentList.arguments.length,
-          ],
-        );
-      }
-      _resolveConstructorInvocationArguments(node);
-      _resolver.analyzeArgumentList(argumentList, constructorElement.parameters,
-          whyNotPromotedList: whyNotPromotedList);
-      return;
-    }
-
-    void resolveWithFixedTypeArguments(
-      List<DartType> typeArguments,
-      ConstructorElement constructorElement,
-    ) {
-      var type = instantiateElement(typeArguments);
-      constructorElement = ConstructorMember.from(constructorElement, type);
-      constructorName?.staticElement = constructorElement;
-      node.element = constructorElement;
-      _resolveConstructorInvocationArguments(node);
-
-      _resolver.analyzeArgumentList(argumentList, constructorElement.parameters,
-          whyNotPromotedList: whyNotPromotedList);
-    }
-
-    if (!_genericMetadataIsEnabled) {
-      var typeArguments = List.filled(
-        typeParameters.length,
-        DynamicTypeImpl.instance,
-      );
-      resolveWithFixedTypeArguments(typeArguments, constructorElement);
-      return;
-    }
-
-    var typeArgumentList = node.typeArguments;
-    if (typeArgumentList != null) {
-      List<DartType> typeArguments;
-      if (typeArgumentList.arguments.length == typeParameters.length) {
-        typeArguments = typeArgumentList.arguments
-            .map((element) => element.typeOrThrow)
-            .toList();
-        var substitution = Substitution.fromPairs(
-          typeParameters,
-          typeArguments,
-        );
-        for (var i = 0; i < typeParameters.length; i++) {
-          var typeParameter = typeParameters[i];
-          var bound = typeParameter.bound;
-          if (bound != null) {
-            bound = substitution.substituteType(bound);
-            var typeArgument = typeArguments[i];
-            if (!_resolver.typeSystem.isSubtypeOf(typeArgument, bound)) {
-              _errorReporter.reportErrorForNode(
-                CompileTimeErrorCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS,
-                typeArgumentList.arguments[i],
-                [typeArgument, typeParameter.name, bound],
-              );
-            }
-          }
-        }
-      } else {
-        _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS,
-          typeArgumentList,
-          [
-            typeDisplayName,
-            typeParameters.length,
-            typeArgumentList.arguments.length,
-          ],
-        );
-        typeArguments = List.filled(
-          typeParameters.length,
-          DynamicTypeImpl.instance,
-        );
-      }
-      resolveWithFixedTypeArguments(typeArguments, constructorElement);
-      return;
-    }
-
     var elementToInfer = ConstructorElementToInfer(
       typeParameters,
       constructorElement,
     );
-    var inferenceResult = inferArgumentTypes(
-        inferenceNode: node,
-        constructorElement: constructorElement,
-        elementToInfer: elementToInfer,
-        typeArguments: node.typeArguments,
-        arguments: node.arguments!,
-        errorNode: node,
-        isConst: true,
-        contextReturnType: null);
-    if (inferenceResult != null) {
-      constructorElement = inferenceResult.constructorElement;
-    }
-    _resolver.analyzeArgumentList(argumentList, constructorElement.parameters,
-        whyNotPromotedList: whyNotPromotedList);
-
     var constructorRawType = elementToInfer.asType;
 
-    var inferred = _resolver.inferenceHelper.inferGenericInvoke(
-        node, constructorRawType, typeArgumentList, argumentList, node,
-        isConst: true, contextReturnType: null)!;
-
-    constructorElement = ConstructorMember.from(
-      constructorElement,
-      inferred.returnType as InterfaceType,
-    );
-    constructorName?.staticElement = constructorElement;
-    node.element = constructorElement;
-    _resolveConstructorInvocationArguments(node);
+    annotationInferrer.resolveInvocation(
+        resolver: _resolver,
+        node: node,
+        rawType: constructorRawType,
+        contextType: null,
+        whyNotPromotedList: whyNotPromotedList);
   }
 
   void _extensionGetter(
@@ -446,24 +333,6 @@
     }
   }
 
-  void _resolveConstructorInvocationArguments(AnnotationImpl node) {
-    var argumentList = node.arguments;
-    // error will be reported in ConstantVerifier
-    if (argumentList == null) {
-      return;
-    }
-    // resolve arguments to parameters
-    var constructor = node.element;
-    if (constructor is ConstructorElement) {
-      argumentList.correspondingStaticParameters =
-          ResolverVisitor.resolveArgumentsToParameters(
-        argumentList: argumentList,
-        parameters: constructor.parameters,
-        errorReporter: _errorReporter,
-      );
-    }
-  }
-
   void _typeAliasConstructorInvocation(
     AnnotationImpl node,
     TypeAliasElement typeAliasElement,
@@ -530,7 +399,11 @@
       AnnotationImpl node, List<WhyNotPromotedGetter> whyNotPromotedList) {
     var arguments = node.arguments;
     if (arguments != null) {
-      _resolver.analyzeArgumentList(arguments, null,
+      AnnotationInferrer(constructorName: null).resolveInvocation(
+          resolver: _resolver,
+          node: node,
+          rawType: null,
+          contextType: null,
           whyNotPromotedList: whyNotPromotedList);
     }
   }
diff --git a/pkg/analyzer/lib/src/dart/resolver/constructor_reference_resolver.dart b/pkg/analyzer/lib/src/dart/resolver/constructor_reference_resolver.dart
index 7c09b9d..db7e1df 100644
--- a/pkg/analyzer/lib/src/dart/resolver/constructor_reference_resolver.dart
+++ b/pkg/analyzer/lib/src/dart/resolver/constructor_reference_resolver.dart
@@ -97,7 +97,9 @@
     //
     // Otherwise we'll have a ConstructorElement, and we can skip inference
     // because there's nothing to infer in a non-generic type.
-    if (elementToInfer != null) {
+    if (elementToInfer != null &&
+        elementToInfer.typeParameters.isNotEmpty &&
+        constructorName.type.typeArguments == null) {
       // TODO(leafp): Currently, we may re-infer types here, since we
       // sometimes resolve multiple times.  We should really check that we
       // have not already inferred something.  However, the obvious ways to
diff --git a/pkg/analyzer/lib/src/dart/resolver/function_expression_invocation_resolver.dart b/pkg/analyzer/lib/src/dart/resolver/function_expression_invocation_resolver.dart
index 5a75cfd..ddbdfdb 100644
--- a/pkg/analyzer/lib/src/dart/resolver/function_expression_invocation_resolver.dart
+++ b/pkg/analyzer/lib/src/dart/resolver/function_expression_invocation_resolver.dart
@@ -11,6 +11,7 @@
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/dart/resolver/extension_member_resolver.dart';
 import 'package:analyzer/src/dart/resolver/invocation_inference_helper.dart';
+import 'package:analyzer/src/dart/resolver/invocation_inferrer.dart';
 import 'package:analyzer/src/dart/resolver/type_property_resolver.dart';
 import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer/src/error/nullable_dereference_verifier.dart';
@@ -59,7 +60,8 @@
     }
 
     if (_checkForUseOfVoidResult(function, receiverType)) {
-      _unresolved(node, DynamicTypeImpl.instance, whyNotPromotedList);
+      _unresolved(node, DynamicTypeImpl.instance, whyNotPromotedList,
+          contextType: contextType);
       return;
     }
 
@@ -77,11 +79,13 @@
     if (identical(receiverType, NeverTypeImpl.instance)) {
       _errorReporter.reportErrorForNode(
           HintCode.RECEIVER_OF_TYPE_NEVER, function);
-      _unresolved(node, NeverTypeImpl.instance, whyNotPromotedList);
+      _unresolved(node, NeverTypeImpl.instance, whyNotPromotedList,
+          contextType: contextType);
       return;
     }
 
-    _unresolved(node, DynamicTypeImpl.instance, whyNotPromotedList);
+    _unresolved(node, DynamicTypeImpl.instance, whyNotPromotedList,
+        contextType: contextType);
   }
 
   /// Check for situations where the result of a method or function is used,
@@ -111,26 +115,19 @@
   void _resolve(FunctionExpressionInvocationImpl node, FunctionType rawType,
       List<WhyNotPromotedGetter> whyNotPromotedList,
       {required DartType? contextType}) {
-    _inferenceHelper.resolveFunctionExpressionInvocation(
+    var returnType =
+        const FunctionExpressionInvocationInferrer().resolveInvocation(
+      resolver: _resolver,
       node: node,
       rawType: rawType,
       whyNotPromotedList: whyNotPromotedList,
       contextType: contextType,
     );
 
-    var returnType = _inferenceHelper.computeInvokeReturnType(
-      node.staticInvokeType,
-    );
     _inferenceHelper.recordStaticType(node, returnType,
         contextType: contextType);
   }
 
-  void _resolveArguments(FunctionExpressionInvocationImpl node,
-      List<WhyNotPromotedGetter> whyNotPromotedList) {
-    _resolver.analyzeArgumentList(node.argumentList, null,
-        whyNotPromotedList: whyNotPromotedList);
-  }
-
   void _resolveReceiverExtensionOverride(FunctionExpressionInvocationImpl node,
       ExtensionOverride function, List<WhyNotPromotedGetter> whyNotPromotedList,
       {required DartType? contextType}) {
@@ -147,7 +144,8 @@
         function,
         [function.extensionName.name],
       );
-      return _unresolved(node, DynamicTypeImpl.instance, whyNotPromotedList);
+      return _unresolved(node, DynamicTypeImpl.instance, whyNotPromotedList,
+          contextType: contextType);
     }
 
     if (callElement.isStatic) {
@@ -183,7 +181,8 @@
           function,
         );
       }
-      _unresolved(node, DynamicTypeImpl.instance, whyNotPromotedList);
+      _unresolved(node, DynamicTypeImpl.instance, whyNotPromotedList,
+          contextType: contextType);
       return;
     }
 
@@ -192,7 +191,8 @@
         CompileTimeErrorCode.INVOCATION_OF_NON_FUNCTION_EXPRESSION,
         function,
       );
-      _unresolved(node, DynamicTypeImpl.instance, whyNotPromotedList);
+      _unresolved(node, DynamicTypeImpl.instance, whyNotPromotedList,
+          contextType: contextType);
       return;
     }
 
@@ -202,9 +202,15 @@
   }
 
   void _unresolved(FunctionExpressionInvocationImpl node, DartType type,
-      List<WhyNotPromotedGetter> whyNotPromotedList) {
+      List<WhyNotPromotedGetter> whyNotPromotedList,
+      {required DartType? contextType}) {
     _setExplicitTypeArgumentTypes(node);
-    _resolveArguments(node, whyNotPromotedList);
+    const FunctionExpressionInvocationInferrer().resolveInvocation(
+        resolver: _resolver,
+        node: node,
+        rawType: null,
+        contextType: contextType,
+        whyNotPromotedList: whyNotPromotedList);
     node.staticInvokeType = DynamicTypeImpl.instance;
     node.staticType = type;
   }
diff --git a/pkg/analyzer/lib/src/dart/resolver/instance_creation_expression_resolver.dart b/pkg/analyzer/lib/src/dart/resolver/instance_creation_expression_resolver.dart
index e139af8..bfdf73f 100644
--- a/pkg/analyzer/lib/src/dart/resolver/instance_creation_expression_resolver.dart
+++ b/pkg/analyzer/lib/src/dart/resolver/instance_creation_expression_resolver.dart
@@ -5,7 +5,7 @@
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/ast/ast.dart';
-import 'package:analyzer/src/dart/resolver/instance_creation_resolver_helper.dart';
+import 'package:analyzer/src/dart/resolver/invocation_inferrer.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 
 /// A resolver for [InstanceCreationExpression] nodes.
@@ -14,15 +14,12 @@
 /// [InstanceCreationExpression] as a [MethodInvocation] if the parsed
 /// [ConstructorName]'s `type` resolves to a [FunctionReference] or
 /// [ConstructorReference], instead of a [NamedType].
-class InstanceCreationExpressionResolver with InstanceCreationResolverMixin {
+class InstanceCreationExpressionResolver {
   /// The resolver driving this participant.
   final ResolverVisitor _resolver;
 
   InstanceCreationExpressionResolver(this._resolver);
 
-  @override
-  ResolverVisitor get resolver => _resolver;
-
   void resolve(InstanceCreationExpressionImpl node,
       {required DartType? contextType}) {
     // The parser can parse certain code as [InstanceCreationExpression] when it
@@ -60,32 +57,20 @@
     constructorName.accept(_resolver);
     // Re-assign constructorName in case the node got replaced.
     constructorName = node.constructorName;
+    _resolver.elementResolver.visitInstanceCreationExpression(node);
     var elementToInfer = _resolver.inferenceHelper.constructorElementToInfer(
       constructorName: constructorName,
       definingLibrary: _resolver.definingLibrary,
     );
-    var typeName = constructorName.type;
-    var constructorElement = constructorName.staticElement;
-    var inferenceResult = inferArgumentTypes(
-        inferenceNode: node,
-        constructorElement: constructorElement,
-        elementToInfer: elementToInfer,
-        typeArguments: typeName.typeArguments,
-        arguments: node.argumentList,
-        errorNode: constructorName,
-        isConst: node.isConst,
-        contextReturnType: contextType);
-    if (inferenceResult != null) {
-      typeName.type = inferenceResult.constructedType;
-      constructorElement =
-          constructorName.staticElement = inferenceResult.constructorElement;
-    }
-    _resolver.analyzeArgumentList(
-        node.argumentList, constructorElement?.parameters,
+    const InstanceCreationInferrer().resolveInvocation(
+        resolver: _resolver,
+        node: node,
+        rawType: elementToInfer?.asType,
+        contextType: contextType,
         whyNotPromotedList: whyNotPromotedList);
-    _resolver.elementResolver.visitInstanceCreationExpression(node);
-    _resolver.typeAnalyzer
-        .visitInstanceCreationExpression(node, contextType: contextType);
+    _resolver.inferenceHelper.recordStaticType(
+        node, node.constructorName.type.type!,
+        contextType: contextType);
     _resolver.checkForArgumentTypesNotAssignableInList(
         node.argumentList, whyNotPromotedList);
   }
diff --git a/pkg/analyzer/lib/src/dart/resolver/instance_creation_resolver_helper.dart b/pkg/analyzer/lib/src/dart/resolver/instance_creation_resolver_helper.dart
deleted file mode 100644
index 0f99c2d..0000000
--- a/pkg/analyzer/lib/src/dart/resolver/instance_creation_resolver_helper.dart
+++ /dev/null
@@ -1,100 +0,0 @@
-// Copyright (c) 2021, 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/dart/ast/ast.dart';
-import 'package:analyzer/dart/element/element.dart';
-import 'package:analyzer/dart/element/type.dart';
-import 'package:analyzer/src/dart/ast/ast.dart';
-import 'package:analyzer/src/dart/element/member.dart';
-import 'package:analyzer/src/dart/resolver/invocation_inference_helper.dart';
-import 'package:analyzer/src/generated/resolver.dart';
-
-/// Data constructor containing information about the result of performing type
-/// inference on an instance creation (either an InstanceCreationExpression or
-/// an Annotation that refers to a constructor).
-class InstanceCreationInferenceResult {
-  /// The refined constructor element (after type inference)
-  final ConstructorElement constructorElement;
-
-  /// The type that was constructed (after type inference)
-  final DartType constructedType;
-
-  InstanceCreationInferenceResult(
-      {required this.constructorElement, required this.constructedType});
-}
-
-/// Mixin containing shared functionality for resolving AST nodes that may
-/// create instances (InstanceCreationExpression and Annotation).
-mixin InstanceCreationResolverMixin {
-  ResolverVisitor get resolver;
-
-  /// Performs the first step of type inference for a constructor invocation.
-  InstanceCreationInferenceResult? inferArgumentTypes(
-      {required AstNode inferenceNode,
-      required ConstructorElement? constructorElement,
-      required ConstructorElementToInfer? elementToInfer,
-      required TypeArgumentListImpl? typeArguments,
-      required ArgumentListImpl arguments,
-      required AstNode errorNode,
-      required bool isConst,
-      required DartType? contextReturnType}) {
-    InstanceCreationInferenceResult? inferenceResult;
-    FunctionType? inferred;
-
-    // If the constructor is generic, we'll have a ConstructorMember that
-    // substitutes in type arguments (possibly `dynamic`) from earlier in
-    // resolution.
-    //
-    // Otherwise we'll have a ConstructorElement, and we can skip inference
-    // because there's nothing to infer in a non-generic type.
-    if (elementToInfer != null) {
-      // TODO(leafp): Currently, we may re-infer types here, since we
-      // sometimes resolve multiple times.  We should really check that we
-      // have not already inferred something.  However, the obvious ways to
-      // check this don't work, since we may have been instantiated
-      // to bounds in an earlier phase, and we *do* want to do inference
-      // in that case.
-
-      // Get back to the uninstantiated generic constructor.
-      // TODO(jmesserly): should we store this earlier in resolution?
-      // Or look it up, instead of jumping backwards through the Member?
-      var rawElement = elementToInfer.element;
-      var constructorType = elementToInfer.asType;
-
-      inferred = resolver.inferenceHelper.inferArgumentTypesForGeneric(
-          inferenceNode, constructorType, typeArguments,
-          isConst: isConst,
-          errorNode: errorNode,
-          contextReturnType: contextReturnType);
-
-      if (inferred != null) {
-        // Fix up the parameter elements based on inferred method.
-        arguments.correspondingStaticParameters =
-            ResolverVisitor.resolveArgumentsToParameters(
-          argumentList: arguments,
-          parameters: inferred.parameters,
-        );
-
-        // Update the static element as well. This is used in some cases, such
-        // as computing constant values. It is stored in two places.
-        constructorElement = ConstructorMember.from(
-          rawElement,
-          inferred.returnType as InterfaceType,
-        );
-        inferenceResult = InstanceCreationInferenceResult(
-            constructorElement: constructorElement,
-            constructedType: inferred.returnType);
-      }
-    }
-
-    if (inferred == null) {
-      if (constructorElement != null) {
-        var type = constructorElement.type;
-        type = resolver.toLegacyTypeIfOptOut(type) as FunctionType;
-      }
-    }
-
-    return inferenceResult;
-  }
-}
diff --git a/pkg/analyzer/lib/src/dart/resolver/invocation_inference_helper.dart b/pkg/analyzer/lib/src/dart/resolver/invocation_inference_helper.dart
index 1e5f7a6..945c794 100644
--- a/pkg/analyzer/lib/src/dart/resolver/invocation_inference_helper.dart
+++ b/pkg/analyzer/lib/src/dart/resolver/invocation_inference_helper.dart
@@ -9,12 +9,10 @@
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/error/listener.dart';
 import 'package:analyzer/src/dart/ast/ast.dart';
-import 'package:analyzer/src/dart/ast/extensions.dart';
 import 'package:analyzer/src/dart/element/member.dart';
 import 'package:analyzer/src/dart/element/type.dart';
-import 'package:analyzer/src/dart/element/type_algebra.dart';
 import 'package:analyzer/src/dart/element/type_system.dart';
-import 'package:analyzer/src/error/codes.dart';
+import 'package:analyzer/src/dart/resolver/invocation_inferrer.dart';
 import 'package:analyzer/src/generated/migration.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 
@@ -46,12 +44,15 @@
   /// For example given the type `class C<T> { C(T arg); }`, the generic
   /// function type is `<T>(T) -> C<T>`.
   FunctionType get asType {
-    return FunctionTypeImpl(
-      typeFormals: typeParameters,
-      parameters: element.parameters,
-      returnType: element.returnType,
-      nullabilitySuffix: NullabilitySuffix.none,
-    );
+    var typeParameters = this.typeParameters;
+    return typeParameters.isEmpty
+        ? element.type
+        : FunctionTypeImpl(
+            typeFormals: typeParameters,
+            parameters: element.parameters,
+            returnType: element.returnType,
+            nullabilitySuffix: NullabilitySuffix.none,
+          );
   }
 }
 
@@ -62,9 +63,6 @@
   final MigrationResolutionHooks? _migrationResolutionHooks;
   final bool _genericMetadataIsEnabled;
 
-  List<DartType>? _typeArgumentTypes;
-  FunctionType? _invokeType;
-
   InvocationInferenceHelper({
     required ResolverVisitor resolver,
     required ErrorReporter errorReporter,
@@ -77,16 +75,6 @@
         _genericMetadataIsEnabled = resolver.definingLibrary.featureSet
             .isEnabled(Feature.generic_metadata);
 
-  /// Compute the return type of the method or function represented by the given
-  /// type that is being invoked.
-  DartType computeInvokeReturnType(DartType? type) {
-    if (type is FunctionType) {
-      return type.returnType;
-    } else {
-      return DynamicTypeImpl.instance;
-    }
-  }
-
   /// If the constructor referenced by the [constructorName] is generic,
   /// and the [constructorName] does not have explicit type arguments,
   /// return the element and type parameters to infer. Otherwise return `null`.
@@ -94,159 +82,44 @@
     required ConstructorName constructorName,
     required LibraryElement definingLibrary,
   }) {
-    List<TypeParameterElement>? typeParameters;
+    List<TypeParameterElement> typeParameters;
     ConstructorElement? rawElement;
 
     var typeName = constructorName.type;
-    var typeArguments = typeName.typeArguments;
     var typeElement = typeName.name.staticElement;
     if (typeElement is ClassElement) {
       typeParameters = typeElement.typeParameters;
-      if (typeParameters.isNotEmpty && typeArguments == null) {
-        var constructorIdentifier = constructorName.name;
-        if (constructorIdentifier == null) {
-          rawElement = typeElement.unnamedConstructor;
-        } else {
-          var name = constructorIdentifier.name;
-          rawElement = typeElement.getNamedConstructor(name);
-          if (rawElement != null &&
-              !rawElement.isAccessibleIn(definingLibrary)) {
-            rawElement = null;
-          }
+      var constructorIdentifier = constructorName.name;
+      if (constructorIdentifier == null) {
+        rawElement = typeElement.unnamedConstructor;
+      } else {
+        var name = constructorIdentifier.name;
+        rawElement = typeElement.getNamedConstructor(name);
+        if (rawElement != null && !rawElement.isAccessibleIn(definingLibrary)) {
+          rawElement = null;
         }
       }
     } else if (typeElement is TypeAliasElement) {
       typeParameters = typeElement.typeParameters;
       var aliasedType = typeElement.aliasedType;
       if (aliasedType is InterfaceType) {
-        if (typeParameters.isNotEmpty && typeArguments == null) {
-          var constructorIdentifier = constructorName.name;
-          rawElement = aliasedType.lookUpConstructor(
-            constructorIdentifier?.name,
-            definingLibrary,
-          );
-        }
+        var constructorIdentifier = constructorName.name;
+        rawElement = aliasedType.lookUpConstructor(
+          constructorIdentifier?.name,
+          definingLibrary,
+        );
       }
+    } else {
+      return null;
     }
 
-    if (typeParameters == null || rawElement == null) {
+    if (rawElement == null) {
       return null;
     }
     rawElement = _resolver.toLegacyElement(rawElement);
     return ConstructorElementToInfer(typeParameters, rawElement);
   }
 
-  FunctionType? inferArgumentTypesForGeneric(AstNode inferenceNode,
-      DartType? uninstantiatedType, TypeArgumentList? typeArguments,
-      {AstNode? errorNode,
-      bool isConst = false,
-      required DartType? contextReturnType}) {
-    errorNode ??= inferenceNode;
-    uninstantiatedType = _getFreshType(uninstantiatedType);
-    if (typeArguments == null &&
-        uninstantiatedType is FunctionType &&
-        uninstantiatedType.typeFormals.isNotEmpty) {
-      var typeArguments = _typeSystem.inferGenericFunctionOrType(
-        typeParameters: uninstantiatedType.typeFormals,
-        parameters: const <ParameterElement>[],
-        declaredReturnType: uninstantiatedType.returnType,
-        argumentTypes: const <DartType>[],
-        contextReturnType: contextReturnType,
-        downwards: true,
-        isConst: isConst,
-        errorReporter: _errorReporter,
-        errorNode: errorNode,
-        genericMetadataIsEnabled: _genericMetadataIsEnabled,
-      );
-      if (typeArguments != null) {
-        return uninstantiatedType.instantiate(typeArguments);
-      }
-    }
-    return null;
-  }
-
-  DartType? inferArgumentTypesForInvocation(
-      InvocationExpression node, DartType? type,
-      {required DartType? contextType}) {
-    return inferArgumentTypesForGeneric(node, type, node.typeArguments,
-            contextReturnType: contextType) ??
-        node.staticInvokeType;
-  }
-
-  /// Given a possibly generic invocation like `o.m(args)` or `(f)(args)` try to
-  /// infer the instantiated generic function type.
-  ///
-  /// This takes into account both the context type, as well as information from
-  /// the argument types.
-  void inferGenericInvocationExpression(
-      InvocationExpressionImpl node, DartType? type,
-      {required DartType? contextType}) {
-    var arguments = node.argumentList;
-    var freshType = _getFreshType(type);
-
-    var inferred = inferGenericInvoke(
-        node, freshType, node.typeArguments, arguments, node.function,
-        contextReturnType: contextType);
-    if (inferred != null && inferred != node.staticInvokeType) {
-      // Fix up the parameter elements based on inferred method.
-      arguments.correspondingStaticParameters =
-          ResolverVisitor.resolveArgumentsToParameters(
-        argumentList: arguments,
-        parameters: inferred.parameters,
-      );
-      node.staticInvokeType = inferred;
-    }
-  }
-
-  /// Given a possibly generic invocation or instance creation, such as
-  /// `o.m(args)` or `(f)(args)` or `new T(args)` try to infer the instantiated
-  /// generic function type.
-  ///
-  /// This takes into account both the context type, as well as information from
-  /// the argument types.
-  FunctionType? inferGenericInvoke(
-      AstNode node,
-      DartType? fnType,
-      TypeArgumentList? typeArguments,
-      ArgumentList argumentList,
-      AstNode errorNode,
-      {bool isConst = false,
-      required DartType? contextReturnType}) {
-    if (typeArguments == null &&
-        fnType is FunctionType &&
-        fnType.typeFormals.isNotEmpty) {
-      // Get the parameters that correspond to the uninstantiated generic.
-      var typeArgs = _inferUpwards(
-        rawType: fnType,
-        argumentList: argumentList,
-        contextType: contextReturnType,
-        isConst: isConst,
-        errorNode: errorNode,
-      );
-      if (node is InvocationExpressionImpl) {
-        node.typeArgumentTypes = typeArgs;
-      }
-      if (typeArgs != null) {
-        return fnType.instantiate(typeArgs);
-      }
-      return fnType;
-    }
-
-    // There is currently no other place where we set type arguments
-    // for FunctionExpressionInvocation(s), so set it here, if not inferred.
-    if (node is FunctionExpressionInvocationImpl) {
-      if (typeArguments != null) {
-        var typeArgs =
-            typeArguments.arguments.map((n) => n.typeOrThrow).toList();
-        node.typeArgumentTypes = typeArgs;
-      } else {
-        node.typeArgumentTypes = const <DartType>[];
-      }
-    }
-
-    return null;
-  }
-
   /// Given an uninstantiated generic function type, referenced by the
   /// [identifier] in the tear-off [expression], try to infer the instantiated
   /// generic function type from the surrounding context.
@@ -286,31 +159,6 @@
     }
   }
 
-  /// Finish resolution of the [FunctionExpressionInvocation].
-  ///
-  /// We have already found the invoked [ExecutableElement], and the [rawType]
-  /// is its not yet instantiated type. Here we perform downwards inference,
-  /// resolution of arguments, and upwards inference.
-  void resolveFunctionExpressionInvocation({
-    required FunctionExpressionInvocationImpl node,
-    required FunctionType rawType,
-    required List<WhyNotPromotedGetter> whyNotPromotedList,
-    required DartType? contextType,
-  }) {
-    _resolveInvocation(
-      rawType: rawType,
-      typeArgumentList: node.typeArguments,
-      argumentList: node.argumentList,
-      contextType: contextType,
-      isConst: false,
-      errorNode: node.function,
-      whyNotPromotedList: whyNotPromotedList,
-    );
-
-    node.typeArgumentTypes = _typeArgumentTypes;
-    node.staticInvokeType = _invokeType;
-  }
-
   /// Finish resolution of the [MethodInvocation].
   ///
   /// We have already found the invoked [ExecutableElement], and the [rawType]
@@ -322,245 +170,14 @@
     required List<WhyNotPromotedGetter> whyNotPromotedList,
     required DartType? contextType,
   }) {
-    _resolveInvocation(
+    var returnType = MethodInvocationInferrer.forNode(node).resolveInvocation(
+      resolver: _resolver,
+      node: node,
       rawType: rawType,
-      typeArgumentList: node.typeArguments,
-      argumentList: node.argumentList,
       contextType: contextType,
-      isConst: false,
-      errorNode: node.function,
       whyNotPromotedList: whyNotPromotedList,
     );
 
-    node.typeArgumentTypes = _typeArgumentTypes;
-    node.staticInvokeType = _invokeType;
-
-    var returnType = computeInvokeReturnType(_invokeType);
-    var targetType = node.realTarget?.staticType;
-    if (targetType != null) {
-      returnType = _typeSystem.refineNumericInvocationType(
-        targetType,
-        node.methodName.staticElement,
-        [
-          for (var argument in node.argumentList.arguments) argument.typeOrThrow
-        ],
-        returnType,
-      );
-    }
     recordStaticType(node, returnType, contextType: contextType);
   }
-
-  List<DartType>? _inferDownwards({
-    required FunctionType rawType,
-    required DartType? contextType,
-    required bool isConst,
-    required AstNode errorNode,
-  }) {
-    return _typeSystem.inferGenericFunctionOrType(
-      typeParameters: rawType.typeFormals,
-      parameters: const <ParameterElement>[],
-      declaredReturnType: rawType.returnType,
-      argumentTypes: const <DartType>[],
-      contextReturnType: contextType,
-      downwards: true,
-      isConst: isConst,
-      errorReporter: _errorReporter,
-      errorNode: errorNode,
-      genericMetadataIsEnabled: _genericMetadataIsEnabled,
-    );
-  }
-
-  /// TODO(scheglov) Instead of [isConst] sanitize [contextType] before calling.
-  List<DartType>? _inferUpwards({
-    required FunctionType rawType,
-    required DartType? contextType,
-    required ArgumentList argumentList,
-    required bool isConst,
-    required AstNode errorNode,
-  }) {
-    rawType = _getFreshType(rawType) as FunctionType;
-
-    // Get the parameters that correspond to the uninstantiated generic.
-    List<ParameterElement?> rawParameters =
-        ResolverVisitor.resolveArgumentsToParameters(
-      argumentList: argumentList,
-      parameters: rawType.parameters,
-    );
-
-    List<ParameterElement> params = <ParameterElement>[];
-    List<DartType> argTypes = <DartType>[];
-    for (int i = 0, length = rawParameters.length; i < length; i++) {
-      ParameterElement? parameter = rawParameters[i];
-      if (parameter != null) {
-        params.add(parameter);
-        argTypes.add(argumentList.arguments[i].typeOrThrow);
-      }
-    }
-    var typeArgs = _typeSystem.inferGenericFunctionOrType(
-      typeParameters: rawType.typeFormals,
-      parameters: params,
-      declaredReturnType: rawType.returnType,
-      argumentTypes: argTypes,
-      contextReturnType: contextType,
-      isConst: isConst,
-      errorReporter: _errorReporter,
-      errorNode: errorNode,
-      genericMetadataIsEnabled: _genericMetadataIsEnabled,
-    );
-    return typeArgs;
-  }
-
-  bool _isCallToIdentical(AstNode? invocation) {
-    if (invocation is MethodInvocation) {
-      var invokedMethod = invocation.methodName.staticElement;
-      return invokedMethod != null &&
-          invokedMethod.name == 'identical' &&
-          invokedMethod.library!.isDartCore;
-    }
-    return false;
-  }
-
-  void _resolveArguments(
-      ArgumentList argumentList,
-      List<WhyNotPromotedGetter> whyNotPromotedList,
-      List<ParameterElement> parameters,
-      {required DartType? methodInvocationContext}) {
-    _resolver.analyzeArgumentList(argumentList, parameters,
-        isIdentical: _isCallToIdentical(argumentList.parent),
-        whyNotPromotedList: whyNotPromotedList,
-        methodInvocationContext: methodInvocationContext);
-  }
-
-  void _resolveInvocation({
-    required FunctionType rawType,
-    required DartType? contextType,
-    required TypeArgumentList? typeArgumentList,
-    required ArgumentListImpl argumentList,
-    required bool isConst,
-    required AstNode errorNode,
-    required List<WhyNotPromotedGetter> whyNotPromotedList,
-  }) {
-    if (typeArgumentList != null) {
-      _resolveInvocationWithTypeArguments(
-        rawType: rawType,
-        typeArgumentList: typeArgumentList,
-        argumentList: argumentList,
-        whyNotPromotedList: whyNotPromotedList,
-        methodInvocationContext: contextType,
-      );
-    } else {
-      _resolveInvocationWithoutTypeArguments(
-        rawType: rawType,
-        contextType: contextType,
-        argumentList: argumentList,
-        isConst: isConst,
-        errorNode: errorNode,
-        whyNotPromotedList: whyNotPromotedList,
-      );
-    }
-    _setCorrespondingParameters(argumentList, _invokeType!);
-  }
-
-  void _resolveInvocationWithoutTypeArguments({
-    required FunctionType rawType,
-    required DartType? contextType,
-    required ArgumentList argumentList,
-    required bool isConst,
-    required AstNode errorNode,
-    required List<WhyNotPromotedGetter> whyNotPromotedList,
-  }) {
-    var typeParameters = rawType.typeFormals;
-
-    if (typeParameters.isEmpty) {
-      _resolveArguments(argumentList, whyNotPromotedList, rawType.parameters,
-          methodInvocationContext: contextType);
-
-      _typeArgumentTypes = const <DartType>[];
-      _invokeType = rawType;
-    } else {
-      rawType = _getFreshType(rawType) as FunctionType;
-
-      var downwardsTypeArguments = _inferDownwards(
-        rawType: rawType,
-        contextType: contextType,
-        isConst: isConst,
-        errorNode: errorNode,
-      )!;
-
-      var downwardsInvokeType = rawType.instantiate(downwardsTypeArguments);
-
-      _resolveArguments(
-          argumentList, whyNotPromotedList, downwardsInvokeType.parameters,
-          methodInvocationContext: contextType);
-
-      _typeArgumentTypes = _inferUpwards(
-        rawType: rawType,
-        argumentList: argumentList,
-        contextType: contextType,
-        isConst: isConst,
-        errorNode: errorNode,
-      );
-      _invokeType = rawType.instantiate(_typeArgumentTypes!);
-    }
-  }
-
-  void _resolveInvocationWithTypeArguments({
-    required FunctionType rawType,
-    required TypeArgumentList typeArgumentList,
-    required ArgumentList argumentList,
-    required List<WhyNotPromotedGetter> whyNotPromotedList,
-    required DartType? methodInvocationContext,
-  }) {
-    var typeParameters = rawType.typeFormals;
-
-    List<DartType> typeArguments;
-    if (typeArgumentList.arguments.length != typeParameters.length) {
-      _errorReporter.reportErrorForNode(
-        CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS_METHOD,
-        typeArgumentList,
-        [
-          rawType,
-          typeParameters.length,
-          typeArgumentList.arguments.length,
-        ],
-      );
-      typeArguments = List.filled(
-        typeParameters.length,
-        DynamicTypeImpl.instance,
-      );
-    } else {
-      typeArguments = typeArgumentList.arguments
-          .map((typeArgument) => typeArgument.typeOrThrow)
-          .toList(growable: true);
-    }
-
-    var invokeType = rawType.instantiate(typeArguments);
-
-    _resolveArguments(argumentList, whyNotPromotedList, invokeType.parameters,
-        methodInvocationContext: methodInvocationContext);
-
-    _typeArgumentTypes = typeArguments;
-    _invokeType = invokeType;
-  }
-
-  void _setCorrespondingParameters(
-    ArgumentListImpl argumentList,
-    FunctionType invokeType,
-  ) {
-    var parameters = ResolverVisitor.resolveArgumentsToParameters(
-      argumentList: argumentList,
-      parameters: invokeType.parameters,
-      errorReporter: _errorReporter,
-    );
-    argumentList.correspondingStaticParameters = parameters;
-  }
-
-  static DartType? _getFreshType(DartType? type) {
-    if (type is FunctionType) {
-      var parameters = getFreshTypeParameters(type.typeFormals);
-      return parameters.applyToFunctionType(type);
-    } else {
-      return type;
-    }
-  }
 }
diff --git a/pkg/analyzer/lib/src/dart/resolver/invocation_inferrer.dart b/pkg/analyzer/lib/src/dart/resolver/invocation_inferrer.dart
new file mode 100644
index 0000000..c40a4ff
--- /dev/null
+++ b/pkg/analyzer/lib/src/dart/resolver/invocation_inferrer.dart
@@ -0,0 +1,545 @@
+// 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:_fe_analyzer_shared/src/base/errors.dart';
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/dart/element/type.dart';
+import 'package:analyzer/src/dart/ast/ast.dart';
+import 'package:analyzer/src/dart/ast/extensions.dart';
+import 'package:analyzer/src/dart/element/member.dart';
+import 'package:analyzer/src/dart/element/type.dart';
+import 'package:analyzer/src/dart/element/type_algebra.dart';
+import 'package:analyzer/src/error/codes.dart';
+import 'package:analyzer/src/generated/resolver.dart';
+
+/// Specialization of [InvocationInferrer] for performing type inference on AST
+/// nodes of type [Annotation] that resolve to a constructor invocation.
+class AnnotationInferrer extends FullInvocationInferrer<AnnotationImpl> {
+  /// The identifier pointing to the constructor that's being invoked, or `null`
+  /// if a constructor name couldn't be found (should only happen when
+  /// recovering from errors).  If the constructor is generic, this identifier's
+  /// static element will be updated to point to a [ConstructorMember] with type
+  /// arguments filled in.
+  final SimpleIdentifierImpl? constructorName;
+
+  AnnotationInferrer({required this.constructorName}) : super._();
+
+  @override
+  bool get _needsTypeArgumentBoundsCheck => true;
+
+  @override
+  ErrorCode get _wrongNumberOfTypeArgumentsErrorCode =>
+      CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS;
+
+  @override
+  ArgumentListImpl _getArgumentList(AnnotationImpl node) => node.arguments!;
+
+  @override
+  bool _getIsConst(AnnotationImpl node) => true;
+
+  @override
+  TypeArgumentListImpl? _getTypeArguments(AnnotationImpl node) =>
+      node.typeArguments;
+
+  @override
+  bool _isGenericInferenceDisabled(ResolverVisitor resolver) =>
+      !resolver.genericMetadataIsEnabled;
+
+  @override
+  List<ParameterElement>? _storeResult(AnnotationImpl node,
+      List<DartType>? typeArgumentTypes, FunctionType? invokeType) {
+    if (invokeType != null) {
+      var constructorElement = ConstructorMember.from(
+        node.element as ConstructorElement,
+        invokeType.returnType as InterfaceType,
+      );
+      constructorName?.staticElement = constructorElement;
+      node.element = constructorElement;
+      return constructorElement.parameters;
+    }
+    return null;
+  }
+}
+
+/// Specialization of [InvocationInferrer] for performing type inference on AST
+/// nodes of type [ExtensionOverride].
+class ExtensionOverrideInferrer
+    extends InvocationInferrer<ExtensionOverrideImpl> {
+  const ExtensionOverrideInferrer() : super._();
+
+  @override
+  ArgumentListImpl _getArgumentList(ExtensionOverrideImpl node) =>
+      node.argumentList;
+}
+
+/// Specialization of [InvocationInferrer] for performing type inference on AST
+/// nodes that require full downward and upward inference.
+abstract class FullInvocationInferrer<Node extends AstNodeImpl>
+    extends InvocationInferrer<Node> {
+  const FullInvocationInferrer._() : super._();
+
+  bool get _needsTypeArgumentBoundsCheck => false;
+
+  ErrorCode get _wrongNumberOfTypeArgumentsErrorCode =>
+      CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS_METHOD;
+
+  @override
+  DartType resolveInvocation({
+    required ResolverVisitor resolver,
+    required Node node,
+    required FunctionType? rawType,
+    required DartType? contextType,
+    required List<WhyNotPromotedGetter> whyNotPromotedList,
+  }) {
+    var typeArgumentList = _getTypeArguments(node);
+
+    List<DartType>? typeArgumentTypes;
+    FunctionType? invokeType;
+    if (_isGenericInferenceDisabled(resolver)) {
+      if (rawType != null && rawType.typeFormals.isNotEmpty) {
+        typeArgumentTypes = List.filled(
+          rawType.typeFormals.length,
+          DynamicTypeImpl.instance,
+        );
+      } else {
+        typeArgumentTypes = const <DartType>[];
+        invokeType = rawType;
+      }
+
+      invokeType = rawType?.instantiate(typeArgumentTypes);
+    } else if (typeArgumentList != null) {
+      if (rawType != null &&
+          typeArgumentList.arguments.length != rawType.typeFormals.length) {
+        var typeParameters = rawType.typeFormals;
+        _reportWrongNumberOfTypeArguments(
+            resolver, typeArgumentList, rawType, typeParameters);
+        typeArgumentTypes = List.filled(
+          typeParameters.length,
+          DynamicTypeImpl.instance,
+        );
+      } else {
+        typeArgumentTypes = typeArgumentList.arguments
+            .map((typeArgument) => typeArgument.typeOrThrow)
+            .toList(growable: true);
+        if (rawType != null && _needsTypeArgumentBoundsCheck) {
+          var typeParameters = rawType.typeFormals;
+          var substitution = Substitution.fromPairs(
+            typeParameters,
+            typeArgumentTypes,
+          );
+          for (var i = 0; i < typeParameters.length; i++) {
+            var typeParameter = typeParameters[i];
+            var bound = typeParameter.bound;
+            if (bound != null) {
+              bound = resolver.definingLibrary.toLegacyTypeIfOptOut(bound);
+              bound = substitution.substituteType(bound);
+              var typeArgument = typeArgumentTypes[i];
+              if (!resolver.typeSystem.isSubtypeOf(typeArgument, bound)) {
+                resolver.errorReporter.reportErrorForNode(
+                  CompileTimeErrorCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS,
+                  typeArgumentList.arguments[i],
+                  [typeArgument, typeParameter.name, bound],
+                );
+              }
+            }
+          }
+        }
+      }
+
+      invokeType = rawType?.instantiate(typeArgumentTypes);
+    } else if (rawType == null || rawType.typeFormals.isEmpty) {
+      typeArgumentTypes = const <DartType>[];
+      invokeType = rawType;
+    } else {
+      rawType = getFreshTypeParameters(rawType.typeFormals)
+          .applyToFunctionType(rawType);
+
+      var downwardsTypeArguments =
+          resolver.typeSystem.inferGenericFunctionOrType(
+        typeParameters: rawType.typeFormals,
+        parameters: const <ParameterElement>[],
+        declaredReturnType: rawType.returnType,
+        argumentTypes: const <DartType>[],
+        contextReturnType: contextType,
+        downwards: true,
+        isConst: _getIsConst(node),
+        errorReporter: resolver.errorReporter,
+        errorNode: _getErrorNode(node),
+        genericMetadataIsEnabled: resolver.genericMetadataIsEnabled,
+      )!;
+
+      invokeType = rawType.instantiate(downwardsTypeArguments);
+    }
+
+    super.resolveInvocation(
+        resolver: resolver,
+        node: node,
+        rawType: invokeType,
+        contextType: contextType,
+        whyNotPromotedList: whyNotPromotedList);
+
+    var argumentList = _getArgumentList(node);
+
+    if (typeArgumentTypes == null) {
+      if (rawType != null) {
+        // Get the parameters that correspond to the uninstantiated generic.
+        List<ParameterElement?> rawParameters =
+            ResolverVisitor.resolveArgumentsToParameters(
+          argumentList: argumentList,
+          parameters: rawType.parameters,
+        );
+
+        List<ParameterElement> params = <ParameterElement>[];
+        List<DartType> argTypes = <DartType>[];
+        for (int i = 0, length = rawParameters.length; i < length; i++) {
+          ParameterElement? parameter = rawParameters[i];
+          if (parameter != null) {
+            params.add(parameter);
+            argTypes.add(argumentList.arguments[i].typeOrThrow);
+          }
+        }
+        typeArgumentTypes = resolver.typeSystem.inferGenericFunctionOrType(
+          typeParameters: rawType.typeFormals,
+          parameters: params,
+          declaredReturnType: rawType.returnType,
+          argumentTypes: argTypes,
+          contextReturnType: contextType,
+          isConst: _getIsConst(node),
+          errorReporter: resolver.errorReporter,
+          errorNode: _getErrorNode(node),
+          genericMetadataIsEnabled: resolver.genericMetadataIsEnabled,
+        )!;
+        invokeType = rawType.instantiate(typeArgumentTypes);
+      } else {
+        typeArgumentTypes = const [];
+      }
+    }
+
+    var parameters = _storeResult(node, typeArgumentTypes, invokeType);
+    if (parameters != null) {
+      argumentList.correspondingStaticParameters =
+          ResolverVisitor.resolveArgumentsToParameters(
+        argumentList: argumentList,
+        parameters: parameters,
+        errorReporter: resolver.errorReporter,
+      );
+    }
+    var returnType = InvocationInferrer.computeInvokeReturnType(invokeType);
+    return _refineReturnType(resolver, node, returnType);
+  }
+
+  AstNode _getErrorNode(Node node) => node;
+
+  bool _getIsConst(Node node) => false;
+
+  TypeArgumentListImpl? _getTypeArguments(Node node);
+
+  bool _isGenericInferenceDisabled(ResolverVisitor resolver) => false;
+
+  DartType _refineReturnType(
+          ResolverVisitor resolver, Node node, DartType returnType) =>
+      returnType;
+
+  void _reportWrongNumberOfTypeArguments(
+      ResolverVisitor resolver,
+      TypeArgumentList typeArgumentList,
+      FunctionType rawType,
+      List<TypeParameterElement> typeParameters) {
+    resolver.errorReporter.reportErrorForNode(
+      _wrongNumberOfTypeArgumentsErrorCode,
+      typeArgumentList,
+      [
+        rawType,
+        typeParameters.length,
+        typeArgumentList.arguments.length,
+      ],
+    );
+  }
+
+  List<ParameterElement>? _storeResult(
+      Node node, List<DartType>? typeArgumentTypes, FunctionType? invokeType) {
+    return invokeType?.parameters;
+  }
+}
+
+/// Specialization of [InvocationInferrer] for performing type inference on AST
+/// nodes of type [FunctionExpressionInvocation].
+class FunctionExpressionInvocationInferrer
+    extends InvocationExpressionInferrer<FunctionExpressionInvocationImpl> {
+  const FunctionExpressionInvocationInferrer() : super._();
+
+  @override
+  ExpressionImpl _getErrorNode(FunctionExpressionInvocationImpl node) =>
+      node.function;
+}
+
+/// Specialization of [InvocationInferrer] for performing type inference on AST
+/// nodes of type [InstanceCreationExpression].
+class InstanceCreationInferrer
+    extends FullInvocationInferrer<InstanceCreationExpressionImpl> {
+  const InstanceCreationInferrer() : super._();
+
+  @override
+  bool get _needsTypeArgumentBoundsCheck => true;
+
+  @override
+  ArgumentListImpl _getArgumentList(InstanceCreationExpressionImpl node) =>
+      node.argumentList;
+
+  @override
+  ConstructorNameImpl _getErrorNode(InstanceCreationExpressionImpl node) =>
+      node.constructorName;
+
+  @override
+  bool _getIsConst(InstanceCreationExpressionImpl node) => node.isConst;
+
+  @override
+  TypeArgumentListImpl? _getTypeArguments(InstanceCreationExpressionImpl node) {
+    // For an instance creation expression the type arguments are on the
+    // constructor name.
+    return node.constructorName.type.typeArguments;
+  }
+
+  @override
+  void _reportWrongNumberOfTypeArguments(
+      ResolverVisitor resolver,
+      TypeArgumentList typeArgumentList,
+      FunctionType rawType,
+      List<TypeParameterElement> typeParameters) {
+    // Error reporting for instance creations is done elsewhere.
+  }
+
+  @override
+  List<ParameterElement>? _storeResult(InstanceCreationExpressionImpl node,
+      List<DartType>? typeArgumentTypes, FunctionType? invokeType) {
+    if (invokeType != null) {
+      var constructedType = invokeType.returnType;
+      node.constructorName.type.type = constructedType;
+      var constructorElement = ConstructorMember.from(
+        node.constructorName.staticElement!,
+        constructedType as InterfaceType,
+      );
+      node.constructorName.staticElement = constructorElement;
+      return constructorElement.parameters;
+    }
+    return null;
+  }
+}
+
+/// Specialization of [InvocationInferrer] for performing type inference on AST
+/// nodes derived from [InvocationExpression].
+abstract class InvocationExpressionInferrer<
+        Node extends InvocationExpressionImpl>
+    extends FullInvocationInferrer<Node> {
+  const InvocationExpressionInferrer._() : super._();
+
+  @override
+  ArgumentListImpl _getArgumentList(Node node) => node.argumentList;
+
+  @override
+  Expression _getErrorNode(Node node) => node.function;
+
+  @override
+  TypeArgumentListImpl? _getTypeArguments(Node node) => node.typeArguments;
+
+  @override
+  List<ParameterElement>? _storeResult(
+      Node node, List<DartType>? typeArgumentTypes, FunctionType? invokeType) {
+    node.typeArgumentTypes = typeArgumentTypes;
+    node.staticInvokeType = invokeType ?? DynamicTypeImpl.instance;
+    return super._storeResult(node, typeArgumentTypes, invokeType);
+  }
+}
+
+/// Base class containing functionality for performing type inference on AST
+/// nodes that invoke a method, function, or constructor.
+abstract class InvocationInferrer<Node extends AstNodeImpl> {
+  const InvocationInferrer._();
+
+  /// Performs type inference on an invocation expression of type [Node].
+  /// [rawType] should be the type of the function the invocation is resolved to
+  /// (with type arguments not applied yet).
+  void resolveInvocation({
+    required ResolverVisitor resolver,
+    required Node node,
+    required FunctionType? rawType,
+    required DartType? contextType,
+    required List<WhyNotPromotedGetter> whyNotPromotedList,
+  }) {
+    var parameters = rawType?.parameters;
+    var namedParameters = <String, ParameterElement>{};
+    if (parameters != null) {
+      for (var i = 0; i < parameters.length; i++) {
+        var parameter = parameters[i];
+        if (parameter.isNamed) {
+          namedParameters[parameter.name] = parameter;
+        }
+      }
+    }
+    var argumentList = _getArgumentList(node);
+    resolver.checkUnreachableNode(argumentList);
+    var flow = resolver.flowAnalysis.flow;
+    var positionalParameterIndex = 0;
+    for (var argument in _iterateArguments(resolver, argumentList)) {
+      ParameterElement? parameter;
+      if (argument is NamedExpression) {
+        parameter = namedParameters[argument.name.label.name];
+      } else if (parameters != null) {
+        while (positionalParameterIndex < parameters.length) {
+          parameter = parameters[positionalParameterIndex++];
+          if (!parameter.isNamed) {
+            break;
+          }
+        }
+      }
+      DartType? parameterContextType;
+      if (parameter != null) {
+        var parameterType = parameter.type;
+        parameterContextType = _computeContextForArgument(
+            resolver, node, parameterType, contextType);
+      }
+      resolver.analyzeExpression(argument, parameterContextType);
+      if (flow != null) {
+        whyNotPromotedList.add(flow.whyNotPromoted(argument));
+      }
+    }
+  }
+
+  /// Computes the type context that should be used when evaluating a particular
+  /// argument of the invocation.  Usually this is just the type of the
+  /// corresponding parameter, but it can be different for certain primitive
+  /// numeric operations.
+  DartType? _computeContextForArgument(ResolverVisitor resolver, Node node,
+          DartType parameterType, DartType? methodInvocationContext) =>
+      parameterType;
+
+  /// Gets the argument list for the invocation.  TODO(paulberry): remove?
+  ArgumentListImpl _getArgumentList(Node node);
+
+  /// Iterates through the argument list for the invocation.  Usually this is
+  /// just a simple iteration through the arguments, but in certain cases, some
+  /// flow analysis methods need to be called in between visiting the various
+  /// arguments.
+  Iterable<Expression> _iterateArguments(
+          ResolverVisitor resolver, ArgumentList argumentList) =>
+      argumentList.arguments;
+
+  /// Computes the return type of the method or function represented by the
+  /// given type that is being invoked.
+  static DartType computeInvokeReturnType(DartType? type) {
+    if (type is FunctionType) {
+      return type.returnType;
+    } else {
+      return DynamicTypeImpl.instance;
+    }
+  }
+}
+
+/// Specialization of [InvocationInferrer] for performing type inference on AST
+/// nodes of type [MethodInvocation].
+class MethodInvocationInferrer
+    extends InvocationExpressionInferrer<MethodInvocationImpl> {
+  /// Gets the appropriate instance of [MethodInvocation] for the given [node].
+  ///
+  /// This factory takes care of the fact that invocations of `identical` need
+  /// to have special integration with flow analysis.
+  factory MethodInvocationInferrer.forNode(MethodInvocationImpl node) {
+    var invokedMethod = node.methodName.staticElement;
+    if (invokedMethod != null &&
+        invokedMethod.name == 'identical' &&
+        invokedMethod.library!.isDartCore &&
+        node.argumentList.arguments.length == 2) {
+      return const _IdenticalInvocationInferrer._();
+    } else {
+      return const MethodInvocationInferrer._();
+    }
+  }
+
+  const MethodInvocationInferrer._() : super._();
+
+  @override
+  DartType? _computeContextForArgument(
+      ResolverVisitor resolver,
+      MethodInvocationImpl node,
+      DartType parameterType,
+      DartType? methodInvocationContext) {
+    var contextType = super._computeContextForArgument(
+        resolver, node, parameterType, methodInvocationContext);
+    var targetType = node.realTarget?.staticType;
+    if (targetType != null) {
+      contextType = resolver.typeSystem.refineNumericInvocationContext(
+          targetType,
+          node.methodName.staticElement,
+          methodInvocationContext,
+          parameterType);
+    }
+    return contextType;
+  }
+
+  @override
+  DartType _refineReturnType(ResolverVisitor resolver,
+      MethodInvocationImpl node, DartType returnType) {
+    var targetType = node.realTarget?.staticType;
+    if (targetType != null) {
+      returnType = resolver.typeSystem.refineNumericInvocationType(
+        targetType,
+        node.methodName.staticElement,
+        [
+          for (var argument in node.argumentList.arguments) argument.typeOrThrow
+        ],
+        returnType,
+      );
+    }
+    return returnType;
+  }
+}
+
+/// Specialization of [InvocationInferrer] for performing type inference on AST
+/// nodes of type [RedirectingConstructorInvocation].
+class RedirectingConstructorInvocationInferrer
+    extends InvocationInferrer<RedirectingConstructorInvocationImpl> {
+  const RedirectingConstructorInvocationInferrer() : super._();
+
+  @override
+  ArgumentListImpl _getArgumentList(
+          RedirectingConstructorInvocationImpl node) =>
+      node.argumentList;
+}
+
+/// Specialization of [InvocationInferrer] for performing type inference on AST
+/// nodes of type [SuperConstructorInvocation].
+class SuperConstructorInvocationInferrer
+    extends InvocationInferrer<SuperConstructorInvocationImpl> {
+  const SuperConstructorInvocationInferrer() : super._();
+
+  @override
+  ArgumentListImpl _getArgumentList(SuperConstructorInvocationImpl node) =>
+      node.argumentList;
+}
+
+/// Specialization of [InvocationInferrer] for performing type inference on AST
+/// nodes of type [MethodInvocation] that resolve to the core function
+/// `identical`.  (Such nodes need to be handled in a special way due to the
+/// interaction between `identical` and flow analysis).
+class _IdenticalInvocationInferrer extends MethodInvocationInferrer {
+  const _IdenticalInvocationInferrer._() : super._();
+
+  @override
+  Iterable<Expression> _iterateArguments(
+      ResolverVisitor resolver, ArgumentList argumentList) sync* {
+    var flow = resolver.flowAnalysis.flow;
+    var arguments = argumentList.arguments;
+    assert(arguments.length == 2);
+    var firstArg = arguments[0];
+    yield firstArg;
+    firstArg = arguments[0]; // In case it was rewritten
+    flow?.equalityOp_rightBegin(firstArg, firstArg.typeOrThrow);
+    var secondArg = arguments[1];
+    yield secondArg;
+    secondArg = arguments[1]; // In case it was rewritten
+    flow?.equalityOp_end(
+        argumentList.parent as Expression, secondArg, secondArg.typeOrThrow);
+  }
+}
diff --git a/pkg/analyzer/lib/src/dart/resolver/method_invocation_resolver.dart b/pkg/analyzer/lib/src/dart/resolver/method_invocation_resolver.dart
index 0cc6306..724f3c1 100644
--- a/pkg/analyzer/lib/src/dart/resolver/method_invocation_resolver.dart
+++ b/pkg/analyzer/lib/src/dart/resolver/method_invocation_resolver.dart
@@ -15,6 +15,7 @@
 import 'package:analyzer/src/dart/element/type_system.dart';
 import 'package:analyzer/src/dart/resolver/extension_member_resolver.dart';
 import 'package:analyzer/src/dart/resolver/invocation_inference_helper.dart';
+import 'package:analyzer/src/dart/resolver/invocation_inferrer.dart';
 import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer/src/generated/migratable_ast_info_provider.dart';
 import 'package:analyzer/src/generated/resolver.dart';
@@ -323,38 +324,17 @@
     );
   }
 
-  /// [InvocationExpression.staticInvokeType] has been set for the [node].
-  /// Use it to set context for arguments, and resolve them.
-  void _resolveArguments(
-      MethodInvocationImpl node, List<WhyNotPromotedGetter> whyNotPromotedList,
-      {required DartType? contextType}) {
-    // TODO(scheglov) This is bad, don't write raw type, carry it
-    var callerType = _inferenceHelper.inferArgumentTypesForInvocation(
-      node,
-      node.methodName.staticType,
-      contextType: contextType,
-    );
-    _resolver.analyzeArgumentList(node.argumentList,
-        callerType is FunctionType ? callerType.parameters : null,
-        whyNotPromotedList: whyNotPromotedList,
-        methodInvocationContext: contextType);
-  }
-
   void _resolveArguments_finishInference(
       MethodInvocationImpl node, List<WhyNotPromotedGetter> whyNotPromotedList,
       {required DartType? contextType}) {
-    _resolveArguments(node, whyNotPromotedList, contextType: contextType);
-
-    // TODO(scheglov) This is bad, don't put / get raw FunctionType this way.
-    _inferenceHelper.inferGenericInvocationExpression(
-      node,
-      node.methodName.staticType,
-      contextType: contextType,
-    );
-
-    DartType staticStaticType = _inferenceHelper.computeInvokeReturnType(
-      node.staticInvokeType,
-    );
+    var methodInvocationInferrer = MethodInvocationInferrer.forNode(node);
+    var rawType = node.methodName.staticType;
+    DartType staticStaticType = methodInvocationInferrer.resolveInvocation(
+        resolver: _resolver,
+        node: node,
+        rawType: rawType is FunctionType ? rawType : null,
+        contextType: contextType,
+        whyNotPromotedList: whyNotPromotedList);
     _inferenceHelper.recordStaticType(node, staticStaticType,
         contextType: contextType);
   }
@@ -473,29 +453,32 @@
     var objectElement = _typeSystem.typeProvider.objectElement;
     var target = objectElement.getMethod(nameNode.name);
 
-    var hasMatchingObjectMethod = false;
+    FunctionType? rawType;
     if (target is MethodElement && !target.isStatic) {
       var arguments = node.argumentList.arguments;
-      hasMatchingObjectMethod = arguments.length == target.parameters.length &&
-          !arguments.any((e) => e is NamedExpression);
+      var hasMatchingObjectMethod =
+          arguments.length == target.parameters.length &&
+              !arguments.any((e) => e is NamedExpression);
       if (hasMatchingObjectMethod) {
         target = _resolver.toLegacyElement(target);
         nameNode.staticElement = target;
-        node.staticInvokeType = target.type;
+        rawType = target.type;
         node.staticType = target.returnType;
       }
     }
 
-    if (!hasMatchingObjectMethod) {
+    if (rawType == null) {
       nameNode.staticType = DynamicTypeImpl.instance;
-      node.staticInvokeType = DynamicTypeImpl.instance;
       node.staticType = DynamicTypeImpl.instance;
     }
 
     _setExplicitTypeArgumentTypes();
-    _resolver.analyzeArgumentList(node.argumentList, null,
+    MethodInvocationInferrer.forNode(node).resolveInvocation(
+        resolver: _resolver,
+        node: node,
+        rawType: rawType,
         whyNotPromotedList: whyNotPromotedList,
-        methodInvocationContext: contextType);
+        contextType: contextType);
   }
 
   void _resolveReceiverFunctionBounded(
@@ -563,7 +546,12 @@
       node.staticInvokeType = _dynamicType;
       node.staticType = NeverTypeImpl.instance;
 
-      _resolveArguments(node, whyNotPromotedList, contextType: contextType);
+      MethodInvocationInferrer.forNode(node).resolveInvocation(
+          resolver: _resolver,
+          node: node,
+          rawType: null,
+          contextType: contextType,
+          whyNotPromotedList: whyNotPromotedList);
 
       _resolver.errorReporter.reportErrorForNode(
         HintCode.RECEIVER_OF_TYPE_NEVER,
@@ -577,7 +565,12 @@
       node.staticInvokeType = _dynamicType;
       node.staticType = _dynamicType;
 
-      _resolveArguments(node, whyNotPromotedList, contextType: contextType);
+      MethodInvocationInferrer.forNode(node).resolveInvocation(
+          resolver: _resolver,
+          node: node,
+          rawType: null,
+          contextType: contextType,
+          whyNotPromotedList: whyNotPromotedList);
       return;
     }
   }
diff --git a/pkg/analyzer/lib/src/dart/resolver/postfix_expression_resolver.dart b/pkg/analyzer/lib/src/dart/resolver/postfix_expression_resolver.dart
index 4cc71c9..9667c37f 100644
--- a/pkg/analyzer/lib/src/dart/resolver/postfix_expression_resolver.dart
+++ b/pkg/analyzer/lib/src/dart/resolver/postfix_expression_resolver.dart
@@ -14,6 +14,7 @@
 import 'package:analyzer/src/dart/error/syntactic_errors.dart';
 import 'package:analyzer/src/dart/resolver/assignment_expression_resolver.dart';
 import 'package:analyzer/src/dart/resolver/invocation_inference_helper.dart';
+import 'package:analyzer/src/dart/resolver/invocation_inferrer.dart';
 import 'package:analyzer/src/dart/resolver/type_property_resolver.dart';
 import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer/src/generated/resolver.dart';
@@ -97,11 +98,11 @@
       // We are invoking a getter and then invoking the returned function.
       //
       FunctionType propertyType = element.type;
-      return _resolver.inferenceHelper.computeInvokeReturnType(
+      return InvocationInferrer.computeInvokeReturnType(
         propertyType.returnType,
       );
     } else if (element is ExecutableElement) {
-      return _resolver.inferenceHelper.computeInvokeReturnType(element.type);
+      return InvocationInferrer.computeInvokeReturnType(element.type);
     }
     return DynamicTypeImpl.instance;
   }
diff --git a/pkg/analyzer/lib/src/dart/resolver/prefix_expression_resolver.dart b/pkg/analyzer/lib/src/dart/resolver/prefix_expression_resolver.dart
index 484e305..fc71e4f 100644
--- a/pkg/analyzer/lib/src/dart/resolver/prefix_expression_resolver.dart
+++ b/pkg/analyzer/lib/src/dart/resolver/prefix_expression_resolver.dart
@@ -14,6 +14,7 @@
 import 'package:analyzer/src/dart/element/type_system.dart';
 import 'package:analyzer/src/dart/resolver/assignment_expression_resolver.dart';
 import 'package:analyzer/src/dart/resolver/invocation_inference_helper.dart';
+import 'package:analyzer/src/dart/resolver/invocation_inferrer.dart';
 import 'package:analyzer/src/dart/resolver/type_property_resolver.dart';
 import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer/src/generated/resolver.dart';
@@ -108,11 +109,11 @@
       // We are invoking a getter and then invoking the returned function.
       //
       var propertyType = element.type;
-      return _resolver.inferenceHelper.computeInvokeReturnType(
+      return InvocationInferrer.computeInvokeReturnType(
         propertyType.returnType,
       );
     } else if (element is ExecutableElement) {
-      return _resolver.inferenceHelper.computeInvokeReturnType(element.type);
+      return InvocationInferrer.computeInvokeReturnType(element.type);
     }
     return DynamicTypeImpl.instance;
   }
diff --git a/pkg/analyzer/lib/src/generated/resolver.dart b/pkg/analyzer/lib/src/generated/resolver.dart
index 5d242c3..92f03a7 100644
--- a/pkg/analyzer/lib/src/generated/resolver.dart
+++ b/pkg/analyzer/lib/src/generated/resolver.dart
@@ -43,6 +43,7 @@
 import 'package:analyzer/src/dart/resolver/function_reference_resolver.dart';
 import 'package:analyzer/src/dart/resolver/instance_creation_expression_resolver.dart';
 import 'package:analyzer/src/dart/resolver/invocation_inference_helper.dart';
+import 'package:analyzer/src/dart/resolver/invocation_inferrer.dart';
 import 'package:analyzer/src/dart/resolver/lexical_lookup.dart';
 import 'package:analyzer/src/dart/resolver/method_invocation_resolver.dart';
 import 'package:analyzer/src/dart/resolver/postfix_expression_resolver.dart';
@@ -248,6 +249,8 @@
 
   late final AnnotationResolver _annotationResolver = AnnotationResolver(this);
 
+  final bool genericMetadataIsEnabled;
+
   /// Initialize a newly created visitor to resolve the nodes in an AST node.
   ///
   /// The [definingLibrary] is the element for the library containing the node
@@ -300,7 +303,9 @@
           isNonNullableByDefault: definingLibrary.isNonNullableByDefault,
         ),
         _featureSet = featureSet,
-        migrationResolutionHooks = migrationResolutionHooks {
+        migrationResolutionHooks = migrationResolutionHooks,
+        genericMetadataIsEnabled =
+            definingLibrary.featureSet.isEnabled(Feature.generic_metadata) {
     var analysisOptions =
         definingLibrary.context.analysisOptions as AnalysisOptionsImpl;
 
@@ -403,73 +408,6 @@
   bool get _isNonNullableByDefault =>
       _featureSet.isEnabled(Feature.non_nullable);
 
-  void analyzeArgumentList(
-      ArgumentList node, List<ParameterElement>? parameters,
-      {bool isIdentical = false,
-      List<WhyNotPromotedGetter>? whyNotPromotedList,
-      DartType? methodInvocationContext}) {
-    whyNotPromotedList ??= [];
-    NodeList<Expression> arguments = node.arguments;
-    var namedParameters = <String, ParameterElement>{};
-    DartType? targetType;
-    Element? methodElement;
-    if (parameters != null) {
-      for (var i = 0; i < parameters.length; i++) {
-        var parameter = parameters[i];
-        if (parameter.isNamed) {
-          namedParameters[parameter.name] = parameter;
-        }
-      }
-
-      var parent = node.parent;
-      if (parent is MethodInvocation) {
-        targetType = parent.realTarget?.staticType;
-        methodElement = parent.methodName.staticElement;
-      }
-    }
-    checkUnreachableNode(node);
-    int length = arguments.length;
-    var flow = flowAnalysis.flow;
-    var positionalParameterIndex = 0;
-    for (var i = 0; i < length; i++) {
-      if (isIdentical && length > 1 && i == 1) {
-        var firstArg = arguments[0];
-        flow?.equalityOp_rightBegin(firstArg, firstArg.typeOrThrow);
-      }
-      var argument = arguments[i];
-      ParameterElement? parameter;
-      if (argument is NamedExpression) {
-        parameter = namedParameters[argument.name.label.name];
-      } else if (parameters != null) {
-        while (positionalParameterIndex < parameters.length) {
-          parameter = parameters[positionalParameterIndex++];
-          if (!parameter.isNamed) {
-            break;
-          }
-        }
-      }
-      DartType? contextType;
-      if (parameter != null) {
-        var parameterType = parameter.type;
-        if (targetType != null) {
-          contextType = typeSystem.refineNumericInvocationContext(targetType,
-              methodElement, methodInvocationContext, parameterType);
-        } else {
-          contextType = parameterType;
-        }
-      }
-      analyzeExpression(argument, contextType);
-      if (flow != null) {
-        whyNotPromotedList.add(flow.whyNotPromoted(arguments[i]));
-      }
-    }
-    if (isIdentical && length > 1) {
-      var secondArg = arguments[1];
-      flow?.equalityOp_end(
-          node.parent as Expression, secondArg, secondArg.typeOrThrow);
-    }
-  }
-
   void analyzeExpression(Expression expression, DartType? contextType) {
     if (contextType != null && contextType.isDynamic) {
       contextType = null;
@@ -1042,12 +980,6 @@
   }
 
   @override
-  void visitArgumentList(ArgumentList node) {
-    assert(false, 'analyzeArgumentList should be used instead');
-    analyzeArgumentList(node, null);
-  }
-
-  @override
   void visitAsExpression(AsExpression node, {DartType? contextType}) {
     checkUnreachableNode(node);
     node.visitChildren(this);
@@ -1600,21 +1532,28 @@
   }
 
   @override
-  void visitExtensionOverride(ExtensionOverride node, {DartType? contextType}) {
+  void visitExtensionOverride(covariant ExtensionOverrideImpl node,
+      {DartType? contextType}) {
     var whyNotPromotedList = <Map<DartType, NonPromotionReason> Function()>[];
     node.extensionName.accept(this);
     node.typeArguments?.accept(this);
 
     var receiverContextType =
         ExtensionMemberResolver(this).computeOverrideReceiverContextType(node);
-    analyzeArgumentList(
-        node.argumentList,
-        receiverContextType == null
+    const ExtensionOverrideInferrer().resolveInvocation(
+        resolver: this,
+        node: node,
+        rawType: receiverContextType == null
             ? null
-            : [
-                ParameterElementImpl.synthetic(
-                    null, receiverContextType, ParameterKind.REQUIRED)
-              ],
+            : FunctionTypeImpl(
+                typeFormals: const [],
+                parameters: [
+                    ParameterElementImpl.synthetic(
+                        null, receiverContextType, ParameterKind.REQUIRED)
+                  ],
+                returnType: DynamicTypeImpl.instance,
+                nullabilitySuffix: NullabilitySuffix.none),
+        contextType: null,
         whyNotPromotedList: whyNotPromotedList);
 
     extensionResolver.resolveOverride(node, whyNotPromotedList);
@@ -2223,7 +2162,11 @@
     var whyNotPromotedList = <Map<DartType, NonPromotionReason> Function()>[];
     elementResolver.visitRedirectingConstructorInvocation(
         node as RedirectingConstructorInvocationImpl);
-    analyzeArgumentList(node.argumentList, node.staticElement?.parameters,
+    const RedirectingConstructorInvocationInferrer().resolveInvocation(
+        resolver: this,
+        node: node,
+        rawType: node.staticElement?.type,
+        contextType: null,
         whyNotPromotedList: whyNotPromotedList);
     checkForArgumentTypesNotAssignableInList(
         node.argumentList, whyNotPromotedList);
@@ -2327,7 +2270,11 @@
     var whyNotPromotedList = <Map<DartType, NonPromotionReason> Function()>[];
     elementResolver.visitSuperConstructorInvocation(
         node as SuperConstructorInvocationImpl);
-    analyzeArgumentList(node.argumentList, node.staticElement?.parameters,
+    const SuperConstructorInvocationInferrer().resolveInvocation(
+        resolver: this,
+        node: node,
+        rawType: node.staticElement?.type,
+        contextType: null,
         whyNotPromotedList: whyNotPromotedList);
     checkForArgumentTypesNotAssignableInList(
         node.argumentList, whyNotPromotedList);
diff --git a/pkg/analyzer/lib/src/generated/static_type_analyzer.dart b/pkg/analyzer/lib/src/generated/static_type_analyzer.dart
index a3ac1e3..946b08f 100644
--- a/pkg/analyzer/lib/src/generated/static_type_analyzer.dart
+++ b/pkg/analyzer/lib/src/generated/static_type_analyzer.dart
@@ -6,7 +6,6 @@
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/ast/ast.dart';
 import 'package:analyzer/src/dart/ast/extensions.dart';
-import 'package:analyzer/src/dart/element/member.dart' show ConstructorMember;
 import 'package:analyzer/src/dart/element/type_provider.dart';
 import 'package:analyzer/src/dart/element/type_system.dart';
 import 'package:analyzer/src/dart/resolver/invocation_inference_helper.dart';
@@ -155,22 +154,6 @@
     node.staticType = _dynamicType;
   }
 
-  /// The Dart Language Specification, 12.11.1: <blockquote>The static type of a new expression of
-  /// either the form <i>new T.id(a<sub>1</sub>, &hellip;, a<sub>n</sub>)</i> or the form <i>new
-  /// T(a<sub>1</sub>, &hellip;, a<sub>n</sub>)</i> is <i>T</i>.</blockquote>
-  ///
-  /// The Dart Language Specification, 12.11.2: <blockquote>The static type of a constant object
-  /// expression of either the form <i>const T.id(a<sub>1</sub>, &hellip;, a<sub>n</sub>)</i> or the
-  /// form <i>const T(a<sub>1</sub>, &hellip;, a<sub>n</sub>)</i> is <i>T</i>. </blockquote>
-  void visitInstanceCreationExpression(
-      covariant InstanceCreationExpressionImpl node,
-      {required DartType? contextType}) {
-    _inferInstanceCreationExpression(node, contextType: contextType);
-    _inferenceHelper.recordStaticType(
-        node, node.constructorName.type.typeOrThrow,
-        contextType: contextType);
-  }
-
   /// <blockquote>
   /// An integer literal has static type \code{int}, unless the surrounding
   /// static context type is a type which \code{int} is not assignable to, and
@@ -342,56 +325,4 @@
     }
     return type;
   }
-
-  /// Given an instance creation of a possibly generic type, infer the type
-  /// arguments using the current context type as well as the argument types.
-  void _inferInstanceCreationExpression(InstanceCreationExpressionImpl node,
-      {required DartType? contextType}) {
-    // TODO(leafp): Currently, we may re-infer types here, since we
-    // sometimes resolve multiple times.  We should really check that we
-    // have not already inferred something.  However, the obvious ways to
-    // check this don't work, since we may have been instantiated
-    // to bounds in an earlier phase, and we *do* want to do inference
-    // in that case.
-
-    // Get back to the uninstantiated generic constructor.
-    // TODO(jmesserly): should we store this earlier in resolution?
-    // Or look it up, instead of jumping backwards through the Member?
-    var constructorName = node.constructorName;
-    var elementToInfer = _resolver.inferenceHelper.constructorElementToInfer(
-      constructorName: constructorName,
-      definingLibrary: _resolver.definingLibrary,
-    );
-
-    // If the constructor is not generic, we are done.
-    if (elementToInfer == null) {
-      return;
-    }
-
-    var typeName = constructorName.type;
-    var typeArguments = typeName.typeArguments;
-
-    var constructorType = elementToInfer.asType;
-    var arguments = node.argumentList;
-    var inferred = _resolver.inferenceHelper.inferGenericInvoke(
-        node, constructorType, typeArguments, arguments, constructorName,
-        isConst: node.isConst, contextReturnType: contextType);
-
-    if (inferred != null) {
-      // Fix up the parameter elements based on inferred method.
-      arguments.correspondingStaticParameters =
-          ResolverVisitor.resolveArgumentsToParameters(
-        argumentList: arguments,
-        parameters: inferred.parameters,
-      );
-      typeName.type = inferred.returnType;
-      // Update the static element as well. This is used in some cases, such as
-      // computing constant values. It is stored in two places.
-      var constructorElement = ConstructorMember.from(
-        elementToInfer.element,
-        inferred.returnType as InterfaceType,
-      );
-      constructorName.staticElement = constructorElement;
-    }
-  }
 }
diff --git a/pkg/analyzer/test/generated/non_error_resolver_test.dart b/pkg/analyzer/test/generated/non_error_resolver_test.dart
index 456f594..bc4e648 100644
--- a/pkg/analyzer/test/generated/non_error_resolver_test.dart
+++ b/pkg/analyzer/test/generated/non_error_resolver_test.dart
@@ -1419,10 +1419,8 @@
 ''');
     var x = findNode.namedExpression('arg: true');
     var y = x.staticParameterElement!;
-    // Note: the staticParameterElement is synthetic; see
-    // https://github.com/dart-lang/sdk/issues/48500
-    expect(y, isNot(TypeMatcher<ParameterMember>()));
-    expect(y.enclosingElement, isNull);
+    expect(y, TypeMatcher<ParameterMember>());
+    expect(y.declaration, findElement.parameter('arg'));
   }
 
   test_generic_staticParameterElement_instanceCreation_implicitNew() async {
@@ -1447,10 +1445,8 @@
 ''');
     var x = findNode.namedExpression('arg: true');
     var y = x.staticParameterElement!;
-    // Note: the staticParameterElement is synthetic; see
-    // https://github.com/dart-lang/sdk/issues/48500
-    expect(y, isNot(TypeMatcher<ParameterMember>()));
-    expect(y.enclosingElement, isNull);
+    expect(y, TypeMatcher<ParameterMember>());
+    expect(y.declaration, findElement.parameter('arg'));
   }
 
   test_generic_staticParameterElement_methodCall() async {
diff --git a/pkg/analyzer/test/src/diagnostics/type_argument_not_matching_bounds_test.dart b/pkg/analyzer/test/src/diagnostics/type_argument_not_matching_bounds_test.dart
index 2944a2b..a4c3dd6 100644
--- a/pkg/analyzer/test/src/diagnostics/type_argument_not_matching_bounds_test.dart
+++ b/pkg/analyzer/test/src/diagnostics/type_argument_not_matching_bounds_test.dart
@@ -310,6 +310,21 @@
 ''');
   }
 
+  Future<void> test_nonFunctionTypeAlias_parameter() async {
+    await assertErrorsInCode('''
+class A {}
+class B extends A {}
+class D<T> {}
+typedef Alias<T extends B> = D<T>;
+main() {
+  D d = Alias<A>();
+}
+''', [
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 94, 1),
+      error(CompileTimeErrorCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS, 104, 1),
+    ]);
+  }
+
   test_notRegularBounded_notSuperBounded_parameter_invariant() async {
     await assertErrorsInCode(r'''
 typedef A<X> = X Function(X);
diff --git a/pkg/compiler/lib/src/js_emitter/startup_emitter/model_emitter.dart b/pkg/compiler/lib/src/js_emitter/startup_emitter/model_emitter.dart
index 0783eff..133789f 100644
--- a/pkg/compiler/lib/src/js_emitter/startup_emitter/model_emitter.dart
+++ b/pkg/compiler/lib/src/js_emitter/startup_emitter/model_emitter.dart
@@ -366,11 +366,19 @@
     return js.Comment(generatedBy(_options, flavor: '$flavor'));
   }
 
-  js.Statement buildDeferredInitializerGlobal() {
-    return js.js.statement(
-        'self.#deferredInitializers = '
-        'self.#deferredInitializers || Object.create(null);',
-        {'deferredInitializers': deferredInitializersGlobal});
+  List<js.Statement> buildDeferredInitializerGlobal() {
+    return [
+      js.js.statement(
+          'self.#deferredInitializers = '
+          'self.#deferredInitializers || Object.create(null);',
+          {'deferredInitializers': deferredInitializersGlobal}),
+      if (_options.experimentalTrackAllocations)
+        js.js.statement(
+            'self.#deferredInitializers["allocations"] = '
+            'self.#deferredInitializers["allocations"] '
+            '|| Object.create(null)',
+            {'deferredInitializers': deferredInitializersGlobal})
+    ];
   }
 
   js.Statement buildStartupMetrics() {
@@ -421,7 +429,7 @@
     js.Program program = js.Program([
       buildGeneratedBy(),
       js.Comment(HOOKS_API_USAGE),
-      if (isSplit) buildDeferredInitializerGlobal(),
+      if (isSplit) ...buildDeferredInitializerGlobal(),
       if (_closedWorld.backendUsage.requiresStartupMetrics)
         buildStartupMetrics(),
       code
@@ -556,7 +564,7 @@
 
     js.Program program = js.Program([
       if (isFirst) buildGeneratedBy(),
-      if (isFirst) buildDeferredInitializerGlobal(),
+      if (isFirst) ...buildDeferredInitializerGlobal(),
       if (_options.experimentalTrackAllocations)
         js.js.statement("var allocations = #deferredGlobal['allocations']",
             {'deferredGlobal': deferredInitializersGlobal}),
diff --git a/tools/VERSION b/tools/VERSION
index b27473d..96ecaf9 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 17
 PATCH 0
-PRERELEASE 180
+PRERELEASE 181
 PRERELEASE_PATCH 0
\ No newline at end of file