diff --git a/pkg/analyzer/lib/src/dart/analysis/library_analyzer.dart b/pkg/analyzer/lib/src/dart/analysis/library_analyzer.dart
index 82b883d..8700900 100644
--- a/pkg/analyzer/lib/src/dart/analysis/library_analyzer.dart
+++ b/pkg/analyzer/lib/src/dart/analysis/library_analyzer.dart
@@ -751,7 +751,6 @@
           relativeUri,
         );
         for (var configuration in directive.configurations) {
-          configuration as ConfigurationImpl;
           var uriLiteral = configuration.uri;
           String? uriContent = uriLiteral.stringValue?.trim();
           Source? defaultSource = _resolveUri(
diff --git a/pkg/analyzer/lib/src/dart/ast/ast.dart b/pkg/analyzer/lib/src/dart/ast/ast.dart
index e38573d..90e7963 100644
--- a/pkg/analyzer/lib/src/dart/ast/ast.dart
+++ b/pkg/analyzer/lib/src/dart/ast/ast.dart
@@ -31,7 +31,7 @@
 ///        [StringLiteral] [StringLiteral]+
 class AdjacentStringsImpl extends StringLiteralImpl implements AdjacentStrings {
   /// The strings that are implicitly concatenated.
-  final NodeListImpl<StringLiteral> _strings = NodeListImpl._();
+  final NodeListImpl<StringLiteralImpl> _strings = NodeListImpl._();
 
   /// Initialize a newly created list of adjacent strings. To be syntactically
   /// valid, the list of [strings] must contain at least two elements.
@@ -50,7 +50,7 @@
   Token get endToken => _strings.endToken!;
 
   @override
-  NodeListImpl<StringLiteral> get strings => _strings;
+  NodeListImpl<StringLiteralImpl> get strings => _strings;
 
   @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitAdjacentStrings(this);
@@ -64,7 +64,7 @@
   void _appendStringValue(StringBuffer buffer) {
     int length = strings.length;
     for (int i = 0; i < length; i++) {
-      var stringLiteral = strings[i] as StringLiteralImpl;
+      var stringLiteral = strings[i];
       stringLiteral._appendStringValue(buffer);
     }
   }
@@ -78,7 +78,7 @@
   CommentImpl? _comment;
 
   /// The annotations associated with this node.
-  final NodeListImpl<Annotation> _metadata = NodeListImpl._();
+  final NodeListImpl<AnnotationImpl> _metadata = NodeListImpl._();
 
   /// Initialize a newly created annotated node. Either or both of the [comment]
   /// and [metadata] can be `null` if the node does not have the corresponding
@@ -115,7 +115,7 @@
   }
 
   @override
-  NodeListImpl<Annotation> get metadata => _metadata;
+  NodeListImpl<AnnotationImpl> get metadata => _metadata;
 
   @override
   List<AstNode> get sortedCommentAndAnnotations {
@@ -325,7 +325,7 @@
   Token leftParenthesis;
 
   /// The expressions producing the values of the arguments.
-  final NodeListImpl<Expression> _arguments = NodeListImpl._();
+  final NodeListImpl<ExpressionImpl> _arguments = NodeListImpl._();
 
   /// The right parenthesis.
   @override
@@ -347,7 +347,7 @@
   }
 
   @override
-  NodeListImpl<Expression> get arguments => _arguments;
+  NodeListImpl<ExpressionImpl> get arguments => _arguments;
 
   @override
   Token get beginToken => leftParenthesis;
@@ -1035,7 +1035,7 @@
   Token leftBracket;
 
   /// The statements contained in the block.
-  final NodeListImpl<Statement> _statements = NodeListImpl._();
+  final NodeListImpl<StatementImpl> _statements = NodeListImpl._();
 
   /// The right curly bracket.
   @override
@@ -1059,7 +1059,7 @@
   Token get endToken => rightBracket;
 
   @override
-  NodeListImpl<Statement> get statements => _statements;
+  NodeListImpl<StatementImpl> get statements => _statements;
 
   @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitBlock(this);
@@ -1187,7 +1187,7 @@
   ExpressionImpl _target;
 
   /// The cascade sections sharing the common target.
-  final NodeListImpl<Expression> _cascadeSections = NodeListImpl._();
+  final NodeListImpl<ExpressionImpl> _cascadeSections = NodeListImpl._();
 
   /// Initialize a newly created cascade expression. The list of
   /// [cascadeSections] must contain at least one element.
@@ -1200,7 +1200,7 @@
   Token get beginToken => _target.beginToken;
 
   @override
-  NodeListImpl<Expression> get cascadeSections => _cascadeSections;
+  NodeListImpl<ExpressionImpl> get cascadeSections => _cascadeSections;
 
   @override
   Iterable<SyntacticEntity> get childEntities => ChildEntities()
@@ -1572,7 +1572,7 @@
   Token leftBracket;
 
   /// The members defined by the class or mixin.
-  final NodeListImpl<ClassMember> _members = NodeListImpl._();
+  final NodeListImpl<ClassMemberImpl> _members = NodeListImpl._();
 
   /// The right curly bracket.
   @override
@@ -1605,7 +1605,7 @@
   }
 
   @override
-  NodeListImpl<ClassMember> get members => _members;
+  NodeListImpl<ClassMemberImpl> get members => _members;
 
   @override
   TypeParameterListImpl? get typeParameters => _typeParameters;
@@ -1831,7 +1831,7 @@
   /// The references embedded within the documentation comment. This list will
   /// be empty unless this is a documentation comment that has references embedded
   /// within it.
-  final NodeListImpl<CommentReference> _references = NodeListImpl._();
+  final NodeListImpl<CommentReferenceImpl> _references = NodeListImpl._();
 
   /// Initialize a newly created comment. The list of [tokens] must contain at
   /// least one token. The [_type] is the type of the comment. The list of
@@ -1861,7 +1861,7 @@
   bool get isEndOfLine => _type == CommentType.END_OF_LINE;
 
   @override
-  NodeListImpl<CommentReference> get references => _references;
+  NodeListImpl<CommentReferenceImpl> get references => _references;
 
   @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitComment(this);
@@ -1990,10 +1990,11 @@
   ScriptTagImpl? _scriptTag;
 
   /// The directives contained in this compilation unit.
-  final NodeListImpl<Directive> _directives = NodeListImpl._();
+  final NodeListImpl<DirectiveImpl> _directives = NodeListImpl._();
 
   /// The declarations contained in this compilation unit.
-  final NodeListImpl<CompilationUnitMember> _declarations = NodeListImpl._();
+  final NodeListImpl<CompilationUnitMemberImpl> _declarations =
+      NodeListImpl._();
 
   /// The last token in the token stream that was parsed to form this
   /// compilation unit. This token should always have a type of [TokenType.EOF].
@@ -2049,10 +2050,10 @@
   }
 
   @override
-  NodeListImpl<CompilationUnitMember> get declarations => _declarations;
+  NodeListImpl<CompilationUnitMemberImpl> get declarations => _declarations;
 
   @override
-  NodeListImpl<Directive> get directives => _directives;
+  NodeListImpl<DirectiveImpl> get directives => _directives;
 
   @override
   set element(CompilationUnitElement? element) {
@@ -2398,7 +2399,8 @@
   Token? separator;
 
   /// The initializers associated with the constructor.
-  final NodeListImpl<ConstructorInitializer> _initializers = NodeListImpl._();
+  final NodeListImpl<ConstructorInitializerImpl> _initializers =
+      NodeListImpl._();
 
   /// The name of the constructor to which this constructor will be redirected,
   /// or `null` if this is not a redirecting factory constructor.
@@ -2487,7 +2489,7 @@
   }
 
   @override
-  NodeListImpl<ConstructorInitializer> get initializers => _initializers;
+  NodeListImpl<ConstructorInitializerImpl> get initializers => _initializers;
 
   @override
   SimpleIdentifierImpl? get name => _name;
@@ -2941,7 +2943,7 @@
   bool get isFinal => _parameter.isFinal;
 
   @override
-  NodeListImpl<Annotation> get metadata => _parameter.metadata;
+  NodeListImpl<AnnotationImpl> get metadata => _parameter.metadata;
 
   @override
   NormalFormalParameterImpl get parameter => _parameter;
@@ -3086,7 +3088,7 @@
 ///        [SimpleIdentifier] ('.' [SimpleIdentifier])*
 class DottedNameImpl extends AstNodeImpl implements DottedName {
   /// The components of the identifier.
-  final NodeListImpl<SimpleIdentifier> _components = NodeListImpl._();
+  final NodeListImpl<SimpleIdentifierImpl> _components = NodeListImpl._();
 
   /// Initialize a newly created dotted name.
   DottedNameImpl(List<SimpleIdentifier> components) {
@@ -3102,7 +3104,7 @@
       ChildEntities()..addAll(_components);
 
   @override
-  NodeListImpl<SimpleIdentifier> get components => _components;
+  NodeListImpl<SimpleIdentifierImpl> get components => _components;
 
   @override
   Token get endToken => _components.endToken!;
@@ -3288,7 +3290,7 @@
   Token leftBracket;
 
   /// The enumeration constants being declared.
-  final NodeListImpl<EnumConstantDeclaration> _constants = NodeListImpl._();
+  final NodeListImpl<EnumConstantDeclarationImpl> _constants = NodeListImpl._();
 
   /// The right curly bracket.
   @override
@@ -3320,7 +3322,7 @@
     ..add(rightBracket);
 
   @override
-  NodeListImpl<EnumConstantDeclaration> get constants => _constants;
+  NodeListImpl<EnumConstantDeclarationImpl> get constants => _constants;
 
   @override
   ClassElement? get declaredElement => _name.staticElement as ClassElement?;
@@ -3712,7 +3714,7 @@
   Token leftBracket;
 
   /// The members being added to the extended class.
-  final NodeListImpl<ClassMember> _members = NodeListImpl._();
+  final NodeListImpl<ClassMemberImpl> _members = NodeListImpl._();
 
   @override
   Token rightBracket;
@@ -3770,7 +3772,7 @@
   Token get firstTokenAfterCommentAndMetadata => extensionKeyword;
 
   @override
-  NodeListImpl<ClassMember> get members => _members;
+  NodeListImpl<ClassMemberImpl> get members => _members;
 
   @override
   SimpleIdentifierImpl? get name => _name;
@@ -4048,7 +4050,7 @@
 
   @override
   Token get beginToken {
-    NodeListImpl<Annotation> metadata = this.metadata;
+    NodeListImpl<AnnotationImpl> metadata = this.metadata;
     if (metadata.isNotEmpty) {
       return metadata.beginToken!;
     } else if (requiredKeyword != null) {
@@ -4404,7 +4406,7 @@
   Token leftParenthesis;
 
   /// The parameters associated with the method.
-  final NodeListImpl<FormalParameter> _parameters = NodeListImpl._();
+  final NodeListImpl<FormalParameterImpl> _parameters = NodeListImpl._();
 
   /// The left square bracket ('[') or left curly brace ('{') introducing the
   /// optional parameters, or `null` if there are no optional parameters.
@@ -4466,7 +4468,7 @@
   }
 
   @override
-  NodeListImpl<FormalParameter> get parameters => _parameters;
+  NodeListImpl<FormalParameterImpl> get parameters => _parameters;
 
   @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitFormalParameterList(this);
@@ -4489,7 +4491,7 @@
   Token rightSeparator;
 
   /// The list of expressions run after each execution of the loop body.
-  final NodeListImpl<Expression> _updaters = NodeListImpl._();
+  final NodeListImpl<ExpressionImpl> _updaters = NodeListImpl._();
 
   /// Initialize a newly created for statement. Either the [variableList] or the
   /// [initialization] must be `null`. Either the [condition] and the list of
@@ -4522,7 +4524,7 @@
   Token get endToken => _updaters.endToken ?? rightSeparator;
 
   @override
-  NodeListImpl<Expression> get updaters => _updaters;
+  NodeListImpl<ExpressionImpl> get updaters => _updaters;
 
   @override
   void visitChildren(AstVisitor visitor) {
@@ -5173,7 +5175,7 @@
 
   @override
   Token get beginToken {
-    NodeListImpl<Annotation> metadata = this.metadata;
+    NodeListImpl<AnnotationImpl> metadata = this.metadata;
     if (metadata.isNotEmpty) {
       return metadata.beginToken!;
     } else if (requiredKeyword != null) {
@@ -5463,7 +5465,7 @@
 ///        'hide' [SimpleIdentifier] (',' [SimpleIdentifier])*
 class HideCombinatorImpl extends CombinatorImpl implements HideCombinator {
   /// The list of names from the library that are hidden by this combinator.
-  final NodeListImpl<SimpleIdentifier> _hiddenNames = NodeListImpl._();
+  final NodeListImpl<SimpleIdentifierImpl> _hiddenNames = NodeListImpl._();
 
   /// Initialize a newly created import show combinator.
   HideCombinatorImpl(Token keyword, List<SimpleIdentifier> hiddenNames)
@@ -5480,7 +5482,7 @@
   Token get endToken => _hiddenNames.endToken!;
 
   @override
-  NodeListImpl<SimpleIdentifier> get hiddenNames => _hiddenNames;
+  NodeListImpl<SimpleIdentifierImpl> get hiddenNames => _hiddenNames;
 
   @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitHideCombinator(this);
@@ -5694,7 +5696,7 @@
   Token implementsKeyword;
 
   /// The interfaces that are being implemented.
-  final NodeListImpl<TypeName> _interfaces = NodeListImpl._();
+  final NodeListImpl<TypeNameImpl> _interfaces = NodeListImpl._();
 
   /// Initialize a newly created implements clause.
   ImplementsClauseImpl(this.implementsKeyword, List<TypeName> interfaces) {
@@ -5714,7 +5716,7 @@
   Token get endToken => _interfaces.endToken!;
 
   @override
-  NodeListImpl<TypeName> get interfaces => _interfaces;
+  NodeListImpl<TypeNameImpl> get interfaces => _interfaces;
 
   @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitImplementsClause(this);
@@ -6438,7 +6440,7 @@
 ///       [Label]+ [Statement]
 class LabeledStatementImpl extends StatementImpl implements LabeledStatement {
   /// The labels being associated with the statement.
-  final NodeListImpl<Label> _labels = NodeListImpl._();
+  final NodeListImpl<LabelImpl> _labels = NodeListImpl._();
 
   /// The statement with which the labels are being associated.
   StatementImpl _statement;
@@ -6466,7 +6468,7 @@
   Token get endToken => _statement.endToken;
 
   @override
-  NodeListImpl<Label> get labels => _labels;
+  NodeListImpl<LabelImpl> get labels => _labels;
 
   @override
   StatementImpl get statement => _statement;
@@ -6601,7 +6603,7 @@
 class LibraryIdentifierImpl extends IdentifierImpl
     implements LibraryIdentifier {
   /// The components of the identifier.
-  final NodeListImpl<SimpleIdentifier> _components = NodeListImpl._();
+  final NodeListImpl<SimpleIdentifierImpl> _components = NodeListImpl._();
 
   /// Initialize a newly created prefixed identifier.
   LibraryIdentifierImpl(List<SimpleIdentifier> components) {
@@ -6617,7 +6619,7 @@
       ChildEntities()..addAll(_components);
 
   @override
-  NodeListImpl<SimpleIdentifier> get components => _components;
+  NodeListImpl<SimpleIdentifierImpl> get components => _components;
 
   @override
   Token get endToken => _components.endToken!;
@@ -6660,7 +6662,7 @@
   Token leftBracket;
 
   /// The expressions used to compute the elements of the list.
-  final NodeListImpl<CollectionElement> _elements = NodeListImpl._();
+  final NodeListImpl<CollectionElementImpl> _elements = NodeListImpl._();
 
   /// The right square bracket.
   @override
@@ -6711,7 +6713,7 @@
     ..add(rightBracket);
 
   @override
-  NodeListImpl<CollectionElement> get elements => _elements;
+  NodeListImpl<CollectionElementImpl> get elements => _elements;
 
   @override
   Token get endToken => rightBracket;
@@ -7222,7 +7224,7 @@
   }
 
   @override
-  NodeListImpl<ClassMember> get members => _members;
+  NodeListImpl<ClassMemberImpl> get members => _members;
 
   @override
   OnClause? get onClause => _onClause;
@@ -7356,10 +7358,10 @@
 
   /// The configurations used to control which library will actually be loaded
   /// at run-time.
-  final NodeListImpl<Configuration> _configurations = NodeListImpl._();
+  final NodeListImpl<ConfigurationImpl> _configurations = NodeListImpl._();
 
   /// The combinators used to control which names are imported or exported.
-  final NodeListImpl<Combinator> _combinators = NodeListImpl._();
+  final NodeListImpl<CombinatorImpl> _combinators = NodeListImpl._();
 
   /// The semicolon terminating the directive.
   @override
@@ -7389,10 +7391,10 @@
   }
 
   @override
-  NodeListImpl<Combinator> get combinators => _combinators;
+  NodeListImpl<CombinatorImpl> get combinators => _combinators;
 
   @override
-  NodeListImpl<Configuration> get configurations => _configurations;
+  NodeListImpl<ConfigurationImpl> get configurations => _configurations;
 
   @override
   Token get endToken => semicolon;
@@ -7604,12 +7606,12 @@
   }
 
   /// Set the [owner] of this container, and populate it with [elements].
-  void _initialize(AstNodeImpl owner, List<E>? elements) {
+  void _initialize<T extends AstNode>(AstNodeImpl owner, List<T>? elements) {
     _owner = owner;
     if (elements != null) {
       var length = elements.length;
       for (var i = 0; i < length; i++) {
-        var node = elements[i];
+        var node = elements[i] as E;
         _elements.add(node);
         owner._becomeParentOf(node as AstNodeImpl);
       }
@@ -7630,7 +7632,7 @@
   CommentImpl? _comment;
 
   /// The annotations associated with this parameter.
-  final NodeListImpl<Annotation> _metadata = NodeListImpl._();
+  final NodeListImpl<AnnotationImpl> _metadata = NodeListImpl._();
 
   /// The 'covariant' keyword, or `null` if the keyword was not used.
   @override
@@ -7679,12 +7681,12 @@
   }
 
   @override
-  NodeListImpl<Annotation> get metadata => _metadata;
+  NodeListImpl<AnnotationImpl> get metadata => _metadata;
 
   @override
   set metadata(List<Annotation> metadata) {
     _metadata.clear();
-    _metadata.addAll(metadata);
+    _metadata.addAll(metadata.cast<AnnotationImpl>());
   }
 
   @override
@@ -7802,7 +7804,7 @@
   Token onKeyword;
 
   /// The classes are super-class constraints for the mixin.
-  final NodeListImpl<TypeName> _superclassConstraints = NodeListImpl._();
+  final NodeListImpl<TypeNameImpl> _superclassConstraints = NodeListImpl._();
 
   /// Initialize a newly created on clause.
   OnClauseImpl(this.onKeyword, List<TypeName> superclassConstraints) {
@@ -7822,7 +7824,8 @@
   Token get endToken => _superclassConstraints.endToken!;
 
   @override
-  NodeListImpl<TypeName> get superclassConstraints => _superclassConstraints;
+  NodeListImpl<TypeNameImpl> get superclassConstraints =>
+      _superclassConstraints;
 
   @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitOnClause(this);
@@ -8577,7 +8580,7 @@
   Token leftBracket;
 
   /// The syntactic elements in the set.
-  final NodeListImpl<CollectionElement> _elements = NodeListImpl._();
+  final NodeListImpl<CollectionElementImpl> _elements = NodeListImpl._();
 
   @override
   Token rightBracket;
@@ -8629,7 +8632,7 @@
     ..add(rightBracket);
 
   @override
-  NodeListImpl<CollectionElement> get elements => _elements;
+  NodeListImpl<CollectionElementImpl> get elements => _elements;
 
   @override
   Token get endToken => rightBracket;
@@ -8674,7 +8677,7 @@
 class ShowCombinatorImpl extends CombinatorImpl implements ShowCombinator {
   /// The list of names from the library that are made visible by this
   /// combinator.
-  final NodeListImpl<SimpleIdentifier> _shownNames = NodeListImpl._();
+  final NodeListImpl<SimpleIdentifierImpl> _shownNames = NodeListImpl._();
 
   /// Initialize a newly created import show combinator.
   ShowCombinatorImpl(Token keyword, List<SimpleIdentifier> shownNames)
@@ -8692,7 +8695,7 @@
   Token get endToken => _shownNames.endToken!;
 
   @override
-  NodeListImpl<SimpleIdentifier> get shownNames => _shownNames;
+  NodeListImpl<SimpleIdentifierImpl> get shownNames => _shownNames;
 
   @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitShowCombinator(this);
@@ -8743,7 +8746,7 @@
 
   @override
   Token get beginToken {
-    NodeListImpl<Annotation> metadata = this.metadata;
+    NodeListImpl<AnnotationImpl> metadata = this.metadata;
     if (metadata.isNotEmpty) {
       return metadata.beginToken!;
     } else if (requiredKeyword != null) {
@@ -9152,7 +9155,7 @@
 class StringInterpolationImpl extends SingleStringLiteralImpl
     implements StringInterpolation {
   /// The elements that will be composed to produce the resulting string.
-  final NodeListImpl<InterpolationElement> _elements = NodeListImpl._();
+  final NodeListImpl<InterpolationElementImpl> _elements = NodeListImpl._();
 
   /// Initialize a newly created string interpolation expression.
   StringInterpolationImpl(List<InterpolationElement> elements) {
@@ -9180,7 +9183,7 @@
 
   /// Return the elements that will be composed to produce the resulting string.
   @override
-  NodeListImpl<InterpolationElement> get elements => _elements;
+  NodeListImpl<InterpolationElementImpl> get elements => _elements;
 
   @override
   Token get endToken => _elements.endToken!;
@@ -9520,7 +9523,7 @@
 ///      | switchDefault
 abstract class SwitchMemberImpl extends AstNodeImpl implements SwitchMember {
   /// The labels associated with the switch member.
-  final NodeListImpl<Label> _labels = NodeListImpl._();
+  final NodeListImpl<LabelImpl> _labels = NodeListImpl._();
 
   /// The token representing the 'case' or 'default' keyword.
   @override
@@ -9531,7 +9534,7 @@
   Token colon;
 
   /// The statements that will be executed if this switch member is selected.
-  final NodeListImpl<Statement> _statements = NodeListImpl._();
+  final NodeListImpl<StatementImpl> _statements = NodeListImpl._();
 
   /// Initialize a newly created switch member. The list of [labels] can be
   /// `null` if there are no labels.
@@ -9558,10 +9561,10 @@
   }
 
   @override
-  NodeListImpl<Label> get labels => _labels;
+  NodeListImpl<LabelImpl> get labels => _labels;
 
   @override
-  NodeListImpl<Statement> get statements => _statements;
+  NodeListImpl<StatementImpl> get statements => _statements;
 }
 
 /// A switch statement.
@@ -9590,7 +9593,7 @@
   Token leftBracket;
 
   /// The switch members that can be selected by the expression.
-  final NodeListImpl<SwitchMember> _members = NodeListImpl._();
+  final NodeListImpl<SwitchMemberImpl> _members = NodeListImpl._();
 
   /// The right curly bracket.
   @override
@@ -9635,7 +9638,7 @@
   }
 
   @override
-  NodeListImpl<SwitchMember> get members => _members;
+  NodeListImpl<SwitchMemberImpl> get members => _members;
 
   @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitSwitchStatement(this);
@@ -9847,7 +9850,7 @@
   BlockImpl _body;
 
   /// The catch clauses contained in the try statement.
-  final NodeListImpl<CatchClause> _catchClauses = NodeListImpl._();
+  final NodeListImpl<CatchClauseImpl> _catchClauses = NodeListImpl._();
 
   /// The token representing the 'finally' keyword, or `null` if the statement
   /// does not contain a finally clause.
@@ -9880,7 +9883,7 @@
   }
 
   @override
-  NodeListImpl<CatchClause> get catchClauses => _catchClauses;
+  NodeListImpl<CatchClauseImpl> get catchClauses => _catchClauses;
 
   @override
   Iterable<SyntacticEntity> get childEntities => ChildEntities()
@@ -9971,7 +9974,7 @@
   Token leftBracket;
 
   /// The type arguments associated with the type.
-  final NodeListImpl<TypeAnnotation> _arguments = NodeListImpl._();
+  final NodeListImpl<TypeAnnotationImpl> _arguments = NodeListImpl._();
 
   /// The right bracket.
   @override
@@ -9984,7 +9987,7 @@
   }
 
   @override
-  NodeListImpl<TypeAnnotation> get arguments => _arguments;
+  NodeListImpl<TypeAnnotationImpl> get arguments => _arguments;
 
   @override
   Token get beginToken => leftBracket;
@@ -10222,7 +10225,7 @@
   final Token leftBracket;
 
   /// The type parameters in the list.
-  final NodeListImpl<TypeParameter> _typeParameters = NodeListImpl._();
+  final NodeListImpl<TypeParameterImpl> _typeParameters = NodeListImpl._();
 
   /// The right angle bracket.
   @override
@@ -10247,7 +10250,7 @@
   Token get endToken => rightBracket;
 
   @override
-  NodeListImpl<TypeParameter> get typeParameters => _typeParameters;
+  NodeListImpl<TypeParameterImpl> get typeParameters => _typeParameters;
 
   @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitTypeParameterList(this);
@@ -10500,7 +10503,7 @@
   TypeAnnotationImpl? _type;
 
   /// A list containing the individual variables being declared.
-  final NodeListImpl<VariableDeclaration> _variables = NodeListImpl._();
+  final NodeListImpl<VariableDeclarationImpl> _variables = NodeListImpl._();
 
   /// Initialize a newly created variable declaration list. Either or both of
   /// the [comment] and [metadata] can be `null` if the variable list does not
@@ -10558,7 +10561,7 @@
   }
 
   @override
-  NodeListImpl<VariableDeclaration> get variables => _variables;
+  NodeListImpl<VariableDeclarationImpl> get variables => _variables;
 
   @override
   E? accept<E>(AstVisitor<E> visitor) =>
@@ -10699,7 +10702,7 @@
   Token withKeyword;
 
   /// The names of the mixins that were specified.
-  final NodeListImpl<TypeName> _mixinTypes = NodeListImpl._();
+  final NodeListImpl<TypeNameImpl> _mixinTypes = NodeListImpl._();
 
   /// Initialize a newly created with clause.
   WithClauseImpl(this.withKeyword, List<TypeName> mixinTypes) {
@@ -10719,7 +10722,7 @@
   Token get endToken => _mixinTypes.endToken!;
 
   @override
-  NodeListImpl<TypeName> get mixinTypes => _mixinTypes;
+  NodeListImpl<TypeNameImpl> get mixinTypes => _mixinTypes;
 
   @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitWithClause(this);
diff --git a/pkg/analyzer/lib/src/fasta/ast_builder.dart b/pkg/analyzer/lib/src/fasta/ast_builder.dart
index 9b9b7af..facba30 100644
--- a/pkg/analyzer/lib/src/fasta/ast_builder.dart
+++ b/pkg/analyzer/lib/src/fasta/ast_builder.dart
@@ -57,17 +57,7 @@
 import 'package:analyzer/dart/ast/token.dart' show Token, TokenType;
 import 'package:analyzer/error/listener.dart';
 import 'package:analyzer/src/dart/analysis/experiments.dart';
-import 'package:analyzer/src/dart/ast/ast.dart'
-    show
-        ClassDeclarationImpl,
-        CompilationUnitImpl,
-        ExtensionDeclarationImpl,
-        ImportDirectiveImpl,
-        MethodInvocationImpl,
-        MixinDeclarationImpl,
-        SimpleIdentifierImpl,
-        TypeArgumentListImpl,
-        TypeParameterImpl;
+import 'package:analyzer/src/dart/ast/ast.dart';
 import 'package:analyzer/src/dart/ast/ast_factory.dart';
 import 'package:analyzer/src/fasta/error_converter.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
@@ -562,7 +552,7 @@
     assert(optional(')', rightParenthesis));
     debugEvent("Arguments");
 
-    var expressions = popTypedList2<Expression>(count);
+    var expressions = popTypedList2<ExpressionImpl>(count);
     ArgumentList arguments =
         ast.argumentList(leftParenthesis, expressions, rightParenthesis);
     push(ast.methodInvocation(
@@ -661,7 +651,7 @@
     assert(optional('}', rightBracket));
     debugEvent("Block");
 
-    var statements = popTypedList2<Statement>(count);
+    var statements = popTypedList2<StatementImpl>(count);
     push(ast.block(leftBracket, statements, rightBracket));
   }
 
@@ -671,7 +661,7 @@
     assert(optional('}', rightBracket));
     debugEvent("BlockFunctionBody");
 
-    var statements = popTypedList2<Statement>(count);
+    var statements = popTypedList2<StatementImpl>(count);
     Block block = ast.block(leftBracket, statements, rightBracket);
     var star = pop() as Token?;
     var asyncKeyword = pop() as Token?;
@@ -896,7 +886,7 @@
       }
     }
 
-    var variables = popTypedList2<VariableDeclaration>(count);
+    var variables = popTypedList2<VariableDeclarationImpl>(count);
     var type = pop() as TypeAnnotation?;
     var variableList = ast.variableDeclarationList2(
       lateKeyword: lateToken,
@@ -1010,7 +1000,7 @@
   @override
   void endCombinators(int count) {
     debugEvent("Combinators");
-    push(popTypedList<Combinator>(count) ?? NullValue.Combinators);
+    push(popTypedList<CombinatorImpl>(count) ?? NullValue.Combinators);
   }
 
   @override
@@ -1073,7 +1063,7 @@
   void endConditionalUris(int count) {
     debugEvent("ConditionalUris");
 
-    push(popTypedList<Configuration>(count) ?? NullValue.ConditionalUris);
+    push(popTypedList<ConfigurationImpl>(count) ?? NullValue.ConditionalUris);
   }
 
   @override
@@ -1138,7 +1128,7 @@
     assert(optional('{', leftBrace));
     debugEvent("Enum");
 
-    var constants = popTypedList2<EnumConstantDeclaration>(count);
+    var constants = popTypedList2<EnumConstantDeclarationImpl>(count);
     var name = pop() as SimpleIdentifier;
     var metadata = pop() as List<Annotation>?;
     var comment = _findComment(metadata, enumKeyword);
@@ -1734,7 +1724,7 @@
     debugEvent("LabeledStatement");
 
     var statement = pop() as Statement;
-    var labels = popTypedList2<Label>(labelCount);
+    var labels = popTypedList2<LabelImpl>(labelCount);
     push(ast.labeledStatement(labels, statement));
   }
 
@@ -1855,7 +1845,7 @@
   void endMetadataStar(int count) {
     debugEvent("MetadataStar");
 
-    push(popTypedList<Annotation>(count) ?? NullValue.Metadata);
+    push(popTypedList<AnnotationImpl>(count) ?? NullValue.Metadata);
   }
 
   @override
@@ -1972,8 +1962,8 @@
         (optional('{', leftDelimeter) && optional('}', rightDelimeter)));
     debugEvent("OptionalFormalParameters");
 
-    push(_OptionalFormalParameters(
-        popTypedList2<FormalParameter>(count), leftDelimeter, rightDelimeter));
+    push(_OptionalFormalParameters(popTypedList2<FormalParameterImpl>(count),
+        leftDelimeter, rightDelimeter));
   }
 
   @override
@@ -2096,12 +2086,12 @@
         : optional(':', colonAfterDefault!));
     debugEvent("SwitchCase");
 
-    var statements = popTypedList2<Statement>(statementCount);
+    var statements = popTypedList2<StatementImpl>(statementCount);
     List<SwitchMember?> members;
 
     if (labelCount == 0 && defaultKeyword == null) {
       // Common situation: case with no default and no labels.
-      members = popTypedList2<SwitchMember>(expressionCount);
+      members = popTypedList2<SwitchMemberImpl>(expressionCount);
     } else {
       // Labels and case statements may be intertwined
       if (defaultKeyword != null) {
@@ -2185,7 +2175,7 @@
       }
     }
 
-    var variables = popTypedList2<VariableDeclaration>(count);
+    var variables = popTypedList2<VariableDeclarationImpl>(count);
     var type = pop() as TypeAnnotation?;
     var variableList = ast.variableDeclarationList2(
       lateKeyword: lateToken,
@@ -2236,7 +2226,7 @@
     debugEvent("TryStatement");
 
     var finallyBlock = popIfNotNull(finallyKeyword) as Block?;
-    var catchClauses = popTypedList2<CatchClause>(catchCount);
+    var catchClauses = popTypedList2<CatchClauseImpl>(catchCount);
     var body = pop() as Block;
     push(ast.tryStatement(
         tryKeyword, body, catchClauses, finallyKeyword, finallyBlock));
@@ -2248,14 +2238,14 @@
     assert(optional('>', rightBracket));
     debugEvent("TypeArguments");
 
-    var arguments = popTypedList2<TypeAnnotation>(count);
+    var arguments = popTypedList2<TypeAnnotationImpl>(count);
     push(ast.typeArgumentList(leftBracket, arguments, rightBracket));
   }
 
   @override
   void endTypeList(int count) {
     debugEvent("TypeList");
-    push(popTypedList<TypeName>(count) ?? NullValue.TypeList);
+    push(popTypedList<TypeNameImpl>(count) ?? NullValue.TypeList);
   }
 
   @override
@@ -2314,7 +2304,7 @@
     assert(optionalOrNull(';', semicolon));
     debugEvent("VariablesDeclaration");
 
-    var variables = popTypedList2<VariableDeclaration>(count);
+    var variables = popTypedList2<VariableDeclarationImpl>(count);
     var modifiers = pop(NullValue.Modifiers) as _Modifiers?;
     var type = pop() as TypeAnnotation?;
     var keyword = modifiers?.finalConstOrVarKeyword;
@@ -2536,7 +2526,7 @@
     debugEvent("ClassImplements");
 
     if (implementsKeyword != null) {
-      var interfaces = popTypedList2<TypeName>(interfacesCount);
+      var interfaces = popTypedList2<TypeNameImpl>(interfacesCount);
       push(ast.implementsClause(implementsKeyword, interfaces));
     } else {
       push(NullValue.IdentifierList);
@@ -2583,7 +2573,7 @@
     assert(firstIdentifier.isIdentifier);
     debugEvent("DottedName");
 
-    var components = popTypedList2<SimpleIdentifier>(count);
+    var components = popTypedList2<SimpleIdentifierImpl>(count);
     push(ast.dottedName(components));
   }
 
@@ -2732,7 +2722,7 @@
     assert(optional(';', leftSeparator));
     assert(updateExpressionCount >= 0);
 
-    var updates = popTypedList2<Expression>(updateExpressionCount);
+    var updates = popTypedList2<ExpressionImpl>(updateExpressionCount);
     var conditionStatement = pop() as Statement;
     var initializerPart = pop();
 
@@ -2807,7 +2797,7 @@
   void handleIdentifierList(int count) {
     debugEvent("IdentifierList");
 
-    push(popTypedList<SimpleIdentifier>(count) ?? NullValue.IdentifierList);
+    push(popTypedList<SimpleIdentifierImpl>(count) ?? NullValue.IdentifierList);
   }
 
   @override
@@ -2994,7 +2984,7 @@
       push(ast.listLiteral(
           constKeyword, typeArguments, leftBracket, elements, rightBracket));
     } else {
-      var elements = popTypedList<Expression>(count) ?? const [];
+      var elements = popTypedList<ExpressionImpl>(count) ?? const [];
       var typeArguments = pop() as TypeArgumentList?;
 
       List<Expression> expressions = <Expression>[];
@@ -3159,7 +3149,7 @@
     debugEvent("MixinOn");
 
     if (onKeyword != null) {
-      var types = popTypedList2<TypeName>(typeCount);
+      var types = popTypedList2<TypeNameImpl>(typeCount);
       push(ast.onClause(onKeyword, types));
     } else {
       push(NullValue.IdentifierList);
@@ -3320,9 +3310,10 @@
   void handleRecoverClassHeader() {
     debugEvent("RecoverClassHeader");
 
-    var implementsClause = pop(NullValue.IdentifierList) as ImplementsClause?;
-    var withClause = pop(NullValue.WithClause) as WithClause?;
-    var extendsClause = pop(NullValue.ExtendsClause) as ExtendsClause?;
+    var implementsClause =
+        pop(NullValue.IdentifierList) as ImplementsClauseImpl?;
+    var withClause = pop(NullValue.WithClause) as WithClauseImpl?;
+    var extendsClause = pop(NullValue.ExtendsClause) as ExtendsClauseImpl?;
     var declaration = declarations.last as ClassDeclarationImpl;
     if (extendsClause != null) {
       if (declaration.extendsClause?.superclass == null) {
@@ -3351,11 +3342,11 @@
     assert(optionalOrNull(';', semicolon));
     debugEvent("RecoverImport");
 
-    var combinators = pop() as List<Combinator>?;
+    var combinators = pop() as List<CombinatorImpl>?;
     var deferredKeyword = pop(NullValue.Deferred) as Token?;
     var asKeyword = pop(NullValue.As) as Token?;
     var prefix = pop(NullValue.Prefix) as SimpleIdentifier?;
-    var configurations = pop() as List<Configuration>?;
+    var configurations = pop() as List<ConfigurationImpl>?;
 
     var directive = directives.last as ImportDirectiveImpl;
     if (combinators != null) {
@@ -3376,7 +3367,8 @@
 
   @override
   void handleRecoverMixinHeader() {
-    var implementsClause = pop(NullValue.IdentifierList) as ImplementsClause?;
+    var implementsClause =
+        pop(NullValue.IdentifierList) as ImplementsClauseImpl?;
     var onClause = pop(NullValue.IdentifierList) as OnClause?;
 
     if (onClause != null) {
@@ -3442,7 +3434,7 @@
   void handleStringJuxtaposition(Token startToken, int literalCount) {
     debugEvent("StringJuxtaposition");
 
-    var strings = popTypedList2<StringLiteral>(literalCount);
+    var strings = popTypedList2<StringLiteralImpl>(literalCount);
     push(ast.adjacentStrings(strings));
   }
 
@@ -3502,7 +3494,7 @@
   void handleTypeVariablesDefined(Token token, int count) {
     debugEvent("handleTypeVariablesDefined");
     assert(count > 0);
-    push(popTypedList<TypeParameter>(count));
+    push(popTypedList<TypeParameterImpl>(count));
   }
 
   @override
@@ -3607,7 +3599,7 @@
       }
     }
 
-    return popTypedList<CommentReference>(count) ?? const [];
+    return popTypedList<CommentReferenceImpl>(count) ?? const [];
   }
 
   List<CollectionElement> popCollectionElements(int count) {
diff --git a/pkg/analyzer/lib/src/summary2/bundle_reader.dart b/pkg/analyzer/lib/src/summary2/bundle_reader.dart
index ecace4e..349e405 100644
--- a/pkg/analyzer/lib/src/summary2/bundle_reader.dart
+++ b/pkg/analyzer/lib/src/summary2/bundle_reader.dart
@@ -1020,7 +1020,7 @@
         var astReader = AstBinaryReader(
           reader: this,
         );
-        var directive = astReader.readNode() as Directive;
+        var directive = astReader.readNode() as DirectiveImpl;
         _unit.directives.add(directive);
       }
     }
diff --git a/pkg/analyzer/test/src/dart/ast/utilities_test.dart b/pkg/analyzer/test/src/dart/ast/utilities_test.dart
index 901b093..646e114 100644
--- a/pkg/analyzer/test/src/dart/ast/utilities_test.dart
+++ b/pkg/analyzer/test/src/dart/ast/utilities_test.dart
@@ -139,9 +139,7 @@
         Keyword.VAR, [AstTestFactory.variableDeclaration('x')],
         isExternal: false);
     TopLevelVariableElement element = TopLevelVariableElementImpl('x', -1);
-    (fromNode.variables.variables[0] as VariableDeclarationImpl)
-        .name
-        .staticElement = element;
+    fromNode.variables.variables[0].name.staticElement = element;
     TopLevelVariableDeclaration toNode1 =
         AstTestFactory.topLevelVariableDeclaration2(
             Keyword.VAR, [AstTestFactory.variableDeclaration('x')],
diff --git a/pkg/analyzer/test/src/dart/constant/utilities_test.dart b/pkg/analyzer/test/src/dart/constant/utilities_test.dart
index 92b5d6e..030fb7c 100644
--- a/pkg/analyzer/test/src/dart/constant/utilities_test.dart
+++ b/pkg/analyzer/test/src/dart/constant/utilities_test.dart
@@ -215,7 +215,7 @@
         keyword == Keyword.CONST,
         _typeProvider.intType);
     variableDeclaration.name.staticElement = fieldElement;
-    FieldDeclaration fieldDeclaration = AstTestFactory.fieldDeclaration2(
+    var fieldDeclaration = AstTestFactory.fieldDeclaration2(
         isStatic, keyword, <VariableDeclaration>[variableDeclaration]);
     var classDeclaration = AstTestFactory.classDeclaration(
         null, className, null, null, null, null);
diff --git a/tools/VERSION b/tools/VERSION
index 96276ba..761f58c 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 13
 PATCH 0
-PRERELEASE 116
+PRERELEASE 117
 PRERELEASE_PATCH 0
\ No newline at end of file
