diff --git a/pkg/analyzer/lib/src/dart/ast/utilities.dart b/pkg/analyzer/lib/src/dart/ast/utilities.dart
index e066a65..b887f0a 100644
--- a/pkg/analyzer/lib/src/dart/ast/utilities.dart
+++ b/pkg/analyzer/lib/src/dart/ast/utilities.dart
@@ -1174,7 +1174,7 @@
 
   @override
   bool visitTypeName(TypeName node) {
-    TypeName other = _other as TypeName;
+    var other = _other as NamedType;
     return isEqualNodes(node.name, other.name) &&
         isEqualNodes(node.typeArguments, other.typeArguments) &&
         isEqualTokens(node.question, other.question);
diff --git a/pkg/analyzer/lib/src/generated/resolver.dart b/pkg/analyzer/lib/src/generated/resolver.dart
index cc2ed46..8a92e94 100644
--- a/pkg/analyzer/lib/src/generated/resolver.dart
+++ b/pkg/analyzer/lib/src/generated/resolver.dart
@@ -3052,7 +3052,12 @@
   }
 
   @override
-  void visitTypeName(TypeName node) {}
+  void visitTypeName(TypeName node) {
+    // All TypeName(s) are already resolved, so we don't resolve it here.
+    // But there might be type arguments with Expression(s), such as
+    // annotations on formal parameters of GenericFunctionType(s).
+    node.typeArguments?.accept(this);
+  }
 
   @override
   void visitVariableDeclaration(VariableDeclaration node) {
diff --git a/pkg/analyzer/test/generated/class_member_parser_test.dart b/pkg/analyzer/test/generated/class_member_parser_test.dart
index 515d419..fe8509a 100644
--- a/pkg/analyzer/test/generated/class_member_parser_test.dart
+++ b/pkg/analyzer/test/generated/class_member_parser_test.dart
@@ -162,15 +162,15 @@
     expect(list.isFinal, isFalse);
     expect(list.isLate, isFalse);
     expect(list.lateKeyword, isNull);
-    var type = list.type as TypeName;
+    var type = list.type as NamedType;
     expect(type.name.name, 'List');
     List typeArguments = type.typeArguments!.arguments;
     expect(typeArguments, hasLength(1));
-    var type2 = typeArguments[0] as TypeName;
+    var type2 = typeArguments[0] as NamedType;
     expect(type2.name.name, 'List');
     NodeList typeArguments2 = type2.typeArguments!.arguments;
     expect(typeArguments2, hasLength(1));
-    var type3 = typeArguments2[0] as TypeName;
+    var type3 = typeArguments2[0] as NamedType;
     expect(type3.name.name, 'N');
     NodeList<VariableDeclaration> variables = list.variables;
     expect(variables, hasLength(1));
@@ -508,7 +508,7 @@
     expect(parameters, isNotNull);
     expect(parameters.parameters, hasLength(1));
     var parameter = parameters.parameters[0] as SimpleFormalParameter;
-    var parameterType = parameter.type as TypeName;
+    var parameterType = parameter.type as NamedType;
     expect(parameterType.name.name, 'T');
 
     expect(method.body, isNotNull);
@@ -544,14 +544,14 @@
     expect(method.externalKeyword, isNull);
     expect(method.modifierKeyword, isNull);
     expect(method.propertyKeyword, isNull);
-    expect((method.returnType as TypeName).name.name, 'T');
+    expect((method.returnType as NamedType).name.name, 'T');
     expect(method.name, isNotNull);
     expect(method.operatorKeyword, isNull);
     expect(method.typeParameters, isNotNull);
     TypeParameter tp = method.typeParameters!.typeParameters[0];
     expect(tp.name.name, 'T');
     expect(tp.extendsKeyword, isNotNull);
-    expect((tp.bound as TypeName).name.name, 'num');
+    expect((tp.bound as NamedType).name.name, 'num');
     expect(method.parameters, isNotNull);
     expect(method.body, isNotNull);
   }
@@ -569,14 +569,14 @@
     expect(method.propertyKeyword, isNull);
 
     {
-      var returnType = method.returnType as TypeName;
+      var returnType = method.returnType as NamedType;
       expect(returnType, isNotNull);
       expect(returnType.name.name, 'Map');
 
       List<TypeAnnotation> typeArguments = returnType.typeArguments!.arguments;
       expect(typeArguments, hasLength(2));
-      expect((typeArguments[0] as TypeName).name.name, 'int');
-      expect((typeArguments[1] as TypeName).name.name, 'T');
+      expect((typeArguments[0] as NamedType).name.name, 'int');
+      expect((typeArguments[1] as NamedType).name.name, 'T');
     }
 
     expect(method.name, isNotNull);
@@ -598,7 +598,7 @@
     expect(method.modifierKeyword, isNotNull);
     expect(method.propertyKeyword, isNull);
     expect(method.returnType, isNotNull);
-    expect((method.returnType as TypeName).name.name, 'T');
+    expect((method.returnType as NamedType).name.name, 'T');
     expect(method.name, isNotNull);
     expect(method.operatorKeyword, isNull);
     expect(method.typeParameters, isNotNull);
@@ -1780,7 +1780,7 @@
     expect(method.operatorKeyword, isNull);
     expect(method.parameters, isNull);
     expect(method.propertyKeyword, isNotNull);
-    expect((method.returnType as TypeName).name.name, 'T');
+    expect((method.returnType as NamedType).name.name, 'T');
   }
 
   void test_parseGetter_static() {
@@ -1797,7 +1797,7 @@
     expect(method.typeParameters, isNull);
     expect(method.parameters, isNull);
     expect(method.propertyKeyword, isNotNull);
-    expect((method.returnType as TypeName).name.name, 'T');
+    expect((method.returnType as NamedType).name.name, 'T');
   }
 
   void test_parseInitializedIdentifierList_type() {
@@ -1809,7 +1809,7 @@
     VariableDeclarationList fields = declaration.fields;
     expect(fields, isNotNull);
     expect(fields.keyword, isNull);
-    expect((fields.type as TypeName).name.name, 'T');
+    expect((fields.type as NamedType).name.name, 'T');
     expect(fields.variables, hasLength(3));
     expect(declaration.staticKeyword!.lexeme, 'static');
     expect(declaration.semicolon, isNotNull);
@@ -1844,7 +1844,7 @@
     expect(method.typeParameters, isNull);
     expect(method.parameters, isNotNull);
     expect(method.propertyKeyword, isNull);
-    expect((method.returnType as TypeName).name.name, 'T');
+    expect((method.returnType as NamedType).name.name, 'T');
   }
 
   void test_parseSetter_nonStatic() {
@@ -1861,7 +1861,7 @@
     expect(method.typeParameters, isNull);
     expect(method.parameters, isNotNull);
     expect(method.propertyKeyword, isNotNull);
-    expect((method.returnType as TypeName).name.name, 'T');
+    expect((method.returnType as NamedType).name.name, 'T');
   }
 
   void test_parseSetter_static() {
@@ -1878,7 +1878,7 @@
     expect(method.typeParameters, isNull);
     expect(method.parameters, isNotNull);
     expect(method.propertyKeyword, isNotNull);
-    expect((method.returnType as TypeName).name.name, 'T');
+    expect((method.returnType as NamedType).name.name, 'T');
   }
 
   void test_simpleFormalParameter_withDocComment() {
diff --git a/pkg/analyzer/test/generated/complex_parser_test.dart b/pkg/analyzer/test/generated/complex_parser_test.dart
index 31ebd1f..bfc6f04 100644
--- a/pkg/analyzer/test/generated/complex_parser_test.dart
+++ b/pkg/analyzer/test/generated/complex_parser_test.dart
@@ -245,7 +245,7 @@
         parseStatement('x as bool? ? (x + y) : z;') as ExpressionStatement;
     var expression = statement.expression as ConditionalExpression;
     var asExpression = expression.condition as AsExpression;
-    var type = asExpression.type as TypeName;
+    var type = asExpression.type as NamedType;
     expect(type.question!.lexeme, '?');
     Expression thenExpression = expression.thenExpression;
     expect(thenExpression, isParenthesizedExpression);
@@ -260,7 +260,7 @@
     var expression = statement.expression as ConditionalExpression;
     var condition = expression.condition as ParenthesizedExpression;
     var asExpression = condition.expression as AsExpression;
-    var type = asExpression.type as TypeName;
+    var type = asExpression.type as NamedType;
     expect(type.question!.lexeme, '?');
     Expression thenExpression = expression.thenExpression;
     expect(thenExpression, isParenthesizedExpression);
@@ -286,7 +286,7 @@
         parseStatement('x is String? ? (x + y) : z;') as ExpressionStatement;
     var expression = statement.expression as ConditionalExpression;
     var isExpression = expression.condition as IsExpression;
-    var type = isExpression.type as TypeName;
+    var type = isExpression.type as NamedType;
     expect(type.question!.lexeme, '?');
     Expression thenExpression = expression.thenExpression;
     expect(thenExpression, isParenthesizedExpression);
@@ -301,7 +301,7 @@
     var expression = statement.expression as ConditionalExpression;
     var condition = expression.condition as ParenthesizedExpression;
     var isExpression = condition.expression as IsExpression;
-    var type = isExpression.type as TypeName;
+    var type = isExpression.type as NamedType;
     expect(type.question!.lexeme, '?');
     Expression thenExpression = expression.thenExpression;
     expect(thenExpression, isParenthesizedExpression);
diff --git a/pkg/analyzer/test/generated/expression_parser_test.dart b/pkg/analyzer/test/generated/expression_parser_test.dart
index cfcbb34..9119e76 100644
--- a/pkg/analyzer/test/generated/expression_parser_test.dart
+++ b/pkg/analyzer/test/generated/expression_parser_test.dart
@@ -1776,7 +1776,7 @@
     var identifier = asExpression.expression as SimpleIdentifier;
     expect(identifier.name, 'x');
     expect(asExpression.asOperator, isNotNull);
-    var typeName = asExpression.type as TypeName;
+    var typeName = asExpression.type as NamedType;
     expect(typeName.name.name, 'Y');
   }
 
@@ -1850,7 +1850,7 @@
     var identifier = isExpression.expression as SimpleIdentifier;
     expect(identifier.name, 'x');
     expect(isExpression.isOperator, isNotNull);
-    var typeName = isExpression.type as TypeName;
+    var typeName = isExpression.type as NamedType;
     expect(typeName.name.name, 'Y');
   }
 
diff --git a/pkg/analyzer/test/generated/formal_parameter_parser_test.dart b/pkg/analyzer/test/generated/formal_parameter_parser_test.dart
index cc1b2f1..cfab781 100644
--- a/pkg/analyzer/test/generated/formal_parameter_parser_test.dart
+++ b/pkg/analyzer/test/generated/formal_parameter_parser_test.dart
@@ -904,7 +904,7 @@
     var required = parameters[0] as SimpleFormalParameter;
     expect(required.identifier, isNull);
     expect(required.type, isTypeName);
-    expect((required.type as TypeName).name.name, 'A');
+    expect((required.type as NamedType).name.name, 'A');
 
     expect(parameters[1], isDefaultFormalParameter);
     var named = parameters[1] as DefaultFormalParameter;
@@ -912,7 +912,7 @@
     expect(named.parameter, isSimpleFormalParameter);
     var simple = named.parameter as SimpleFormalParameter;
     expect(simple.type, isTypeName);
-    expect((simple.type as TypeName).name.name, 'B');
+    expect((simple.type as NamedType).name.name, 'B');
   }
 
   void test_parseFormalParameterList_normal_positional() {
@@ -1016,7 +1016,7 @@
     var parameter = list.parameters[0] as SimpleFormalParameter;
     expect(parameter.toSource(), 'io.File ');
     expect(parameter.identifier!.token.isSynthetic, isTrue);
-    var type = parameter.type as TypeName;
+    var type = parameter.type as NamedType;
     var typeName = type.name as PrefixedIdentifier;
     expect(typeName.prefix.token.isSynthetic, isFalse);
     expect(typeName.identifier.token.isSynthetic, isFalse);
@@ -1037,7 +1037,7 @@
     var parameter = list.parameters[0] as SimpleFormalParameter;
     expect(parameter.toSource(), 'io. ');
     expect(parameter.identifier!.token.isSynthetic, isTrue);
-    var type = parameter.type as TypeName;
+    var type = parameter.type as NamedType;
     var typeName = type.name as PrefixedIdentifier;
     expect(typeName.prefix.token.isSynthetic, isFalse);
     expect(typeName.identifier.token.isSynthetic, isTrue);
diff --git a/pkg/analyzer/test/generated/function_reference_parser_test.dart b/pkg/analyzer/test/generated/function_reference_parser_test.dart
index 89ffcb5..07f8755 100644
--- a/pkg/analyzer/test/generated/function_reference_parser_test.dart
+++ b/pkg/analyzer/test/generated/function_reference_parser_test.dart
@@ -24,8 +24,8 @@
     expect((functionReference.function as SimpleIdentifier).name, 'f');
     var typeArgs = functionReference.typeArguments!.arguments;
     expect(typeArgs, hasLength(2));
-    expect(((typeArgs[0] as TypeName).name as SimpleIdentifier).name, 'a');
-    expect(((typeArgs[1] as TypeName).name as SimpleIdentifier).name, 'b');
+    expect(((typeArgs[0] as NamedType).name as SimpleIdentifier).name, 'a');
+    expect(((typeArgs[1] as NamedType).name as SimpleIdentifier).name, 'b');
   }
 
   void expect_two_args(MethodInvocation methodInvocation) {
@@ -101,8 +101,8 @@
     expect(methodInvocation.methodName.name, 'f');
     var typeArgs = methodInvocation.typeArguments!.arguments;
     expect(typeArgs, hasLength(2));
-    expect(((typeArgs[0] as TypeName).name as SimpleIdentifier).name, 'a');
-    expect(((typeArgs[1] as TypeName).name as SimpleIdentifier).name, 'b');
+    expect(((typeArgs[0] as NamedType).name as SimpleIdentifier).name, 'a');
+    expect(((typeArgs[1] as NamedType).name as SimpleIdentifier).name, 'b');
     expect(methodInvocation.argumentList.arguments, isEmpty);
   }
 
@@ -117,8 +117,8 @@
     expect((type.name as SimpleIdentifier).name, 'f');
     var typeArgs = type.typeArguments!.arguments;
     expect(typeArgs, hasLength(2));
-    expect(((typeArgs[0] as TypeName).name as SimpleIdentifier).name, 'a');
-    expect(((typeArgs[1] as TypeName).name as SimpleIdentifier).name, 'b');
+    expect(((typeArgs[0] as NamedType).name as SimpleIdentifier).name, 'a');
+    expect(((typeArgs[1] as NamedType).name as SimpleIdentifier).name, 'b');
     expect(constructorName.name!.name, 'toString');
     expect(instanceCreationExpression.argumentList.arguments, isEmpty);
   }
@@ -358,8 +358,8 @@
     expect(functionReference.function, TypeMatcher<IndexExpression>());
     var typeArgs = functionReference.typeArguments!.arguments;
     expect(typeArgs, hasLength(2));
-    expect(((typeArgs[0] as TypeName).name as SimpleIdentifier).name, 'a');
-    expect(((typeArgs[1] as TypeName).name as SimpleIdentifier).name, 'b');
+    expect(((typeArgs[0] as NamedType).name as SimpleIdentifier).name, 'a');
+    expect(((typeArgs[1] as NamedType).name as SimpleIdentifier).name, 'b');
   }
 
   void test_functionReference_after_indexExpression_bang() {
@@ -371,8 +371,8 @@
     expect(functionReference.function, TypeMatcher<PostfixExpression>());
     var typeArgs = functionReference.typeArguments!.arguments;
     expect(typeArgs, hasLength(2));
-    expect(((typeArgs[0] as TypeName).name as SimpleIdentifier).name, 'a');
-    expect(((typeArgs[1] as TypeName).name as SimpleIdentifier).name, 'b');
+    expect(((typeArgs[0] as NamedType).name as SimpleIdentifier).name, 'a');
+    expect(((typeArgs[1] as NamedType).name as SimpleIdentifier).name, 'b');
   }
 
   void test_functionReference_after_indexExpression_functionCall() {
@@ -385,8 +385,8 @@
         TypeMatcher<FunctionExpressionInvocation>());
     var typeArgs = functionReference.typeArguments!.arguments;
     expect(typeArgs, hasLength(2));
-    expect(((typeArgs[0] as TypeName).name as SimpleIdentifier).name, 'a');
-    expect(((typeArgs[1] as TypeName).name as SimpleIdentifier).name, 'b');
+    expect(((typeArgs[0] as NamedType).name as SimpleIdentifier).name, 'a');
+    expect(((typeArgs[1] as NamedType).name as SimpleIdentifier).name, 'b');
   }
 
   void test_functionReference_after_indexExpression_nullAware() {
@@ -398,8 +398,8 @@
     expect(functionReference.function, TypeMatcher<IndexExpression>());
     var typeArgs = functionReference.typeArguments!.arguments;
     expect(typeArgs, hasLength(2));
-    expect(((typeArgs[0] as TypeName).name as SimpleIdentifier).name, 'a');
-    expect(((typeArgs[1] as TypeName).name as SimpleIdentifier).name, 'b');
+    expect(((typeArgs[0] as NamedType).name as SimpleIdentifier).name, 'a');
+    expect(((typeArgs[1] as NamedType).name as SimpleIdentifier).name, 'b');
   }
 
   void test_methodTearoff() {
@@ -412,8 +412,8 @@
     expect(function.propertyName.name, 'm');
     var typeArgs = functionReference.typeArguments!.arguments;
     expect(typeArgs, hasLength(2));
-    expect(((typeArgs[0] as TypeName).name as SimpleIdentifier).name, 'a');
-    expect(((typeArgs[1] as TypeName).name as SimpleIdentifier).name, 'b');
+    expect(((typeArgs[0] as NamedType).name as SimpleIdentifier).name, 'a');
+    expect(((typeArgs[1] as NamedType).name as SimpleIdentifier).name, 'b');
   }
 
   void test_methodTearoff_cascaded() {
@@ -427,8 +427,8 @@
     expect(function.propertyName.name, 'm');
     var typeArgs = functionReference.typeArguments!.arguments;
     expect(typeArgs, hasLength(2));
-    expect(((typeArgs[0] as TypeName).name as SimpleIdentifier).name, 'a');
-    expect(((typeArgs[1] as TypeName).name as SimpleIdentifier).name, 'b');
+    expect(((typeArgs[0] as NamedType).name as SimpleIdentifier).name, 'a');
+    expect(((typeArgs[1] as NamedType).name as SimpleIdentifier).name, 'b');
   }
 
   void test_prefixedIdentifier() {
@@ -440,8 +440,8 @@
     expect(function.identifier.name, 'f');
     var typeArgs = functionReference.typeArguments!.arguments;
     expect(typeArgs, hasLength(2));
-    expect(((typeArgs[0] as TypeName).name as SimpleIdentifier).name, 'a');
-    expect(((typeArgs[1] as TypeName).name as SimpleIdentifier).name, 'b');
+    expect(((typeArgs[0] as NamedType).name as SimpleIdentifier).name, 'a');
+    expect(((typeArgs[1] as NamedType).name as SimpleIdentifier).name, 'b');
   }
 
   void test_three_identifiers() {
@@ -454,7 +454,7 @@
     expect(function.propertyName.name, 'm');
     var typeArgs = functionReference.typeArguments!.arguments;
     expect(typeArgs, hasLength(2));
-    expect(((typeArgs[0] as TypeName).name as SimpleIdentifier).name, 'a');
-    expect(((typeArgs[1] as TypeName).name as SimpleIdentifier).name, 'b');
+    expect(((typeArgs[0] as NamedType).name as SimpleIdentifier).name, 'a');
+    expect(((typeArgs[1] as NamedType).name as SimpleIdentifier).name, 'b');
   }
 }
diff --git a/pkg/analyzer/test/generated/generic_metadata_parser_test.dart b/pkg/analyzer/test/generated/generic_metadata_parser_test.dart
index c4627d1..9e967e9 100644
--- a/pkg/analyzer/test/generated/generic_metadata_parser_test.dart
+++ b/pkg/analyzer/test/generated/generic_metadata_parser_test.dart
@@ -59,7 +59,7 @@
     var className = annotation.name as PrefixedIdentifier;
     expect(className.prefix.name, 'p');
     expect(className.identifier.name, 'A');
-    var typeArgument = annotation.typeArguments!.arguments.single as TypeName;
+    var typeArgument = annotation.typeArguments!.arguments.single as NamedType;
     var typeArgumentName = typeArgument.name as SimpleIdentifier;
     expect(typeArgumentName.name, 'B');
     expect(annotation.constructorName, isNull);
@@ -75,7 +75,7 @@
     var className = annotation.name as PrefixedIdentifier;
     expect(className.prefix.name, 'p');
     expect(className.identifier.name, 'A');
-    var typeArgument = annotation.typeArguments!.arguments.single as TypeName;
+    var typeArgument = annotation.typeArguments!.arguments.single as NamedType;
     var typeArgumentName = typeArgument.name as SimpleIdentifier;
     expect(typeArgumentName.name, 'B');
     expect(annotation.constructorName!.name, 'ctor');
@@ -90,7 +90,7 @@
     var annotation = classDeclaration.metadata.single;
     var className = annotation.name as SimpleIdentifier;
     expect(className.name, 'A');
-    var typeArgument = annotation.typeArguments!.arguments.single as TypeName;
+    var typeArgument = annotation.typeArguments!.arguments.single as NamedType;
     var typeArgumentName = typeArgument.name as SimpleIdentifier;
     expect(typeArgumentName.name, 'B');
     expect(annotation.constructorName, isNull);
@@ -105,7 +105,7 @@
     var annotation = classDeclaration.metadata.single;
     var className = annotation.name as SimpleIdentifier;
     expect(className.name, 'A');
-    var typeArgument = annotation.typeArguments!.arguments.single as TypeName;
+    var typeArgument = annotation.typeArguments!.arguments.single as NamedType;
     var typeArgumentName = typeArgument.name as SimpleIdentifier;
     expect(typeArgumentName.name, 'B');
     expect(annotation.constructorName!.name, 'ctor');
@@ -127,7 +127,7 @@
     var name = annotation.name as PrefixedIdentifier;
     expect(name.prefix.name, 'p');
     expect(name.identifier.name, 'x');
-    var typeArgument = annotation.typeArguments!.arguments.single as TypeName;
+    var typeArgument = annotation.typeArguments!.arguments.single as NamedType;
     var typeArgumentName = typeArgument.name as SimpleIdentifier;
     expect(typeArgumentName.name, 'A');
     expect(annotation.constructorName, isNull);
@@ -148,7 +148,7 @@
     var annotation = classDeclaration.metadata.single;
     var name = annotation.name as SimpleIdentifier;
     expect(name.name, 'x');
-    var typeArgument = annotation.typeArguments!.arguments.single as TypeName;
+    var typeArgument = annotation.typeArguments!.arguments.single as NamedType;
     var typeArgumentName = typeArgument.name as SimpleIdentifier;
     expect(typeArgumentName.name, 'A');
     expect(annotation.constructorName, isNull);
diff --git a/pkg/analyzer/test/generated/nnbd_parser_test.dart b/pkg/analyzer/test/generated/nnbd_parser_test.dart
index 113fa2b..53a1772 100644
--- a/pkg/analyzer/test/generated/nnbd_parser_test.dart
+++ b/pkg/analyzer/test/generated/nnbd_parser_test.dart
@@ -95,7 +95,7 @@
     expect(functionExpression.operator.lexeme, '!');
 
     expect(expression.typeArguments!.arguments.length, 1);
-    var typeArgument = expression.typeArguments!.arguments.single as TypeName;
+    var typeArgument = expression.typeArguments!.arguments.single as NamedType;
     expect(typeArgument.name.name, "int");
 
     expect(expression.argumentList.arguments.length, 1);
@@ -395,7 +395,7 @@
     var parameter =
         constructor.parameters.parameters.single as SimpleFormalParameter;
     expect(parameter.identifier!.name, 'o');
-    var type = parameter.type as TypeName;
+    var type = parameter.type as NamedType;
     expect(type.question!.lexeme, '?');
     expect(type.name.name, 'Object');
 
@@ -409,7 +409,7 @@
       var expression = initializer.expression as AsExpression;
       var identifier = expression.expression as SimpleIdentifier;
       expect(identifier.name, 'o');
-      var expressionType = expression.type as TypeName;
+      var expressionType = expression.type as NamedType;
       expect(expressionType.question!.lexeme, '?');
       expect(expressionType.name.name, 'String');
     }
@@ -441,7 +441,7 @@
     var parameter =
         constructor.parameters.parameters.single as SimpleFormalParameter;
     expect(parameter.identifier!.name, 'o');
-    var type = parameter.type as TypeName;
+    var type = parameter.type as NamedType;
     expect(type.question!.lexeme, '?');
     expect(type.name.name, 'Object');
 
@@ -456,7 +456,7 @@
       var condition = expression.condition as IsExpression;
       var identifier = condition.expression as SimpleIdentifier;
       expect(identifier.name, 'o');
-      var expressionType = condition.type as TypeName;
+      var expressionType = condition.type as NamedType;
       expect(expressionType.question!.lexeme, '?');
       expect(expressionType.name.name, 'String');
       var thenExpression = expression.thenExpression as PrefixedIdentifier;
@@ -494,7 +494,7 @@
     var parameter =
         constructor.parameters.parameters.single as SimpleFormalParameter;
     expect(parameter.identifier!.name, 'o');
-    var type = parameter.type as TypeName;
+    var type = parameter.type as NamedType;
     expect(type.question!.lexeme, '?');
     expect(type.name.name, 'Object');
 
@@ -509,7 +509,7 @@
       var condition = expression.condition as IsExpression;
       var identifier = condition.expression as SimpleIdentifier;
       expect(identifier.name, 'o');
-      var expressionType = condition.type as TypeName;
+      var expressionType = condition.type as NamedType;
       expect(expressionType.question, isNull);
       expect(expressionType.name.name, 'String');
       var thenExpression = expression.thenExpression as PrefixedIdentifier;
diff --git a/pkg/analyzer/test/generated/recovery_parser_test.dart b/pkg/analyzer/test/generated/recovery_parser_test.dart
index 523a736..e110012 100644
--- a/pkg/analyzer/test/generated/recovery_parser_test.dart
+++ b/pkg/analyzer/test/generated/recovery_parser_test.dart
@@ -968,7 +968,7 @@
     VariableDeclaration field = fields[0];
     expect(field.name.name, 'f');
 // validate the type
-    var typeArguments = (fieldList.type as TypeName).typeArguments!;
+    var typeArguments = (fieldList.type as NamedType).typeArguments!;
     expect(typeArguments.arguments, hasLength(1));
 // synthetic '>'
     Token token = typeArguments.endToken;
diff --git a/pkg/analyzer/test/generated/simple_parser_test.dart b/pkg/analyzer/test/generated/simple_parser_test.dart
index 3a52b79..a5072f7 100644
--- a/pkg/analyzer/test/generated/simple_parser_test.dart
+++ b/pkg/analyzer/test/generated/simple_parser_test.dart
@@ -1605,13 +1605,13 @@
     var parameter = parameters[0] as SimpleFormalParameter;
     expect(parameter.identifier, isNull);
     expect(parameter.type, isTypeName);
-    expect((parameter.type as TypeName).name.name, 'int');
+    expect((parameter.type as NamedType).name.name, 'int');
 
     expect(parameters[1], isSimpleFormalParameter);
     parameter = parameters[1] as SimpleFormalParameter;
     expect(parameter.identifier, isNull);
     expect(parameter.type, isTypeName);
-    expect((parameter.type as TypeName).name.name, 'int');
+    expect((parameter.type as NamedType).name.name, 'int');
   }
 
   void test_parseTypeAnnotation_function_noReturnType_typeParameters() {
@@ -1647,7 +1647,7 @@
 
   void test_parseTypeAnnotation_function_returnType_classFunction() {
     createParser('Function');
-    var functionType = parser.parseTypeAnnotation(false) as TypeName;
+    var functionType = parser.parseTypeAnnotation(false) as NamedType;
     expectNotNullIfNoErrors(functionType);
     assertNoErrors();
   }
@@ -1691,14 +1691,14 @@
     expect(parameter.identifier, isNotNull);
     expect(parameter.identifier!.name, 's');
     expect(parameter.type, isTypeName);
-    expect((parameter.type as TypeName).name.name, 'String');
+    expect((parameter.type as NamedType).name.name, 'String');
 
     expect(parameters[1], isSimpleFormalParameter);
     parameter = parameters[1] as SimpleFormalParameter;
     expect(parameter.identifier, isNotNull);
     expect(parameter.identifier!.name, 'i');
     expect(parameter.type, isTypeName);
-    expect((parameter.type as TypeName).name.name, 'int');
+    expect((parameter.type as NamedType).name.name, 'int');
   }
 
   void test_parseTypeAnnotation_function_returnType_simple() {
@@ -1750,7 +1750,7 @@
 
   void test_parseTypeAnnotation_named() {
     createParser('A<B>');
-    var typeName = parser.parseTypeAnnotation(false) as TypeName;
+    var typeName = parser.parseTypeAnnotation(false) as NamedType;
     expectNotNullIfNoErrors(typeName);
     assertNoErrors();
   }
@@ -1782,7 +1782,7 @@
     assertNoErrors();
     expect(argumentList.leftBracket, isNotNull);
     expect(argumentList.arguments, hasLength(1));
-    var argument = argumentList.arguments[0] as TypeName;
+    var argument = argumentList.arguments[0] as NamedType;
     expect(argument, isNotNull);
     var innerList = argument.typeArguments!;
     expect(innerList, isNotNull);
@@ -1799,7 +1799,7 @@
     expect(argumentList.rightBracket, isNotNull);
     expect(argumentList.arguments, hasLength(1));
 
-    var argument = argumentList.arguments[0] as TypeName;
+    var argument = argumentList.arguments[0] as NamedType;
     expect(argument, isNotNull);
 
     var innerList = argument.typeArguments!;
@@ -1819,7 +1819,7 @@
     expect(argumentList.rightBracket, isNotNull);
     expect(argumentList.arguments, hasLength(1));
 
-    var argument = argumentList.arguments[0] as TypeName;
+    var argument = argumentList.arguments[0] as NamedType;
     expect(argument, isNotNull);
 
     var innerList = argument.typeArguments!;
@@ -1828,7 +1828,7 @@
     expect(innerList.arguments, hasLength(1));
     expect(innerList.rightBracket, isNotNull);
 
-    var innerArgument = innerList.arguments[0] as TypeName;
+    var innerArgument = innerList.arguments[0] as NamedType;
     expect(innerArgument, isNotNull);
 
     var innerInnerList = innerArgument.typeArguments!;
@@ -1947,13 +1947,13 @@
     expect(parameterList.typeParameters, hasLength(1));
     TypeParameter typeParameter = parameterList.typeParameters[0];
     expect(typeParameter.name.name, 'A');
-    var bound = typeParameter.bound as TypeName;
+    var bound = typeParameter.bound as NamedType;
     expect(bound.name.name, 'B');
     var typeArguments = bound.typeArguments!;
     expect(typeArguments.arguments, hasLength(1));
     expect(typeArguments.rightBracket, isNotNull);
     expect(typeArguments.rightBracket.precedingComments!.lexeme, '/* foo */');
-    var argument = typeArguments.arguments[0] as TypeName;
+    var argument = typeArguments.arguments[0] as NamedType;
     expect(argument.name.name, 'E');
   }
 
diff --git a/pkg/analyzer/test/generated/statement_parser_test.dart b/pkg/analyzer/test/generated/statement_parser_test.dart
index d86564a..5e90e69 100644
--- a/pkg/analyzer/test/generated/statement_parser_test.dart
+++ b/pkg/analyzer/test/generated/statement_parser_test.dart
@@ -27,7 +27,7 @@
     var funct1 = statement.expression as FunctionExpressionInvocation;
     List<TypeAnnotation> typeArgs = funct1.typeArguments!.arguments;
     expect(typeArgs, hasLength(1));
-    var typeName = typeArgs[0] as TypeName;
+    var typeName = typeArgs[0] as NamedType;
     expect(typeName.name.name, 'int');
     expect(funct1.argumentList.arguments, hasLength(0));
 
@@ -1183,10 +1183,10 @@
     List<VariableDeclaration> variables = variableList.variables;
     expect(variables, hasLength(1));
     expect(variables[0].name.name, 'v');
-    var typeName = variableList.type as TypeName;
+    var typeName = variableList.type as NamedType;
     expect(typeName.name.name, 'C');
     expect(typeName.typeArguments!.arguments, hasLength(1));
-    var typeArgument = typeName.typeArguments!.arguments[0] as TypeName;
+    var typeArgument = typeName.typeArguments!.arguments[0] as NamedType;
     expect(typeArgument.name.name, 'T');
   }
 
@@ -1198,10 +1198,10 @@
     List<VariableDeclaration> variables = variableList.variables;
     expect(variables, hasLength(1));
     expect(variables[0].name.name, 'v');
-    var typeName = variableList.type as TypeName;
+    var typeName = variableList.type as NamedType;
     expect(typeName.name.name, 'C');
     expect(typeName.typeArguments!.arguments, hasLength(1));
-    var typeArgument = typeName.typeArguments!.arguments[0] as TypeName;
+    var typeArgument = typeName.typeArguments!.arguments[0] as NamedType;
     expect(typeArgument.name.name, 'T');
   }
 
@@ -1213,7 +1213,7 @@
     List<VariableDeclaration> variables = variableList.variables;
     expect(variables, hasLength(1));
     expect(variables[0].name.name, 'v');
-    var typeName = variableList.type as TypeName;
+    var typeName = variableList.type as NamedType;
     expect(typeName.name.name, 'C');
     expect(typeName.typeArguments!.arguments, hasLength(1));
     expect(typeName.typeArguments!.arguments[0], isGenericFunctionType);
@@ -1223,7 +1223,7 @@
     var declaration = parseStatement('C<> c;') as VariableDeclarationStatement;
     assertErrorsWithCodes([ParserErrorCode.EXPECTED_TYPE_NAME]);
     VariableDeclarationList variables = declaration.variables;
-    var type = variables.type as TypeName;
+    var type = variables.type as NamedType;
     var argumentList = type.typeArguments!;
     expect(argumentList.leftBracket, isNotNull);
     expect(argumentList.arguments, hasLength(1));
diff --git a/pkg/analyzer/test/generated/top_level_parser_test.dart b/pkg/analyzer/test/generated/top_level_parser_test.dart
index acf54ac..0ec3d0a 100644
--- a/pkg/analyzer/test/generated/top_level_parser_test.dart
+++ b/pkg/analyzer/test/generated/top_level_parser_test.dart
@@ -93,15 +93,15 @@
     expect(declaration.variables.type, isNotNull);
     expect(declaration.variables.type!.question, isNull);
     expect(declaration.variables.type, TypeMatcher<TypeName>());
-    var type = declaration.variables.type as TypeName;
+    var type = declaration.variables.type as NamedType;
     expect(type.name.name, "Future");
     expect(type.typeArguments!.arguments.length, 1);
     expect(type.typeArguments!.arguments.single, TypeMatcher<TypeName>());
-    var subType = type.typeArguments!.arguments.single as TypeName;
+    var subType = type.typeArguments!.arguments.single as NamedType;
     expect(subType.name.name, "List");
     expect(subType.typeArguments!.arguments.length, 1);
     expect(subType.typeArguments!.arguments.single, TypeMatcher<TypeName>());
-    var subSubType = subType.typeArguments!.arguments.single as TypeName;
+    var subSubType = subType.typeArguments!.arguments.single as NamedType;
     expect(subSubType.name.name, "");
     expect(subSubType.typeArguments, isNull);
   }
@@ -1467,7 +1467,7 @@
     expect(declaration, isNotNull);
     assertNoErrors();
     expectCommentText(declaration.documentationComment, '/// Doc');
-    expect((declaration.returnType as TypeName).name.name, 'T');
+    expect((declaration.returnType as NamedType).name.name, 'T');
     expect(declaration.name, isNotNull);
     FunctionExpression expression = declaration.functionExpression;
     expect(expression, isNotNull);
@@ -1483,7 +1483,7 @@
     expect(declaration, isNotNull);
     assertNoErrors();
     expectCommentText(declaration.documentationComment, '/// Doc');
-    expect((declaration.returnType as TypeName).name.name, 'T');
+    expect((declaration.returnType as NamedType).name.name, 'T');
     expect(declaration.name, isNotNull);
     FunctionExpression expression = declaration.functionExpression;
     expect(expression, isNotNull);
@@ -1499,7 +1499,7 @@
     expect(declaration, isNotNull);
     assertNoErrors();
     expectCommentText(declaration.documentationComment, '/// Doc');
-    expect((declaration.returnType as TypeName).name.name, 'T');
+    expect((declaration.returnType as NamedType).name.name, 'T');
     expect(declaration.name, isNotNull);
     FunctionExpression expression = declaration.functionExpression;
     expect(expression, isNotNull);
@@ -1516,7 +1516,7 @@
     expect(declaration, isNotNull);
     assertNoErrors();
     expect(declaration.documentationComment, isNull);
-    expect((declaration.returnType as TypeName).name.name, 'T');
+    expect((declaration.returnType as NamedType).name.name, 'T');
     expect(declaration.name, isNotNull);
     FunctionExpression expression = declaration.functionExpression;
     expect(expression, isNotNull);
@@ -1577,7 +1577,7 @@
     expect(declaration, isNotNull);
     assertNoErrors();
     expectCommentText(declaration.documentationComment, '/// Doc');
-    expect((declaration.returnType as TypeName).name.name, 'T');
+    expect((declaration.returnType as NamedType).name.name, 'T');
     expect(declaration.name, isNotNull);
     FunctionExpression expression = declaration.functionExpression;
     expect(expression, isNotNull);
diff --git a/pkg/analyzer/test/src/dart/analysis/driver_resolution_test.dart b/pkg/analyzer/test/src/dart/analysis/driver_resolution_test.dart
index 757cb6f..9564da7 100644
--- a/pkg/analyzer/test/src/dart/analysis/driver_resolution_test.dart
+++ b/pkg/analyzer/test/src/dart/analysis/driver_resolution_test.dart
@@ -743,7 +743,7 @@
       expect(target.staticElement, vElement);
       expect(target.staticType, typeProvider.numType);
 
-      var intName = asExpression.type as TypeName;
+      var intName = asExpression.type as NamedType;
       expect(intName.name.staticElement, typeProvider.intType.element);
       expect(intName.name.staticType, isNull);
     }
@@ -1723,7 +1723,7 @@
 
     var statement = statements[0] as VariableDeclarationStatement;
 
-    var typeName = statement.variables.type as TypeName;
+    var typeName = statement.variables.type as NamedType;
     expect(typeName.type, isDynamicType);
     expect(typeName.typeArguments!.arguments[0].type, typeProvider.intType);
 
@@ -2466,8 +2466,8 @@
       assertNamedType(typeName, cElement, 'C<int, double>');
 
       var typeArguments = typeName.typeArguments!.arguments;
-      assertNamedType(typeArguments[0] as TypeName, intElement, 'int');
-      assertNamedType(typeArguments[1] as TypeName, doubleElement, 'double');
+      assertNamedType(typeArguments[0] as NamedType, intElement, 'int');
+      assertNamedType(typeArguments[1] as NamedType, doubleElement, 'double');
 
       expect(creation.constructorName.name, isNull);
 
@@ -2485,8 +2485,8 @@
       assertNamedType(typeName, cElement, 'C<num, String>');
 
       var typeArguments = typeName.typeArguments!.arguments;
-      assertNamedType(typeArguments[0] as TypeName, numElement, 'num');
-      assertNamedType(typeArguments[1] as TypeName, stringElement, 'String');
+      assertNamedType(typeArguments[0] as NamedType, numElement, 'num');
+      assertNamedType(typeArguments[1] as NamedType, stringElement, 'String');
 
       var constructorName = creation.constructorName.name;
       assertMember(
@@ -3640,7 +3640,7 @@
     assertElement(tRef, tElement);
     assertTypeDynamic(tRef);
 
-    var typeName = prefixedName.parent as TypeName;
+    var typeName = prefixedName.parent as NamedType;
     expect(typeName.type, isDynamicType);
   }
 
@@ -3708,7 +3708,7 @@
     assertElement(tRef, tElement);
     assertTypeDynamic(tRef);
 
-    var typeName = prefixedName.parent as TypeName;
+    var typeName = prefixedName.parent as NamedType;
     expect(typeName.type, isDynamicType);
   }
 
@@ -3793,7 +3793,7 @@
     expect(target.staticElement, findElement.parameter('a'));
     expect(target.staticType, dynamicType);
 
-    var numName = isExpression.type as TypeName;
+    var numName = isExpression.type as NamedType;
     expect(numName.name.staticElement, typeProvider.numType.element);
     expect(numName.name.staticType, isNull);
   }
@@ -3813,7 +3813,7 @@
     expect(target.staticElement, findElement.parameter('a'));
     expect(target.staticType, dynamicType);
 
-    var numName = isExpression.type as TypeName;
+    var numName = isExpression.type as NamedType;
     expect(numName.name.staticElement, typeProvider.numType.element);
     expect(numName.name.staticType, isNull);
   }
@@ -3921,7 +3921,7 @@
     expect(fNode.name.staticElement, same(fElement));
     expect(fNode.name.staticType, isNull);
 
-    var fReturnTypeNode = fNode.returnType as TypeName;
+    var fReturnTypeNode = fNode.returnType as NamedType;
     expect(fReturnTypeNode.name.staticElement, same(doubleType.element));
     expect(fReturnTypeNode.type, doubleType);
 
@@ -4016,7 +4016,7 @@
     expect(fNode.name.staticElement, same(fElement));
     expect(fNode.name.staticType, fElement.type);
 
-    var fReturnTypeNode = fNode.returnType as TypeName;
+    var fReturnTypeNode = fNode.returnType as NamedType;
     expect(fReturnTypeNode.name.staticElement, same(tElement));
     expect(fReturnTypeNode.type, typeParameterTypeStar(tElement));
 
@@ -4148,7 +4148,7 @@
     expect(fNode.name.staticElement, same(fElement));
     expect(fNode.name.staticType, isNull);
 
-    var fReturnTypeNode = fNode.returnType as TypeName;
+    var fReturnTypeNode = fNode.returnType as NamedType;
     expect(fReturnTypeNode.name.staticElement, same(doubleType.element));
     expect(fReturnTypeNode.type, doubleType);
 
@@ -4240,7 +4240,7 @@
     expect(fNode.name.staticElement, same(fElement));
     expect(fNode.name.staticType, isNull);
 
-    var fReturnTypeNode = fNode.returnType as TypeName;
+    var fReturnTypeNode = fNode.returnType as NamedType;
     expect(fReturnTypeNode.name.staticElement, same(doubleType.element));
     expect(fReturnTypeNode.type, doubleType);
 
@@ -4451,7 +4451,7 @@
     var gParameterType =
         ((gType.parameters.parameters[0] as DefaultFormalParameter).parameter
                 as SimpleFormalParameter)
-            .type as TypeName;
+            .type as NamedType;
     var tReference = gParameterType.name;
     assertElement(tReference, tElement);
     assertTypeNull(tReference);
@@ -4482,7 +4482,7 @@
     expect(gTypeParameterType.element, same(tElement));
     var gParameterType =
         (gType.parameters.parameters[0] as SimpleFormalParameter).type
-            as TypeName;
+            as NamedType;
     var tReference = gParameterType.name;
     assertElement(tReference, tElement);
     assertTypeNull(tReference);
@@ -4514,7 +4514,7 @@
     var gParameterType =
         ((gType.parameters.parameters[0] as DefaultFormalParameter).parameter
                 as SimpleFormalParameter)
-            .type as TypeName;
+            .type as NamedType;
     var tReference = gParameterType.name;
     assertElement(tReference, tElement);
     assertTypeNull(tReference);
@@ -4542,7 +4542,7 @@
     var gTypeType = gType.type as FunctionType;
     var gTypeReturnType = gTypeType.returnType as TypeParameterType;
     expect(gTypeReturnType.element, same(tElement));
-    var gReturnType = gType.returnType as TypeName;
+    var gReturnType = gType.returnType as NamedType;
     var tReference = gReturnType.name;
     assertElement(tReference, tElement);
     assertTypeNull(tReference);
@@ -4566,11 +4566,11 @@
     var body = fDeclaration.functionDeclaration.functionExpression.body
         as BlockFunctionBody;
     var yDeclaration = body.block.statements[0] as VariableDeclarationStatement;
-    var yType = yDeclaration.variables.type as TypeName;
+    var yType = yDeclaration.variables.type as NamedType;
     var yTypeType = yType.type as InterfaceType;
     var yTypeTypeArgument = yTypeType.typeArguments[0] as TypeParameterType;
     expect(yTypeTypeArgument.element, same(tElement));
-    var yElementType = yType.typeArguments!.arguments[0] as TypeName;
+    var yElementType = yType.typeArguments!.arguments[0] as NamedType;
     var tReference = yElementType.name;
     assertElement(tReference, tElement);
     assertTypeNull(tReference);
@@ -4594,7 +4594,7 @@
     var body = fDeclaration.functionDeclaration.functionExpression.body
         as BlockFunctionBody;
     var yDeclaration = body.block.statements[0] as VariableDeclarationStatement;
-    var yType = yDeclaration.variables.type as TypeName;
+    var yType = yDeclaration.variables.type as NamedType;
     var tReference = yType.name;
     assertElement(tReference, tElement);
     assertTypeNull(tReference);
@@ -4621,7 +4621,7 @@
         gTypeType.namedParameterTypes['u'] as TypeParameterType;
     expect(gTypeParameterType.element, same(tElement));
 
-    var gArgumentType = gType.typeArguments!.arguments[0] as TypeName;
+    var gArgumentType = gType.typeArguments!.arguments[0] as NamedType;
     var tReference = gArgumentType.name;
     assertElement(tReference, tElement);
     assertTypeNull(tReference);
@@ -4648,7 +4648,7 @@
         gTypeType.normalParameterTypes[0] as TypeParameterType;
     expect(gTypeParameterType.element, same(tElement));
 
-    var gArgumentType = gType.typeArguments!.arguments[0] as TypeName;
+    var gArgumentType = gType.typeArguments!.arguments[0] as NamedType;
     var tReference = gArgumentType.name;
     assertElement(tReference, tElement);
     assertTypeNull(tReference);
@@ -4675,7 +4675,7 @@
         gTypeType.optionalParameterTypes[0] as TypeParameterType;
     expect(gTypeParameterType.element, same(tElement));
 
-    var gArgumentType = gType.typeArguments!.arguments[0] as TypeName;
+    var gArgumentType = gType.typeArguments!.arguments[0] as NamedType;
     var tReference = gArgumentType.name;
     assertElement(tReference, tElement);
     assertTypeNull(tReference);
@@ -4701,7 +4701,7 @@
     var gTypeReturnType = gTypeType.returnType as TypeParameterType;
     expect(gTypeReturnType.element, same(tElement));
 
-    var gArgumentType = gType.typeArguments!.arguments[0] as TypeName;
+    var gArgumentType = gType.typeArguments!.arguments[0] as NamedType;
     var tReference = gArgumentType.name;
     assertElement(tReference, tElement);
     assertTypeNull(tReference);
@@ -4906,7 +4906,7 @@
     LocalVariableElement vElement = vNode.declaredElement!;
     expect(vElement.type, typeProvider.numType);
 
-    var vTypeName = vNode.type as TypeName;
+    var vTypeName = vNode.type as NamedType;
     expect(vTypeName.type, typeProvider.numType);
 
     var vTypeIdentifier = vTypeName.name as SimpleIdentifier;
@@ -5083,7 +5083,7 @@
     expect(methodDeclaration.name.staticElement, same(methodElement));
     expect(methodDeclaration.name.staticType, isNull);
 
-    var fReturnTypeNode = methodDeclaration.returnType as TypeName;
+    var fReturnTypeNode = methodDeclaration.returnType as NamedType;
     expect(fReturnTypeNode.name.staticElement, same(doubleType.element));
     expect(fReturnTypeNode.type, doubleType);
     //
@@ -5558,14 +5558,14 @@
       List<TypeAnnotation> typeArguments = invocation.typeArguments!.arguments;
       expect(typeArguments, hasLength(2));
       {
-        var typeArgument = typeArguments[0] as TypeName;
+        var typeArgument = typeArguments[0] as NamedType;
         InterfaceType boolType = typeProvider.boolType;
         expect(typeArgument.type, boolType);
         expect(typeArgument.name.staticElement, boolType.element);
         expect(typeArgument.name.staticType, boolType);
       }
       {
-        var typeArgument = typeArguments[1] as TypeName;
+        var typeArgument = typeArguments[1] as NamedType;
         InterfaceType stringType = typeProvider.stringType;
         expect(typeArgument.type, stringType);
         expect(typeArgument.name.staticElement, stringType.element);
@@ -7140,7 +7140,7 @@
       assertType(node.declaredElement!.type, 'int Function(double)');
 
       // method return type
-      var returnType = node.returnType as TypeName;
+      var returnType = node.returnType as NamedType;
       var returnTypeName = returnType.name as SimpleIdentifier;
       expect(returnType.type, intType);
       expect(returnTypeName.staticElement, intElement);
@@ -7156,7 +7156,7 @@
         expect(pNode.declaredElement, isNotNull);
         expect(pNode.declaredElement!.type, doubleType);
 
-        var pType = pNode.type as TypeName;
+        var pType = pNode.type as NamedType;
         expect(pType.name.staticElement, doubleElement);
         expect(pType.name.staticType, isNull);
 
@@ -7172,7 +7172,7 @@
       assertType(node.declaredElement!.type, 'int Function()');
 
       // getter return type
-      var returnType = node.returnType as TypeName;
+      var returnType = node.returnType as NamedType;
       var returnTypeName = returnType.name as SimpleIdentifier;
       expect(returnType.type, intType);
       expect(returnTypeName.staticElement, intElement);
@@ -7190,7 +7190,7 @@
       assertType(node.declaredElement!.type, 'void Function(double)');
 
       // setter return type
-      var returnType = node.returnType as TypeName;
+      var returnType = node.returnType as NamedType;
       var returnTypeName = returnType.name as SimpleIdentifier;
       expect(returnType.type, VoidTypeImpl.instance);
       expect(returnTypeName.staticElement, isNull);
@@ -7206,7 +7206,7 @@
         expect(pNode.declaredElement, isNotNull);
         expect(pNode.declaredElement!.type, doubleType);
 
-        var pType = pNode.type as TypeName;
+        var pType = pNode.type as NamedType;
         expect(pType.name.staticElement, doubleElement);
         expect(pType.name.staticType, isNull);
 
@@ -7235,7 +7235,7 @@
       assertType(node.declaredElement!.type, 'int Function(double)');
 
       // function return type
-      var returnType = node.returnType as TypeName;
+      var returnType = node.returnType as NamedType;
       var returnTypeName = returnType.name as SimpleIdentifier;
       expect(returnType.type, intType);
       expect(returnTypeName.staticElement, intElement);
@@ -7252,7 +7252,7 @@
         expect(pNode.declaredElement, isNotNull);
         expect(pNode.declaredElement!.type, doubleType);
 
-        var pType = pNode.type as TypeName;
+        var pType = pNode.type as NamedType;
         expect(pType.name.staticElement, doubleElement);
         expect(pType.name.staticType, isNull);
 
@@ -7268,7 +7268,7 @@
       assertType(node.declaredElement!.type, 'int Function()');
 
       // getter return type
-      var returnType = node.returnType as TypeName;
+      var returnType = node.returnType as NamedType;
       var returnTypeName = returnType.name as SimpleIdentifier;
       expect(returnType.type, intType);
       expect(returnTypeName.staticElement, intElement);
@@ -7286,7 +7286,7 @@
       assertType(node.declaredElement!.type, 'void Function(double)');
 
       // setter return type
-      var returnType = node.returnType as TypeName;
+      var returnType = node.returnType as NamedType;
       var returnTypeName = returnType.name as SimpleIdentifier;
       expect(returnType.type, VoidTypeImpl.instance);
       expect(returnTypeName.staticElement, isNull);
@@ -7303,7 +7303,7 @@
         expect(pNode.declaredElement, isNotNull);
         expect(pNode.declaredElement!.type, doubleType);
 
-        var pType = pNode.type as TypeName;
+        var pType = pNode.type as NamedType;
         expect(pType.name.staticElement, doubleElement);
         expect(pType.name.staticType, isNull);
 
@@ -7348,7 +7348,7 @@
       FieldElement bElement = cElement.getField('b')!;
       var bDeclaration = cNode.members[1] as FieldDeclaration;
 
-      var typeName = bDeclaration.fields.type as TypeName;
+      var typeName = bDeclaration.fields.type as NamedType;
       var typeIdentifier = typeName.name as SimpleIdentifier;
       expect(typeIdentifier.staticElement, same(tElement));
       expect(typeIdentifier.staticType, isNull);
@@ -7438,7 +7438,7 @@
       expect(bElement, same(unitElement.topLevelVariables[1]));
       expect(bElement.type, typeProvider.doubleType);
 
-      var typeName = bDeclaration.variables.type as TypeName;
+      var typeName = bDeclaration.variables.type as NamedType;
       _assertTypeNameSimple(typeName, typeProvider.doubleType);
 
       expect(bNode.name.staticElement, same(bElement));
@@ -7511,7 +7511,7 @@
     expect(fDeclaration.name.staticElement, same(fElement));
     expect(fDeclaration.name.staticType, isNull);
 
-    var fReturnTypeNode = fDeclaration.returnType as TypeName;
+    var fReturnTypeNode = fDeclaration.returnType as NamedType;
     expect(fReturnTypeNode.name.staticElement, same(doubleType.element));
     expect(fReturnTypeNode.type, doubleType);
     //
@@ -7579,7 +7579,7 @@
     expect(aliasElement, same(findElement.typeAlias('F')));
     expect(function.returnType, typeProvider.intType);
 
-    _assertTypeNameSimple(alias.returnType as TypeName, typeProvider.intType);
+    _assertTypeNameSimple(alias.returnType as NamedType, typeProvider.intType);
 
     _assertSimpleParameter(
         alias.parameters.parameters[0] as SimpleFormalParameter,
@@ -7620,7 +7620,7 @@
       TypeParameter tNode = cNode.typeParameters!.typeParameters[0];
       expect(tNode.declaredElement, same(cElement.typeParameters[0]));
 
-      var bound = tNode.bound as TypeName;
+      var bound = tNode.bound as NamedType;
       expect(bound.type, interfaceTypeNone(aElement));
 
       var boundIdentifier = bound.name as SimpleIdentifier;
@@ -7638,14 +7638,14 @@
       TypeParameter uNode = cNode.typeParameters!.typeParameters[1];
       expect(uNode.declaredElement, same(cElement.typeParameters[1]));
 
-      var bound = uNode.bound as TypeName;
+      var bound = uNode.bound as NamedType;
       expect(bound.type, listOfA);
 
       var listIdentifier = bound.name as SimpleIdentifier;
       expect(listIdentifier.staticElement, same(listElement));
       expect(listIdentifier.staticType, isNull);
 
-      var aTypeName = bound.typeArguments!.arguments[0] as TypeName;
+      var aTypeName = bound.typeArguments!.arguments[0] as NamedType;
       expect(aTypeName.type, interfaceTypeNone(aElement));
 
       var aIdentifier = aTypeName.name as SimpleIdentifier;
@@ -7718,7 +7718,7 @@
       var statement = statements[1] as TryStatement;
       CatchClause catchClause = statement.catchClauses[0];
       _assertTypeNameSimple(
-          catchClause.exceptionType as TypeName, typeProvider.intType);
+          catchClause.exceptionType as NamedType, typeProvider.intType);
 
       var exceptionNode = catchClause.exceptionParameter as SimpleIdentifier;
       var exceptionElement =
@@ -7774,7 +7774,7 @@
       var statement = statements[4] as TryStatement;
       CatchClause catchClause = statement.catchClauses[0];
       _assertTypeNameSimple(
-          catchClause.exceptionType as TypeName, typeProvider.intType);
+          catchClause.exceptionType as NamedType, typeProvider.intType);
       expect(catchClause.exceptionParameter, isNull);
       expect(catchClause.stackTraceParameter, isNull);
     }
@@ -7790,7 +7790,7 @@
     var statements = _getMainStatements(result);
     var variableDeclarationStatement =
         statements[0] as VariableDeclarationStatement;
-    var type = variableDeclarationStatement.variables.type as TypeName;
+    var type = variableDeclarationStatement.variables.type as NamedType;
     expect(type.type, isDynamicType);
     var typeName = type.name;
     assertTypeNull(typeName);
@@ -7812,7 +7812,7 @@
 
     FieldDeclaration fDeclaration = findNode.fieldDeclaration('F<int> f');
 
-    var typeName = fDeclaration.fields.type as TypeName;
+    var typeName = fDeclaration.fields.type as NamedType;
     assertType(typeName, 'int Function(bool)');
 
     var typeIdentifier = typeName.name as SimpleIdentifier;
@@ -7834,7 +7834,7 @@
     var statements = _getMainStatements(result);
     var variableDeclarationStatement =
         statements[0] as VariableDeclarationStatement;
-    var type = variableDeclarationStatement.variables.type as TypeName;
+    var type = variableDeclarationStatement.variables.type as NamedType;
     expect(type.type, isVoidType);
     var typeName = type.name;
     expect(typeName.staticType, isNull);
@@ -7863,7 +7863,7 @@
 
     {
       var declaration = unit.declarations[0] as TopLevelVariableDeclaration;
-      var typeName = declaration.variables.type as TypeName;
+      var typeName = declaration.variables.type as NamedType;
 
       var typeIdentifier = typeName.name as PrefixedIdentifier;
       expect(typeIdentifier.staticElement, aClass);
@@ -7876,7 +7876,7 @@
 
     {
       var declaration = unit.declarations[1] as TopLevelVariableDeclaration;
-      var typeName = declaration.variables.type as TypeName;
+      var typeName = declaration.variables.type as NamedType;
 
       var typeIdentifier = typeName.name as PrefixedIdentifier;
       expect(typeIdentifier.staticElement, aClass);
@@ -8681,7 +8681,7 @@
     expect(node.declaredElement, same(element));
     expect(node.identifier!.staticElement, same(element));
 
-    var typeName = node.type as TypeName?;
+    var typeName = node.type as NamedType?;
     if (typeName != null) {
       expect(typeName.type, type);
       expect(typeName.name.staticElement, same(type!.element));
@@ -8689,7 +8689,7 @@
   }
 
   void _assertTypeNameSimple(TypeAnnotation typeName, DartType type) {
-    typeName as TypeName;
+    typeName as NamedType;
     expect(typeName.type, type);
 
     var identifier = typeName.name as SimpleIdentifier;
diff --git a/pkg/analyzer/test/src/dart/ast/utilities_test.dart b/pkg/analyzer/test/src/dart/ast/utilities_test.dart
index 9d96e0e..81e36e0 100644
--- a/pkg/analyzer/test/src/dart/ast/utilities_test.dart
+++ b/pkg/analyzer/test/src/dart/ast/utilities_test.dart
@@ -25,7 +25,7 @@
     CompilationUnit unit = parseCompilationUnit(code);
     var declaration = unit.declarations[0] as TopLevelVariableDeclaration;
     VariableDeclarationList variableList = declaration.variables;
-    Identifier typeName = (variableList.type as TypeName).name;
+    Identifier typeName = (variableList.type as NamedType).name;
     SimpleIdentifier varName = variableList.variables[0].name;
     expect(NodeLocator2(0).searchWithin(unit), same(unit));
     expect(NodeLocator2(1).searchWithin(unit), same(typeName));
@@ -46,7 +46,7 @@
     CompilationUnit unit = parseCompilationUnit(code);
     var declaration = unit.declarations[0] as TopLevelVariableDeclaration;
     VariableDeclarationList variableList = declaration.variables;
-    Identifier typeName = (variableList.type as TypeName).name;
+    Identifier typeName = (variableList.type as NamedType).name;
     SimpleIdentifier varName = variableList.variables[0].name;
     expect(NodeLocator2(-1, 2).searchWithin(unit), isNull);
     expect(NodeLocator2(0, 2).searchWithin(unit), same(unit));
diff --git a/pkg/analyzer/test/src/dart/resolution/metadata_test.dart b/pkg/analyzer/test/src/dart/resolution/metadata_test.dart
index 95765b9..034b2bb3 100644
--- a/pkg/analyzer/test/src/dart/resolution/metadata_test.dart
+++ b/pkg/analyzer/test/src/dart/resolution/metadata_test.dart
@@ -27,6 +27,27 @@
     return findElement.importFind('package:test/a.dart');
   }
 
+  test_at_genericFunctionType_formalParameter() async {
+    await assertNoErrorsInCode(r'''
+const a = 42;
+List<void Function(@a int b)> f() => [];
+''');
+
+    var annotation = findNode.annotation('@a');
+    _assertResolvedNodeText(annotation, r'''
+Annotation
+  atSign: @
+  element: self::@getter::a
+  name: SimpleIdentifier
+    staticElement: self::@getter::a
+    staticType: null
+    token: a
+''');
+    _assertAnnotationValueText(annotation, '''
+int 42
+''');
+  }
+
   test_location_partDirective() async {
     newFile('$testPackageLibPath/a.dart', content: r'''
 part of 'test.dart';
diff --git a/pkg/nnbd_migration/lib/src/edge_builder.dart b/pkg/nnbd_migration/lib/src/edge_builder.dart
index 62cd9a3..078631a 100644
--- a/pkg/nnbd_migration/lib/src/edge_builder.dart
+++ b/pkg/nnbd_migration/lib/src/edge_builder.dart
@@ -489,9 +489,12 @@
   @override
   DecoratedType visitAwaitExpression(AwaitExpression node) {
     var expressionType = _dispatch(node.expression)!;
-    // TODO(paulberry) Handle subclasses of Future.
-    if (expressionType.type!.isDartAsyncFuture ||
-        expressionType.type!.isDartAsyncFutureOr) {
+    var type = expressionType.type!;
+    if (_typeSystem.isSubtypeOf(type, typeProvider.futureDynamicType)) {
+      expressionType = _decoratedClassHierarchy!
+          .asInstanceOf(expressionType, typeProvider.futureElement)
+          .typeArguments[0]!;
+    } else if (type.isDartAsyncFutureOr) {
       expressionType = expressionType.typeArguments[0]!;
     }
     return expressionType;
diff --git a/pkg/nnbd_migration/lib/src/node_builder.dart b/pkg/nnbd_migration/lib/src/node_builder.dart
index 05cb79d..3b8b51c 100644
--- a/pkg/nnbd_migration/lib/src/node_builder.dart
+++ b/pkg/nnbd_migration/lib/src/node_builder.dart
@@ -601,7 +601,7 @@
     }
     DecoratedType decoratedType;
     if (type is FunctionType && node is! GenericFunctionType) {
-      (node as TypeName).typeArguments?.accept(this);
+      (node as NamedType).typeArguments?.accept(this);
       // node is a reference to a typedef.  Treat it like an inferred type (we
       // synthesize new nodes for it).  These nodes will be unioned with the
       // typedef nodes by the edge builder.
diff --git a/pkg/nnbd_migration/test/api_test.dart b/pkg/nnbd_migration/test/api_test.dart
index 5307de5..9815198 100644
--- a/pkg/nnbd_migration/test/api_test.dart
+++ b/pkg/nnbd_migration/test/api_test.dart
@@ -1601,6 +1601,26 @@
     await _checkSingleFileChanges(content, expected);
   }
 
+  Future<void> test_custom_future() async {
+    var content = '''
+class CustomFuture<T> implements Future<T> {
+  @override
+  noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+}
+
+f(CustomFuture<List<int>> x) async => (await x).first;
+''';
+    var expected = '''
+class CustomFuture<T> implements Future<T> {
+  @override
+  noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+}
+
+f(CustomFuture<List<int>> x) async => (await x).first;
+''';
+    await _checkSingleFileChanges(content, expected);
+  }
+
   Future<void> test_data_flow_assignment_field() async {
     var content = '''
 class C {
diff --git a/runtime/vm/isolate.cc b/runtime/vm/isolate.cc
index 2306f23..7e0034b 100644
--- a/runtime/vm/isolate.cc
+++ b/runtime/vm/isolate.cc
@@ -3604,16 +3604,9 @@
  private:
   bool ShouldKill(Isolate* isolate) {
     // If a target_ is specified, then only kill the target_.
-    // Otherwise, don't kill the core system isolates (e.g, service, kernel, or
-    // vm isolates).
+    // Otherwise, don't kill the service isolate or vm isolate.
     return (((target_ != nullptr) && (isolate == target_)) ||
-            ((target_ == nullptr) && !IsCoreSystemIsolate(isolate)));
-  }
-
-  bool IsCoreSystemIsolate(Isolate* isolate) {
-    return KernelIsolate::IsKernelIsolate(isolate) ||
-           ServiceIsolate::IsServiceIsolate(isolate) ||
-           Dart::vm_isolate() == isolate;
+            ((target_ == nullptr) && !IsSystemIsolate(isolate)));
   }
 
   Isolate* target_;
diff --git a/tests/co19_2/co19_2-dartdevc.status b/tests/co19_2/co19_2-dartdevc.status
index 9e86a17..4129481 100644
--- a/tests/co19_2/co19_2-dartdevc.status
+++ b/tests/co19_2/co19_2-dartdevc.status
@@ -86,3 +86,23 @@
 LibTest/html/IFrameElement/onTransitionEnd_A01_t01: SkipSlow
 LibTest/io/*: SkipByDesign # dart:io not supported.
 LibTest/isolate/*: SkipByDesign # dart:isolate not supported.
+LibTest/typed_data/ByteBuffer/asInt64List_A01_t01: SkipByDesign # Int64List not supported on the web
+LibTest/typed_data/ByteBuffer/asInt64List_A02_t01: SkipByDesign # Int64List not supported on the web
+LibTest/typed_data/ByteBuffer/asInt64List_A03_t01: SkipByDesign # Int64List not supported on the web
+LibTest/typed_data/ByteBuffer/asUint64List_A01_t01: SkipByDesign # UInt64List not supported on the web
+LibTest/typed_data/ByteBuffer/asUint64List_A02_t01: SkipByDesign # UInt64List not supported on the web
+LibTest/typed_data/ByteBuffer/asUint64List_A03_t01: SkipByDesign # UInt64List not supported on the web
+LibTest/typed_data/ByteData/getInt64_A01_t01: SkipByDesign # 64-bit int not supported on the web
+LibTest/typed_data/ByteData/getInt64_A02_t01: SkipByDesign # 64-bit int not supported on the web
+LibTest/typed_data/ByteData/getInt64_A02_t02: SkipByDesign # 64-bit int not supported on the web
+LibTest/typed_data/ByteData/getUint64_A01_t01: SkipByDesign # 64-bit int not supported on the web
+LibTest/typed_data/ByteData/getUint64_A02_t01: SkipByDesign # 64-bit int not supported on the web
+LibTest/typed_data/ByteData/getUint64_A02_t02: SkipByDesign # 64-bit int not supported on the web
+LibTest/typed_data/ByteData/setInt64_A01_t01: SkipByDesign # 64-bit int not supported on the web
+LibTest/typed_data/ByteData/setInt64_A02_t01: SkipByDesign # 64-bit int not supported on the web
+LibTest/typed_data/ByteData/setInt64_A02_t02: SkipByDesign # 64-bit int not supported on the web
+LibTest/typed_data/ByteData/setUint64_A01_t01: SkipByDesign # 64-bit int not supported on the web
+LibTest/typed_data/ByteData/setUint64_A02_t01: SkipByDesign # 64-bit int not supported on the web
+LibTest/typed_data/ByteData/setUint64_A02_t02: SkipByDesign # 64-bit int not supported on the web
+LibTest/typed_data/Int64List/*: SkipByDesign # Int64List not supported on the web
+LibTest/typed_data/Uint64List/*: SkipByDesign # Uint64List not supported on the web
diff --git a/tests/language/function_subtype/nested_function_type_test.dart b/tests/language/function_subtype/nested_function_type_test.dart
new file mode 100644
index 0000000..a284690
--- /dev/null
+++ b/tests/language/function_subtype/nested_function_type_test.dart
@@ -0,0 +1,44 @@
+// 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:expect/expect.dart";
+
+// Two function types that are identical except the argument type of the
+// nested function is a type variable from the outer function.
+typedef Fn = void Function<S>(S val) Function<T>(T val);
+typedef Gn = void Function<S>(T val) Function<T>(T val);
+
+void Function<S>(S) fn<T>(T val) => <R>(R val) {};
+void Function<S>(T) gn<T>(T val) => <R>(T val) {};
+
+// The same pattern here except with bounds on the type arguments.
+typedef Xn = void Function<S extends num>(S val) Function<T extends num>(T val);
+typedef Yn = void Function<S extends num>(T val) Function<T extends num>(T val);
+
+void Function<S extends num>(S) xn<T extends num>(T val) =>
+    <R extends num>(R val) {};
+void Function<S extends num>(T) yn<T extends num>(T val) =>
+    <R extends num>(T val) {};
+
+// The nested function here uses concrete type in the argument position so it
+// should satisfy either of the previous typedefs.
+void Function<S extends num>(num) zn<T extends num>(T val) =>
+    <R extends num>(num val) {};
+
+void main() {
+  Expect.isTrue(fn is Fn);
+  Expect.isFalse(fn is Gn);
+
+  Expect.isTrue(gn is Gn);
+  Expect.isFalse(gn is Fn);
+
+  Expect.isTrue(xn is Xn);
+  Expect.isFalse(xn is Yn);
+
+  Expect.isTrue(yn is Yn);
+  Expect.isFalse(yn is Xn);
+
+  Expect.isTrue(zn is Xn);
+  Expect.isTrue(zn is Yn);
+}
diff --git a/tests/language_2/function_subtype/nested_function_type_test.dart b/tests/language_2/function_subtype/nested_function_type_test.dart
new file mode 100644
index 0000000..79bc0aa
--- /dev/null
+++ b/tests/language_2/function_subtype/nested_function_type_test.dart
@@ -0,0 +1,46 @@
+// 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.
+
+// @dart = 2.9
+
+import "package:expect/expect.dart";
+
+// Two function types that are identical except the argument type of the
+// nested function is a type variable from the outer function.
+typedef Fn = void Function<S>(S val) Function<T>(T val);
+typedef Gn = void Function<S>(T val) Function<T>(T val);
+
+void Function<S>(S) fn<T>(T val) => <R>(R val) {};
+void Function<S>(T) gn<T>(T val) => <R>(T val) {};
+
+// The same pattern here except with bounds on the type arguments.
+typedef Xn = void Function<S extends num>(S val) Function<T extends num>(T val);
+typedef Yn = void Function<S extends num>(T val) Function<T extends num>(T val);
+
+void Function<S extends num>(S) xn<T extends num>(T val) =>
+    <R extends num>(R val) {};
+void Function<S extends num>(T) yn<T extends num>(T val) =>
+    <R extends num>(T val) {};
+
+// The nested function here uses concrete type in the argument position so it
+// should satisfy either of the previous typedefs.
+void Function<S extends num>(num) zn<T extends num>(T val) =>
+    <R extends num>(num val) {};
+
+void main() {
+  Expect.isTrue(fn is Fn);
+  Expect.isFalse(fn is Gn);
+
+  Expect.isTrue(gn is Gn);
+  Expect.isFalse(gn is Fn);
+
+  Expect.isTrue(xn is Xn);
+  Expect.isFalse(xn is Yn);
+
+  Expect.isTrue(yn is Yn);
+  Expect.isFalse(yn is Xn);
+
+  Expect.isTrue(zn is Xn);
+  Expect.isTrue(zn is Yn);
+}
diff --git a/tools/VERSION b/tools/VERSION
index 1d8fac2..1cfc234 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 15
 PATCH 0
-PRERELEASE 133
+PRERELEASE 134
 PRERELEASE_PATCH 0
\ No newline at end of file