feat: add static code diagnostics avoid-global-state. (#624)

Author: Konoshenko Vlad

CHANGELOG.md

@@ -2,6 +2,7 @@
 
 ## Unreleased
 
+* feat: add static code diagnostics `avoid-global-state`.
 * chore: migrate from deprecated api
 * fix: fixed issue with type check in prefer-match-file-name
 * doc: add flutter favorite badge

analysis_options.yaml

@@ -47,6 +47,7 @@ dart_code_metrics:
     - avoid-unused-parameters
     - avoid-unnecessary-type-assertions
     - avoid-unnecessary-type-casts
+    - avoid-global-state
     - binary-expression-operand-order
     - double-literal-format
     - newline-before-return

lib/src/analyzers/lint_analyzer/rules/rules_factory.dart

@@ -1,6 +1,7 @@
 import 'models/rule.dart';
 import 'rules_list/always_remove_listener/always_remove_listener_rule.dart';
 import 'rules_list/avoid-unnecessary-type-casts/avoid_unnecessary_type_casts_rule.dart';
+import 'rules_list/avoid_global_state/avoid_global_state_rule.dart';
 import 'rules_list/avoid_ignoring_return_values/avoid_ignoring_return_values_rule.dart';
 import 'rules_list/avoid_late_keyword/avoid_late_keyword_rule.dart';
 import 'rules_list/avoid_missing_enum_constant_in_map/avoid_missing_enum_constant_in_map_rule.dart';
@@ -43,6 +44,7 @@ final _implementedRules = <String, Rule Function(Map<String, Object>)>{
   AlwaysRemoveListenerRule.ruleId: (config) => AlwaysRemoveListenerRule(config),
   AvoidUnnecessaryTypeCastsRule.ruleId: (config) =>
       AvoidUnnecessaryTypeCastsRule(config),
+  AvoidGlobalStateRule.ruleId: (config) => AvoidGlobalStateRule(config),
   AvoidIgnoringReturnValuesRule.ruleId: (config) =>
       AvoidIgnoringReturnValuesRule(config),
   AvoidLateKeywordRule.ruleId: (config) => AvoidLateKeywordRule(config),

lib/src/analyzers/lint_analyzer/rules/rules_list/avoid_global_state/avoid_global_state_rule.dart

@@ -0,0 +1,47 @@
+// ignore_for_file: public_member_api_docs
+
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/visitor.dart';
+import 'package:analyzer/dart/element/element.dart';
+
+import '../../../../../utils/node_utils.dart';
+import '../../../lint_utils.dart';
+import '../../../models/internal_resolved_unit_result.dart';
+import '../../../models/issue.dart';
+import '../../../models/severity.dart';
+import '../../models/common_rule.dart';
+import '../../rule_utils.dart';
+
+part 'visitor.dart';
+
+class AvoidGlobalStateRule extends CommonRule {
+  static const String ruleId = 'avoid-global-state';
+
+  static const _warning =
+      'Avoid using global variable without const or final keywords.';
+
+  AvoidGlobalStateRule([Map<String, Object> config = const {}])
+      : super(
+          id: ruleId,
+          severity: readSeverity(config, Severity.warning),
+          excludes: readExcludes(config),
+        );
+
+  @override
+  Iterable<Issue> check(InternalResolvedUnitResult source) {
+    final visitor = _Visitor();
+
+    source.unit.visitChildren(visitor);
+
+    return visitor.declarations
+        .map((declaration) => createIssue(
+              rule: this,
+              location: nodeLocation(
+                node: declaration,
+                source: source,
+              ),
+              message: _warning,
+            ))
+        .toList(growable: false);
+  }
+}

lib/src/analyzers/lint_analyzer/rules/rules_list/avoid_global_state/visitor.dart

@@ -0,0 +1,18 @@
+part of 'avoid_global_state_rule.dart';
+
+class _Visitor extends RecursiveAstVisitor<void> {
+  final _declarations = <AstNode>[];
+
+  Iterable<AstNode> get declarations => _declarations;
+
+  @override
+  void visitVariableDeclaration(VariableDeclaration node) {
+    super.visitVariableDeclaration(node);
+
+    if (!node.isFinal &&
+        !node.isConst &&
+        node.declaredElement?.enclosingElement is CompilationUnitElement) {
+      _declarations.add(node);
+    }
+  }
+}

test/src/analyzers/lint_analyzer/rules/rules_list/avoid_global_state/avoid_global_state_rule_test.dart

@@ -0,0 +1,44 @@
+@TestOn('vm')
+import 'package:dart_code_metrics/src/analyzers/lint_analyzer/models/severity.dart';
+import 'package:dart_code_metrics/src/analyzers/lint_analyzer/rules/rules_list/avoid_global_state/avoid_global_state_rule.dart';
+import 'package:test/test.dart';
+
+import '../../../../../helpers/rule_test_helper.dart';
+
+const _examplePath = 'avoid_global_state/examples/example.dart';
+
+void main() {
+  group('AvoidGlobalStateRule', () {
+    test('initialization', () async {
+      final unit = await RuleTestHelper.resolveFromFile(_examplePath);
+      final issues = AvoidGlobalStateRule().check(unit);
+
+      RuleTestHelper.verifyInitialization(
+        issues: issues,
+        ruleId: 'avoid-global-state',
+        severity: Severity.warning,
+      );
+    });
+
+    test('reports about found issues', () async {
+      final unit = await RuleTestHelper.resolveFromFile(_examplePath);
+      final issues = AvoidGlobalStateRule().check(unit);
+
+      RuleTestHelper.verifyIssues(
+        issues: issues,
+        startOffsets: [4, 29],
+        startLines: [1, 2],
+        startColumns: [5, 5],
+        endOffsets: [15, 87],
+        locationTexts: [
+          'answer = 42',
+          'evenNumbers = [1, 2, 3].where((element) => element.isEven)',
+        ],
+        messages: [
+          'Avoid using global variable without const or final keywords.',
+          'Avoid using global variable without const or final keywords.',
+        ],
+      );
+    });
+  });
+}

test/src/analyzers/lint_analyzer/rules/rules_list/avoid_global_state/examples/example.dart

@@ -0,0 +1,14 @@
+var answer = 42; // LINT
+var evenNumbers = [1, 2, 3].where((element) => element.isEven); // LINT
+const a = 1;
+final b = 1;
+
+void function() {}
+
+class Foo {
+  static int? a;
+  final int? b;
+  dynamic c;
+  const d = 1;
+  void function() {}
+}

website/docs/rules/common/avoid-global-state.md

@@ -0,0 +1,44 @@
+# Avoid global state
+
+## Rule id {#rule-id}
+
+avoid-global-state
+
+## Severity {#severity}
+
+Warning
+
+## Description {#description}
+
+The rule should violate on not final and non-const top-level variables.
+
+Having many mutable global variables inside application is a pretty bad practice:
+- application state becomes distributed between multiple files
+- application state is not protected: it can be modified in almost any place
+- it might be hard to debug such applications
+
+So the common practice is to use state management solutions instead of mutable global variables.
+
+### Example {#example}
+
+Bad:
+
+```dart
+var answer = 42; // LINT
+var evenNumbers = [1, 2, 3].where((element) => element.isEven); // LINT
+
+class Foo {
+  static int? bar; // LINT
+}
+```
+
+Good:
+
+```dart
+const answer = 42;
+final evenNumbers = [1, 2, 3].where((element) => element.isEven);
+
+class Foo {
+  static int bar = 42;
+}
+```