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/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/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.