diff --git a/pkg/analysis_server/lib/src/services/correction/bulk_fix_processor.dart b/pkg/analysis_server/lib/src/services/correction/bulk_fix_processor.dart
index e082c28..a3ebe12 100644
--- a/pkg/analysis_server/lib/src/services/correction/bulk_fix_processor.dart
+++ b/pkg/analysis_server/lib/src/services/correction/bulk_fix_processor.dart
@@ -535,7 +535,7 @@
     RuleContextUnit currentUnit,
     List<RuleContextUnit> allUnits,
   ) {
-    var nodeRegistry = RuleVisitorRegistry(enableTiming: false);
+    var nodeRegistry = RuleVisitorRegistryImpl(enableTiming: false);
     // TODO(srawlins): We are passing `currentUnit` in as `definingUnit`. Seems
     // wrong.
     var context = RuleContextWithParsedResults(allUnits, currentUnit);
diff --git a/pkg/analysis_server_plugin/api.txt b/pkg/analysis_server_plugin/api.txt
index 39dc392..9289d45 100644
--- a/pkg/analysis_server_plugin/api.txt
+++ b/pkg/analysis_server_plugin/api.txt
@@ -157,6 +157,8 @@
   int (referenced)
 package:_fe_analyzer_shared/src/scanner/token.dart:
   Token (referenced)
+package:analyzer/analysis_rule/analysis_rule.dart:
+  AnalysisRule (referenced)
 package:analyzer/dart/analysis/analysis_options.dart:
   AnalysisOptions (referenced)
 package:analyzer/dart/analysis/features.dart:
@@ -202,8 +204,6 @@
   Name (referenced)
 package:analyzer/src/dart/error/lint_codes.dart:
   LintCode (referenced)
-package:analyzer/src/lint/linter.dart:
-  AnalysisRule (referenced)
 package:analyzer_plugin/protocol/protocol_common.dart:
   SourceChange (referenced)
 package:analyzer_plugin/utilities/assist/assist.dart:
diff --git a/pkg/analysis_server_plugin/lib/src/plugin_server.dart b/pkg/analysis_server_plugin/lib/src/plugin_server.dart
index 0a0eee2..267f20a 100644
--- a/pkg/analysis_server_plugin/lib/src/plugin_server.dart
+++ b/pkg/analysis_server_plugin/lib/src/plugin_server.dart
@@ -340,7 +340,7 @@
 
     // TODO(srawlins): Enable timing similar to what the linter package's
     // `benchhmark.dart` script does.
-    var nodeRegistry = RuleVisitorRegistry(enableTiming: false);
+    var nodeRegistry = RuleVisitorRegistryImpl(enableTiming: false);
 
     var context = RuleContextWithResolvedResults(
       allUnits,
diff --git a/pkg/analysis_server_plugin/test/src/lint_rules.dart b/pkg/analysis_server_plugin/test/src/lint_rules.dart
index 97440d2..cd1160c 100644
--- a/pkg/analysis_server_plugin/test/src/lint_rules.dart
+++ b/pkg/analysis_server_plugin/test/src/lint_rules.dart
@@ -2,11 +2,11 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
+import 'package:analyzer/analysis_rule/rule_visitor_registry.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/src/lint/linter.dart';
-import 'package:analyzer/src/lint/linter_visitor.dart';
 
 class NoBoolsRule extends AnalysisRule {
   static const LintCode code = LintCode('no_bools', 'No bools message');
diff --git a/pkg/analysis_server_plugin/test/src/plugin_server_error_test.dart b/pkg/analysis_server_plugin/test/src/plugin_server_error_test.dart
index be12a3b..7c44a7a 100644
--- a/pkg/analysis_server_plugin/test/src/plugin_server_error_test.dart
+++ b/pkg/analysis_server_plugin/test/src/plugin_server_error_test.dart
@@ -8,11 +8,11 @@
 import 'package:analysis_server_plugin/plugin.dart';
 import 'package:analysis_server_plugin/registry.dart';
 import 'package:analysis_server_plugin/src/plugin_server.dart';
+import 'package:analyzer/analysis_rule/rule_visitor_registry.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/src/lint/linter.dart';
-import 'package:analyzer/src/lint/linter_visitor.dart';
 import 'package:analyzer_plugin/protocol/protocol_constants.dart' as protocol;
 import 'package:analyzer_plugin/protocol/protocol_generated.dart' as protocol;
 import 'package:analyzer_plugin/utilities/change_builder/change_builder_core.dart';
diff --git a/pkg/analyzer/api.txt b/pkg/analyzer/api.txt
index 536876e..4f3d512 100644
--- a/pkg/analyzer/api.txt
+++ b/pkg/analyzer/api.txt
@@ -1,3 +1,84 @@
+package:analyzer/analysis_rule/analysis_rule.dart:
+  AbstractAnalysisRule (class extends Object, sealed (immediate subtypes: AnalysisRule, MultiAnalysisRule)):
+    canUseParsedResult (getter: bool)
+    description (getter: String)
+    diagnosticCodes (getter: List<DiagnosticCode>)
+    incompatibleRules (getter: List<String>)
+    name (getter: String)
+    pubspecVisitor (getter: PubspecVisitor<dynamic>?)
+    reporter= (setter: ErrorReporter)
+    state (getter: RuleState)
+    registerNodeProcessors (method: void Function(RuleVisitorRegistry, RuleContext))
+  AnalysisRule (class extends AbstractAnalysisRule):
+    new (constructor: AnalysisRule Function({required String description, required String name, RuleState state}))
+    diagnosticCode (getter: DiagnosticCode)
+    diagnosticCodes (getter: List<DiagnosticCode>)
+    reportAtNode (method: void Function(AstNode?, {List<Object> arguments, List<DiagnosticMessage>? contextMessages}))
+    reportAtOffset (method: void Function(int, int, {List<Object> arguments, List<DiagnosticMessage>? contextMessages}))
+    reportAtPubNode (method: void Function(PubspecNode, {List<Object> arguments, List<DiagnosticMessage> contextMessages}))
+    reportAtToken (method: void Function(Token, {List<Object> arguments, List<DiagnosticMessage>? contextMessages}))
+  MultiAnalysisRule (class extends AbstractAnalysisRule):
+    new (constructor: MultiAnalysisRule Function({required String description, required String name, RuleState state}))
+    reportAtNode (method: void Function(AstNode?, {List<Object> arguments, List<DiagnosticMessage>? contextMessages, required DiagnosticCode diagnosticCode}))
+    reportAtOffset (method: void Function(int, int, {List<Object> arguments, List<DiagnosticMessage>? contextMessages, required DiagnosticCode diagnosticCode}))
+    reportAtPubNode (method: void Function(PubspecNode, {List<Object> arguments, List<DiagnosticMessage> contextMessages, required DiagnosticCode diagnosticCode}))
+    reportAtToken (method: void Function(Token, {List<Object> arguments, List<DiagnosticMessage>? contextMessages, required DiagnosticCode diagnosticCode}))
+package:analyzer/analysis_rule/pubspec.dart:
+  PubspecDependency (class extends Object):
+    new (constructor: PubspecDependency Function())
+    git (getter: PubspecGitRepo?)
+    host (getter: PubspecHost?)
+    name (getter: PubspecNode?)
+    path (getter: PubspecEntry?)
+    version (getter: PubspecEntry?)
+  PubspecDependencyList (class extends Object):
+    new (constructor: PubspecDependencyList Function())
+  PubspecEntry (class extends Object):
+    new (constructor: PubspecEntry Function(PubspecNode?, PubspecNode))
+    key (getter: PubspecNode?)
+    value (getter: PubspecNode)
+    toString (method: String Function())
+  PubspecEnvironment (class extends Object implements PubspecSection):
+    new (constructor: PubspecEnvironment Function())
+    flutter (getter: PubspecEntry?)
+    sdk (getter: PubspecEntry?)
+  PubspecGitRepo (class extends Object implements PubspecSection):
+    new (constructor: PubspecGitRepo Function())
+    ref (getter: PubspecEntry?)
+    url (getter: PubspecEntry?)
+  PubspecHost (class extends Object implements PubspecSection):
+    new (constructor: PubspecHost Function())
+    isShortForm (getter: bool)
+    name (getter: PubspecEntry?)
+    url (getter: PubspecEntry?)
+  PubspecNode (class extends Object):
+    new (constructor: PubspecNode Function())
+    span (getter: SourceSpan)
+    text (getter: String?)
+  PubspecNodeList (class extends Object implements PubspecSection):
+    new (constructor: PubspecNodeList Function())
+    iterator (getter: Iterator<PubspecNode>)
+  PubspecSection (class extends Object):
+    new (constructor: PubspecSection Function())
+    token (getter: PubspecNode)
+  PubspecVisitor (class<T> extends Object):
+    new (constructor: PubspecVisitor<T> Function())
+    visitPackageAuthor (method: T? Function(PubspecEntry))
+    visitPackageAuthors (method: T? Function(PubspecNodeList))
+    visitPackageDependencies (method: T? Function(PubspecDependencyList))
+    visitPackageDependency (method: T? Function(PubspecDependency))
+    visitPackageDependencyOverride (method: T? Function(PubspecDependency))
+    visitPackageDependencyOverrides (method: T? Function(PubspecDependencyList))
+    visitPackageDescription (method: T? Function(PubspecEntry))
+    visitPackageDevDependencies (method: T? Function(PubspecDependencyList))
+    visitPackageDevDependency (method: T? Function(PubspecDependency))
+    visitPackageDocumentation (method: T? Function(PubspecEntry))
+    visitPackageEnvironment (method: T? Function(PubspecEnvironment))
+    visitPackageHomepage (method: T? Function(PubspecEntry))
+    visitPackageIssueTracker (method: T? Function(PubspecEntry))
+    visitPackageName (method: T? Function(PubspecEntry))
+    visitPackageRepository (method: T? Function(PubspecEntry))
+    visitPackageVersion (method: T? Function(PubspecEntry))
 package:analyzer/analysis_rule/rule_context.dart:
   RuleContext (class extends Object):
     new (constructor: RuleContext Function())
@@ -34,6 +115,181 @@
     label (getter: String)
     replacedBy (getter: String?)
     since (getter: Version?)
+package:analyzer/analysis_rule/rule_visitor_registry.dart:
+  RuleVisitorRegistry (class extends Object):
+    new (constructor: RuleVisitorRegistry Function())
+    addAdjacentStrings (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addAnnotation (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addArgumentList (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addAsExpression (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addAssertInitializer (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addAssertStatement (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addAssignedVariablePattern (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addAssignmentExpression (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addAugmentedExpression (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addAugmentedInvocation (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addAwaitExpression (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addBinaryExpression (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addBlock (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addBlockFunctionBody (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addBooleanLiteral (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addBreakStatement (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addCascadeExpression (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addCaseClause (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addCastPattern (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addCatchClause (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addCatchClauseParameter (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addClassDeclaration (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addClassTypeAlias (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addComment (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addCommentReference (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addCompilationUnit (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addConditionalExpression (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addConfiguration (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addConstantPattern (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addConstructorDeclaration (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addConstructorFieldInitializer (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addConstructorName (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addConstructorReference (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addConstructorSelector (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addContinueStatement (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addDeclaredIdentifier (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addDeclaredVariablePattern (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addDefaultFormalParameter (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addDoStatement (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addDotShorthandConstructorInvocation (method: void Function(AnalysisRule, AstVisitor<dynamic>))
+    addDotShorthandInvocation (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addDotShorthandPropertyAccess (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addDottedName (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addDoubleLiteral (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addEmptyFunctionBody (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addEmptyStatement (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addEnumConstantArguments (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addEnumConstantDeclaration (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addEnumDeclaration (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addExportDirective (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addExpressionFunctionBody (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addExpressionStatement (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addExtendsClause (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addExtensionDeclaration (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addExtensionOnClause (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addExtensionOverride (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addExtensionTypeDeclaration (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addFieldDeclaration (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addFieldFormalParameter (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addForEachPartsWithDeclaration (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addForEachPartsWithIdentifier (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addForEachPartsWithPattern (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addForElement (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addForPartsWithDeclarations (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addForPartsWithExpression (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addForPartsWithPattern (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addForStatement (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addFormalParameterList (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addFunctionDeclaration (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addFunctionDeclarationStatement (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addFunctionExpression (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addFunctionExpressionInvocation (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addFunctionReference (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addFunctionTypeAlias (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addFunctionTypedFormalParameter (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addGenericFunctionType (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addGenericTypeAlias (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addGuardedPattern (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addHideCombinator (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addIfElement (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addIfStatement (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addImplementsClause (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addImplicitCallReference (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addImportDirective (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addImportPrefixReference (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addIndexExpression (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addInstanceCreationExpression (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addIntegerLiteral (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addInterpolationExpression (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addInterpolationString (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addIsExpression (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addLabel (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addLabeledStatement (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addLibraryDirective (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addLibraryIdentifier (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addListLiteral (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addListPattern (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addLogicalAndPattern (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addLogicalOrPattern (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addMapLiteralEntry (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addMapPattern (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addMapPatternEntry (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addMethodDeclaration (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addMethodInvocation (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addMixinDeclaration (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addMixinOnClause (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addNamedExpression (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addNamedType (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addNativeClause (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addNativeFunctionBody (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addNullAssertPattern (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addNullCheckPattern (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addNullLiteral (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addObjectPattern (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addParenthesizedExpression (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addParenthesizedPattern (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addPartDirective (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addPartOfDirective (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addPatternAssignment (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addPatternField (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addPatternFieldName (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addPatternVariableDeclaration (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addPatternVariableDeclarationStatement (method: void Function(AnalysisRule, AstVisitor<dynamic>))
+    addPostfixExpression (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addPrefixExpression (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addPrefixedIdentifier (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addPropertyAccess (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addRecordLiteral (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addRecordPattern (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addRecordTypeAnnotation (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addRedirectingConstructorInvocation (method: void Function(AnalysisRule, AstVisitor<dynamic>))
+    addRelationalPattern (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addRepresentationConstructorName (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addRepresentationDeclaration (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addRestPatternElement (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addRethrowExpression (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addReturnStatement (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addScriptTag (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addSetOrMapLiteral (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addShowCombinator (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addSimpleFormalParameter (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addSimpleIdentifier (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addSimpleStringLiteral (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addSpreadElement (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addStringInterpolation (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addSuperConstructorInvocation (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addSuperExpression (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addSuperFormalParameter (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addSwitchCase (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addSwitchDefault (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addSwitchExpression (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addSwitchExpressionCase (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addSwitchPatternCase (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addSwitchStatement (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addSymbolLiteral (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addThisExpression (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addThrowExpression (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addTopLevelVariableDeclaration (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addTryStatement (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addTypeArgumentList (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addTypeLiteral (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addTypeParameter (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addTypeParameterList (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addVariableDeclaration (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addVariableDeclarationList (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addVariableDeclarationStatement (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addWhenClause (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addWhileStatement (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addWildcardPattern (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addWithClause (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    addYieldStatement (method: void Function(AbstractAnalysisRule, AstVisitor<dynamic>))
+    afterLibrary (method: void Function(AbstractAnalysisRule, void Function()))
 package:analyzer/dart/analysis/analysis_context.dart:
   AnalysisContext@1 (class extends Object):
     new (constructor: AnalysisContext@1 Function())
@@ -4881,8 +5137,6 @@
     modificationTime (getter: int)
 package:analyzer/src/lint/config.dart:
   RuleConfig (non-public)
-package:analyzer/src/lint/linter.dart:
-  AbstractAnalysisRule (non-public)
 package:analyzer/src/workspace/workspace.dart:
   Workspace (non-public)
 package:analyzer/utilities/extensions/ast.dart:
@@ -4917,6 +5171,7 @@
   Duration (referenced)
   Exception (referenced)
   Iterable (referenced)
+  Iterator (referenced)
   List (referenced)
   Map (referenced)
   Null (referenced)
diff --git a/pkg/analyzer/lib/analysis_rule/analysis_rule.dart b/pkg/analyzer/lib/analysis_rule/analysis_rule.dart
new file mode 100644
index 0000000..e7e6e83
--- /dev/null
+++ b/pkg/analyzer/lib/analysis_rule/analysis_rule.dart
@@ -0,0 +1,284 @@
+// Copyright (c) 2015, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:analyzer/analysis_rule/pubspec.dart';
+import 'package:analyzer/analysis_rule/rule_context.dart';
+import 'package:analyzer/analysis_rule/rule_state.dart';
+import 'package:analyzer/analysis_rule/rule_visitor_registry.dart';
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/token.dart';
+import 'package:analyzer/diagnostic/diagnostic.dart';
+import 'package:analyzer/error/error.dart';
+import 'package:analyzer/error/listener.dart';
+import 'package:analyzer/src/lint/pub.dart';
+
+/// Describes a static analysis rule, either a lint rule (which must be enabled
+/// via analysis options) or a warning rule (which is enabled by default).
+sealed class AbstractAnalysisRule {
+  /// Used to report lints and warnings.
+  ///
+  /// NOTE: this is set by the framework before any node processors start
+  /// visiting nodes.
+  late ErrorReporter _reporter;
+
+  /// Short description suitable for display in console output and IDEs.
+  ///
+  /// This text may be used when providing information about a rule listed in
+  /// analysis options file, or to suggest enabling a rule.
+  final String description;
+
+  /// The rule name.
+  final String name;
+
+  /// The state of this analysis rule.
+  ///
+  /// See [RuleState] for a list of the possible states and when they should be
+  /// applied to a given rule.
+  final RuleState state;
+
+  AbstractAnalysisRule({
+    required this.name,
+    required this.description,
+    this.state = const RuleState.stable(),
+  });
+
+  /// Indicates whether this analysis rule can work with just the parsed
+  /// information or if it requires a resolved unit.
+  bool get canUseParsedResult => false;
+
+  /// The diagnostic codes associated with this analysis rule.
+  List<DiagnosticCode> get diagnosticCodes;
+
+  /// A list of incompatible rule names.
+  ///
+  /// Two rules are incompatible if there are situations where it is difficult
+  /// or impossible to comply with both. The analyzer will warn if two
+  /// incompatible rules are both enabled in analysis options.
+  List<String> get incompatibleRules => const [];
+
+  /// A visitor that visits a [Pubspec] to perform analysis.
+  ///
+  /// Diagnostics are reported via this [AbstractAnalysisRule]'s error
+  /// [reporter].
+  PubspecVisitor? get pubspecVisitor => null;
+
+  /// Sets the [ErrorReporter] for the [CompilationUnit] currently being
+  /// visited.
+  set reporter(ErrorReporter value) => _reporter = value;
+
+  /// Registers node processors in the given [registry].
+  ///
+  /// The node processors may use the provided [context] to access information
+  /// that is not available from the AST nodes or their associated elements.
+  void registerNodeProcessors(
+    RuleVisitorRegistry registry,
+    RuleContext context,
+  ) {}
+
+  void _reportAtNode(
+    AstNode? node, {
+    List<Object> arguments = const [],
+    List<DiagnosticMessage>? contextMessages,
+    required DiagnosticCode diagnosticCode,
+  }) {
+    if (node != null && !node.isSynthetic) {
+      _reporter.atNode(
+        node,
+        diagnosticCode,
+        arguments: arguments,
+        contextMessages: contextMessages,
+      );
+    }
+  }
+
+  void _reportAtOffset(
+    int offset,
+    int length, {
+    required DiagnosticCode diagnosticCode,
+    List<Object> arguments = const [],
+    List<DiagnosticMessage>? contextMessages,
+  }) {
+    _reporter.atOffset(
+      offset: offset,
+      length: length,
+      diagnosticCode: diagnosticCode,
+      arguments: arguments,
+      contextMessages: contextMessages,
+    );
+  }
+
+  void _reportAtPubNode(
+    PubspecNodeImpl node, {
+    List<Object> arguments = const [],
+    List<DiagnosticMessage> contextMessages = const [],
+    required DiagnosticCode diagnosticCode,
+  }) {
+    // Cache diagnostic and location info for creating `AnalysisErrorInfo`s.
+    var diagnostic = Diagnostic.tmp(
+      source: node.source,
+      offset: node.span.start.offset,
+      length: node.span.length,
+      errorCode: diagnosticCode,
+      arguments: arguments,
+      contextMessages: contextMessages,
+    );
+    _reporter.reportError(diagnostic);
+  }
+
+  void _reportAtToken(
+    Token token, {
+    required DiagnosticCode diagnosticCode,
+    List<Object> arguments = const [],
+    List<DiagnosticMessage>? contextMessages,
+  }) {
+    if (!token.isSynthetic) {
+      _reporter.atToken(
+        token,
+        diagnosticCode,
+        arguments: arguments,
+        contextMessages: contextMessages,
+      );
+    }
+  }
+}
+
+/// Describes an [AbstractAnalysisRule] which reports exactly one type of
+/// diagnostic (one [DiagnosticCode]).
+abstract class AnalysisRule extends AbstractAnalysisRule {
+  AnalysisRule({required super.name, required super.description, super.state});
+
+  /// The code to report for a violation.
+  DiagnosticCode get diagnosticCode;
+
+  @override
+  List<DiagnosticCode> get diagnosticCodes => [diagnosticCode];
+
+  /// Reports a diagnostic at [node] with message [arguments] and
+  /// [contextMessages].
+  void reportAtNode(
+    AstNode? node, {
+    List<Object> arguments = const [],
+    List<DiagnosticMessage>? contextMessages,
+  }) => _reportAtNode(
+    node,
+    diagnosticCode: diagnosticCode,
+    arguments: arguments,
+    contextMessages: contextMessages,
+  );
+
+  /// Reports a diagnostic at [offset], with [length], with message [arguments]
+  /// and [contextMessages].
+  void reportAtOffset(
+    int offset,
+    int length, {
+    List<Object> arguments = const [],
+    List<DiagnosticMessage>? contextMessages,
+  }) => _reportAtOffset(
+    offset,
+    length,
+    diagnosticCode: diagnosticCode,
+    arguments: arguments,
+    contextMessages: contextMessages,
+  );
+
+  /// Reports a diagnostic at Pubspec [node], with message [arguments] and
+  /// [contextMessages].
+  void reportAtPubNode(
+    PubspecNode node, {
+    List<Object> arguments = const [],
+    List<DiagnosticMessage> contextMessages = const [],
+  }) => _reportAtPubNode(
+    node as PubspecNodeImpl,
+    diagnosticCode: diagnosticCode,
+    arguments: arguments,
+    contextMessages: contextMessages,
+  );
+
+  /// Reports a diagnostic at [token], with message [arguments] and
+  /// [contextMessages].
+  void reportAtToken(
+    Token token, {
+    List<Object> arguments = const [],
+    List<DiagnosticMessage>? contextMessages,
+  }) => _reportAtToken(
+    token,
+    diagnosticCode: diagnosticCode,
+    arguments: arguments,
+    contextMessages: contextMessages,
+  );
+}
+
+/// Describes an [AbstractAnalysisRule] which reports diagnostics using multiple
+/// [DiagnosticCode]s).
+abstract class MultiAnalysisRule extends AbstractAnalysisRule {
+  MultiAnalysisRule({
+    required super.name,
+    required super.description,
+    super.state,
+  });
+
+  /// Reports [diagnosticCode] at [node] with message [arguments] and
+  /// [contextMessages].
+  void reportAtNode(
+    AstNode? node, {
+    List<Object> arguments = const [],
+    List<DiagnosticMessage>? contextMessages,
+    required DiagnosticCode diagnosticCode,
+  }) => _reportAtNode(
+    node,
+    diagnosticCode: diagnosticCode,
+    arguments: arguments,
+    contextMessages: contextMessages,
+  );
+
+  /// Reports [diagnosticCode] at [offset], with [length], with message [arguments]
+  /// and [contextMessages].
+  void reportAtOffset(
+    int offset,
+    int length, {
+    required DiagnosticCode diagnosticCode,
+    List<Object> arguments = const [],
+    List<DiagnosticMessage>? contextMessages,
+  }) => _reportAtOffset(
+    offset,
+    length,
+    diagnosticCode: diagnosticCode,
+    arguments: arguments,
+    contextMessages: contextMessages,
+  );
+
+  /// Reports [diagnosticCode] at Pubspec [node], with message [arguments] and
+  /// [contextMessages].
+  void reportAtPubNode(
+    PubspecNode node, {
+    required DiagnosticCode diagnosticCode,
+    List<Object> arguments = const [],
+    List<DiagnosticMessage> contextMessages = const [],
+  }) {
+    // Cache error and location info for creating `AnalysisErrorInfo`s.
+    var error = Diagnostic.tmp(
+      source: (node as PubspecNodeImpl).source,
+      offset: node.span.start.offset,
+      length: node.span.length,
+      errorCode: diagnosticCode,
+      arguments: arguments,
+      contextMessages: contextMessages,
+    );
+    _reporter.reportError(error);
+  }
+
+  /// Reports [diagnosticCode] at [token], with message [arguments] and
+  /// [contextMessages].
+  void reportAtToken(
+    Token token, {
+    required DiagnosticCode diagnosticCode,
+    List<Object> arguments = const [],
+    List<DiagnosticMessage>? contextMessages,
+  }) => _reportAtToken(
+    token,
+    diagnosticCode: diagnosticCode,
+    arguments: arguments,
+    contextMessages: contextMessages,
+  );
+}
diff --git a/pkg/analyzer/lib/analysis_rule/pubspec.dart b/pkg/analyzer/lib/analysis_rule/pubspec.dart
new file mode 100644
index 0000000..fdf253f
--- /dev/null
+++ b/pkg/analyzer/lib/analysis_rule/pubspec.dart
@@ -0,0 +1,209 @@
+// Copyright (c) 2015, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:collection';
+
+import 'package:source_span/source_span.dart';
+
+/// Representation of a key/value pair which maps a package name to a
+/// _package description_.
+///
+/// **Example** of a path-dependency:
+/// ```yaml
+/// dependencies:
+///   <name>:
+///     version: <version>
+///     path: <path>
+/// ```
+abstract class PubspecDependency {
+  /// The git dependency section, if specified.
+  PubspecGitRepo? get git;
+
+  /// The host section, if specified.
+  PubspecHost? get host;
+
+  /// The dependency name, if specified.
+  PubspecNode? get name;
+
+  /// The path section, if specified.
+  PubspecEntry? get path;
+
+  /// The dependency version, if specified.
+  PubspecEntry? get version;
+}
+
+/// Representation of the map from package name to _package description_ used
+/// under `dependencies`, `dev_dependencies` and `dependency_overrides`.
+abstract class PubspecDependencyList with IterableMixin<PubspecDependency> {}
+
+/// Representation of a YAML section in a pubspec file.
+class PubspecEntry {
+  final PubspecNode? key;
+  final PubspecNode value;
+
+  PubspecEntry(this.key, this.value);
+
+  @override
+  String toString() => '${key != null ? '$key: ' : ''}$value';
+}
+
+/// Representation of an `environment` section in a pubspec file.
+///
+/// **Example** of an environment:
+/// ```yaml
+/// environment:
+///   sdk: '>=2.12.0 <4.0.0'
+///   flutter: ^3.3.10
+/// ```
+abstract class PubspecEnvironment implements PubspecSection {
+  /// The `flutter` section, if specified.
+  PubspecEntry? get flutter;
+
+  /// The (Dart) `sdk` section, if specified.
+  PubspecEntry? get sdk;
+}
+
+/// Representation of git-dependency section in a pubspec file.
+///
+/// **Example** of a git-dependency:
+/// ```yaml
+/// dependencies:
+///   foo:
+///     git: # <-- this is the [token] property
+///       url: https://github.com/example/example
+///       ref: main # ref is optional
+/// ```
+///
+/// This may also be written in the form:
+/// ```yaml
+/// dependencies:
+///   foo:
+///     git:       https://github.com/example/example
+///     # ^-token  ^--url
+///     # In this case [ref] is `null`.
+/// ```
+abstract class PubspecGitRepo implements PubspecSection {
+  /// [PubspecEntry] for `ref: main` where [PubspecEntry.key] is `ref` and
+  /// [PubspecEntry.value] is `main`.
+  PubspecEntry? get ref;
+
+  /// [PubspecEntry] for `url: https://...` or `git: https://`, where [PubspecEntry.key]
+  /// is either `url` or `git`, and [PubspecEntry.key] is the URL.
+  ///
+  /// If the git-dependency is given in the form:
+  /// ```yaml
+  /// dependencies:
+  ///   foo:
+  ///     git:       https://github.com/example/example
+  /// ```
+  /// Then [token] and `url.key` will be the same object.
+  PubspecEntry? get url;
+}
+
+/// A section describing where a package is hosted in a custom package
+/// repository.
+abstract class PubspecHost implements PubspecSection {
+  /// True, if _short-form_ for writing hosted-dependencies was used.
+  ///
+  /// **Example** of a hosted-dependency written in short-form:
+  /// ```yaml
+  /// dependencies:
+  ///   foo:
+  ///     hosted: https://some-pub-server.com
+  ///     version: ^1.2.3
+  /// ```
+  ///
+  /// The _long-form_ for writing the dependency given above is:
+  /// ```yaml
+  /// dependencies:
+  ///   foo:
+  ///     hosted:
+  ///       url: https://some-pub-server.com
+  ///       name: foo
+  ///     version: ^1.2.3
+  /// ```
+  ///
+  /// The short-form was added in Dart 2.15.0 because:
+  ///  * The `name` property just specifies the package name, which can be
+  ///    inferred from the context. So it is unnecessary to write it.
+  ///  * The nested object and `url` key becomes unnecessary when the `name`
+  ///    property is removed.
+  bool get isShortForm;
+
+  /// The name of the package at the package repository.
+  PubspecEntry? get name;
+
+  /// The URL of the package repository.
+  PubspecEntry? get url;
+}
+
+/// Representation of a leaf-node in a pubspec file.
+abstract class PubspecNode {
+  /// Information about this node's location in the pubspec file.
+  SourceSpan get span;
+
+  /// String value of the node, or `null` if value in the pubspec file is `null`
+  /// or omitted.
+  ///
+  /// **Example**
+  /// ```
+  /// name: foo
+  /// version:
+  /// ```
+  /// In the example above the [PubspecNode] for `foo` will have [text] "foo", and
+  /// the [PubspecNode] for `version` will have not have [text] as `null`, as empty
+  /// value or `"null"` is the same in YAML.
+  String? get text;
+}
+
+/// A list of [PubspecNode]s in a section.
+abstract class PubspecNodeList
+    with IterableMixin<PubspecNode>
+    implements PubspecSection {
+  @override
+  Iterator<PubspecNode> get iterator;
+}
+
+abstract class PubspecSection {
+  /// The node for this section's key.
+  ///
+  /// This is primarily used in the string representation of node classes.
+  PubspecNode get token;
+}
+
+/// A visitor that visits various semantic sections of a pubspec file.
+abstract class PubspecVisitor<T> {
+  T? visitPackageAuthor(PubspecEntry author) => null;
+
+  T? visitPackageAuthors(PubspecNodeList authors) => null;
+
+  T? visitPackageDependencies(PubspecDependencyList dependencies) => null;
+
+  T? visitPackageDependency(PubspecDependency dependency) => null;
+
+  T? visitPackageDependencyOverride(PubspecDependency dependency) => null;
+
+  T? visitPackageDependencyOverrides(PubspecDependencyList dependencies) =>
+      null;
+
+  T? visitPackageDescription(PubspecEntry description) => null;
+
+  T? visitPackageDevDependencies(PubspecDependencyList dependencies) => null;
+
+  T? visitPackageDevDependency(PubspecDependency dependency) => null;
+
+  T? visitPackageDocumentation(PubspecEntry documentation) => null;
+
+  T? visitPackageEnvironment(PubspecEnvironment environment) => null;
+
+  T? visitPackageHomepage(PubspecEntry homepage) => null;
+
+  T? visitPackageIssueTracker(PubspecEntry issueTracker) => null;
+
+  T? visitPackageName(PubspecEntry name) => null;
+
+  T? visitPackageRepository(PubspecEntry repository) => null;
+
+  T? visitPackageVersion(PubspecEntry version) => null;
+}
diff --git a/pkg/analyzer/lib/analysis_rule/rule_visitor_registry.dart b/pkg/analyzer/lib/analysis_rule/rule_visitor_registry.dart
new file mode 100644
index 0000000..0ab48ca
--- /dev/null
+++ b/pkg/analyzer/lib/analysis_rule/rule_visitor_registry.dart
@@ -0,0 +1,438 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/src/lint/linter.dart';
+
+/// The container to register visitors for separate AST node types.
+///
+/// Source files are visited by the Dart analysis server recursively. Only the
+/// visitors that are registered to visit a given node type will visit such
+/// nodes. Each analysis rule overrides
+/// [AbstractAnalysisRule.registerNodeProcessors] and calls `add*` for each of
+/// the node types it needs to visit with an [AstVisitor], which registers that
+/// visitor.
+abstract class RuleVisitorRegistry {
+  void addAdjacentStrings(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addAnnotation(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addArgumentList(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addAsExpression(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addAssertInitializer(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addAssertStatement(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addAssignedVariablePattern(
+    AbstractAnalysisRule rule,
+    AstVisitor visitor,
+  );
+
+  void addAssignmentExpression(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addAugmentedExpression(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addAugmentedInvocation(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addAwaitExpression(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addBinaryExpression(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addBlock(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addBlockFunctionBody(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addBooleanLiteral(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addBreakStatement(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addCascadeExpression(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addCaseClause(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addCastPattern(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addCatchClause(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addCatchClauseParameter(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addClassDeclaration(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addClassTypeAlias(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addComment(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addCommentReference(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addCompilationUnit(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addConditionalExpression(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addConfiguration(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addConstantPattern(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addConstructorDeclaration(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addConstructorFieldInitializer(
+    AbstractAnalysisRule rule,
+    AstVisitor visitor,
+  );
+
+  void addConstructorName(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addConstructorReference(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addConstructorSelector(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addContinueStatement(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addDeclaredIdentifier(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addDeclaredVariablePattern(
+    AbstractAnalysisRule rule,
+    AstVisitor visitor,
+  );
+
+  void addDefaultFormalParameter(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addDoStatement(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addDotShorthandConstructorInvocation(
+    AnalysisRule rule,
+    AstVisitor visitor,
+  );
+
+  void addDotShorthandInvocation(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addDotShorthandPropertyAccess(
+    AbstractAnalysisRule rule,
+    AstVisitor visitor,
+  );
+
+  void addDottedName(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addDoubleLiteral(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addEmptyFunctionBody(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addEmptyStatement(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addEnumConstantArguments(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addEnumConstantDeclaration(
+    AbstractAnalysisRule rule,
+    AstVisitor visitor,
+  );
+
+  void addEnumDeclaration(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addExportDirective(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addExpressionFunctionBody(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addExpressionStatement(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addExtendsClause(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addExtensionDeclaration(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addExtensionOnClause(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addExtensionOverride(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addExtensionTypeDeclaration(
+    AbstractAnalysisRule rule,
+    AstVisitor visitor,
+  );
+
+  void addFieldDeclaration(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addFieldFormalParameter(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addForEachPartsWithDeclaration(
+    AbstractAnalysisRule rule,
+    AstVisitor visitor,
+  );
+
+  void addForEachPartsWithIdentifier(
+    AbstractAnalysisRule rule,
+    AstVisitor visitor,
+  );
+
+  void addForEachPartsWithPattern(
+    AbstractAnalysisRule rule,
+    AstVisitor visitor,
+  );
+
+  void addForElement(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addFormalParameterList(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addForPartsWithDeclarations(
+    AbstractAnalysisRule rule,
+    AstVisitor visitor,
+  );
+
+  void addForPartsWithExpression(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addForPartsWithPattern(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addForStatement(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addFunctionDeclaration(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addFunctionDeclarationStatement(
+    AbstractAnalysisRule rule,
+    AstVisitor visitor,
+  );
+
+  void addFunctionExpression(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addFunctionExpressionInvocation(
+    AbstractAnalysisRule rule,
+    AstVisitor visitor,
+  );
+
+  void addFunctionReference(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addFunctionTypeAlias(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addFunctionTypedFormalParameter(
+    AbstractAnalysisRule rule,
+    AstVisitor visitor,
+  );
+
+  void addGenericFunctionType(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addGenericTypeAlias(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addGuardedPattern(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addHideCombinator(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addIfElement(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addIfStatement(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addImplementsClause(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addImplicitCallReference(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addImportDirective(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addImportPrefixReference(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addIndexExpression(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addInstanceCreationExpression(
+    AbstractAnalysisRule rule,
+    AstVisitor visitor,
+  );
+
+  void addIntegerLiteral(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addInterpolationExpression(
+    AbstractAnalysisRule rule,
+    AstVisitor visitor,
+  );
+
+  void addInterpolationString(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addIsExpression(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addLabel(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addLabeledStatement(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addLibraryDirective(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addLibraryIdentifier(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addListLiteral(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addListPattern(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addLogicalAndPattern(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addLogicalOrPattern(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addMapLiteralEntry(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addMapPattern(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addMapPatternEntry(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addMethodDeclaration(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addMethodInvocation(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addMixinDeclaration(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addMixinOnClause(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addNamedExpression(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addNamedType(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addNativeClause(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addNativeFunctionBody(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addNullAssertPattern(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addNullCheckPattern(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addNullLiteral(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addObjectPattern(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addParenthesizedExpression(
+    AbstractAnalysisRule rule,
+    AstVisitor visitor,
+  );
+
+  void addParenthesizedPattern(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addPartDirective(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addPartOfDirective(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addPatternAssignment(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addPatternField(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addPatternFieldName(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addPatternVariableDeclaration(
+    AbstractAnalysisRule rule,
+    AstVisitor visitor,
+  );
+
+  void addPatternVariableDeclarationStatement(
+    AnalysisRule rule,
+    AstVisitor visitor,
+  );
+
+  void addPostfixExpression(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addPrefixedIdentifier(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addPrefixExpression(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addPropertyAccess(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addRecordLiteral(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addRecordPattern(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addRecordTypeAnnotation(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addRedirectingConstructorInvocation(
+    AnalysisRule rule,
+    AstVisitor visitor,
+  );
+
+  void addRelationalPattern(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addRepresentationConstructorName(
+    AbstractAnalysisRule rule,
+    AstVisitor visitor,
+  );
+
+  void addRepresentationDeclaration(
+    AbstractAnalysisRule rule,
+    AstVisitor visitor,
+  );
+
+  void addRestPatternElement(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addRethrowExpression(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addReturnStatement(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addScriptTag(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addSetOrMapLiteral(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addShowCombinator(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addSimpleFormalParameter(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addSimpleIdentifier(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addSimpleStringLiteral(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addSpreadElement(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addStringInterpolation(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addSuperConstructorInvocation(
+    AbstractAnalysisRule rule,
+    AstVisitor visitor,
+  );
+
+  void addSuperExpression(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addSuperFormalParameter(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addSwitchCase(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addSwitchDefault(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addSwitchExpression(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addSwitchExpressionCase(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addSwitchPatternCase(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addSwitchStatement(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addSymbolLiteral(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addThisExpression(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addThrowExpression(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addTopLevelVariableDeclaration(
+    AbstractAnalysisRule rule,
+    AstVisitor visitor,
+  );
+
+  void addTryStatement(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addTypeArgumentList(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addTypeLiteral(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addTypeParameter(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addTypeParameterList(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addVariableDeclaration(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addVariableDeclarationList(
+    AbstractAnalysisRule rule,
+    AstVisitor visitor,
+  );
+
+  void addVariableDeclarationStatement(
+    AbstractAnalysisRule rule,
+    AstVisitor visitor,
+  );
+
+  void addWhenClause(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addWhileStatement(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addWildcardPattern(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addWithClause(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void addYieldStatement(AbstractAnalysisRule rule, AstVisitor visitor);
+
+  void afterLibrary(AbstractAnalysisRule rule, void Function() callback);
+}
diff --git a/pkg/analyzer/lib/src/dart/analysis/file_state_filter.dart b/pkg/analyzer/lib/src/dart/analysis/file_state_filter.dart
index eeaa6d5..f412c43 100644
--- a/pkg/analyzer/lib/src/dart/analysis/file_state_filter.dart
+++ b/pkg/analyzer/lib/src/dart/analysis/file_state_filter.dart
@@ -2,8 +2,8 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
+import 'package:analyzer/analysis_rule/pubspec.dart';
 import 'package:analyzer/src/dart/analysis/file_state.dart';
-import 'package:analyzer/src/lint/pub.dart';
 import 'package:analyzer/src/workspace/pub.dart';
 
 abstract class FileStateFilter {
@@ -141,7 +141,7 @@
   }
 }
 
-extension on PSDependencyList? {
+extension on PubspecDependencyList? {
   List<String> get names {
     var self = this;
     if (self == null) {
diff --git a/pkg/analyzer/lib/src/dart/analysis/library_analyzer.dart b/pkg/analyzer/lib/src/dart/analysis/library_analyzer.dart
index 23b0741..9b9fa86 100644
--- a/pkg/analyzer/lib/src/dart/analysis/library_analyzer.dart
+++ b/pkg/analyzer/lib/src/dart/analysis/library_analyzer.dart
@@ -402,7 +402,9 @@
     var allUnits = analysesToContextUnits.values.toList();
     definingContextUnit ??= allUnits.first;
 
-    var nodeRegistry = RuleVisitorRegistry(enableTiming: _enableLintRuleTiming);
+    var nodeRegistry = RuleVisitorRegistryImpl(
+      enableTiming: _enableLintRuleTiming,
+    );
     var context = RuleContextWithResolvedResults(
       allUnits,
       definingContextUnit,
diff --git a/pkg/analyzer/lib/src/lint/linter.dart b/pkg/analyzer/lib/src/lint/linter.dart
index 0111c4a..f9c24ca 100644
--- a/pkg/analyzer/lib/src/lint/linter.dart
+++ b/pkg/analyzer/lib/src/lint/linter.dart
@@ -2,22 +2,17 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
+import 'package:analyzer/analysis_rule/analysis_rule.dart';
 import 'package:analyzer/analysis_rule/rule_context.dart';
-import 'package:analyzer/analysis_rule/rule_state.dart';
 import 'package:analyzer/dart/analysis/features.dart';
 import 'package:analyzer/dart/analysis/results.dart';
-import 'package:analyzer/dart/ast/ast.dart';
-import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type_provider.dart';
 import 'package:analyzer/dart/element/type_system.dart';
-import 'package:analyzer/diagnostic/diagnostic.dart';
 import 'package:analyzer/error/error.dart';
-import 'package:analyzer/error/listener.dart';
-import 'package:analyzer/src/lint/linter_visitor.dart' show RuleVisitorRegistry;
-import 'package:analyzer/src/lint/pub.dart';
 import 'package:analyzer/workspace/workspace.dart';
 
+export 'package:analyzer/analysis_rule/analysis_rule.dart';
 export 'package:analyzer/analysis_rule/rule_state.dart'
     show dart2_12, dart3, dart3_3, RuleState;
 export 'package:analyzer/src/lint/linter_visitor.dart' show NodeLintRegistry;
@@ -37,266 +32,6 @@
 /// one [DiagnosticCode].
 typedef LintRule = AnalysisRule;
 
-/// Describes a static analysis rule, either a lint rule (which must be enabled
-/// via analysis options) or a warning rule (which is enabled by default).
-sealed class AbstractAnalysisRule {
-  /// Used to report lints and warnings.
-  /// NOTE: this is set by the framework before any node processors start
-  /// visiting nodes.
-  late ErrorReporter _reporter;
-
-  /// Short description suitable for display in console output.
-  final String description;
-
-  /// The rule name.
-  final String name;
-
-  /// The state of this analysis rule, optionally indicating the "version" that
-  /// this state started applying to this rule.
-  final RuleState state;
-
-  AbstractAnalysisRule({
-    required this.name,
-    required this.description,
-    this.state = const RuleState.stable(),
-  });
-
-  /// Indicates whether this analysis rule can work with just the parsed
-  /// information or if it requires a resolved unit.
-  bool get canUseParsedResult => false;
-
-  /// The diagnostic codes associated with this analysis rule.
-  List<DiagnosticCode> get diagnosticCodes;
-
-  /// A list of incompatible rule ids.
-  List<String> get incompatibleRules => const [];
-
-  /// A visitor that visits a [Pubspec] to perform analysis.
-  ///
-  /// Diagnostics are reported via this [AbstractAnalysisRule]'s error
-  /// [reporter].
-  PubspecVisitor? get pubspecVisitor => null;
-
-  /// Sets the [ErrorReporter] for the [CompilationUnit] currently being
-  /// visited.
-  set reporter(ErrorReporter value) => _reporter = value;
-
-  /// Registers node processors in the given [registry].
-  ///
-  /// The node processors may use the provided [context] to access information
-  /// that is not available from the AST nodes or their associated elements.
-  void registerNodeProcessors(
-    RuleVisitorRegistry registry,
-    RuleContext context,
-  ) {}
-
-  void _reportAtNode(
-    AstNode? node, {
-    List<Object> arguments = const [],
-    List<DiagnosticMessage>? contextMessages,
-    required DiagnosticCode diagnosticCode,
-  }) {
-    if (node != null && !node.isSynthetic) {
-      _reporter.atNode(
-        node,
-        diagnosticCode,
-        arguments: arguments,
-        contextMessages: contextMessages,
-      );
-    }
-  }
-
-  void _reportAtOffset(
-    int offset,
-    int length, {
-    required DiagnosticCode diagnosticCode,
-    List<Object> arguments = const [],
-    List<DiagnosticMessage>? contextMessages,
-  }) {
-    _reporter.atOffset(
-      offset: offset,
-      length: length,
-      diagnosticCode: diagnosticCode,
-      arguments: arguments,
-      contextMessages: contextMessages,
-    );
-  }
-
-  void _reportAtPubNode(
-    PSNode node, {
-    List<Object> arguments = const [],
-    List<DiagnosticMessage> contextMessages = const [],
-    required DiagnosticCode diagnosticCode,
-  }) {
-    // Cache diagnostic and location info for creating `AnalysisErrorInfo`s.
-    var diagnostic = Diagnostic.tmp(
-      source: node.source,
-      offset: node.span.start.offset,
-      length: node.span.length,
-      errorCode: diagnosticCode,
-      arguments: arguments,
-      contextMessages: contextMessages,
-    );
-    _reporter.reportError(diagnostic);
-  }
-
-  void _reportAtToken(
-    Token token, {
-    required DiagnosticCode diagnosticCode,
-    List<Object> arguments = const [],
-    List<DiagnosticMessage>? contextMessages,
-  }) {
-    if (!token.isSynthetic) {
-      _reporter.atToken(
-        token,
-        diagnosticCode,
-        arguments: arguments,
-        contextMessages: contextMessages,
-      );
-    }
-  }
-}
-
-/// Describes an [AbstractAnalysisRule] which reports exactly one type of
-/// diagnostic (one [DiagnosticCode]).
-abstract class AnalysisRule extends AbstractAnalysisRule {
-  AnalysisRule({required super.name, required super.description, super.state});
-
-  /// The code to report for a violation.
-  DiagnosticCode get diagnosticCode;
-
-  @override
-  List<DiagnosticCode> get diagnosticCodes => [diagnosticCode];
-
-  /// Reports a diagnostic at [node] with message [arguments] and
-  /// [contextMessages].
-  void reportAtNode(
-    AstNode? node, {
-    List<Object> arguments = const [],
-    List<DiagnosticMessage>? contextMessages,
-  }) => _reportAtNode(
-    node,
-    diagnosticCode: diagnosticCode,
-    arguments: arguments,
-    contextMessages: contextMessages,
-  );
-
-  /// Reports a diagnostic at [offset], with [length], with message [arguments]
-  /// and [contextMessages].
-  void reportAtOffset(
-    int offset,
-    int length, {
-    List<Object> arguments = const [],
-    List<DiagnosticMessage>? contextMessages,
-  }) => _reportAtOffset(
-    offset,
-    length,
-    diagnosticCode: diagnosticCode,
-    arguments: arguments,
-    contextMessages: contextMessages,
-  );
-
-  /// Reports a diagnostic at Pubspec [node], with message [arguments] and
-  /// [contextMessages].
-  void reportAtPubNode(
-    PSNode node, {
-    List<Object> arguments = const [],
-    List<DiagnosticMessage> contextMessages = const [],
-  }) => _reportAtPubNode(
-    node,
-    diagnosticCode: diagnosticCode,
-    arguments: arguments,
-    contextMessages: contextMessages,
-  );
-
-  /// Reports a diagnostic at [token], with message [arguments] and
-  /// [contextMessages].
-  void reportAtToken(
-    Token token, {
-    List<Object> arguments = const [],
-    List<DiagnosticMessage>? contextMessages,
-  }) => _reportAtToken(
-    token,
-    diagnosticCode: diagnosticCode,
-    arguments: arguments,
-    contextMessages: contextMessages,
-  );
-}
-
-/// Describes an [AbstractAnalysisRule] which reports diagnostics using multiple
-/// [DiagnosticCode]s).
-abstract class MultiAnalysisRule extends AbstractAnalysisRule {
-  MultiAnalysisRule({
-    required super.name,
-    required super.description,
-    super.state,
-  });
-
-  /// Reports [diagnosticCode] at [node] with message [arguments] and
-  /// [contextMessages].
-  void reportAtNode(
-    AstNode? node, {
-    List<Object> arguments = const [],
-    List<DiagnosticMessage>? contextMessages,
-    required DiagnosticCode diagnosticCode,
-  }) => _reportAtNode(
-    node,
-    diagnosticCode: diagnosticCode,
-    arguments: arguments,
-    contextMessages: contextMessages,
-  );
-
-  /// Reports [diagnosticCode] at [offset], with [length], with message [arguments]
-  /// and [contextMessages].
-  void reportAtOffset(
-    int offset,
-    int length, {
-    required DiagnosticCode diagnosticCode,
-    List<Object> arguments = const [],
-    List<DiagnosticMessage>? contextMessages,
-  }) => _reportAtOffset(
-    offset,
-    length,
-    diagnosticCode: diagnosticCode,
-    arguments: arguments,
-    contextMessages: contextMessages,
-  );
-
-  /// Reports [diagnosticCode] at Pubspec [node], with message [arguments] and
-  /// [contextMessages].
-  void reportAtPubNode(
-    PSNode node, {
-    required DiagnosticCode diagnosticCode,
-    List<Object> arguments = const [],
-    List<DiagnosticMessage> contextMessages = const [],
-  }) {
-    // Cache error and location info for creating `AnalysisErrorInfo`s.
-    var error = Diagnostic.tmp(
-      source: node.source,
-      offset: node.span.start.offset,
-      length: node.span.length,
-      errorCode: diagnosticCode,
-      arguments: arguments,
-      contextMessages: contextMessages,
-    );
-    _reporter.reportError(error);
-  }
-
-  /// Reports [diagnosticCode] at [token], with message [arguments] and
-  /// [contextMessages].
-  void reportAtToken(
-    Token token, {
-    required DiagnosticCode diagnosticCode,
-    List<Object> arguments = const [],
-    List<DiagnosticMessage>? contextMessages,
-  }) => _reportAtToken(
-    token,
-    diagnosticCode: diagnosticCode,
-    arguments: arguments,
-    contextMessages: contextMessages,
-  );
-}
-
 /// A [RuleContext] for a library, parsed into [ParsedUnitResult]s.
 ///
 /// This is available for analysis rules that can operate on parsed,
diff --git a/pkg/analyzer/lib/src/lint/linter_visitor.dart b/pkg/analyzer/lib/src/lint/linter_visitor.dart
index fb94c8f..4d55088 100644
--- a/pkg/analyzer/lib/src/lint/linter_visitor.dart
+++ b/pkg/analyzer/lib/src/lint/linter_visitor.dart
@@ -2,6 +2,7 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
+import 'package:analyzer/analysis_rule/rule_visitor_registry.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/exception/exception.dart';
 import 'package:analyzer/src/generated/engine.dart';
@@ -13,7 +14,7 @@
 
 /// The AST visitor that runs handlers for nodes from the [_registry].
 class AnalysisRuleVisitor implements AstVisitor<void> {
-  final RuleVisitorRegistry _registry;
+  final RuleVisitorRegistryImpl _registry;
 
   /// Whether exceptions should be propagated (by rethrowing them).
   final bool _shouldPropagateExceptions;
@@ -1144,8 +1145,7 @@
   }
 }
 
-/// The container to register visitors for separate AST node types.
-class RuleVisitorRegistry {
+class RuleVisitorRegistryImpl implements RuleVisitorRegistry {
   final bool _enableTiming;
   final List<_AfterLibrarySubscription> _afterLibrary = [];
   final List<_Subscription<AdjacentStrings>> _forAdjacentStrings = [];
@@ -1363,33 +1363,40 @@
   final List<_Subscription<WithClause>> _forWithClause = [];
   final List<_Subscription<YieldStatement>> _forYieldStatement = [];
 
-  RuleVisitorRegistry({required bool enableTiming})
+  RuleVisitorRegistryImpl({required bool enableTiming})
     : _enableTiming = enableTiming;
 
+  @override
   void addAdjacentStrings(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forAdjacentStrings.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addAnnotation(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forAnnotation.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addArgumentList(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forArgumentList.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addAsExpression(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forAsExpression.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addAssertInitializer(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forAssertInitializer.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addAssertStatement(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forAssertStatement.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addAssignedVariablePattern(
     AbstractAnalysisRule rule,
     AstVisitor visitor,
@@ -1399,96 +1406,119 @@
     );
   }
 
+  @override
   void addAssignmentExpression(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forAssignmentExpression.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addAugmentedExpression(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forAugmentedExpression.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addAugmentedInvocation(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forAugmentedInvocation.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addAwaitExpression(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forAwaitExpression.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addBinaryExpression(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forBinaryExpression.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addBlock(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forBlock.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addBlockFunctionBody(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forBlockFunctionBody.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addBooleanLiteral(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forBooleanLiteral.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addBreakStatement(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forBreakStatement.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addCascadeExpression(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forCascadeExpression.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addCaseClause(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forCaseClause.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addCastPattern(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forCastPattern.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addCatchClause(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forCatchClause.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addCatchClauseParameter(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forCatchClauseParameter.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addClassDeclaration(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forClassDeclaration.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addClassTypeAlias(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forClassTypeAlias.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addComment(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forComment.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addCommentReference(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forCommentReference.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addCompilationUnit(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forCompilationUnit.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addConditionalExpression(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forConditionalExpression.add(
       _Subscription(rule, visitor, _getTimer(rule)),
     );
   }
 
+  @override
   void addConfiguration(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forConfiguration.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addConstantPattern(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forConstantPattern.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addConstructorDeclaration(
     AbstractAnalysisRule rule,
     AstVisitor visitor,
@@ -1498,6 +1528,7 @@
     );
   }
 
+  @override
   void addConstructorFieldInitializer(
     AbstractAnalysisRule rule,
     AstVisitor visitor,
@@ -1507,26 +1538,32 @@
     );
   }
 
+  @override
   void addConstructorName(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forConstructorName.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addConstructorReference(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forConstructorReference.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addConstructorSelector(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forConstructorSelector.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addContinueStatement(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forContinueStatement.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addDeclaredIdentifier(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forDeclaredIdentifier.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addDeclaredVariablePattern(
     AbstractAnalysisRule rule,
     AstVisitor visitor,
@@ -1536,6 +1573,7 @@
     );
   }
 
+  @override
   void addDefaultFormalParameter(
     AbstractAnalysisRule rule,
     AstVisitor visitor,
@@ -1545,10 +1583,12 @@
     );
   }
 
+  @override
   void addDoStatement(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forDoStatement.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addDotShorthandConstructorInvocation(
     AnalysisRule rule,
     AstVisitor visitor,
@@ -1558,6 +1598,7 @@
     );
   }
 
+  @override
   void addDotShorthandInvocation(
     AbstractAnalysisRule rule,
     AstVisitor visitor,
@@ -1567,6 +1608,7 @@
     );
   }
 
+  @override
   void addDotShorthandPropertyAccess(
     AbstractAnalysisRule rule,
     AstVisitor visitor,
@@ -1576,28 +1618,34 @@
     );
   }
 
+  @override
   void addDottedName(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forDottedName.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addDoubleLiteral(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forDoubleLiteral.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addEmptyFunctionBody(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forEmptyFunctionBody.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addEmptyStatement(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forEmptyStatement.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addEnumConstantArguments(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forEnumConstantArguments.add(
       _Subscription(rule, visitor, _getTimer(rule)),
     );
   }
 
+  @override
   void addEnumConstantDeclaration(
     AbstractAnalysisRule rule,
     AstVisitor visitor,
@@ -1607,14 +1655,17 @@
     );
   }
 
+  @override
   void addEnumDeclaration(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forEnumDeclaration.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addExportDirective(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forExportDirective.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addExpressionFunctionBody(
     AbstractAnalysisRule rule,
     AstVisitor visitor,
@@ -1624,26 +1675,32 @@
     );
   }
 
+  @override
   void addExpressionStatement(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forExpressionStatement.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addExtendsClause(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forExtendsClause.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addExtensionDeclaration(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forExtensionDeclaration.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addExtensionOnClause(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forExtensionOnClause.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addExtensionOverride(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forExtensionOverride.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addExtensionTypeDeclaration(
     AbstractAnalysisRule rule,
     AstVisitor visitor,
@@ -1653,14 +1710,17 @@
     );
   }
 
+  @override
   void addFieldDeclaration(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forFieldDeclaration.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addFieldFormalParameter(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forFieldFormalParameter.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addForEachPartsWithDeclaration(
     AbstractAnalysisRule rule,
     AstVisitor visitor,
@@ -1670,6 +1730,7 @@
     );
   }
 
+  @override
   void addForEachPartsWithIdentifier(
     AbstractAnalysisRule rule,
     AstVisitor visitor,
@@ -1679,6 +1740,7 @@
     );
   }
 
+  @override
   void addForEachPartsWithPattern(
     AbstractAnalysisRule rule,
     AstVisitor visitor,
@@ -1688,14 +1750,17 @@
     );
   }
 
+  @override
   void addForElement(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forForElement.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addFormalParameterList(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forFormalParameterList.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addForPartsWithDeclarations(
     AbstractAnalysisRule rule,
     AstVisitor visitor,
@@ -1705,6 +1770,7 @@
     );
   }
 
+  @override
   void addForPartsWithExpression(
     AbstractAnalysisRule rule,
     AstVisitor visitor,
@@ -1714,18 +1780,22 @@
     );
   }
 
+  @override
   void addForPartsWithPattern(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forForPartsWithPattern.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addForStatement(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forForStatement.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addFunctionDeclaration(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forFunctionDeclaration.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addFunctionDeclarationStatement(
     AbstractAnalysisRule rule,
     AstVisitor visitor,
@@ -1735,10 +1805,12 @@
     );
   }
 
+  @override
   void addFunctionExpression(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forFunctionExpression.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addFunctionExpressionInvocation(
     AbstractAnalysisRule rule,
     AstVisitor visitor,
@@ -1748,14 +1820,17 @@
     );
   }
 
+  @override
   void addFunctionReference(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forFunctionReference.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addFunctionTypeAlias(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forFunctionTypeAlias.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addFunctionTypedFormalParameter(
     AbstractAnalysisRule rule,
     AstVisitor visitor,
@@ -1765,54 +1840,66 @@
     );
   }
 
+  @override
   void addGenericFunctionType(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forGenericFunctionType.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addGenericTypeAlias(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forGenericTypeAlias.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addGuardedPattern(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forGuardedPattern.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addHideCombinator(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forHideCombinator.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addIfElement(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forIfElement.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addIfStatement(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forIfStatement.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addImplementsClause(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forImplementsClause.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addImplicitCallReference(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forImplicitCallReference.add(
       _Subscription(rule, visitor, _getTimer(rule)),
     );
   }
 
+  @override
   void addImportDirective(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forImportDirective.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addImportPrefixReference(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forImportPrefixReference.add(
       _Subscription(rule, visitor, _getTimer(rule)),
     );
   }
 
+  @override
   void addIndexExpression(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forIndexExpression.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addInstanceCreationExpression(
     AbstractAnalysisRule rule,
     AstVisitor visitor,
@@ -1822,10 +1909,12 @@
     );
   }
 
+  @override
   void addIntegerLiteral(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forIntegerLiteral.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addInterpolationExpression(
     AbstractAnalysisRule rule,
     AstVisitor visitor,
@@ -1835,106 +1924,132 @@
     );
   }
 
+  @override
   void addInterpolationString(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forInterpolationString.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addIsExpression(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forIsExpression.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addLabel(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forLabel.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addLabeledStatement(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forLabeledStatement.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addLibraryDirective(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forLibraryDirective.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addLibraryIdentifier(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forLibraryIdentifier.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addListLiteral(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forListLiteral.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addListPattern(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forListPattern.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addLogicalAndPattern(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forLogicalAndPattern.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addLogicalOrPattern(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forLogicalOrPattern.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addMapLiteralEntry(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forMapLiteralEntry.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addMapPattern(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forMapPattern.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addMapPatternEntry(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forMapPatternEntry.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addMethodDeclaration(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forMethodDeclaration.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addMethodInvocation(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forMethodInvocation.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addMixinDeclaration(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forMixinDeclaration.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addMixinOnClause(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forMixinOnClause.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addNamedExpression(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forNamedExpression.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addNamedType(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forNamedType.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addNativeClause(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forNativeClause.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addNativeFunctionBody(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forNativeFunctionBody.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addNullAssertPattern(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forNullAssertPattern.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addNullCheckPattern(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forNullCheckPattern.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addNullLiteral(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forNullLiteral.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addObjectPattern(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forObjectPattern.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addParenthesizedExpression(
     AbstractAnalysisRule rule,
     AstVisitor visitor,
@@ -1944,30 +2059,37 @@
     );
   }
 
+  @override
   void addParenthesizedPattern(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forParenthesizedPattern.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addPartDirective(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forPartDirective.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addPartOfDirective(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forPartOfDirective.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addPatternAssignment(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forPatternAssignment.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addPatternField(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forPatternField.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addPatternFieldName(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forPatternFieldName.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addPatternVariableDeclaration(
     AbstractAnalysisRule rule,
     AstVisitor visitor,
@@ -1977,6 +2099,7 @@
     );
   }
 
+  @override
   void addPatternVariableDeclarationStatement(
     AnalysisRule rule,
     AstVisitor visitor,
@@ -1986,34 +2109,42 @@
     );
   }
 
+  @override
   void addPostfixExpression(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forPostfixExpression.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addPrefixedIdentifier(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forPrefixedIdentifier.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addPrefixExpression(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forPrefixExpression.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addPropertyAccess(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forPropertyAccess.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addRecordLiteral(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forRecordLiterals.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addRecordPattern(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forRecordPattern.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addRecordTypeAnnotation(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forRecordTypeAnnotation.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addRedirectingConstructorInvocation(
     AnalysisRule rule,
     AstVisitor visitor,
@@ -2023,10 +2154,12 @@
     );
   }
 
+  @override
   void addRelationalPattern(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forRelationalPattern.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addRepresentationConstructorName(
     AbstractAnalysisRule rule,
     AstVisitor visitor,
@@ -2036,6 +2169,7 @@
     );
   }
 
+  @override
   void addRepresentationDeclaration(
     AbstractAnalysisRule rule,
     AstVisitor visitor,
@@ -2045,52 +2179,64 @@
     );
   }
 
+  @override
   void addRestPatternElement(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forRestPatternElement.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addRethrowExpression(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forRethrowExpression.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addReturnStatement(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forReturnStatement.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addScriptTag(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forScriptTag.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addSetOrMapLiteral(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forSetOrMapLiteral.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addShowCombinator(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forShowCombinator.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addSimpleFormalParameter(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forSimpleFormalParameter.add(
       _Subscription(rule, visitor, _getTimer(rule)),
     );
   }
 
+  @override
   void addSimpleIdentifier(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forSimpleIdentifier.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addSimpleStringLiteral(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forSimpleStringLiteral.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addSpreadElement(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forSpreadElement.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addStringInterpolation(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forStringInterpolation.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addSuperConstructorInvocation(
     AbstractAnalysisRule rule,
     AstVisitor visitor,
@@ -2100,50 +2246,62 @@
     );
   }
 
+  @override
   void addSuperExpression(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forSuperExpression.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addSuperFormalParameter(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forSuperFormalParameter.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addSwitchCase(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forSwitchCase.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addSwitchDefault(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forSwitchDefault.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addSwitchExpression(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forSwitchExpression.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addSwitchExpressionCase(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forSwitchExpressionCase.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addSwitchPatternCase(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forSwitchPatternCase.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addSwitchStatement(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forSwitchStatement.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addSymbolLiteral(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forSymbolLiteral.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addThisExpression(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forThisExpression.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addThrowExpression(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forThrowExpression.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addTopLevelVariableDeclaration(
     AbstractAnalysisRule rule,
     AstVisitor visitor,
@@ -2153,30 +2311,37 @@
     );
   }
 
+  @override
   void addTryStatement(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forTryStatement.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addTypeArgumentList(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forTypeArgumentList.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addTypeLiteral(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forTypeLiteral.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addTypeParameter(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forTypeParameter.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addTypeParameterList(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forTypeParameterList.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addVariableDeclaration(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forVariableDeclaration.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addVariableDeclarationList(
     AbstractAnalysisRule rule,
     AstVisitor visitor,
@@ -2186,6 +2351,7 @@
     );
   }
 
+  @override
   void addVariableDeclarationStatement(
     AbstractAnalysisRule rule,
     AstVisitor visitor,
@@ -2195,26 +2361,32 @@
     );
   }
 
+  @override
   void addWhenClause(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forWhenClause.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addWhileStatement(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forWhileStatement.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addWildcardPattern(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forWildcardPattern.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addWithClause(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forWithClause.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void addYieldStatement(AbstractAnalysisRule rule, AstVisitor visitor) {
     _forYieldStatement.add(_Subscription(rule, visitor, _getTimer(rule)));
   }
 
+  @override
   void afterLibrary(AbstractAnalysisRule rule, void Function() callback) {
     _afterLibrary.add(
       _AfterLibrarySubscription(rule, callback, _getTimer(rule)),
diff --git a/pkg/analyzer/lib/src/lint/pub.dart b/pkg/analyzer/lib/src/lint/pub.dart
index a4f2905..e613cc1 100644
--- a/pkg/analyzer/lib/src/lint/pub.dart
+++ b/pkg/analyzer/lib/src/lint/pub.dart
@@ -2,8 +2,7 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-import 'dart:collection';
-
+import 'package:analyzer/analysis_rule/pubspec.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/file_system/physical_file_system.dart';
 import 'package:analyzer/source/file_source.dart';
@@ -11,12 +10,12 @@
 import 'package:source_span/source_span.dart';
 import 'package:yaml/yaml.dart';
 
-PSEntry? _findEntry(
+PubspecEntry? _findEntry(
   YamlMap map,
   String key,
   ResourceProvider? resourceProvider,
 ) {
-  PSEntry? entry;
+  PubspecEntry? entry;
   map.nodes.forEach((k, v) {
     if (k is YamlScalar && key == k.toString()) {
       entry = _processScalar(k, v, resourceProvider);
@@ -25,7 +24,7 @@
   return entry;
 }
 
-PSDependencyList? _processDependencies(
+PubspecDependencyList? _processDependencies(
   YamlScalar key,
   YamlNode value,
   ResourceProvider? resourceProvider,
@@ -34,14 +33,16 @@
     return null;
   }
 
-  _PSDependencyList deps = _PSDependencyList(_PSNode(key, resourceProvider));
+  _PubspecDependencyList deps = _PubspecDependencyList(
+    PubspecNodeImpl(key, resourceProvider),
+  );
   value.nodes.forEach((k, v) {
-    if (k is YamlScalar) deps.add(_PSDependency(k, v, resourceProvider));
+    if (k is YamlScalar) deps.add(_PubspecDependency(k, v, resourceProvider));
   });
   return deps;
 }
 
-PSEnvironment? _processEnvironment(
+PubspecEnvironment? _processEnvironment(
   YamlScalar key,
   YamlNode value,
   ResourceProvider? resourceProvider,
@@ -50,23 +51,23 @@
     return null;
   }
 
-  return _PSEnvironment(
-    _PSNode(key, resourceProvider),
+  return _PubspecEnvironment(
+    PubspecNodeImpl(key, resourceProvider),
     flutter: _findEntry(value, 'flutter', resourceProvider),
     sdk: _findEntry(value, 'sdk', resourceProvider),
   );
 }
 
-PSGitRepo? _processGitRepo(
+PubspecGitRepo? _processGitRepo(
   YamlScalar key,
   YamlNode value,
   ResourceProvider? resourceProvider,
 ) {
   if (value is YamlScalar) {
-    var token = _PSNode(key, resourceProvider);
-    return _PSGitRepo(
+    var token = PubspecNodeImpl(key, resourceProvider);
+    return _PubspecGitRepo(
       token,
-      url: PSEntry(token, _PSNode(value, resourceProvider)),
+      url: PubspecEntry(token, PubspecNodeImpl(value, resourceProvider)),
     );
   }
   if (value is! YamlMap) {
@@ -75,14 +76,14 @@
 
   // url: git://github.com/munificent/kittens.git
   // ref: some-branch
-  return _PSGitRepo(
-    _PSNode(key, resourceProvider),
+  return _PubspecGitRepo(
+    PubspecNodeImpl(key, resourceProvider),
     ref: _findEntry(value, 'ref', resourceProvider),
     url: _findEntry(value, 'url', resourceProvider),
   );
 }
 
-PSHost? _processHost(
+PubspecHost? _processHost(
   YamlScalar key,
   YamlNode value,
   ResourceProvider? resourceProvider,
@@ -92,8 +93,8 @@
     //   mypkg:
     //     hosted:  https://some-pub-server.com
     //     version: ^1.2.3
-    return _PSHost(
-      _PSNode(key, resourceProvider),
+    return _PubspecHost(
+      PubspecNodeImpl(key, resourceProvider),
       isShortForm: true,
       url: _processScalar(key, value, resourceProvider),
     );
@@ -101,8 +102,8 @@
   if (value is YamlMap) {
     // name: transmogrify
     // url: http://your-package-server.com
-    return _PSHost(
-      _PSNode(key, resourceProvider),
+    return _PubspecHost(
+      PubspecNodeImpl(key, resourceProvider),
       isShortForm: false,
       name: _findEntry(value, 'name', resourceProvider),
       url: _findEntry(value, 'url', resourceProvider),
@@ -111,7 +112,7 @@
   return null;
 }
 
-PSEntry? _processScalar(
+PubspecEntry? _processScalar(
   YamlScalar key,
   YamlNode value,
   ResourceProvider? resourceProvider,
@@ -120,13 +121,13 @@
     return null;
     //WARN?
   }
-  return PSEntry(
-    _PSNode(key, resourceProvider),
-    _PSNode(value, resourceProvider),
+  return PubspecEntry(
+    PubspecNodeImpl(key, resourceProvider),
+    PubspecNodeImpl(value, resourceProvider),
   );
 }
 
-PSNodeList? _processScalarList(
+PubspecNodeList? _processScalarList(
   YamlScalar key,
   YamlNode value,
   ResourceProvider? resourceProvider,
@@ -134,169 +135,14 @@
   if (value is! YamlList) {
     return null;
   }
-  return _PSNodeList(
-    _PSNode(key, resourceProvider),
+  return _PubspecNodeList(
+    PubspecNodeImpl(key, resourceProvider),
     value.nodes.whereType<YamlScalar>().map(
-      (n) => _PSNode(n, resourceProvider),
+      (n) => PubspecNodeImpl(n, resourceProvider),
     ),
   );
 }
 
-/// Representation of a key/value pair which maps a package name to a
-/// _package description_.
-///
-/// **Example** of a path-dependency:
-/// ```yaml
-/// dependencies:
-///   <name>:
-///     version: <version>
-///     path: <path>
-/// ```
-abstract class PSDependency {
-  PSGitRepo? get git;
-
-  PSHost? get host;
-
-  PSNode? get name;
-
-  PSEntry? get path;
-
-  PSEntry? get version;
-}
-
-/// Representation of the map from package name to _package description_ used
-/// under `dependencies`, `dev_dependencies` and `dependency_overrides`.
-abstract class PSDependencyList with IterableMixin<PSDependency> {}
-
-class PSEntry {
-  final PSNode? key;
-  final PSNode value;
-
-  PSEntry(this.key, this.value);
-
-  @override
-  String toString() => '${key != null ? '$key: ' : ''}$value';
-}
-
-/// Representation of an `environment` section in a pubspec file.
-///
-/// **Example** of an environment:
-/// ```yaml
-/// environment:
-///   sdk: '>=2.12.0 <4.0.0'
-///   flutter: ^3.3.10
-/// ```
-abstract class PSEnvironment {
-  PSEntry? get flutter;
-
-  PSEntry? get sdk;
-
-  PSNode get token;
-}
-
-/// Representation of git-dependency section in a pubspec file.
-///
-/// **Example** of a git-dependency:
-/// ```yaml
-/// dependencies:
-///   foo:
-///     git: # <-- this is the [token] property
-///       url: https://github.com/example/example
-///       ref: main # ref is optional
-/// ```
-///
-/// This may also be written in the form:
-/// ```yaml
-/// dependencies:
-///   foo:
-///     git:       https://github.com/example/example
-///     # ^-token  ^--url
-///     # In this case [ref] is `null`.
-/// ```
-abstract class PSGitRepo {
-  /// [PSEntry] for `ref: main` where [PSEntry.key] is `ref` and [PSEntry.value]
-  /// is `main`.
-  PSEntry? get ref;
-
-  /// The `'git'` from the `pubspec.yaml`, this is the key that indicates this
-  /// is a git-dependency.
-  PSNode get token;
-
-  /// [PSEntry] for `url: https://...` or `git: https://`, where [PSEntry.key]
-  /// is either `url` or `git`, and [PSEntry.key] is the URL.
-  ///
-  /// If the git-dependency is given in the form:
-  /// ```yaml
-  /// dependencies:
-  ///   foo:
-  ///     git:       https://github.com/example/example
-  /// ```
-  /// Then [token] and `url.key` will be the same object.
-  PSEntry? get url;
-}
-
-abstract class PSHost {
-  /// True, if _short-form_ for writing hosted-dependencies was used.
-  ///
-  /// **Example** of a hosted-dependency written in short-form:
-  /// ```yaml
-  /// dependencies:
-  ///   foo:
-  ///     hosted: https://some-pub-server.com
-  ///     version: ^1.2.3
-  /// ```
-  ///
-  /// The _long-form_ for writing the dependency given above is:
-  /// ```yaml
-  /// dependencies:
-  ///   foo:
-  ///     hosted:
-  ///       url: https://some-pub-server.com
-  ///       name: foo
-  ///     version: ^1.2.3
-  /// ```
-  ///
-  /// The short-form was added in Dart 2.15.0 because:
-  ///  * The `name` property just specifies the package name, which can be
-  ///    inferred from the context. So it is unnecessary to write it.
-  ///  * The nested object and `url` key becomes unnecessary when the `name`
-  ///    property is removed.
-  bool get isShortForm;
-
-  PSEntry? get name;
-
-  PSNode get token;
-
-  PSEntry? get url;
-}
-
-/// Representation of a leaf-node in a pubspec file.
-abstract class PSNode {
-  Source get source;
-
-  SourceSpan get span;
-
-  /// String value of the node, or `null` if value in the pubspec file is `null`
-  /// or omitted.
-  ///
-  /// **Example**
-  /// ```
-  /// name: foo
-  /// version:
-  /// ```
-  /// In the example above the [PSNode] for `foo` will have [text] "foo", and
-  /// the [PSNode] for `version` will have not have [text] as `null`, as empty
-  /// value or `"null"` is the same in YAML.
-  String? get text;
-}
-
-abstract class PSNodeList with IterableMixin<PSNode> {
-  @override
-  Iterator<PSNode> get iterator;
-
-  PSNode get token;
-}
-
 abstract class Pubspec {
   factory Pubspec.parse(
     String pubspec, {
@@ -318,240 +164,36 @@
     return _Pubspec.parse(yaml, resourceProvider: resourceProvider);
   }
 
-  PSEntry? get author;
+  PubspecEntry? get author;
 
-  PSNodeList? get authors;
+  PubspecNodeList? get authors;
 
-  PSDependencyList? get dependencies;
+  PubspecDependencyList? get dependencies;
 
-  PSDependencyList? get dependencyOverrides;
+  PubspecDependencyList? get dependencyOverrides;
 
-  PSEntry? get description;
+  PubspecEntry? get description;
 
-  PSDependencyList? get devDependencies;
+  PubspecDependencyList? get devDependencies;
 
-  PSEntry? get documentation;
+  PubspecEntry? get documentation;
 
-  PSEnvironment? get environment;
+  PubspecEnvironment? get environment;
 
-  PSEntry? get homepage;
+  PubspecEntry? get homepage;
 
-  PSEntry? get issueTracker;
+  PubspecEntry? get issueTracker;
 
-  PSEntry? get name;
+  PubspecEntry? get name;
 
-  PSEntry? get repository;
+  PubspecEntry? get repository;
 
-  PSEntry? get version;
+  PubspecEntry? get version;
 
   void accept(PubspecVisitor visitor);
 }
 
-abstract class PubspecVisitor<T> {
-  T? visitPackageAuthor(PSEntry author) => null;
-
-  T? visitPackageAuthors(PSNodeList authors) => null;
-
-  T? visitPackageDependencies(PSDependencyList dependencies) => null;
-
-  T? visitPackageDependency(PSDependency dependency) => null;
-
-  T? visitPackageDependencyOverride(PSDependency dependency) => null;
-
-  T? visitPackageDependencyOverrides(PSDependencyList dependencies) => null;
-
-  T? visitPackageDescription(PSEntry description) => null;
-
-  T? visitPackageDevDependencies(PSDependencyList dependencies) => null;
-
-  T? visitPackageDevDependency(PSDependency dependency) => null;
-
-  T? visitPackageDocumentation(PSEntry documentation) => null;
-
-  T? visitPackageEnvironment(PSEnvironment environment) => null;
-
-  T? visitPackageHomepage(PSEntry homepage) => null;
-
-  T? visitPackageIssueTracker(PSEntry issueTracker) => null;
-
-  T? visitPackageName(PSEntry name) => null;
-
-  T? visitPackageRepository(PSEntry repository) => null;
-
-  T? visitPackageVersion(PSEntry version) => null;
-}
-
-class _PSDependency extends PSDependency {
-  @override
-  final PSNode? name;
-
-  @override
-  final PSEntry? path;
-
-  @override
-  final PSEntry? version;
-
-  @override
-  final PSHost? host;
-
-  @override
-  final PSGitRepo? git;
-
-  factory _PSDependency(
-    YamlScalar key,
-    YamlNode value,
-    ResourceProvider? resourceProvider,
-  ) {
-    var name = _PSNode(key, resourceProvider);
-    PSEntry? path;
-    PSEntry? version;
-    PSHost? host;
-    PSGitRepo? git;
-
-    if (value is YamlScalar) {
-      // Simple version constraint.
-      version = PSEntry(null, _PSNode(value, resourceProvider));
-    } else if (value is YamlMap) {
-      value.nodes.forEach((k, v) {
-        if (k is! YamlScalar) {
-          return;
-        }
-        YamlScalar key = k;
-        switch (key.toString()) {
-          case 'path':
-            path = _processScalar(key, v, resourceProvider);
-          case 'version':
-            version = _processScalar(key, v, resourceProvider);
-          case 'hosted':
-            host = _processHost(key, v, resourceProvider);
-          case 'git':
-            git = _processGitRepo(key, v, resourceProvider);
-        }
-      });
-    }
-
-    return _PSDependency._(
-      name: name,
-      path: path,
-      version: version,
-      host: host,
-      git: git,
-    );
-  }
-
-  _PSDependency._({
-    required this.name,
-    required this.path,
-    required this.version,
-    required this.host,
-    required this.git,
-  });
-
-  @override
-  String toString() {
-    var sb = StringBuffer();
-    if (name != null) {
-      sb.write('$name:');
-    }
-    var versionInfo = '';
-    if (version != null) {
-      if (version!.key == null) {
-        versionInfo = ' $version';
-      } else {
-        versionInfo = '\n    $version';
-      }
-    }
-    sb.writeln(versionInfo);
-    if (host != null) {
-      sb.writeln(host);
-    }
-    if (git != null) {
-      sb.writeln(git);
-    }
-    return sb.toString();
-  }
-}
-
-class _PSDependencyList extends PSDependencyList {
-  final dependencies = <PSDependency>[];
-  final PSNode token;
-
-  _PSDependencyList(this.token);
-
-  @override
-  Iterator<PSDependency> get iterator => dependencies.iterator;
-
-  void add(PSDependency? dependency) {
-    if (dependency != null) {
-      dependencies.add(dependency);
-    }
-  }
-
-  @override
-  String toString() => '$token\n${dependencies.join('  ')}';
-}
-
-class _PSEnvironment implements PSEnvironment {
-  @override
-  final PSNode token;
-
-  @override
-  final PSEntry? flutter;
-
-  @override
-  final PSEntry? sdk;
-
-  _PSEnvironment(this.token, {required this.flutter, required this.sdk});
-
-  @override
-  String toString() => '''
-    $token:
-      $sdk
-      $flutter''';
-}
-
-class _PSGitRepo implements PSGitRepo {
-  @override
-  final PSNode token;
-
-  @override
-  final PSEntry? ref;
-
-  @override
-  final PSEntry? url;
-
-  _PSGitRepo(this.token, {this.ref, required this.url});
-
-  @override
-  String toString() => '''
-    $token:
-      $url
-      $ref''';
-}
-
-class _PSHost implements PSHost {
-  @override
-  final bool isShortForm;
-
-  @override
-  final PSEntry? name;
-
-  @override
-  final PSNode token;
-
-  @override
-  final PSEntry? url;
-
-  _PSHost(this.token, {required this.isShortForm, this.name, this.url});
-
-  @override
-  String toString() => '''
-    $token:
-      $name
-      $url''';
-}
-
-class _PSNode implements PSNode {
+class PubspecNodeImpl implements PubspecNode {
   @override
   final String? text;
 
@@ -560,12 +202,12 @@
 
   final ResourceProvider _resourceProvider;
 
-  _PSNode(YamlScalar node, ResourceProvider? resourceProvider)
+  PubspecNodeImpl(YamlScalar node, ResourceProvider? resourceProvider)
     : text = node.value?.toString(),
       span = node.span,
       _resourceProvider = resourceProvider ?? PhysicalResourceProvider.INSTANCE;
 
-  @override
+  /// The [Source] information of the pubspec file in which this node is located.
   Source get source {
     var uri = span.sourceUrl!;
     var filePath = _resourceProvider.pathContext.fromUri(uri);
@@ -577,81 +219,64 @@
   String toString() => '$text';
 }
 
-class _PSNodeList extends PSNodeList {
-  @override
-  final PSNode token;
-
-  final Iterable<PSNode> nodes;
-
-  _PSNodeList(this.token, this.nodes);
-
-  @override
-  Iterator<PSNode> get iterator => nodes.iterator;
-
-  @override
-  String toString() => '''
-$token:
-  - ${nodes.join('\n  - ')}''';
-}
-
 class _Pubspec implements Pubspec {
   @override
-  final PSEntry? author;
+  final PubspecEntry? author;
 
   @override
-  final PSNodeList? authors;
+  final PubspecNodeList? authors;
 
   @override
-  final PSEntry? description;
+  final PubspecEntry? description;
 
   @override
-  final PSEntry? documentation;
+  final PubspecEntry? documentation;
 
   @override
-  final PSEnvironment? environment;
+  final PubspecEnvironment? environment;
 
   @override
-  final PSEntry? homepage;
+  final PubspecEntry? homepage;
 
   @override
-  final PSEntry? issueTracker;
+  final PubspecEntry? issueTracker;
 
   @override
-  final PSEntry? name;
+  final PubspecEntry? name;
 
   @override
-  final PSEntry? repository;
+  final PubspecEntry? repository;
 
   @override
-  final PSEntry? version;
+  final PubspecEntry? version;
 
   @override
-  final PSDependencyList? dependencies;
+  final PubspecDependencyList? dependencies;
 
   @override
-  final PSDependencyList? devDependencies;
+  final PubspecDependencyList? devDependencies;
 
   @override
-  final PSDependencyList? dependencyOverrides;
+  final PubspecDependencyList? dependencyOverrides;
 
   factory _Pubspec.parse(YamlNode yaml, {ResourceProvider? resourceProvider}) {
     if (yaml is! YamlMap) {
       return _Pubspec._();
     }
 
-    PSEntry? author;
-    PSNodeList? authors;
-    PSEntry? description;
-    PSEntry? documentation;
-    PSEnvironment? environment;
-    PSEntry? homepage;
-    PSEntry? issueTracker;
-    PSEntry? name;
-    PSEntry? repository;
-    PSEntry? version;
-    PSDependencyList? dependencies;
-    PSDependencyList? devDependencies;
-    PSDependencyList? dependencyOverrides;
+    PubspecEntry? author;
+    PubspecNodeList? authors;
+    PubspecEntry? description;
+    PubspecEntry? documentation;
+    PubspecEnvironment? environment;
+    PubspecEntry? homepage;
+    PubspecEntry? issueTracker;
+    PubspecEntry? name;
+    PubspecEntry? repository;
+    PubspecEntry? version;
+    PubspecDependencyList? dependencies;
+    PubspecDependencyList? devDependencies;
+    PubspecDependencyList? dependencyOverrides;
 
     yaml.nodes.forEach((k, v) {
       if (k is! YamlScalar) {
@@ -785,6 +410,193 @@
   }
 }
 
+class _PubspecDependency extends PubspecDependency {
+  @override
+  final PubspecNode? name;
+
+  @override
+  final PubspecEntry? path;
+
+  @override
+  final PubspecEntry? version;
+
+  @override
+  final PubspecHost? host;
+
+  @override
+  final PubspecGitRepo? git;
+
+  factory _PubspecDependency(
+    YamlScalar key,
+    YamlNode value,
+    ResourceProvider? resourceProvider,
+  ) {
+    var name = PubspecNodeImpl(key, resourceProvider);
+    PubspecEntry? path;
+    PubspecEntry? version;
+    PubspecHost? host;
+    PubspecGitRepo? git;
+
+    if (value is YamlScalar) {
+      // Simple version constraint.
+      version = PubspecEntry(null, PubspecNodeImpl(value, resourceProvider));
+    } else if (value is YamlMap) {
+      value.nodes.forEach((k, v) {
+        if (k is! YamlScalar) {
+          return;
+        }
+        YamlScalar key = k;
+        switch (key.toString()) {
+          case 'path':
+            path = _processScalar(key, v, resourceProvider);
+          case 'version':
+            version = _processScalar(key, v, resourceProvider);
+          case 'hosted':
+            host = _processHost(key, v, resourceProvider);
+          case 'git':
+            git = _processGitRepo(key, v, resourceProvider);
+        }
+      });
+    }
+
+    return _PubspecDependency._(
+      name: name,
+      path: path,
+      version: version,
+      host: host,
+      git: git,
+    );
+  }
+
+  _PubspecDependency._({
+    required this.name,
+    required this.path,
+    required this.version,
+    required this.host,
+    required this.git,
+  });
+
+  @override
+  String toString() {
+    var sb = StringBuffer();
+    if (name != null) {
+      sb.write('$name:');
+    }
+    var versionInfo = '';
+    if (version != null) {
+      if (version!.key == null) {
+        versionInfo = ' $version';
+      } else {
+        versionInfo = '\n    $version';
+      }
+    }
+    sb.writeln(versionInfo);
+    if (host != null) {
+      sb.writeln(host);
+    }
+    if (git != null) {
+      sb.writeln(git);
+    }
+    return sb.toString();
+  }
+}
+
+class _PubspecDependencyList extends PubspecDependencyList {
+  final dependencies = <PubspecDependency>[];
+  final PubspecNode token;
+
+  _PubspecDependencyList(this.token);
+
+  @override
+  Iterator<PubspecDependency> get iterator => dependencies.iterator;
+
+  void add(PubspecDependency? dependency) {
+    if (dependency != null) {
+      dependencies.add(dependency);
+    }
+  }
+
+  @override
+  String toString() => '$token\n${dependencies.join('  ')}';
+}
+
+class _PubspecEnvironment implements PubspecEnvironment {
+  @override
+  final PubspecNode token;
+
+  @override
+  final PubspecEntry? flutter;
+
+  @override
+  final PubspecEntry? sdk;
+
+  _PubspecEnvironment(this.token, {required this.flutter, required this.sdk});
+
+  @override
+  String toString() => '''
+    $token:
+      $sdk
+      $flutter''';
+}
+
+class _PubspecGitRepo implements PubspecGitRepo {
+  @override
+  final PubspecNode token;
+
+  @override
+  final PubspecEntry? ref;
+
+  @override
+  final PubspecEntry? url;
+
+  _PubspecGitRepo(this.token, {this.ref, required this.url});
+
+  @override
+  String toString() => '''
+    $token:
+      $url
+      $ref''';
+}
+
+class _PubspecHost implements PubspecHost {
+  @override
+  final bool isShortForm;
+
+  @override
+  final PubspecEntry? name;
+
+  @override
+  final PubspecNode token;
+
+  @override
+  final PubspecEntry? url;
+
+  _PubspecHost(this.token, {required this.isShortForm, this.name, this.url});
+
+  @override
+  String toString() => '''
+    $token:
+      $name
+      $url''';
+}
+
+class _PubspecNodeList extends PubspecNodeList {
+  @override
+  final PubspecNode token;
+
+  final Iterable<PubspecNode> nodes;
+
+  _PubspecNodeList(this.token, this.nodes);
+
+  @override
+  Iterator<PubspecNode> get iterator => nodes.iterator;
+
+  @override
+  String toString() => '''
+$token:
+  - ${nodes.join('\n  - ')}''';
+}
+
 extension on StringBuffer {
   void maybeWrite(Object? value) {
     if (value != null) {
diff --git a/pkg/analyzer/lib/src/pubspec/pubspec_validator.dart b/pkg/analyzer/lib/src/pubspec/pubspec_validator.dart
index 52fcc96..333e964 100644
--- a/pkg/analyzer/lib/src/pubspec/pubspec_validator.dart
+++ b/pkg/analyzer/lib/src/pubspec/pubspec_validator.dart
@@ -2,6 +2,7 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
+import 'package:analyzer/analysis_rule/pubspec.dart';
 import 'package:analyzer/dart/analysis/analysis_options.dart';
 import 'package:analyzer/diagnostic/diagnostic.dart';
 import 'package:analyzer/error/error.dart';
diff --git a/pkg/analyzer/test/src/dart/analysis/driver_test.dart b/pkg/analyzer/test/src/dart/analysis/driver_test.dart
index 1b8bb5e..c07dd40 100644
--- a/pkg/analyzer/test/src/dart/analysis/driver_test.dart
+++ b/pkg/analyzer/test/src/dart/analysis/driver_test.dart
@@ -4,6 +4,7 @@
 
 import 'dart:async';
 
+import 'package:analyzer/analysis_rule/rule_visitor_registry.dart';
 import 'package:analyzer/dart/analysis/results.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/element.dart';
@@ -20,7 +21,6 @@
 import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer/src/fine/requirements.dart';
 import 'package:analyzer/src/lint/linter.dart';
-import 'package:analyzer/src/lint/linter_visitor.dart';
 import 'package:analyzer/src/test_utilities/lint_registration_mixin.dart';
 import 'package:analyzer/src/utilities/extensions/async.dart';
 import 'package:analyzer/utilities/package_config_file_builder.dart';
diff --git a/pkg/analyzer/test/src/diagnostics/unignorable_ignore_test.dart b/pkg/analyzer/test/src/diagnostics/unignorable_ignore_test.dart
index af67e7a..61ea50e 100644
--- a/pkg/analyzer/test/src/diagnostics/unignorable_ignore_test.dart
+++ b/pkg/analyzer/test/src/diagnostics/unignorable_ignore_test.dart
@@ -2,12 +2,12 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
+import 'package:analyzer/analysis_rule/rule_visitor_registry.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer/src/lint/linter.dart';
-import 'package:analyzer/src/lint/linter_visitor.dart';
 import 'package:analyzer/src/test_utilities/lint_registration_mixin.dart';
 import 'package:analyzer_testing/utilities/utilities.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
diff --git a/pkg/analyzer/test/src/lint/pub_test.dart b/pkg/analyzer/test/src/lint/pub_test.dart
index d70527b..15409a5 100644
--- a/pkg/analyzer/test/src/lint/pub_test.dart
+++ b/pkg/analyzer/test/src/lint/pub_test.dart
@@ -2,6 +2,7 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
+import 'package:analyzer/analysis_rule/pubspec.dart';
 import 'package:analyzer/src/lint/pub.dart';
 import 'package:source_span/source_span.dart';
 import 'package:test/test.dart';
@@ -100,11 +101,11 @@
       testValue('author', ps.author, equals('Dart Team <misc@dartlang.org>'));
 
       group('authors', () {
-        PSNodeList authors = ps.authors!;
+        PubspecNodeList authors = ps.authors!;
         test('contents', () {
           expect(authors, isNotNull);
-          expect(authors.any((PSNode n) => n.text == 'Bill'), isTrue);
-          expect(authors.any((PSNode n) => n.text == 'Ted'), isTrue);
+          expect(authors.any((PubspecNode n) => n.text == 'Bill'), isTrue);
+          expect(authors.any((PubspecNode n) => n.text == 'Ted'), isTrue);
         });
       });
 
@@ -121,7 +122,7 @@
       ]);
 
       group('environment', () {
-        PSEnvironment environment = ps.environment!;
+        PubspecEnvironment environment = ps.environment!;
         test('contents', () {
           expect(environment, isNotNull);
           expect(environment.sdk!.value.text, equals('>=2.12.0 <3.0.0'));
@@ -130,20 +131,20 @@
       });
 
       group('path', () {
-        PSDependency dep = findDependency(
+        PubspecDependency dep = findDependency(
           ps.dependencies,
           name: 'relative_path',
         );
-        PSEntry depPath = dep.path!;
+        PubspecEntry depPath = dep.path!;
         testValue('path', depPath, equals('../somewhere'));
       });
 
       group('hosted', () {
-        PSDependency dep = findDependency(
+        PubspecDependency dep = findDependency(
           ps.dependencies,
           name: 'transmogrify',
         );
-        PSHost host = dep.host!;
+        PubspecHost host = dep.host!;
         testValue('name', host.name, equals('transmogrify'));
         testValue('url', host.url, equals('http://your-package-server.com'));
         testKeySpan('name', host.name, startOffset: 293, endOffset: 297);
@@ -151,11 +152,11 @@
       });
 
       group('hosted (optional name)', () {
-        PSDependency dep = findDependency(
+        PubspecDependency dep = findDependency(
           ps.dependencies,
           name: 'transmogrify_optional_name',
         );
-        PSHost host = dep.host!;
+        PubspecHost host = dep.host!;
         test('name', () => expect(host.name, isNull));
         testValue('url', host.url, equals('http://your-package-server.com'));
         testKeySpan('url', host.url, startOffset: 432, endOffset: 435);
@@ -163,11 +164,11 @@
       });
 
       group('hosted (short-form)', () {
-        PSDependency dep = findDependency(
+        PubspecDependency dep = findDependency(
           ps.dependencies,
           name: 'transmogrify_short_form',
         );
-        PSHost host = dep.host!;
+        PubspecHost host = dep.host!;
         test('name', () => expect(host.name, isNull));
         testValue('url', host.url, equals('http://your-package-server.com'));
         testKeySpan('url', host.url, startOffset: 529, endOffset: 535);
@@ -175,8 +176,11 @@
       });
 
       group('git', () {
-        PSDependency dep = findDependency(ps.dependencies, name: 'kittens');
-        PSGitRepo git = dep.git!;
+        PubspecDependency dep = findDependency(
+          ps.dependencies,
+          name: 'kittens',
+        );
+        PubspecGitRepo git = dep.git!;
         testValue('ref', git.ref, equals('some-branch'));
         testValue(
           'url',
@@ -186,8 +190,11 @@
       });
 
       group('git (short form)', () {
-        PSDependency dep = findDependency(ps.devDependencies, name: 'kittens2');
-        PSGitRepo git = dep.git!;
+        PubspecDependency dep = findDependency(
+          ps.devDependencies,
+          name: 'kittens2',
+        );
+        PubspecGitRepo git = dep.git!;
         test('ref', () => expect(git.ref, isNull));
         testValue(
           'url',
@@ -235,18 +242,18 @@
   });
 }
 
-PSDependency findDependency(PSDependencyList? deps, {String? name}) =>
+PubspecDependency findDependency(PubspecDependencyList? deps, {String? name}) =>
     deps!.firstWhere((dep) => dep.name!.text == name);
 
 testDepListContains(
   String label,
-  PSDependencyList? list,
+  PubspecDependencyList? list,
   List<Map<String, String>> exp,
 ) {
   test(label, () {
     for (var entry in exp) {
       entry.forEach((k, v) {
-        PSDependency dep = findDependency(list, name: k);
+        PubspecDependency dep = findDependency(list, name: k);
         expect(dep, isNotNull);
         expect(dep.version!.value.text, equals(v));
       });
@@ -254,7 +261,12 @@
   });
 }
 
-testKeySpan(String label, PSEntry? node, {int? startOffset, int? endOffset}) {
+testKeySpan(
+  String label,
+  PubspecEntry? node, {
+  int? startOffset,
+  int? endOffset,
+}) {
   group(label, () {
     group('key', () {
       testSpan(node!.key!.span, startOffset: startOffset, endOffset: endOffset);
@@ -273,7 +285,7 @@
   });
 }
 
-testValue(String label, PSEntry? node, Matcher m) {
+testValue(String label, PubspecEntry? node, Matcher m) {
   group(label, () {
     test('value', () {
       expect(node!.value.text, m);
@@ -281,7 +293,12 @@
   });
 }
 
-testValueSpan(String label, PSEntry? node, {int? startOffset, int? endOffset}) {
+testValueSpan(
+  String label,
+  PubspecEntry? node, {
+  int? startOffset,
+  int? endOffset,
+}) {
   group(label, () {
     group('value', () {
       testSpan(
diff --git a/pkg/analyzer_testing/lib/analysis_rule/analysis_rule.dart b/pkg/analyzer_testing/lib/analysis_rule/analysis_rule.dart
index a6e91bb..0ffbfee 100644
--- a/pkg/analyzer_testing/lib/analysis_rule/analysis_rule.dart
+++ b/pkg/analyzer_testing/lib/analysis_rule/analysis_rule.dart
@@ -2,6 +2,7 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
+import 'package:analyzer/analysis_rule/pubspec.dart';
 import 'package:analyzer/diagnostic/diagnostic.dart';
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/error/listener.dart';
diff --git a/pkg/linter/lib/src/analyzer.dart b/pkg/linter/lib/src/analyzer.dart
index d88f288..ff78ee5 100644
--- a/pkg/linter/lib/src/analyzer.dart
+++ b/pkg/linter/lib/src/analyzer.dart
@@ -14,7 +14,6 @@
         LinterContext,
         MultiAnalysisRule,
         NodeLintRegistry;
-export 'package:analyzer/src/lint/pub.dart' show PSEntry, PubspecVisitor;
 export 'package:analyzer/src/workspace/pub.dart' show PubPackage;
 
 export 'lint_codes.dart';
diff --git a/pkg/linter/lib/src/rules/pub/package_names.dart b/pkg/linter/lib/src/rules/pub/package_names.dart
index 95b12b0..88eae2b 100644
--- a/pkg/linter/lib/src/rules/pub/package_names.dart
+++ b/pkg/linter/lib/src/rules/pub/package_names.dart
@@ -2,6 +2,7 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
+import 'package:analyzer/analysis_rule/pubspec.dart';
 import 'package:analyzer/error/error.dart';
 
 import '../../analyzer.dart';
@@ -25,7 +26,7 @@
   Visitor(this.rule);
 
   @override
-  void visitPackageName(PSEntry name) {
+  void visitPackageName(PubspecEntry name) {
     var packageName = name.value.text;
     if (packageName != null && !isValidPackageName(packageName)) {
       rule.reportAtPubNode(name.value, arguments: [packageName]);
diff --git a/pkg/linter/lib/src/rules/pub/secure_pubspec_urls.dart b/pkg/linter/lib/src/rules/pub/secure_pubspec_urls.dart
index ed2a4d5..5290e57 100644
--- a/pkg/linter/lib/src/rules/pub/secure_pubspec_urls.dart
+++ b/pkg/linter/lib/src/rules/pub/secure_pubspec_urls.dart
@@ -2,8 +2,8 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
+import 'package:analyzer/analysis_rule/pubspec.dart';
 import 'package:analyzer/error/error.dart';
-import 'package:analyzer/src/lint/pub.dart'; // ignore: implementation_imports
 
 import '../../analyzer.dart';
 
@@ -26,41 +26,41 @@
   Visitor(this.rule);
 
   @override
-  void visitPackageDependencies(PSDependencyList dependencies) {
+  void visitPackageDependencies(PubspecDependencyList dependencies) {
     _visitDeps(dependencies);
   }
 
   @override
-  void visitPackageDependencyOverrides(PSDependencyList dependencies) {
+  void visitPackageDependencyOverrides(PubspecDependencyList dependencies) {
     _visitDeps(dependencies);
   }
 
   @override
-  void visitPackageDevDependencies(PSDependencyList dependencies) {
+  void visitPackageDevDependencies(PubspecDependencyList dependencies) {
     _visitDeps(dependencies);
   }
 
   @override
-  void visitPackageDocumentation(PSEntry documentation) {
+  void visitPackageDocumentation(PubspecEntry documentation) {
     _checkUrl(documentation.value);
   }
 
   @override
-  void visitPackageHomepage(PSEntry homepage) {
+  void visitPackageHomepage(PubspecEntry homepage) {
     _checkUrl(homepage.value);
   }
 
   @override
-  void visitPackageIssueTracker(PSEntry issueTracker) {
+  void visitPackageIssueTracker(PubspecEntry issueTracker) {
     _checkUrl(issueTracker.value);
   }
 
   @override
-  void visitPackageRepository(PSEntry repository) {
+  void visitPackageRepository(PubspecEntry repository) {
     _checkUrl(repository.value);
   }
 
-  void _checkUrl(PSNode? node) {
+  void _checkUrl(PubspecNode? node) {
     if (node == null) return;
     var text = node.text;
     if (text != null) {
@@ -71,7 +71,7 @@
     }
   }
 
-  void _visitDeps(PSDependencyList dependencies) {
+  void _visitDeps(PubspecDependencyList dependencies) {
     for (var dep in dependencies) {
       _checkUrl(dep.git?.url?.value);
       _checkUrl(dep.host?.url?.value);
diff --git a/pkg/linter/lib/src/rules/pub/sort_pub_dependencies.dart b/pkg/linter/lib/src/rules/pub/sort_pub_dependencies.dart
index 2abab21..2ee0af2 100644
--- a/pkg/linter/lib/src/rules/pub/sort_pub_dependencies.dart
+++ b/pkg/linter/lib/src/rules/pub/sort_pub_dependencies.dart
@@ -2,8 +2,8 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
+import 'package:analyzer/analysis_rule/pubspec.dart';
 import 'package:analyzer/error/error.dart';
-import 'package:analyzer/src/lint/pub.dart'; // ignore: implementation_imports
 import 'package:source_span/source_span.dart';
 
 import '../../analyzer.dart';
@@ -27,21 +27,21 @@
   Visitor(this.rule);
 
   @override
-  void visitPackageDependencies(PSDependencyList dependencies) {
+  void visitPackageDependencies(PubspecDependencyList dependencies) {
     _visitDeps(dependencies);
   }
 
   @override
-  void visitPackageDependencyOverrides(PSDependencyList dependencies) {
+  void visitPackageDependencyOverrides(PubspecDependencyList dependencies) {
     _visitDeps(dependencies);
   }
 
   @override
-  void visitPackageDevDependencies(PSDependencyList dependencies) {
+  void visitPackageDevDependencies(PubspecDependencyList dependencies) {
     _visitDeps(dependencies);
   }
 
-  void _visitDeps(PSDependencyList dependencies) {
+  void _visitDeps(PubspecDependencyList dependencies) {
     int compare(SourceLocation? lc1, SourceLocation? lc2) {
       if (lc1 == null || lc2 == null) {
         return 0;