diff --git a/pkg/analyzer/lib/error/error.dart b/pkg/analyzer/lib/error/error.dart
index 52d52dc..e6eb121 100644
--- a/pkg/analyzer/lib/error/error.dart
+++ b/pkg/analyzer/lib/error/error.dart
@@ -456,6 +456,7 @@
   CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS,
   CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS_CONSTRUCTOR,
   CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS_EXTENSION,
+  CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS_FUNCTION,
   CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS_METHOD,
   CompileTimeErrorCode.WRONG_TYPE_PARAMETER_VARIANCE_IN_SUPERINTERFACE,
   CompileTimeErrorCode.WRONG_TYPE_PARAMETER_VARIANCE_POSITION,
diff --git a/pkg/analyzer/lib/src/dart/resolver/exit_detector.dart b/pkg/analyzer/lib/src/dart/resolver/exit_detector.dart
index a09335c..adb9ff5 100644
--- a/pkg/analyzer/lib/src/dart/resolver/exit_detector.dart
+++ b/pkg/analyzer/lib/src/dart/resolver/exit_detector.dart
@@ -551,6 +551,9 @@
   }
 
   @override
+  bool visitTypeLiteral(TypeLiteral node) => _nodeExits(node.typeName);
+
+  @override
   bool visitTypeName(TypeName node) => false;
 
   @override
diff --git a/pkg/analyzer/lib/src/dart/resolver/function_reference_resolver.dart b/pkg/analyzer/lib/src/dart/resolver/function_reference_resolver.dart
index 96cc743..802fa11 100644
--- a/pkg/analyzer/lib/src/dart/resolver/function_reference_resolver.dart
+++ b/pkg/analyzer/lib/src/dart/resolver/function_reference_resolver.dart
@@ -4,10 +4,13 @@
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/dart/element/nullability_suffix.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/error/listener.dart';
 import 'package:analyzer/src/dart/ast/ast.dart';
+import 'package:analyzer/src/dart/ast/ast_factory.dart';
 import 'package:analyzer/src/dart/ast/extensions.dart';
+import 'package:analyzer/src/dart/ast/utilities.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/dart/resolver/resolution_result.dart';
 import 'package:analyzer/src/error/codes.dart';
@@ -22,25 +25,54 @@
   /// The resolver driving this participant.
   final ResolverVisitor _resolver;
 
-  FunctionReferenceResolver(this._resolver);
+  final bool _isNonNullableByDefault;
+
+  /// The type representing the type 'type'.
+  final InterfaceType _typeType;
+
+  FunctionReferenceResolver(this._resolver, this._isNonNullableByDefault)
+      : _typeType = _resolver.typeProvider.typeType;
 
   ErrorReporter get _errorReporter => _resolver.errorReporter;
 
+  NullabilitySuffix get _nullabilitySuffixForTypeNames =>
+      _isNonNullableByDefault ? NullabilitySuffix.none : NullabilitySuffix.star;
+
   void resolve(FunctionReferenceImpl node) {
     var function = node.function;
     node.typeArguments?.accept(_resolver);
 
     if (function is SimpleIdentifierImpl) {
       var element = _resolver.nameScope.lookup(function.name).getter;
-      if (element is ExecutableElement) {
+
+      // Classes and type aliases are checked first so as to include a
+      // PropertyAccess parent check, which does not need to be done for
+      // functions.
+      if (element is ClassElement || element is TypeAliasElement) {
+        // A type-instantiated constructor tearoff like `C<int>.name` or
+        // `prefix.C<int>.name` is initially represented as a [PropertyAccess]
+        // with a [FunctionReference] target.
+        if (node.parent is PropertyAccess) {
+          _resolveConstructorReference(node);
+          return;
+        } else if (element is ClassElement) {
+          function.staticElement = element;
+          _resolveDirectTypeLiteral(node, function, element);
+          return;
+        } else if (element is TypeAliasElement) {
+          function.staticElement = element;
+          _resolveTypeAlias(node: node, element: element, typeAlias: function);
+          return;
+        }
+      } else if (element is ExecutableElement) {
         function.staticElement = element;
-        _resolve(node: node, rawType: element.type);
+        _resolve(node: node, name: element.name, rawType: element.type);
         return;
       } else if (element is VariableElement) {
         var functionType = element.type;
         if (functionType is FunctionType) {
           function.accept(_resolver);
-          _resolve(node: node, rawType: functionType);
+          _resolve(node: node, name: element.name ?? '', rawType: functionType);
           return;
         }
       }
@@ -52,32 +84,7 @@
       var prefixElement =
           _resolver.nameScope.lookup(function.prefix.name).getter;
       if (prefixElement is PrefixElement) {
-        var nameNode = function.identifier;
-        var name = nameNode.name;
-        _resolveReceiverPrefix(node, prefixElement, nameNode, name);
-        return;
-      }
-
-      if (prefixElement is ClassElement) {
-        // TODO(srawlins): Rewrite `node` as a [TypeLiteral], then resolve the
-        // [TypeLiteral] instead of `function`.
-        function.accept(_resolver);
-        node.staticType = DynamicTypeImpl.instance;
-        return;
-      } else if (prefixElement is TypeAliasElement) {
-        var aliasedType = prefixElement.aliasedType;
-        if (aliasedType is InterfaceType) {
-          // TODO(srawlins): Rewrite `node` as a [TypeLiteral], then resolve
-          // the [TypeLiteral] instead of `function`.
-          function.accept(_resolver);
-          node.staticType = DynamicTypeImpl.instance;
-          return;
-        }
-      } else if (prefixElement is ExtensionElement) {
-        // TODO(srawlins): Rewrite `node` as a [TypeLiteral], then resolve the
-        // [TypeLiteral] instead of `function`.
-        function.accept(_resolver);
-        node.staticType = DynamicTypeImpl.instance;
+        _resolveReceiverPrefix(node, prefixElement, function);
         return;
       }
 
@@ -103,23 +110,61 @@
         methodElement = resolveTypeProperty(prefixType).getter;
       }
       if (methodElement is MethodElement) {
-        _resolveFunctionReferenceMethod(node: node, function: function);
+        _resolveFunctionReferenceMethod(
+            node: node, function: function, element: methodElement);
         return;
       }
 
-      // TODO(srawlins): Check for [ConstructorElement] and rewrite to
-      // [ConstructorReference] before resolving.
+      // TODO(srawlins): Need to report cases where [methodElement] is not
+      // generic. The 'test_instanceGetter_explicitReceiver' test case needs to
+      // be updated to handle this.
+
       function.accept(_resolver);
       node.staticType = DynamicTypeImpl.instance;
       return;
     }
 
-    if (function is PropertyAccess) {
+    if (function is PropertyAccessImpl) {
       function.accept(_resolver);
-      DartType functionType = function.typeOrThrow;
+      var target = function.target;
+      DartType targetType;
+      if (target is SuperExpressionImpl) {
+        targetType = target.typeOrThrow;
+      } else if (target is ThisExpressionImpl) {
+        targetType = target.typeOrThrow;
+      } else if (target is SimpleIdentifierImpl) {
+        var targetElement = _resolver.nameScope.lookup(target.name).getter;
+        if (targetElement is VariableElement) {
+          targetType = targetElement.type;
+        } else if (targetElement is PropertyAccessorElement) {
+          targetType = targetElement.returnType;
+        } else {
+          // TODO(srawlins): Can we get here?
+          node.staticType = DynamicTypeImpl.instance;
+          return;
+        }
+      } else {
+        // TODO(srawlins): Can we get here? PrefixedIdentifier?
+        node.staticType = DynamicTypeImpl.instance;
+        return;
+      }
+      var propertyElement = _resolver.typePropertyResolver
+          .resolve(
+            receiver: function.realTarget,
+            receiverType: targetType,
+            name: function.propertyName.name,
+            propertyErrorEntity: function.propertyName,
+            nameErrorEntity: function,
+          )
+          .getter;
 
-      if (functionType is FunctionType) {
-        _resolve(node: node, rawType: function.staticType as FunctionType);
+      var functionType = function.typeOrThrow;
+      if (functionType is FunctionType && propertyElement != null) {
+        _resolve(
+          node: node,
+          name: propertyElement.name,
+          rawType: functionType,
+        );
         return;
       }
 
@@ -133,45 +178,70 @@
     node.staticType = DynamicTypeImpl.instance;
   }
 
+  List<DartType> _checkTypeArguments(
+    TypeArgumentList typeArgumentList,
+    String name,
+    List<TypeParameterElement> typeParameters,
+    CompileTimeErrorCode errorCode,
+  ) {
+    if (typeArgumentList.arguments.length != typeParameters.length) {
+      _errorReporter.reportErrorForNode(
+        errorCode,
+        typeArgumentList,
+        [name, typeParameters.length, typeArgumentList.arguments.length],
+      );
+      return List.filled(typeParameters.length, DynamicTypeImpl.instance);
+    } else {
+      return typeArgumentList.arguments
+          .map((typeAnnotation) => typeAnnotation.typeOrThrow)
+          .toList();
+    }
+  }
+
   /// Resolves [node]'s static type, as an instantiated function type, and type
   /// argument types, using [rawType] as the uninstantiated function type.
   void _resolve({
     required FunctionReferenceImpl node,
+    required String name,
     required FunctionType rawType,
   }) {
-    // `node.typeArguments`, coming from the parser, is never null.
-    var typeArgumentList = node.typeArguments!;
-    var typeParameters = rawType.typeFormals;
-
-    List<DartType> typeArguments;
-    if (typeArgumentList.arguments.length != typeParameters.length) {
-      _errorReporter.reportErrorForNode(
-        CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS,
-        typeArgumentList,
-        [
-          rawType,
-          typeParameters.length,
-          typeArgumentList.arguments.length,
-        ],
-      );
-      typeArguments = List.filled(
-        typeParameters.length,
-        DynamicTypeImpl.instance,
-      );
-    } else {
-      typeArguments = typeArgumentList.arguments
-          .map((typeArgument) => typeArgument.typeOrThrow)
-          .toList();
-    }
+    var typeArguments = _checkTypeArguments(
+      // `node.typeArguments`, coming from the parser, is never null.
+      node.typeArguments!, name, rawType.typeFormals,
+      CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS_FUNCTION,
+    );
 
     var invokeType = rawType.instantiate(typeArguments);
     node.typeArgumentTypes = typeArguments;
     node.staticType = invokeType;
   }
 
+  void _resolveConstructorReference(FunctionReferenceImpl node) {
+    // TODO(srawlins): Rewrite and resolve [node] as a constructor reference.
+    node.function.accept(_resolver);
+    node.staticType = DynamicTypeImpl.instance;
+  }
+
+  /// Resolves [node] as a [TypeLiteral] referencing an interface type directly
+  /// (not through a type alias).
+  void _resolveDirectTypeLiteral(
+      FunctionReferenceImpl node, Identifier name, ClassElement element) {
+    var typeArguments = _checkTypeArguments(
+      // `node.typeArguments`, coming from the parser, is never null.
+      node.typeArguments!, name.name, element.typeParameters,
+      CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS,
+    );
+    var type = element.instantiate(
+      typeArguments: typeArguments,
+      nullabilitySuffix: _nullabilitySuffixForTypeNames,
+    );
+    _resolveTypeLiteral(node: node, instantiatedType: type, name: name);
+  }
+
   void _resolveFunctionReferenceMethod({
     required FunctionReferenceImpl node,
     required PrefixedIdentifier function,
+    required MethodElement element,
   }) {
     function.accept(_resolver);
     var receiver = function.prefix;
@@ -196,10 +266,7 @@
     if (target != null) {
       // TODO(srawlins): Set static type on `nameNode`?
 
-      _resolve(
-        node: node,
-        rawType: function.staticType as FunctionType,
-      );
+      _resolve(node: node, name: name, rawType: element.type);
       return;
     }
 
@@ -210,15 +277,15 @@
 
   void _resolveReceiverPrefix(
     FunctionReferenceImpl node,
-    PrefixElement prefix,
-    SimpleIdentifierImpl nameNode,
-    String name,
+    PrefixElement prefixElement,
+    PrefixedIdentifier prefix,
   ) {
     // TODO(srawlins): Handle `loadLibrary`, as in `p.loadLibrary<int>;`.
 
-    var element = prefix.scope.lookup(name).getter;
+    var nameNode = prefix.identifier;
+    var name = nameNode.name;
+    var element = prefixElement.scope.lookup(name).getter;
     element = _resolver.toLegacyElement(element);
-    nameNode.staticElement = element;
 
     if (element is MultiplyDefinedElement) {
       MultiplyDefinedElement multiply = element;
@@ -227,18 +294,68 @@
       // TODO(srawlins): Add a resolution test for this case.
     }
 
-    if (element is ExecutableElement) {
-      var function = node.function;
-      function.accept(_resolver);
-      return _resolve(
-          node: node, rawType: function.typeOrThrow as FunctionType);
+    // Classes and type aliases are checked first so as to include a
+    // PropertyAccess parent check, which does not need to be done for
+    // functions.
+    if (element is ClassElement || element is TypeAliasElement) {
+      // A type-instantiated constructor tearoff like `prefix.C<int>.name` is
+      // initially represented as a [PropertyAccess] with a
+      // [FunctionReference] 'target'.
+      if (node.parent is PropertyAccess) {
+        _resolveConstructorReference(node);
+        return;
+      } else if (element is ClassElement) {
+        node.function.accept(_resolver);
+        _resolveDirectTypeLiteral(node, prefix, element);
+        return;
+      } else if (element is TypeAliasElement) {
+        prefix.accept(_resolver);
+        (nameNode as SimpleIdentifierImpl).staticElement = element;
+        _resolveTypeAlias(node: node, element: element, typeAlias: prefix);
+        return;
+      }
+    } else if (element is ExecutableElement) {
+      node.function.accept(_resolver);
+      _resolve(
+        node: node,
+        name: element.name,
+        rawType: node.function.typeOrThrow as FunctionType,
+      );
+      return;
     }
 
-    // TODO(srawlins): Handle prefixed constructor references and type literals.
-
     // TODO(srawlins): Report undefined prefixed identifier.
 
     node.function.accept(_resolver);
     node.staticType = DynamicTypeImpl.instance;
   }
+
+  void _resolveTypeAlias({
+    required FunctionReferenceImpl node,
+    required TypeAliasElement element,
+    required Identifier typeAlias,
+  }) {
+    var typeArguments = _checkTypeArguments(
+      // `node.typeArguments`, coming from the parser, is never null.
+      node.typeArguments!, element.name, element.typeParameters,
+      CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS,
+    );
+    var type = element.instantiate(
+        typeArguments: typeArguments,
+        nullabilitySuffix: _nullabilitySuffixForTypeNames);
+    _resolveTypeLiteral(node: node, instantiatedType: type, name: typeAlias);
+  }
+
+  void _resolveTypeLiteral({
+    required FunctionReferenceImpl node,
+    required DartType instantiatedType,
+    required Identifier name,
+  }) {
+    var typeName = astFactory.typeName(name, node.typeArguments);
+    typeName.type = instantiatedType;
+    typeName.name.staticType = instantiatedType;
+    var typeLiteral = astFactory.typeLiteral(typeName: typeName);
+    typeLiteral.staticType = _typeType;
+    NodeReplacer.replace(node, typeLiteral);
+  }
 }
diff --git a/pkg/analyzer/lib/src/error/codes.dart b/pkg/analyzer/lib/src/error/codes.dart
index d383272..a5fdaf2 100644
--- a/pkg/analyzer/lib/src/error/codes.dart
+++ b/pkg/analyzer/lib/src/error/codes.dart
@@ -14735,6 +14735,22 @@
 
   /**
    * Parameters:
+   * 0: the name of the function being referenced
+   * 1: the number of type parameters that were declared
+   * 2: the number of type arguments provided
+   */
+  static const CompileTimeErrorCode WRONG_NUMBER_OF_TYPE_ARGUMENTS_FUNCTION =
+      CompileTimeErrorCode(
+          'WRONG_NUMBER_OF_TYPE_ARGUMENTS_FUNCTION',
+          "The function '{0}' is declared with {1} type parameters, "
+              "but {2} type arguments were given.",
+          correction:
+              "Try adjusting the number of type arguments to match the number "
+              "of type parameters.",
+          hasPublishedDocs: true);
+
+  /**
+   * Parameters:
    * 0: the name of the method being referenced (<i>G</i>)
    * 1: the number of type parameters that were declared
    * 2: the number of type arguments provided
diff --git a/pkg/analyzer/lib/src/generated/resolver.dart b/pkg/analyzer/lib/src/generated/resolver.dart
index a089bf5..112f2e7 100644
--- a/pkg/analyzer/lib/src/generated/resolver.dart
+++ b/pkg/analyzer/lib/src/generated/resolver.dart
@@ -371,7 +371,8 @@
         migratableAstInfoProvider: _migratableAstInfoProvider);
     inferenceContext = InferenceContext._(this);
     typeAnalyzer = StaticTypeAnalyzer(this, migrationResolutionHooks);
-    _functionReferenceResolver = FunctionReferenceResolver(this);
+    _functionReferenceResolver =
+        FunctionReferenceResolver(this, _isNonNullableByDefault);
   }
 
   /// Return the element representing the function containing the current node,
diff --git a/pkg/analyzer/lib/src/test_utilities/find_node.dart b/pkg/analyzer/lib/src/test_utilities/find_node.dart
index 260f431..1a71750 100644
--- a/pkg/analyzer/lib/src/test_utilities/find_node.dart
+++ b/pkg/analyzer/lib/src/test_utilities/find_node.dart
@@ -362,6 +362,10 @@
     return _node(search, (n) => n is TypedLiteral);
   }
 
+  TypeLiteral typeLiteral(String search) {
+    return _node(search, (n) => n is TypeLiteral);
+  }
+
   TypeName typeName(String search) {
     return _node(search, (n) => n is TypeName);
   }
diff --git a/pkg/analyzer/test/src/dart/element/inheritance_manager3_test.dart b/pkg/analyzer/test/src/dart/element/inheritance_manager3_test.dart
index 7e56db3..b8af67e 100644
--- a/pkg/analyzer/test/src/dart/element/inheritance_manager3_test.dart
+++ b/pkg/analyzer/test/src/dart/element/inheritance_manager3_test.dart
@@ -1039,8 +1039,7 @@
 }
 
 @reflectiveTest
-class InheritanceManager3WithNullSafetyTest extends _InheritanceManager3Base
-    with WithNullSafetyMixin {
+class InheritanceManager3WithNullSafetyTest extends _InheritanceManager3Base {
   test_getInheritedMap_topMerge_method() async {
     newFile('$testPackageLibPath/a.dart', content: r'''
 // @dart = 2.6
diff --git a/pkg/analyzer/test/src/dart/resolution/context_collection_resolution.dart b/pkg/analyzer/test/src/dart/resolution/context_collection_resolution.dart
index b545267..27ec665 100644
--- a/pkg/analyzer/test/src/dart/resolution/context_collection_resolution.dart
+++ b/pkg/analyzer/test/src/dart/resolution/context_collection_resolution.dart
@@ -424,6 +424,11 @@
   bool get typeToStringWithNullability => true;
 }
 
+mixin WithoutConstructorTearoffsMixin on PubPackageResolutionTest {
+  @override
+  String? get testPackageLanguageVersion => '2.13';
+}
+
 mixin WithoutNullSafetyMixin on PubPackageResolutionTest {
   @override
   String? get testPackageLanguageVersion => '2.9';
diff --git a/pkg/analyzer/test/src/dart/resolution/extension_method_test.dart b/pkg/analyzer/test/src/dart/resolution/extension_method_test.dart
index 1f7f618..902e2e7 100644
--- a/pkg/analyzer/test/src/dart/resolution/extension_method_test.dart
+++ b/pkg/analyzer/test/src/dart/resolution/extension_method_test.dart
@@ -14,21 +14,61 @@
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(ExtensionMethodsDeclarationTest);
-    defineReflectiveTests(ExtensionMethodsDeclarationWithNullSafetyTest);
+    defineReflectiveTests(ExtensionMethodsDeclarationWithoutNullSafetyTest);
     defineReflectiveTests(ExtensionMethodsExtendedTypeTest);
-    defineReflectiveTests(ExtensionMethodsExtendedTypeWithNullSafetyTest);
+    defineReflectiveTests(ExtensionMethodsExtendedTypeWithoutNullSafetyTest);
     defineReflectiveTests(ExtensionMethodsExternalReferenceTest);
-    defineReflectiveTests(ExtensionMethodsExternalReferenceWithNullSafetyTest);
+    defineReflectiveTests(
+        ExtensionMethodsExternalReferenceWithoutNullSafetyTest);
     defineReflectiveTests(ExtensionMethodsInternalReferenceTest);
-    defineReflectiveTests(ExtensionMethodsInternalReferenceWithNullSafetyTest);
+    defineReflectiveTests(
+        ExtensionMethodsInternalReferenceWithoutNullSafetyTest);
   });
 }
 
 /// Tests that show that extension declarations and the members inside them are
 /// resolved correctly.
 @reflectiveTest
-class ExtensionMethodsDeclarationTest extends PubPackageResolutionTest
-    with WithoutNullSafetyMixin {
+class ExtensionMethodsDeclarationTest extends PubPackageResolutionTest {
+  test_this_type_interface() async {
+    await assertNoErrorsInCode('''
+extension E on int {
+  void foo() {
+    this;
+  }
+}
+''');
+    assertType(findNode.this_('this;'), 'int');
+  }
+
+  test_this_type_typeParameter() async {
+    await assertNoErrorsInCode('''
+extension E<T> on T {
+  void foo() {
+    this;
+  }
+}
+''');
+    assertType(findNode.this_('this;'), 'T');
+  }
+
+  test_this_type_typeParameter_withBound() async {
+    await assertNoErrorsInCode('''
+extension E<T extends Object> on T {
+  void foo() {
+    this;
+  }
+}
+''');
+    assertType(findNode.this_('this;'), 'T');
+  }
+}
+
+/// Tests that show that extension declarations and the members inside them are
+/// resolved correctly.
+@reflectiveTest
+class ExtensionMethodsDeclarationWithoutNullSafetyTest
+    extends PubPackageResolutionTest with WithoutNullSafetyMixin {
   @override
   List<MockSdkLibrary> get additionalMockSdkLibraries => [
         MockSdkLibrary([
@@ -314,50 +354,11 @@
   }
 }
 
-/// Tests that show that extension declarations and the members inside them are
-/// resolved correctly.
-@reflectiveTest
-class ExtensionMethodsDeclarationWithNullSafetyTest
-    extends PubPackageResolutionTest {
-  test_this_type_interface() async {
-    await assertNoErrorsInCode('''
-extension E on int {
-  void foo() {
-    this;
-  }
-}
-''');
-    assertType(findNode.this_('this;'), 'int');
-  }
-
-  test_this_type_typeParameter() async {
-    await assertNoErrorsInCode('''
-extension E<T> on T {
-  void foo() {
-    this;
-  }
-}
-''');
-    assertType(findNode.this_('this;'), 'T');
-  }
-
-  test_this_type_typeParameter_withBound() async {
-    await assertNoErrorsInCode('''
-extension E<T extends Object> on T {
-  void foo() {
-    this;
-  }
-}
-''');
-    assertType(findNode.this_('this;'), 'T');
-  }
-}
-
-/// Tests that show that extension declarations support all of the possible
-/// types in the `on` clause.
 @reflectiveTest
 class ExtensionMethodsExtendedTypeTest extends PubPackageResolutionTest
-    with WithoutNullSafetyMixin {
+    with ExtensionMethodsExtendedTypeTestCases {}
+
+mixin ExtensionMethodsExtendedTypeTestCases on PubPackageResolutionTest {
   test_named_generic() async {
     await assertNoErrorsInCode('''
 class C<T> {}
@@ -477,15 +478,287 @@
   }
 }
 
+/// Tests that show that extension declarations support all of the possible
+/// types in the `on` clause.
 @reflectiveTest
-class ExtensionMethodsExtendedTypeWithNullSafetyTest
-    extends ExtensionMethodsExtendedTypeTest with WithNullSafetyMixin {}
+class ExtensionMethodsExtendedTypeWithoutNullSafetyTest
+    extends PubPackageResolutionTest
+    with ExtensionMethodsExtendedTypeTestCases, WithoutNullSafetyMixin {}
 
-/// Tests that extension members can be correctly resolved when referenced
-/// by code external to the extension declaration.
 @reflectiveTest
 class ExtensionMethodsExternalReferenceTest extends PubPackageResolutionTest
-    with WithoutNullSafetyMixin {
+    with ExtensionMethodsExternalReferenceTestCases {
+  test_instance_getter_fromInstance_Never() async {
+    await assertNoErrorsInCode('''
+extension E on Never {
+  int get foo => 0;
+}
+
+f(Never a) {
+  a.foo;
+}
+''');
+    var access = findNode.prefixed('a.foo');
+    assertElementNull(access);
+    assertType(access, 'Never');
+  }
+
+  test_instance_getter_fromInstance_nullable() async {
+    await assertNoErrorsInCode('''
+extension E on int? {
+  int get foo => 0;
+}
+
+f(int? a) {
+  a.foo;
+}
+''');
+    var access = findNode.prefixed('a.foo');
+    assertElement(access, findElement.getter('foo', of: 'E'));
+    assertType(access, 'int');
+  }
+
+  test_instance_getter_fromInstance_nullAware() async {
+    await assertNoErrorsInCode('''
+extension E on int {
+  int get foo => 0;
+}
+
+f(int? a) {
+  a?.foo;
+}
+''');
+    var identifier = findNode.simple('foo;');
+    assertElement(identifier, findElement.getter('foo', of: 'E'));
+    assertType(identifier, 'int');
+  }
+
+  test_instance_method_fromInstance_Never() async {
+    await assertErrorsInCode('''
+extension E on Never {
+  void foo() {}
+}
+
+f(Never a) {
+  a.foo();
+}
+''', [
+      error(HintCode.RECEIVER_OF_TYPE_NEVER, 57, 1),
+      error(HintCode.DEAD_CODE, 62, 3),
+    ]);
+    assertMethodInvocation2(
+      findNode.methodInvocation('a.foo()'),
+      element: null,
+      typeArgumentTypes: [],
+      invokeType: 'dynamic',
+      type: 'Never',
+    );
+  }
+
+  test_instance_method_fromInstance_nullable() async {
+    await assertNoErrorsInCode('''
+extension E on int? {
+  void foo() {}
+}
+
+f(int? a) {
+  a.foo();
+}
+''');
+    var invocation = findNode.methodInvocation('a.foo()');
+    assertElement(invocation, findElement.method('foo', of: 'E'));
+    assertInvokeType(invocation, 'void Function()');
+  }
+
+  test_instance_method_fromInstance_nullable_nullLiteral() async {
+    await assertNoErrorsInCode('''
+extension E on int? {
+  void foo() {}
+}
+
+f(int? a) {
+  null.foo();
+}
+''');
+    var invocation = findNode.methodInvocation('null.foo()');
+    assertElement(invocation, findElement.method('foo', of: 'E'));
+    assertInvokeType(invocation, 'void Function()');
+  }
+
+  test_instance_method_fromInstance_nullAware() async {
+    await assertNoErrorsInCode('''
+extension E on int {
+  void foo() {}
+}
+
+f(int? a) {
+  a?.foo();
+}
+''');
+    var invocation = findNode.methodInvocation('a?.foo()');
+    assertElement(invocation, findElement.method('foo', of: 'E'));
+    assertInvokeType(invocation, 'void Function()');
+  }
+
+  test_instance_method_fromInstance_nullLiteral() async {
+    await assertNoErrorsInCode('''
+extension E<T> on T {
+  void foo() {}
+}
+
+f() {
+  null.foo();
+}
+''');
+    var invocation = findNode.methodInvocation('null.foo()');
+    assertMember(
+      invocation,
+      findElement.method('foo', of: 'E'),
+      {'T': 'Null'},
+    );
+    assertInvokeType(invocation, 'void Function()');
+  }
+
+  test_instance_operator_binary_fromInstance_nullable() async {
+    await assertNoErrorsInCode('''
+class A {}
+
+extension E on A? {
+  int operator +(int _) => 0;
+}
+
+f(A? a) {
+  a + 1;
+}
+''');
+    var binary = findNode.binary('a + 1');
+    assertElement(binary, findElement.method('+'));
+    assertType(binary, 'int');
+  }
+
+  test_instance_operator_index_fromInstance_nullable() async {
+    await assertNoErrorsInCode('''
+extension E on int? {
+  int operator [](int index) => 0;
+}
+
+f(int? a) {
+  a[0];
+}
+''');
+    var index = findNode.index('a[0]');
+    assertElement(index, findElement.method('[]'));
+  }
+
+  test_instance_operator_index_fromInstance_nullAware() async {
+    await assertNoErrorsInCode('''
+extension E on int {
+  int operator [](int index) => 0;
+}
+
+f(int? a) {
+  a?[0];
+}
+''');
+    var index = findNode.index('a?[0]');
+    assertElement(index, findElement.method('[]'));
+  }
+
+  test_instance_operator_postfixInc_fromInstance_nullable() async {
+    await assertNoErrorsInCode('''
+class A {}
+
+extension E on A? {
+  A? operator +(int _) => this;
+}
+
+f(A? a) {
+  a++;
+}
+''');
+    var expression = findNode.postfix('a++');
+    assertElement(expression, findElement.method('+'));
+    assertType(expression, 'A?');
+  }
+
+  test_instance_operator_prefixInc_fromInstance_nullable() async {
+    await assertNoErrorsInCode('''
+class A {}
+
+extension E on A? {
+  A? operator +(int _) => this;
+}
+
+f(A? a) {
+  ++a;
+}
+''');
+    var expression = findNode.prefix('++a');
+    assertElement(expression, findElement.method('+'));
+    assertType(expression, 'A?');
+  }
+
+  test_instance_operator_unaryMinus_fromInstance_nullable() async {
+    await assertNoErrorsInCode('''
+class A {}
+
+extension E on A? {
+  A? operator -() => this;
+}
+
+f(A? a) {
+  -a;
+}
+''');
+    var expression = findNode.prefix('-a');
+    assertElement(expression, findElement.method('unary-'));
+    assertType(expression, 'A?');
+  }
+
+  test_instance_setter_fromInstance_nullable() async {
+    await assertNoErrorsInCode('''
+extension E on int? {
+  set foo(int _) {}
+}
+
+f(int? a) {
+  a.foo = 1;
+}
+''');
+    assertAssignment(
+      findNode.assignment('foo = 1'),
+      readElement: null,
+      readType: null,
+      writeElement: findElement.setter('foo'),
+      writeType: 'int',
+      operatorElement: null,
+      type: 'int',
+    );
+  }
+
+  test_instance_setter_fromInstance_nullAware() async {
+    await assertNoErrorsInCode('''
+extension E on int {
+  set foo(int _) {}
+}
+
+f(int? a) {
+  a?.foo = 1;
+}
+''');
+    assertAssignment(
+      findNode.assignment('foo = 1'),
+      readElement: null,
+      readType: null,
+      writeElement: findElement.setter('foo'),
+      writeType: 'int',
+      operatorElement: null,
+      type: 'int?',
+    );
+  }
+}
+
+mixin ExtensionMethodsExternalReferenceTestCases on PubPackageResolutionTest {
   /// Corresponds to: extension_member_resolution_t07
   test_dynamicInvocation() async {
     await assertNoErrorsInCode(r'''
@@ -1474,284 +1747,18 @@
   }
 }
 
-@reflectiveTest
-class ExtensionMethodsExternalReferenceWithNullSafetyTest
-    extends ExtensionMethodsExternalReferenceTest with WithNullSafetyMixin {
-  test_instance_getter_fromInstance_Never() async {
-    await assertNoErrorsInCode('''
-extension E on Never {
-  int get foo => 0;
-}
-
-f(Never a) {
-  a.foo;
-}
-''');
-    var access = findNode.prefixed('a.foo');
-    assertElementNull(access);
-    assertType(access, 'Never');
-  }
-
-  test_instance_getter_fromInstance_nullable() async {
-    await assertNoErrorsInCode('''
-extension E on int? {
-  int get foo => 0;
-}
-
-f(int? a) {
-  a.foo;
-}
-''');
-    var access = findNode.prefixed('a.foo');
-    assertElement(access, findElement.getter('foo', of: 'E'));
-    assertType(access, 'int');
-  }
-
-  test_instance_getter_fromInstance_nullAware() async {
-    await assertNoErrorsInCode('''
-extension E on int {
-  int get foo => 0;
-}
-
-f(int? a) {
-  a?.foo;
-}
-''');
-    var identifier = findNode.simple('foo;');
-    assertElement(identifier, findElement.getter('foo', of: 'E'));
-    assertType(identifier, 'int');
-  }
-
-  test_instance_method_fromInstance_Never() async {
-    await assertErrorsInCode('''
-extension E on Never {
-  void foo() {}
-}
-
-f(Never a) {
-  a.foo();
-}
-''', [
-      error(HintCode.RECEIVER_OF_TYPE_NEVER, 57, 1),
-      error(HintCode.DEAD_CODE, 62, 3),
-    ]);
-    assertMethodInvocation2(
-      findNode.methodInvocation('a.foo()'),
-      element: null,
-      typeArgumentTypes: [],
-      invokeType: 'dynamic',
-      type: 'Never',
-    );
-  }
-
-  test_instance_method_fromInstance_nullable() async {
-    await assertNoErrorsInCode('''
-extension E on int? {
-  void foo() {}
-}
-
-f(int? a) {
-  a.foo();
-}
-''');
-    var invocation = findNode.methodInvocation('a.foo()');
-    assertElement(invocation, findElement.method('foo', of: 'E'));
-    assertInvokeType(invocation, 'void Function()');
-  }
-
-  test_instance_method_fromInstance_nullable_nullLiteral() async {
-    await assertNoErrorsInCode('''
-extension E on int? {
-  void foo() {}
-}
-
-f(int? a) {
-  null.foo();
-}
-''');
-    var invocation = findNode.methodInvocation('null.foo()');
-    assertElement(invocation, findElement.method('foo', of: 'E'));
-    assertInvokeType(invocation, 'void Function()');
-  }
-
-  test_instance_method_fromInstance_nullAware() async {
-    await assertNoErrorsInCode('''
-extension E on int {
-  void foo() {}
-}
-
-f(int? a) {
-  a?.foo();
-}
-''');
-    var invocation = findNode.methodInvocation('a?.foo()');
-    assertElement(invocation, findElement.method('foo', of: 'E'));
-    assertInvokeType(invocation, 'void Function()');
-  }
-
-  test_instance_method_fromInstance_nullLiteral() async {
-    await assertNoErrorsInCode('''
-extension E<T> on T {
-  void foo() {}
-}
-
-f() {
-  null.foo();
-}
-''');
-    var invocation = findNode.methodInvocation('null.foo()');
-    assertMember(
-      invocation,
-      findElement.method('foo', of: 'E'),
-      {'T': 'Null'},
-    );
-    assertInvokeType(invocation, 'void Function()');
-  }
-
-  test_instance_operator_binary_fromInstance_nullable() async {
-    await assertNoErrorsInCode('''
-class A {}
-
-extension E on A? {
-  int operator +(int _) => 0;
-}
-
-f(A? a) {
-  a + 1;
-}
-''');
-    var binary = findNode.binary('a + 1');
-    assertElement(binary, findElement.method('+'));
-    assertType(binary, 'int');
-  }
-
-  test_instance_operator_index_fromInstance_nullable() async {
-    await assertNoErrorsInCode('''
-extension E on int? {
-  int operator [](int index) => 0;
-}
-
-f(int? a) {
-  a[0];
-}
-''');
-    var index = findNode.index('a[0]');
-    assertElement(index, findElement.method('[]'));
-  }
-
-  test_instance_operator_index_fromInstance_nullAware() async {
-    await assertNoErrorsInCode('''
-extension E on int {
-  int operator [](int index) => 0;
-}
-
-f(int? a) {
-  a?[0];
-}
-''');
-    var index = findNode.index('a?[0]');
-    assertElement(index, findElement.method('[]'));
-  }
-
-  test_instance_operator_postfixInc_fromInstance_nullable() async {
-    await assertNoErrorsInCode('''
-class A {}
-
-extension E on A? {
-  A? operator +(int _) => this;
-}
-
-f(A? a) {
-  a++;
-}
-''');
-    var expression = findNode.postfix('a++');
-    assertElement(expression, findElement.method('+'));
-    assertType(expression, 'A?');
-  }
-
-  test_instance_operator_prefixInc_fromInstance_nullable() async {
-    await assertNoErrorsInCode('''
-class A {}
-
-extension E on A? {
-  A? operator +(int _) => this;
-}
-
-f(A? a) {
-  ++a;
-}
-''');
-    var expression = findNode.prefix('++a');
-    assertElement(expression, findElement.method('+'));
-    assertType(expression, 'A?');
-  }
-
-  test_instance_operator_unaryMinus_fromInstance_nullable() async {
-    await assertNoErrorsInCode('''
-class A {}
-
-extension E on A? {
-  A? operator -() => this;
-}
-
-f(A? a) {
-  -a;
-}
-''');
-    var expression = findNode.prefix('-a');
-    assertElement(expression, findElement.method('unary-'));
-    assertType(expression, 'A?');
-  }
-
-  test_instance_setter_fromInstance_nullable() async {
-    await assertNoErrorsInCode('''
-extension E on int? {
-  set foo(int _) {}
-}
-
-f(int? a) {
-  a.foo = 1;
-}
-''');
-    assertAssignment(
-      findNode.assignment('foo = 1'),
-      readElement: null,
-      readType: null,
-      writeElement: findElement.setter('foo'),
-      writeType: 'int',
-      operatorElement: null,
-      type: 'int',
-    );
-  }
-
-  test_instance_setter_fromInstance_nullAware() async {
-    await assertNoErrorsInCode('''
-extension E on int {
-  set foo(int _) {}
-}
-
-f(int? a) {
-  a?.foo = 1;
-}
-''');
-    assertAssignment(
-      findNode.assignment('foo = 1'),
-      readElement: null,
-      readType: null,
-      writeElement: findElement.setter('foo'),
-      writeType: 'int',
-      operatorElement: null,
-      type: 'int?',
-    );
-  }
-}
-
 /// Tests that extension members can be correctly resolved when referenced
-/// by code internal to (within) the extension declaration.
+/// by code external to the extension declaration.
+@reflectiveTest
+class ExtensionMethodsExternalReferenceWithoutNullSafetyTest
+    extends PubPackageResolutionTest
+    with ExtensionMethodsExternalReferenceTestCases, WithoutNullSafetyMixin {}
+
 @reflectiveTest
 class ExtensionMethodsInternalReferenceTest extends PubPackageResolutionTest
-    with WithoutNullSafetyMixin {
+    with ExtensionMethodsInternalReferenceTestCases {}
+
+mixin ExtensionMethodsInternalReferenceTestCases on PubPackageResolutionTest {
   test_instance_call() async {
     await assertNoErrorsInCode('''
 class C {}
@@ -2350,6 +2357,9 @@
   }
 }
 
+/// Tests that extension members can be correctly resolved when referenced
+/// by code internal to (within) the extension declaration.
 @reflectiveTest
-class ExtensionMethodsInternalReferenceWithNullSafetyTest
-    extends ExtensionMethodsInternalReferenceTest with WithNullSafetyMixin {}
+class ExtensionMethodsInternalReferenceWithoutNullSafetyTest
+    extends PubPackageResolutionTest
+    with ExtensionMethodsInternalReferenceTestCases, WithoutNullSafetyMixin {}
diff --git a/pkg/analyzer/test/src/dart/resolution/extension_override_test.dart b/pkg/analyzer/test/src/dart/resolution/extension_override_test.dart
index eea3223..946f223 100644
--- a/pkg/analyzer/test/src/dart/resolution/extension_override_test.dart
+++ b/pkg/analyzer/test/src/dart/resolution/extension_override_test.dart
@@ -14,13 +14,106 @@
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(ExtensionOverrideTest);
-    defineReflectiveTests(ExtensionOverrideWithNullSafetyTest);
+    defineReflectiveTests(ExtensionOverrideWithoutNullSafetyTest);
   });
 }
 
 @reflectiveTest
 class ExtensionOverrideTest extends PubPackageResolutionTest
-    with WithoutNullSafetyMixin {
+    with ExtensionOverrideTestCases {
+  test_indexExpression_read_nullAware() async {
+    await assertNoErrorsInCode('''
+extension E on int {
+  int operator [](int index) => 0;
+}
+
+void f(int? a) {
+  E(a)?[0];
+}
+''');
+
+    assertIndexExpression(
+      findNode.index('[0]'),
+      readElement: findElement.method('[]', of: 'E'),
+      writeElement: null,
+      type: 'int?',
+    );
+  }
+
+  test_indexExpression_write_nullAware() async {
+    await assertNoErrorsInCode('''
+extension E on int {
+  operator []=(int index, int value) {}
+}
+
+void f(int? a) {
+  E(a)?[0] = 1;
+}
+''');
+
+    assertAssignment(
+      findNode.assignment('[0] ='),
+      readElement: null,
+      readType: null,
+      writeElement: findElement.method('[]=', of: 'E'),
+      writeType: 'int',
+      operatorElement: null,
+      type: 'int?',
+    );
+  }
+
+  test_methodInvocation_nullAware() async {
+    await assertNoErrorsInCode('''
+extension E on int {
+  int foo() => 0;
+}
+
+void f(int? a) {
+  E(a)?.foo();
+}
+''');
+
+    assertMethodInvocation2(
+      findNode.methodInvocation('foo();'),
+      element: findElement.method('foo'),
+      typeArgumentTypes: [],
+      invokeType: 'int Function()',
+      type: 'int?',
+    );
+  }
+
+  test_propertyAccess_getter_nullAware() async {
+    await assertNoErrorsInCode('''
+extension E on int {
+  int get foo => 0;
+}
+
+void f(int? a) {
+  E(a)?.foo;
+}
+''');
+
+    assertPropertyAccess2(
+      findNode.propertyAccess('?.foo'),
+      element: findElement.getter('foo'),
+      type: 'int?',
+    );
+  }
+
+  test_propertyAccess_setter_nullAware() async {
+    await assertNoErrorsInCode('''
+extension E on int {
+  set foo(int _) {}
+}
+
+void f(int? a) {
+  E(a)?.foo = 0;
+}
+''');
+  }
+}
+
+mixin ExtensionOverrideTestCases on PubPackageResolutionTest {
   late ExtensionElement extension;
   late ExtensionOverride extensionOverride;
 
@@ -720,96 +813,5 @@
 }
 
 @reflectiveTest
-class ExtensionOverrideWithNullSafetyTest extends ExtensionOverrideTest
-    with WithNullSafetyMixin {
-  test_indexExpression_read_nullAware() async {
-    await assertNoErrorsInCode('''
-extension E on int {
-  int operator [](int index) => 0;
-}
-
-void f(int? a) {
-  E(a)?[0];
-}
-''');
-
-    assertIndexExpression(
-      findNode.index('[0]'),
-      readElement: findElement.method('[]', of: 'E'),
-      writeElement: null,
-      type: 'int?',
-    );
-  }
-
-  test_indexExpression_write_nullAware() async {
-    await assertNoErrorsInCode('''
-extension E on int {
-  operator []=(int index, int value) {}
-}
-
-void f(int? a) {
-  E(a)?[0] = 1;
-}
-''');
-
-    assertAssignment(
-      findNode.assignment('[0] ='),
-      readElement: null,
-      readType: null,
-      writeElement: findElement.method('[]=', of: 'E'),
-      writeType: 'int',
-      operatorElement: null,
-      type: 'int?',
-    );
-  }
-
-  test_methodInvocation_nullAware() async {
-    await assertNoErrorsInCode('''
-extension E on int {
-  int foo() => 0;
-}
-
-void f(int? a) {
-  E(a)?.foo();
-}
-''');
-
-    assertMethodInvocation2(
-      findNode.methodInvocation('foo();'),
-      element: findElement.method('foo'),
-      typeArgumentTypes: [],
-      invokeType: 'int Function()',
-      type: 'int?',
-    );
-  }
-
-  test_propertyAccess_getter_nullAware() async {
-    await assertNoErrorsInCode('''
-extension E on int {
-  int get foo => 0;
-}
-
-void f(int? a) {
-  E(a)?.foo;
-}
-''');
-
-    assertPropertyAccess2(
-      findNode.propertyAccess('?.foo'),
-      element: findElement.getter('foo'),
-      type: 'int?',
-    );
-  }
-
-  test_propertyAccess_setter_nullAware() async {
-    await assertNoErrorsInCode('''
-extension E on int {
-  set foo(int _) {}
-}
-
-void f(int? a) {
-  E(a)?.foo = 0;
-}
-''');
-  }
-}
+class ExtensionOverrideWithoutNullSafetyTest extends PubPackageResolutionTest
+    with ExtensionOverrideTestCases, WithoutNullSafetyMixin {}
diff --git a/pkg/analyzer/test/src/dart/resolution/function_reference_test.dart b/pkg/analyzer/test/src/dart/resolution/function_reference_test.dart
index 4dba4a4..19e9a10 100644
--- a/pkg/analyzer/test/src/dart/resolution/function_reference_test.dart
+++ b/pkg/analyzer/test/src/dart/resolution/function_reference_test.dart
@@ -15,6 +15,36 @@
 
 @reflectiveTest
 class FunctionReferenceResolutionTest extends PubPackageResolutionTest {
+  test_explicitReceiver_unknown() async {
+    await assertErrorsInCode('''
+bar() {
+  a.foo<int>;
+}
+''', [
+      error(CompileTimeErrorCode.UNDEFINED_IDENTIFIER, 10, 1),
+    ]);
+
+    var reference = findNode.functionReference('foo<int>;');
+    assertType(reference, 'dynamic');
+  }
+
+  test_instanceGetter_explicitReceiver() async {
+    // This test is here to assert that the resolver does not throw, but in the
+    // future, an error should be reported here as well.
+    await assertNoErrorsInCode('''
+class A {
+  int foo = 0;
+}
+
+bar(A a) {
+  a.foo<int>;
+}
+''');
+
+    var reference = findNode.functionReference('foo<int>;');
+    assertType(reference, 'dynamic');
+  }
+
   test_instanceMethod() async {
     await assertNoErrorsInCode('''
 class A {
@@ -26,9 +56,9 @@
 }
 ''');
 
-    var identifier = findNode.functionReference('foo<int>;');
-    assertElement(identifier, findElement.method('foo'));
-    assertType(identifier, 'void Function(int)');
+    var reference = findNode.functionReference('foo<int>;');
+    assertFunctionReference(
+        reference, findElement.method('foo'), 'void Function(int)');
   }
 
   test_instanceMethod_explicitReceiver_field() async {
@@ -46,9 +76,9 @@
 }
 ''');
 
-    var identifier = findNode.functionReference('foo<int>;');
-    assertElement(identifier, findElement.method('foo'));
-    assertType(identifier, 'void Function(int)');
+    var reference = findNode.functionReference('foo<int>;');
+    assertFunctionReference(
+        reference, findElement.method('foo'), 'void Function(int)');
   }
 
   test_instanceMethod_explicitReceiver_super() async {
@@ -63,9 +93,37 @@
 }
 ''');
 
-    var identifier = findNode.functionReference('foo<int>;');
-    assertElement(identifier, findElement.method('foo'));
-    assertType(identifier, 'void Function(int)');
+    var reference = findNode.functionReference('foo<int>;');
+    assertFunctionReference(
+        reference, findElement.method('foo'), 'void Function(int)');
+  }
+
+  test_instanceMethod_explicitReceiver_super_noMethod() async {
+    await assertErrorsInCode('''
+class A {
+  bar() {
+    super.foo<int>;
+  }
+}
+''', [
+      error(CompileTimeErrorCode.UNDEFINED_SUPER_GETTER, 30, 3),
+    ]);
+
+    var reference = findNode.functionReference('foo<int>;');
+    assertType(reference, 'dynamic');
+  }
+
+  test_instanceMethod_explicitReceiver_super_noSuper() async {
+    await assertErrorsInCode('''
+bar() {
+  super.foo<int>;
+}
+''', [
+      error(CompileTimeErrorCode.SUPER_IN_INVALID_CONTEXT, 10, 5),
+    ]);
+
+    var reference = findNode.functionReference('foo<int>;');
+    assertType(reference, 'dynamic');
   }
 
   test_instanceMethod_explicitReceiver_this() async {
@@ -79,9 +137,9 @@
 }
 ''');
 
-    var identifier = findNode.functionReference('foo<int>;');
-    assertElement(identifier, findElement.method('foo'));
-    assertType(identifier, 'void Function(int)');
+    var reference = findNode.functionReference('foo<int>;');
+    assertFunctionReference(
+        reference, findElement.method('foo'), 'void Function(int)');
   }
 
   test_instanceMethod_explicitReceiver_variable() async {
@@ -97,9 +155,9 @@
 }
 ''');
 
-    var identifier = findNode.functionReference('foo<int>;');
-    assertElement(identifier, findElement.method('foo'));
-    assertType(identifier, 'void Function(int)');
+    var reference = findNode.functionReference('foo<int>;');
+    assertFunctionReference(
+        reference, findElement.method('foo'), 'void Function(int)');
   }
 
   test_localFunction() async {
@@ -111,9 +169,9 @@
 }
 ''');
 
-    var identifier = findNode.functionReference('foo<int>;');
-    assertElement(identifier, findElement.localFunction('foo'));
-    assertType(identifier, 'void Function(int)');
+    var reference = findNode.functionReference('foo<int>;');
+    assertFunctionReference(
+        reference, findElement.localFunction('foo'), 'void Function(int)');
   }
 
   test_localVariable() async {
@@ -123,9 +181,9 @@
 }
 ''');
 
-    var identifier = findNode.functionReference('foo<int>;');
-    assertElement(identifier, findElement.parameter('foo'));
-    assertType(identifier, 'void Function(int)');
+    var reference = findNode.functionReference('foo<int>;');
+    assertFunctionReference(
+        reference, findElement.parameter('foo'), 'void Function(int)');
   }
 
   test_nonGenericFunction() async {
@@ -138,12 +196,13 @@
   }
 }
 ''', [
-      error(CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS, 44, 5),
+      error(
+          CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS_FUNCTION, 44, 5),
     ]);
 
-    var identifier = findNode.functionReference('foo<int>;');
-    assertElement(identifier, findElement.method('foo'));
-    assertType(identifier, 'void Function()');
+    var reference = findNode.functionReference('foo<int>;');
+    assertFunctionReference(
+        reference, findElement.method('foo'), 'void Function()');
   }
 
   test_staticMethod() async {
@@ -157,9 +216,9 @@
 }
 ''');
 
-    var identifier = findNode.functionReference('foo<int>;');
-    assertElement(identifier, findElement.method('foo'));
-    assertType(identifier, 'void Function(int)');
+    var reference = findNode.functionReference('foo<int>;');
+    assertFunctionReference(
+        reference, findElement.method('foo'), 'void Function(int)');
   }
 
   @FailingTest(reason: 'Unresolved TODO in FunctionReferenceResolver')
@@ -174,9 +233,9 @@
 }
 ''');
 
-    var identifier = findNode.functionReference('foo<int>;');
-    assertElement(identifier, findElement.method('foo'));
-    assertType(identifier, 'void Function(int)');
+    var reference = findNode.functionReference('foo<int>;');
+    assertElement(reference, findElement.method('foo'));
+    assertType(reference, 'void Function(int)');
   }
 
   @FailingTest(reason: 'Unresolved TODO in FunctionReferenceResolver')
@@ -194,9 +253,9 @@
 }
 ''');
 
-    var identifier = findNode.functionReference('foo<int>;');
-    assertElement(identifier, findElement.method('foo'));
-    assertType(identifier, 'void Function(int)');
+    var reference = findNode.functionReference('foo<int>;');
+    assertElement(reference, findElement.method('foo'));
+    assertType(reference, 'void Function(int)');
   }
 
   test_tooFewTypeArguments() async {
@@ -209,12 +268,13 @@
   }
 }
 ''', [
-      error(CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS, 58, 5),
+      error(
+          CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS_FUNCTION, 58, 5),
     ]);
 
-    var identifier = findNode.functionReference('foo<int>;');
-    assertElement(identifier, findElement.method('foo'));
-    assertType(identifier, 'void Function(dynamic, dynamic)');
+    var reference = findNode.functionReference('foo<int>;');
+    assertFunctionReference(reference, findElement.method('foo'),
+        'void Function(dynamic, dynamic)');
   }
 
   test_tooManyTypeArguments() async {
@@ -227,12 +287,13 @@
   }
 }
 ''', [
-      error(CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS, 50, 10),
+      error(
+          CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS_FUNCTION, 50, 10),
     ]);
 
-    var identifier = findNode.functionReference('foo<int, int>;');
-    assertElement(identifier, findElement.method('foo'));
-    assertType(identifier, 'void Function(dynamic)');
+    var reference = findNode.functionReference('foo<int, int>;');
+    assertFunctionReference(
+        reference, findElement.method('foo'), 'void Function(dynamic)');
   }
 
   test_topLevelFunction() async {
@@ -244,9 +305,9 @@
 }
 ''');
 
-    var identifier = findNode.functionReference('foo<int>;');
-    assertElement(identifier, findElement.topFunction('foo'));
-    assertType(identifier, 'void Function(int)');
+    var reference = findNode.functionReference('foo<int>;');
+    assertFunctionReference(
+        reference, findElement.topFunction('foo'), 'void Function(int)');
   }
 
   test_topLevelFunction_importPrefix() async {
@@ -261,10 +322,12 @@
 }
 ''');
 
-    var identifier = findNode.functionReference('foo<int>;');
-    assertElement(identifier,
-        findElement.importFind('package:test/a.dart').topFunction('foo'));
-    assertType(identifier, 'void Function(int)');
+    var reference = findNode.functionReference('foo<int>;');
+    assertFunctionReference(
+      reference,
+      findElement.importFind('package:test/a.dart').topFunction('foo'),
+      'void Function(int)',
+    );
   }
 
   test_unknownIdentifier() async {
diff --git a/pkg/analyzer/test/src/dart/resolution/resolution.dart b/pkg/analyzer/test/src/dart/resolution/resolution.dart
index 2d2415b..65d329f 100644
--- a/pkg/analyzer/test/src/dart/resolution/resolution.dart
+++ b/pkg/analyzer/test/src/dart/resolution/resolution.dart
@@ -340,6 +340,12 @@
     assertType(node, type);
   }
 
+  void assertFunctionReference(
+      FunctionReference node, Element expectedElement, String expectedType) {
+    assertElement(node, expectedElement);
+    assertType(node, expectedType);
+  }
+
   void assertHasTestErrors() {
     expect(result.errors, isNotEmpty);
   }
@@ -798,6 +804,14 @@
     expect(actual, NullabilitySuffix.star);
   }
 
+  void assertTypeLiteral(
+      TypeLiteral node, Element? expectedElement, String expectedType,
+      {Element? expectedPrefix}) {
+    assertType(node, 'Type');
+    assertTypeName(node.typeName, expectedElement, expectedType,
+        expectedPrefix: expectedPrefix);
+  }
+
   void assertTypeName(
       TypeName node, Element? expectedElement, String expectedType,
       {Element? expectedPrefix}) {
diff --git a/pkg/analyzer/test/src/dart/resolution/test_all.dart b/pkg/analyzer/test/src/dart/resolution/test_all.dart
index 5b1355f..5f1c71d 100644
--- a/pkg/analyzer/test/src/dart/resolution/test_all.dart
+++ b/pkg/analyzer/test/src/dart/resolution/test_all.dart
@@ -60,6 +60,7 @@
 import 'top_type_inference_test.dart' as top_type_inference;
 import 'try_statement_test.dart' as try_statement;
 import 'type_inference/test_all.dart' as type_inference;
+import 'type_literal_test.dart' as type_literal;
 import 'type_name_test.dart' as type_name;
 import 'yield_statement_test.dart' as yield_statement;
 
@@ -117,8 +118,9 @@
     top_level_variable.main();
     top_type_inference.main();
     try_statement.main();
-    type_name.main();
     type_inference.main();
+    type_literal.main();
+    type_name.main();
     yield_statement.main();
   }, name: 'resolution');
 }
diff --git a/pkg/analyzer/test/src/dart/resolution/type_literal_test.dart b/pkg/analyzer/test/src/dart/resolution/type_literal_test.dart
new file mode 100644
index 0000000..5391331
--- /dev/null
+++ b/pkg/analyzer/test/src/dart/resolution/type_literal_test.dart
@@ -0,0 +1,193 @@
+// 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/src/dart/error/syntactic_errors.dart';
+import 'package:analyzer/src/error/codes.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import 'context_collection_resolution.dart';
+
+main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(TypeLiteralResolutionTest);
+    defineReflectiveTests(TypeLiteralResolutionWithoutConstructorTearoffsTest);
+  });
+}
+
+@reflectiveTest
+class TypeLiteralResolutionTest extends PubPackageResolutionTest {
+  test_class() async {
+    await assertNoErrorsInCode('''
+class C<T> {}
+var t = C<int>;
+''');
+
+    var typeLiteral = findNode.typeLiteral('C<int>;');
+    assertTypeLiteral(typeLiteral, findElement.class_('C'), 'C<int>');
+  }
+
+  test_class_importPrefix() async {
+    newFile('$testPackageLibPath/a.dart', content: '''
+class C<T> {}
+''');
+    await assertNoErrorsInCode('''
+import 'a.dart' as a;
+var t = a.C<int>;
+''');
+
+    var typeLiteral = findNode.typeLiteral('C<int>;');
+    assertTypeLiteral(
+      typeLiteral,
+      findElement.importFind('package:test/a.dart').class_('C'),
+      'C<int>',
+      expectedPrefix: findElement.import('package:test/a.dart').prefix,
+    );
+  }
+
+  test_class_tooFewTypeArgs() async {
+    await assertErrorsInCode('''
+class C<T, U> {}
+var t = C<int>;
+''', [
+      error(CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS, 26, 5),
+    ]);
+
+    var typeLiteral = findNode.typeLiteral('C<int>;');
+    assertTypeLiteral(
+        typeLiteral, findElement.class_('C'), 'C<dynamic, dynamic>');
+  }
+
+  test_class_tooManyTypeArgs() async {
+    await assertErrorsInCode('''
+class C<T> {}
+var t = C<int, int>;
+''', [
+      error(CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS, 23, 10),
+    ]);
+
+    var typeLiteral = findNode.typeLiteral('C<int, int>;');
+    assertTypeLiteral(typeLiteral, findElement.class_('C'), 'C<dynamic>');
+  }
+
+  test_classAlias() async {
+    await assertNoErrorsInCode('''
+class C<T> {}
+typedef CA<T> = C<T>;
+var t = CA<int>;
+''');
+
+    var typeLiteral = findNode.typeLiteral('CA<int>;');
+    assertTypeLiteral(typeLiteral, findElement.typeAlias('CA'), 'C<int>');
+  }
+
+  test_classAlias_differentTypeArgCount() async {
+    await assertNoErrorsInCode('''
+class C<T, U> {}
+typedef CA<T> = C<T, int>;
+var t = CA<String>;
+''');
+
+    var typeLiteral = findNode.typeLiteral('CA<String>;');
+    assertTypeLiteral(
+        typeLiteral, findElement.typeAlias('CA'), 'C<String, int>');
+  }
+
+  test_classAlias_functionTypeArg() async {
+    await assertNoErrorsInCode('''
+class C<T> {}
+typedef CA<T> = C<T>;
+var t = CA<void Function()>;
+''');
+
+    var typeLiteral = findNode.typeLiteral('CA<void Function()>;');
+    assertTypeLiteral(
+        typeLiteral, findElement.typeAlias('CA'), 'C<void Function()>');
+  }
+
+  test_classAlias_importPrefix() async {
+    newFile('$testPackageLibPath/a.dart', content: '''
+class C<T> {}
+typedef CA<T> = C<T>;
+''');
+    await assertNoErrorsInCode('''
+import 'a.dart' as a;
+var t = a.CA<int>;
+''');
+
+    var typeLiteral = findNode.typeLiteral('CA<int>;');
+    assertTypeLiteral(
+      typeLiteral,
+      findElement.importFind('package:test/a.dart').typeAlias('CA'),
+      'C<int>',
+      expectedPrefix: findElement.import('package:test/a.dart').prefix,
+    );
+  }
+
+  test_functionAlias() async {
+    await assertNoErrorsInCode('''
+typedef Fn<T> = void Function(T);
+var t = Fn<int>;
+''');
+
+    var typeLiteral = findNode.typeLiteral('Fn<int>;');
+    assertTypeLiteral(
+        typeLiteral, findElement.typeAlias('Fn'), 'void Function(int)');
+  }
+
+  test_mixin() async {
+    await assertNoErrorsInCode('''
+mixin M<T> {}
+var t = M<int>;
+''');
+
+    var typeLiteral = findNode.typeLiteral('M<int>;');
+    assertTypeLiteral(typeLiteral, findElement.mixin('M'), 'M<int>');
+  }
+
+  test_typeVariableTypeAlias() async {
+    await assertNoErrorsInCode('''
+typedef T<E> = E;
+var t = T<int>;
+''');
+
+    var typeLiteral = findNode.typeLiteral('T<int>;');
+    assertTypeLiteral(typeLiteral, findElement.typeAlias('T'), 'int');
+  }
+
+  test_typeVariableTypeAlias_functionTypeArgument() async {
+    await assertNoErrorsInCode('''
+typedef T<E> = E;
+var t = T<void Function()>;
+''');
+
+    var typeLiteral = findNode.typeLiteral('T<void Function()>;');
+    assertTypeLiteral(
+        typeLiteral, findElement.typeAlias('T'), 'void Function()');
+  }
+}
+
+@reflectiveTest
+class TypeLiteralResolutionWithoutConstructorTearoffsTest
+    extends PubPackageResolutionTest with WithoutConstructorTearoffsMixin {
+  test_class() async {
+    await assertErrorsInCode('''
+class C<T> {}
+var t = C<int>;
+''', [
+      error(ParserErrorCode.EXPERIMENT_NOT_ENABLED, 23, 5),
+    ]);
+  }
+
+  test_class_importPrefix() async {
+    newFile('$testPackageLibPath/a.dart', content: '''
+class C<T> {}
+''');
+    await assertErrorsInCode('''
+import 'a.dart' as a;
+var t = a.C<int>;
+''', [
+      error(ParserErrorCode.EXPERIMENT_NOT_ENABLED, 33, 5),
+    ]);
+  }
+}
diff --git a/pkg/analyzer/test/src/diagnostics/wrong_number_of_type_arguments_test.dart b/pkg/analyzer/test/src/diagnostics/wrong_number_of_type_arguments_test.dart
index b610200..ae55d6f 100644
--- a/pkg/analyzer/test/src/diagnostics/wrong_number_of_type_arguments_test.dart
+++ b/pkg/analyzer/test/src/diagnostics/wrong_number_of_type_arguments_test.dart
@@ -99,7 +99,8 @@
   foo<int>;
 }
 ''', [
-      error(CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS, 36, 5),
+      error(
+          CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS_FUNCTION, 36, 5),
     ]);
   }
 
@@ -109,7 +110,8 @@
   foo<int, int>;
 }
 ''', [
-      error(CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS, 33, 10),
+      error(
+          CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS_FUNCTION, 33, 10),
     ]);
   }
 
diff --git a/tests/standalone/io/large_file_read_small_file_test.dart b/tests/standalone/io/large_file_read_small_file_test.dart
index 2f4c276..9a7e97d 100644
--- a/tests/standalone/io/large_file_read_small_file_test.dart
+++ b/tests/standalone/io/large_file_read_small_file_test.dart
@@ -30,6 +30,9 @@
     try {
       final buffers = [];
       for (int i = 0; i < 100 * 1000; ++i) {
+        if (i % 1000 == 0) {
+          print(i);
+        }
         // We issue a 1 MB read but get only a small typed data back. We hang on
         // to those buffers. If the implementation actually malloc()ed 1 MB then
         // we would hang on to 100 GB and this test would OOM.
diff --git a/tests/standalone/standalone.status b/tests/standalone/standalone.status
index fc091da..f2d93f5 100644
--- a/tests/standalone/standalone.status
+++ b/tests/standalone/standalone.status
@@ -73,6 +73,9 @@
 io/https_connection_closed_during_handshake_test: SkipByDesign # long_ssl_cert_evaluation needed for long handshake is only supported on mac.
 io/https_nonblocking_trust_evaluation_test: SkipByDesign
 
+[ $system == windows ]
+io/large_file_read_small_file_test: Slow # Test reads small file 1M times
+
 [ $builder_tag == swarming && $system == macos ]
 io/*: Skip # Issue 30618
 
diff --git a/tests/standalone_2/io/large_file_read_small_file_test.dart b/tests/standalone_2/io/large_file_read_small_file_test.dart
index 0f62b12..755bc78 100644
--- a/tests/standalone_2/io/large_file_read_small_file_test.dart
+++ b/tests/standalone_2/io/large_file_read_small_file_test.dart
@@ -32,6 +32,9 @@
     try {
       final buffers = [];
       for (int i = 0; i < 100 * 1000; ++i) {
+        if (i % 1000 == 0) {
+          print(i);
+        }
         // We issue a 1 MB read but get only a small typed data back. We hang on
         // to those buffers. If the implementation actually malloc()ed 1 MB then
         // we would hang on to 100 GB and this test would OOM.
diff --git a/tests/standalone_2/standalone_2.status b/tests/standalone_2/standalone_2.status
index d875452..becc448 100644
--- a/tests/standalone_2/standalone_2.status
+++ b/tests/standalone_2/standalone_2.status
@@ -83,6 +83,9 @@
 io/https_connection_closed_during_handshake_test: SkipByDesign # long_ssl_cert_evaluation needed for long handshake is only supported on mac.
 io/https_nonblocking_trust_evaluation_test: SkipByDesign
 
+[ $system == windows ]
+io/large_file_read_small_file_test: Slow # Test reads small file 1M times
+
 [ $builder_tag == swarming && $system == macos ]
 io/*: Skip # Issue 30618
 
diff --git a/tools/VERSION b/tools/VERSION
index f272f4f..d1e510e 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 14
 PATCH 0
-PRERELEASE 270
+PRERELEASE 271
 PRERELEASE_PATCH 0
\ No newline at end of file