analyzer: Add an AnalysisRule alias for LintRule

Since the LintRule class is the basis for writing both "lint rules"
(rules that must be explicitly enabled) and "warning rules" (rules that
are enabled by default), it is a misnomer to use 'LintRule' as a
supertype. This change adds an alias, 'AnalysisRule'. Additionally:

* Rename LinterVisitor to AnalysisRuleVisitor.
* Rename lintRuleTimers to AnalysisRuleTimers.
* Rename LinterExceptionHandler to AnalysisRuleExceptionHandler.
* Rename LintRuleExceptionHandler to _AnalysisRuleExceptionHandler.

* NodeLintRegistry is used in too many places, so I have left it for
  now.

Change-Id: I43340cca0f9b64502960d8f5e05c6c9b81c3dfd9
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/392203
Reviewed-by: Phil Quitslund <[email protected]>
Commit-Queue: Samuel Rawlins <[email protected]>

Author: srawlins

pkg/analysis_server/lib/src/services/correction/bulk_fix_processor.dart

@@ -584,9 +584,9 @@ class BulkFixProcessor {
 
     // Run lints that handle specific node types.
     currentUnit.unit.accept(
-      LinterVisitor(
+      AnalysisRuleVisitor(
         nodeRegistry,
-        LinterExceptionHandler(
+        AnalysisRuleExceptionHandler(
           propagateExceptions: false,
         ).logException,
       ),

pkg/analysis_server_plugin/lib/registry.dart

@@ -10,8 +10,8 @@ abstract class PluginRegistry {
   void registerFixForRule(LintCode code, ProducerGenerator generator);
 
   /// Register this [rule] with the analyzer's rule registry.
-  void registerLintRule(LintRule rule);
+  void registerLintRule(AnalysisRule rule);
 
   /// Register this [rule] with the analyzer's rule registry.
-  void registerWarningRule(LintRule rule);
+  void registerWarningRule(AnalysisRule rule);
 }

pkg/analysis_server_plugin/lib/src/plugin_server.dart

@@ -26,7 +26,7 @@ import 'package:analyzer/src/dart/analysis/byte_store.dart';
 import 'package:analyzer/src/dart/analysis/file_content_cache.dart';
 import 'package:analyzer/src/dart/analysis/session.dart';
 import 'package:analyzer/src/dart/element/type_system.dart';
-import 'package:analyzer/src/lint/lint_rule_timers.dart';
+import 'package:analyzer/src/lint/analysis_rule_timers.dart';
 import 'package:analyzer/src/lint/linter.dart';
 import 'package:analyzer/src/lint/linter_visitor.dart';
 import 'package:analyzer/src/lint/registry.dart';
@@ -259,14 +259,14 @@ class PluginServer {
       var rules = Registry.ruleRegistry.enabled(configuration.ruleConfigs);
       for (var rule in rules) {
         rule.reporter = errorReporter;
-        var timer = enableTiming ? lintRuleTimers.getTimer(rule) : null;
+        var timer = enableTiming ? analysisRuleTimers.getTimer(rule) : null;
         timer?.start();
         rule.registerNodeProcessors(nodeRegistry, context);
         timer?.stop();
       }
     }
 
-    currentUnit.unit.accept(LinterVisitor(nodeRegistry));
+    currentUnit.unit.accept(AnalysisRuleVisitor(nodeRegistry));
     // The list of the `AnalysisError`s and their associated
     // `protocol.AnalysisError`s.
     var errorsAndProtocolErrors = [

pkg/analysis_server_plugin/lib/src/registry.dart

@@ -10,22 +10,22 @@ import 'package:analyzer/src/lint/registry.dart';
 
 final class PluginRegistryImpl implements PluginRegistry {
   /// Returns currently registered lint rules.
-  Iterable<LintRule> get registeredRules => Registry.ruleRegistry;
+  Iterable<AnalysisRule> get registeredRules => Registry.ruleRegistry;
 
   @override
   void registerFixForRule(LintCode code, ProducerGenerator generator) {
     registeredFixGenerators.registerFixForLint(code, generator);
   }
 
   @override
-  void registerLintRule(LintRule rule) {
+  void registerLintRule(AnalysisRule rule) {
     Registry.ruleRegistry.registerLintRule(rule);
   }
 
   @override
-  void registerWarningRule(LintRule rule) {
+  void registerWarningRule(AnalysisRule rule) {
     Registry.ruleRegistry.registerWarningRule(rule);
   }
 
-  LintRule? ruleNamed(String name) => Registry.ruleRegistry[name];
+  AnalysisRule? ruleNamed(String name) => Registry.ruleRegistry[name];
 }

pkg/analysis_server_plugin/test/src/lint_rules.dart

@@ -7,7 +7,7 @@ import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/src/lint/linter.dart';
 
-class NoBoolsRule extends LintRule {
+class NoBoolsRule extends AnalysisRule {
   static const LintCode code = LintCode('no_bools', 'No bools message');
 
   NoBoolsRule() : super(name: 'no_bools', description: 'No bools desc');
@@ -24,7 +24,7 @@ class NoBoolsRule extends LintRule {
 }
 
 class _NoBoolsVisitor extends SimpleAstVisitor<void> {
-  final LintRule rule;
+  final AnalysisRule rule;
 
   _NoBoolsVisitor(this.rule);
 

pkg/analysis_server_plugin/test/src/plugin_server_error_test.dart

@@ -205,7 +205,7 @@ class _ThrowsAsyncErrorFix extends ResolvedCorrectionProducer {
   }
 }
 
-class _ThrowsAsyncErrorRule extends LintRule {
+class _ThrowsAsyncErrorRule extends AnalysisRule {
   static const LintCode code = LintCode('no_bools', 'No bools message');
 
   _ThrowsAsyncErrorRule()
@@ -223,7 +223,7 @@ class _ThrowsAsyncErrorRule extends LintRule {
 }
 
 class _ThrowsAsyncErrorVisitor extends SimpleAstVisitor<void> {
-  final LintRule rule;
+  final AnalysisRule rule;
 
   _ThrowsAsyncErrorVisitor(this.rule);
 
@@ -253,7 +253,7 @@ class _ThrowsSyncErrorFix extends ResolvedCorrectionProducer {
   }
 }
 
-class _ThrowsSyncErrorRule extends LintRule {
+class _ThrowsSyncErrorRule extends AnalysisRule {
   static const LintCode code = LintCode('no_bools', 'No bools message');
 
   _ThrowsSyncErrorRule()
@@ -271,7 +271,7 @@ class _ThrowsSyncErrorRule extends LintRule {
 }
 
 class _ThrowsSyncErrorVisitor extends SimpleAstVisitor<void> {
-  final LintRule rule;
+  final AnalysisRule rule;
 
   _ThrowsSyncErrorVisitor(this.rule);
 

pkg/analyzer/lib/src/dart/analysis/library_analyzer.dart

@@ -46,7 +46,7 @@ import 'package:analyzer/src/generated/ffi_verifier.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/hint/sdk_constraint_verifier.dart';
 import 'package:analyzer/src/ignore_comments/ignore_info.dart';
-import 'package:analyzer/src/lint/lint_rule_timers.dart';
+import 'package:analyzer/src/lint/analysis_rule_timers.dart';
 import 'package:analyzer/src/lint/linter.dart';
 import 'package:analyzer/src/lint/linter_visitor.dart';
 import 'package:analyzer/src/util/performance/operation_performance.dart';
@@ -383,13 +383,13 @@ class LibraryAnalyzer {
     );
 
     for (var linter in _analysisOptions.lintRules) {
-      var timer = enableTiming ? lintRuleTimers.getTimer(linter) : null;
+      var timer = enableTiming ? analysisRuleTimers.getTimer(linter) : null;
       timer?.start();
       linter.registerNodeProcessors(nodeRegistry, context);
       timer?.stop();
     }
 
-    var logException = LinterExceptionHandler(
+    var logException = AnalysisRuleExceptionHandler(
       propagateExceptions: _analysisOptions.propagateLinterExceptions,
     ).logException;
 
@@ -408,13 +408,13 @@ class LibraryAnalyzer {
 
       // Run lint rules that handle specific node types.
       unit.accept(
-        LinterVisitor(nodeRegistry, logException),
+        AnalysisRuleVisitor(nodeRegistry, logException),
       );
     }
 
     // Now that all lint rules have visited the code in each of the compilation
     // units, we can accept each lint rule's `afterLibrary` hook.
-    LinterVisitor(nodeRegistry, logException).afterLibrary();
+    AnalysisRuleVisitor(nodeRegistry, logException).afterLibrary();
   }
 
   void _computeVerifyErrors(FileAnalysis fileAnalysis) {

pkg/analyzer/lib/src/dart/ast/utilities.dart

@@ -2,6 +2,10 @@
 // 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.
 
+/// @docImport 'package:analyzer/src/lint/linter.dart';
+/// @docImport 'package:analyzer/src/lint/linter_visitor.dart';
+library;
+
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/exception/exception.dart';
@@ -11,6 +15,44 @@ import 'package:analyzer/src/generated/engine.dart' show AnalysisEngine;
 
 export 'package:analyzer/src/dart/ast/constant_evaluator.dart';
 
+/// Class capable of handling exceptions generated during the execution of an
+/// analysis rule.
+final class AnalysisRuleExceptionHandler {
+  /// Indicates whether exceptions should be propagated to the caller (by
+  /// re-throwing them).
+  final bool propagateExceptions;
+
+  AnalysisRuleExceptionHandler({
+    required this.propagateExceptions,
+  });
+
+  /// A method that can be passed to the [AnalysisRuleVisitor] constructor to
+  /// handle exceptions that occur during the execution of an [AnalysisRule].
+  ///
+  /// Returns `true` if the exception was fully handled, and `false` if the
+  /// exception should be rethrown.
+  bool logException(
+      AstNode node, Object visitor, Object exception, StackTrace stackTrace) {
+    StringBuffer buffer = StringBuffer();
+    buffer.write('Exception while using a ${visitor.runtimeType} to visit a ');
+    AstNode? currentNode = node;
+    bool first = true;
+    while (currentNode != null) {
+      if (first) {
+        first = false;
+      } else {
+        buffer.write(' in ');
+      }
+      buffer.write(currentNode.runtimeType);
+      currentNode = currentNode.parent;
+    }
+    // TODO(39284): should this exception be silent?
+    AnalysisEngine.instance.instrumentationService.logException(
+        SilentException(buffer.toString(), exception, stackTrace));
+    return !propagateExceptions;
+  }
+}
+
 /// An AstVisitor that compares the structure of two AstNodes to see whether
 /// they are equal.
 class AstComparator implements AstVisitor<bool> {
@@ -1673,45 +1715,6 @@ class AstComparator implements AstVisitor<bool> {
   }
 }
 
-/// Class capable of handling exceptions generated during linting.
-///
-/// Clients may not extend, implement or mix-in this class.
-class LinterExceptionHandler {
-  /// Indicates whether linter exceptions should be propagated to the caller (by
-  /// re-throwing them)
-  final bool propagateExceptions;
-
-  LinterExceptionHandler({
-    required this.propagateExceptions,
-  });
-
-  /// A method that can be passed to the `LinterVisitor` constructor to handle
-  /// exceptions that occur during linting.
-  ///
-  /// Returns `true` if the exception was fully handled, and `false` if the
-  /// exception should be rethrown.
-  bool logException(
-      AstNode node, Object visitor, Object exception, StackTrace stackTrace) {
-    StringBuffer buffer = StringBuffer();
-    buffer.write('Exception while using a ${visitor.runtimeType} to visit a ');
-    AstNode? currentNode = node;
-    bool first = true;
-    while (currentNode != null) {
-      if (first) {
-        first = false;
-      } else {
-        buffer.write(' in ');
-      }
-      buffer.write(currentNode.runtimeType);
-      currentNode = currentNode.parent;
-    }
-    // TODO(39284): should this exception be silent?
-    AnalysisEngine.instance.instrumentationService.logException(
-        SilentException(buffer.toString(), exception, stackTrace));
-    return !propagateExceptions;
-  }
-}
-
 /// An object used to locate the [AstNode] associated with a source range, given
 /// the AST structure built from the source. More specifically, they will return
 /// the [AstNode] with the shortest length whose source range completely

pkg/analyzer/lib/src/lint/lint_rule_timers.dart renamed to pkg/analyzer/lib/src/lint/analysis_rule_timers.dart

@@ -4,16 +4,16 @@
 
 import 'package:analyzer/src/lint/linter.dart';
 
-/// Shared registry of lint rule timers.
-final lintRuleTimers = LintRuleTimers();
+/// Shared registry of analysis rule timers.
+final analysisRuleTimers = AnalysisRuleTimers();
 
-/// Manages lint timing.
-class LintRuleTimers {
-  /// Dictionary mapping lints (by name) to timers.
+/// Manages analysis rule timing.
+class AnalysisRuleTimers {
+  /// Dictionary mapping rules (by name) to timers.
   final Map<String, Stopwatch> timers = <String, Stopwatch>{};
 
-  /// Get a timer associated with the given lint rule (or create one if none
+  /// Get a timer associated with the given analysis rule (or create one if none
   /// exists).
-  Stopwatch getTimer(LintRule linter) =>
+  Stopwatch getTimer(AnalysisRule linter) =>
       timers.putIfAbsent(linter.name, () => Stopwatch());
 }

pkg/analyzer/lib/src/lint/linter.dart

@@ -36,6 +36,10 @@ export 'package:analyzer/src/lint/linter_visitor.dart' show NodeLintRegistry;
 export 'package:analyzer/src/lint/state.dart'
     show dart2_12, dart3, dart3_3, State;
 
+/// 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).
+typedef AnalysisRule = LintRule;
+
 /// The result of attempting to evaluate an expression as a constant.
 final class LinterConstantEvaluationResult {
   /// The value of the expression, or `null` if has [errors].