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
new file mode 100644
index 0000000..cf4574c
--- /dev/null
+++ b/pkg/analyzer/lib/src/dart/resolver/instance_creation_expression_resolver.dart
@@ -0,0 +1,152 @@
+// 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/type.dart';
+import 'package:analyzer/src/dart/ast/ast.dart';
+import 'package:analyzer/src/dart/element/member.dart';
+import 'package:analyzer/src/generated/resolver.dart';
+
+/// A resolver for [InstanceCreationExpression] nodes.
+///
+/// This resolver is responsible for rewriting a given
+/// [InstanceCreationExpression] as a [MethodInvocation] if the parsed
+/// [ConstructorName]'s `type` resolves to a [FunctionReference] or
+/// [ConstructorReference], instead of a [TypeName].
+class InstanceCreationExpressionResolver {
+  /// The resolver driving this participant.
+  final ResolverVisitor _resolver;
+
+  InstanceCreationExpressionResolver(this._resolver);
+
+  void resolve(InstanceCreationExpressionImpl node) {
+    // The parser can parse certain code as [InstanceCreationExpression] when it
+    // might be an invocation of a method on a [FunctionReference] or
+    // [ConstructorReference]. In such a case, it is this resolver's
+    // responsibility to rewrite. For example, given:
+    //
+    //     a.m<int>.apply();
+    //
+    // the parser will give an InstanceCreationExpression (`a.m<int>.apply()`)
+    // with a name of `a.m<int>.apply` (ConstructorName) with a type of
+    // `a.m<int>` (TypeName with a name of `a.m` (PrefixedIdentifier) and
+    // typeArguments of `<int>`) and a name of `apply` (SimpleIdentifier). If
+    // `a.m<int>` is actually a function reference, then the
+    // InstanceCreationExpression needs to be rewritten as a MethodInvocation
+    // with a target of `a.m<int>` (a FunctionReference) and a name of `apply`.
+    if (node.keyword == null) {
+      var typeNameTypeArguments = node.constructorName.type.typeArguments;
+      if (typeNameTypeArguments != null) {
+        // This could be a method call on a function reference or a constructor
+        // reference.
+        _resolveWithTypeNameWithTypeArguments(node, typeNameTypeArguments);
+        return;
+      }
+    }
+
+    _resolveInstanceCreationExpression(node);
+  }
+
+  void _inferArgumentTypes(covariant InstanceCreationExpressionImpl node) {
+    var constructorName = node.constructorName;
+    var typeName = constructorName.type;
+    var typeArguments = typeName.typeArguments;
+    var elementToInfer = _resolver.inferenceHelper.constructorElementToInfer(
+      constructorName: constructorName,
+      definingLibrary: _resolver.definingLibrary,
+    );
+    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(
+          node, constructorType, typeArguments,
+          isConst: node.isConst, errorNode: node.constructorName);
+
+      if (inferred != null) {
+        var arguments = node.argumentList;
+        InferenceContext.setType(arguments, inferred);
+        // Fix up the parameter elements based on inferred method.
+        arguments.correspondingStaticParameters =
+            ResolverVisitor.resolveArgumentsToParameters(
+                arguments, inferred.parameters, null);
+
+        constructorName.type.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(
+          rawElement,
+          inferred.returnType as InterfaceType,
+        );
+        constructorName.staticElement = constructorElement;
+      }
+    }
+
+    if (inferred == null) {
+      var constructorElement = constructorName.staticElement;
+      if (constructorElement != null) {
+        var type = constructorElement.type;
+        type = _resolver.toLegacyTypeIfOptOut(type) as FunctionType;
+        InferenceContext.setType(node.argumentList, type);
+      }
+    }
+  }
+
+  void _resolveInstanceCreationExpression(InstanceCreationExpressionImpl node) {
+    var whyNotPromotedList = <WhyNotPromotedGetter>[];
+    node.constructorName.accept(_resolver);
+    _inferArgumentTypes(node);
+    _resolver.visitArgumentList(node.argumentList,
+        whyNotPromotedList: whyNotPromotedList);
+    node.accept(_resolver.elementResolver);
+    node.accept(_resolver.typeAnalyzer);
+    _resolver.checkForArgumentTypesNotAssignableInList(
+        node.argumentList, whyNotPromotedList);
+  }
+
+  /// Resolve [node] which has a [TypeName] with type arguments (given as
+  /// [typeNameTypeArguments]).
+  ///
+  /// The instance creation expression may actually be a method call on a
+  /// type-instantiated function reference or constructor reference.
+  void _resolveWithTypeNameWithTypeArguments(
+    InstanceCreationExpressionImpl node,
+    TypeArgumentListImpl typeNameTypeArguments,
+  ) {
+    var typeNameName = node.constructorName.type.name;
+    if (typeNameName is SimpleIdentifierImpl) {
+      // TODO(srawlins): Lookup the name and potentially rewrite `node` as a
+      // [MethodInvocation].
+      _resolveInstanceCreationExpression(node);
+      return;
+    } else if (typeNameName is PrefixedIdentifierImpl) {
+      // TODO(srawlins): Lookup the name and potentially rewrite `node` as a
+      // [MethodInvocation].
+      _resolveInstanceCreationExpression(node);
+    } else {
+      assert(
+          false, 'Unexpected typeNameName type: ${typeNameName.runtimeType}');
+      _resolveInstanceCreationExpression(node);
+    }
+  }
+}
diff --git a/pkg/analyzer/lib/src/generated/resolver.dart b/pkg/analyzer/lib/src/generated/resolver.dart
index 112f2e7..c175e24 100644
--- a/pkg/analyzer/lib/src/generated/resolver.dart
+++ b/pkg/analyzer/lib/src/generated/resolver.dart
@@ -21,8 +21,7 @@
 import 'package:analyzer/src/dart/ast/extensions.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/inheritance_manager3.dart';
-import 'package:analyzer/src/dart/element/member.dart'
-    show ConstructorMember, Member;
+import 'package:analyzer/src/dart/element/member.dart' show Member;
 import 'package:analyzer/src/dart/element/nullability_eliminator.dart';
 import 'package:analyzer/src/dart/element/scope.dart';
 import 'package:analyzer/src/dart/element/type.dart';
@@ -38,6 +37,7 @@
 import 'package:analyzer/src/dart/resolver/function_expression_invocation_resolver.dart';
 import 'package:analyzer/src/dart/resolver/function_expression_resolver.dart';
 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/lexical_lookup.dart';
 import 'package:analyzer/src/dart/resolver/method_invocation_resolver.dart';
@@ -253,6 +253,9 @@
 
   late final FunctionReferenceResolver _functionReferenceResolver;
 
+  late final InstanceCreationExpressionResolver
+      _instanceCreationExpressionResolver;
+
   /// Initialize a newly created visitor to resolve the nodes in an AST node.
   ///
   /// The [definingLibrary] is the element for the library containing the node
@@ -373,6 +376,8 @@
     typeAnalyzer = StaticTypeAnalyzer(this, migrationResolutionHooks);
     _functionReferenceResolver =
         FunctionReferenceResolver(this, _isNonNullableByDefault);
+    _instanceCreationExpressionResolver =
+        InstanceCreationExpressionResolver(this);
   }
 
   /// Return the element representing the function containing the current node,
@@ -1677,15 +1682,7 @@
   @override
   void visitInstanceCreationExpression(
       covariant InstanceCreationExpressionImpl node) {
-    var whyNotPromotedList = <Map<DartType, NonPromotionReason> Function()>[];
-    node.constructorName.accept(this);
-    _inferArgumentTypesForInstanceCreate(node);
-    visitArgumentList(node.argumentList,
-        whyNotPromotedList: whyNotPromotedList);
-    node.accept(elementResolver);
-    node.accept(typeAnalyzer);
-    checkForArgumentTypesNotAssignableInList(
-        node.argumentList, whyNotPromotedList);
+    _instanceCreationExpressionResolver.resolve(node);
   }
 
   @override
@@ -2176,72 +2173,6 @@
     return typeProvider.futureOrType(type);
   }
 
-  void _inferArgumentTypesForInstanceCreate(
-      covariant InstanceCreationExpressionImpl node) {
-    var constructorName = node.constructorName;
-
-    var typeName = constructorName.type;
-    var typeArguments = typeName.typeArguments;
-
-    var elementToInfer = inferenceHelper.constructorElementToInfer(
-      constructorName: constructorName,
-      definingLibrary: definingLibrary,
-    );
-
-    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 = inferenceHelper.inferArgumentTypesForGeneric(
-          node, constructorType, typeArguments,
-          isConst: node.isConst, errorNode: node.constructorName);
-
-      if (inferred != null) {
-        var arguments = node.argumentList;
-        InferenceContext.setType(arguments, inferred);
-        // Fix up the parameter elements based on inferred method.
-        arguments.correspondingStaticParameters =
-            resolveArgumentsToParameters(arguments, inferred.parameters, null);
-
-        constructorName.type.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(
-          rawElement,
-          inferred.returnType as InterfaceType,
-        );
-        constructorName.staticElement = constructorElement;
-      }
-    }
-
-    if (inferred == null) {
-      var constructorElement = constructorName.staticElement;
-      if (constructorElement != null) {
-        var type = constructorElement.type;
-        type = toLegacyTypeIfOptOut(type) as FunctionType;
-        InferenceContext.setType(node.argumentList, type);
-      }
-    }
-  }
-
   /// Continues resolution of a [FunctionExpressionInvocation] that was created
   /// from a rewritten [MethodInvocation]. The target function is already
   /// resolved.
diff --git a/tools/VERSION b/tools/VERSION
index 2713250..38834f5 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 14
 PATCH 0
-PRERELEASE 371
+PRERELEASE 372
 PRERELEASE_PATCH 0
\ No newline at end of file