feat: add avoid missing enum constant in map rule (#564)

* feat: add avoid missing enum constant in map rule

* chore: add trailing comma

Author: incendial

CHANGELOG.md

@@ -2,7 +2,8 @@
 
 ## Unreleased
 
-* feat: add static code diagnostics `avoid-throw-in-catch-block`, `avoid-unnecessary-type-assertions`, `avoid-unnecessary-type-casts`
+* feat: add static code diagnostics `avoid-throw-in-catch-block`, `avoid-unnecessary-type-assertions`, `avoid-unnecessary-type-casts`,
+`avoid-missing-enum-constant-in-map`
 * feat: introduce file metrics
 * chore: activate self implemented rules: `avoid-unnecessary-type-assertions`, `avoid-unnecessary-type-casts`, `prefer-first`, `prefer-last`, `prefer-match-file-name`
 * refactor: cleanup anti-patterns, metrics and rules documentation

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

@@ -3,6 +3,7 @@ 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_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';
 import 'rules_list/avoid_nested_conditional_expressions/avoid_nested_conditional_expressions_rule.dart';
 import 'rules_list/avoid_non_null_assertion/avoid_non_null_assertion_rule.dart';
 import 'rules_list/avoid_preserve_whitespace_false/avoid_preserve_whitespace_false_rule.dart';
@@ -45,6 +46,8 @@ final _implementedRules = <String, Rule Function(Map<String, Object>)>{
   AvoidIgnoringReturnValuesRule.ruleId: (config) =>
       AvoidIgnoringReturnValuesRule(config),
   AvoidLateKeywordRule.ruleId: (config) => AvoidLateKeywordRule(config),
+  AvoidMissingEnumConstantInMapRule.ruleId: (config) =>
+      AvoidMissingEnumConstantInMapRule(config),
   AvoidNestedConditionalExpressionsRule.ruleId: (config) =>
       AvoidNestedConditionalExpressionsRule(config),
   AvoidNonNullAssertionRule.ruleId: (config) =>

lib/src/analyzers/lint_analyzer/rules/rules_list/avoid_missing_enum_constant_in_map/avoid_missing_enum_constant_in_map_rule.dart

@@ -0,0 +1,46 @@
+// 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 AvoidMissingEnumConstantInMapRule extends CommonRule {
+  static const String ruleId = 'avoid-missing-enum-constant-in-map';
+
+  static const _warning = 'Missing map entry for';
+
+  AvoidMissingEnumConstantInMapRule([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.parent,
+                source: source,
+              ),
+              message: '$_warning ${declaration.name}',
+            ))
+        .toList(growable: false);
+  }
+}

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

@@ -0,0 +1,51 @@
+part of 'avoid_missing_enum_constant_in_map_rule.dart';
+
+class _Visitor extends RecursiveAstVisitor<void> {
+  final _declarations = <_MapInfo>[];
+
+  Iterable<_MapInfo> get declarations => _declarations;
+
+  @override
+  void visitSetOrMapLiteral(SetOrMapLiteral node) {
+    super.visitSetOrMapLiteral(node);
+
+    if (!node.isMap) {
+      return;
+    }
+
+    final usages = <String>[];
+    ClassElement? enumElement;
+
+    for (final element in node.elements) {
+      if (element is MapLiteralEntry) {
+        final key = element.key;
+        if (key is PrefixedIdentifier) {
+          final staticElement = key.prefix.staticElement;
+          if (staticElement is ClassElement &&
+              staticElement.kind == ElementKind.ENUM) {
+            enumElement ??= staticElement;
+            usages.add(key.identifier.name);
+          }
+        }
+      }
+    }
+
+    final parent = node.parent;
+    final fields = enumElement?.fields;
+    if (fields != null && parent != null) {
+      for (final field in fields) {
+        final name = field.displayName;
+        if (field.isConst && !usages.contains(name) && name != 'values') {
+          _declarations.add(_MapInfo(name, parent));
+        }
+      }
+    }
+  }
+}
+
+class _MapInfo {
+  final AstNode parent;
+  final String name;
+
+  const _MapInfo(this.name, this.parent);
+}

test/src/analyzers/lint_analyzer/rules/rules_list/avoid_missing_enum_constant_in_map/avoid_missing_enum_constant_in_map_rule_test.dart

@@ -0,0 +1,53 @@
+@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_missing_enum_constant_in_map/avoid_missing_enum_constant_in_map_rule.dart';
+import 'package:test/test.dart';
+
+import '../../../../../helpers/rule_test_helper.dart';
+
+const _examplePath = 'avoid_missing_enum_constant_in_map/examples/example.dart';
+
+void main() {
+  group('AvoidMissingEnumConstantInMapRule', () {
+    test('initialization', () async {
+      final unit = await RuleTestHelper.resolveFromFile(_examplePath);
+      final issues = AvoidMissingEnumConstantInMapRule().check(unit);
+
+      RuleTestHelper.verifyInitialization(
+        issues: issues,
+        ruleId: 'avoid-missing-enum-constant-in-map',
+        severity: Severity.warning,
+      );
+    });
+
+    test('reports about found issues with the default config', () async {
+      final unit = await RuleTestHelper.resolveFromFile(_examplePath);
+      final issues = AvoidMissingEnumConstantInMapRule().check(unit);
+
+      RuleTestHelper.verifyIssues(
+        issues: issues,
+        startOffsets: [119, 241, 241],
+        startLines: [9, 15, 15],
+        startColumns: [16, 16, 16],
+        endOffsets: [213, 308, 308],
+        locationTexts: [
+          '_code = <CountyCode, String>{\n'
+              "    CountyCode.russia: 'RUS',\n"
+              "    CountyCode.another: 'XXX',\n"
+              '  }',
+          '_title = <CountyCode, String>{\n'
+              "    CountyCode.russia: 'Россия',\n"
+              '  }',
+          '_title = <CountyCode, String>{\n'
+              "    CountyCode.russia: 'Россия',\n"
+              '  }',
+        ],
+        messages: [
+          'Missing map entry for kazachstan',
+          'Missing map entry for kazachstan',
+          'Missing map entry for another',
+        ],
+      );
+    });
+  });
+}

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

@@ -0,0 +1,24 @@
+enum CountyCode {
+  russia,
+  kazachstan,
+  another,
+}
+
+extension CountyTypeX on CountyCode {
+  // LINT
+  static const _code = <CountyCode, String>{
+    CountyCode.russia: 'RUS',
+    CountyCode.another: 'XXX',
+  };
+
+  // LINT
+  static const _title = <CountyCode, String>{
+    CountyCode.russia: 'Россия',
+  };
+
+  static CountyCode? fromCode(String? code) => enumDecodeNullable(_code, code);
+
+  String get title => _title[this]!;
+
+  String get code => _code[this]!;
+}

website/docs/rules/common/avoid-missing-enum-constant-in-map.md

@@ -0,0 +1,62 @@
+# Avoid late keyword
+
+## Rule id {#rule-id}
+
+avoid-missing-enum-constant-in-map
+
+## Severity {#severity}
+
+Warning
+
+## Description {#description}
+
+Warns when a enum constant is missing in a map declaration.
+
+### Example {#example}
+
+Bad:
+
+```dart
+enum SomeEnum {
+  firstEntry,
+  secondEntry,
+  thirdEntry,
+}
+
+extension SomeX on SomeEnum {
+  // LINT
+  static const firstMap = <SomeEnum, String>{
+    CountyCode.firstEntry: 'foo',
+    CountyCode.secondEntry: 'bar',
+  };
+
+  // LINT twice since `secondEntry` and `thirdEntry` are missing
+  static const secondMap = <SomeEnum, String>{
+    CountyCode.firstEntry: 'foo',
+  };
+}
+```
+
+Good:
+
+```dart
+enum SomeEnum {
+  firstEntry,
+  secondEntry,
+  thirdEntry,
+}
+
+extension SomeX on SomeEnum {
+  static const firstMap = <SomeEnum, String>{
+    CountyCode.firstEntry: 'foo',
+    CountyCode.secondEntry: 'bar',
+    CountyCode.thirdEntry: 'baz',
+  };
+
+  static const secondMap = <SomeEnum, String>{
+    CountyCode.firstEntry: 'foo',
+    CountyCode.secondEntry: 'bar',
+    CountyCode.thirdEntry: 'baz',
+  };
+}
+```

website/docs/rules/overview.md

@@ -19,6 +19,10 @@ Rules configuration is [described here](../getting-started/configuration#configu
 
     Warns when a field or variable is declared with a `late` keyword.
 
+- [avoid-missing-enum-constant-in-map](./common/avoid-missing-enum-constant-in-map.md)
+
+    Warns when a enum constant is missing in a map declaration.
+
 - [avoid-nested-conditional-expressions](./common/avoid-nested-conditional-expressions.md)   [![Configurable](https://img.shields.io/badge/-configurable-informational)](./common/member-ordering.md#config-example)
 
     Warns about nested conditional expressions.