feat: add static code diagnostic prefer-correct-type-name. (#501)

* feat: add static code diagnostic `prefer-correct-type-name`.

* added test cases

* review suggestions changed

Author: Konoshenko Vlad

CHANGELOG.md

@@ -2,6 +2,7 @@
 
 ## Unreleased
 
+* feat: add static code diagnostic `prefer-correct-type-name`.
 * chore: deprecate documentation in Github repo.
 * chore: restrict `analyzer` version to `>=2.4.0 <2.7.0`.
 

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

@@ -23,6 +23,7 @@ import 'rules_list/no_object_declaration/no_object_declaration.dart';
 import 'rules_list/prefer_conditional_expressions/prefer_conditional_expressions.dart';
 import 'rules_list/prefer_const_border_radius/prefer_const_border_radius.dart';
 import 'rules_list/prefer_correct_identifier_length/prefer_correct_identifier_length.dart';
+import 'rules_list/prefer_correct_type_name/prefer_correct_type_name.dart';
 import 'rules_list/prefer_extracting_callbacks/prefer_extracting_callbacks.dart';
 import 'rules_list/prefer_first/prefer_first.dart';
 import 'rules_list/prefer_intl_name/prefer_intl_name.dart';
@@ -71,6 +72,7 @@ final _implementedRules = <String, Rule Function(Map<String, Object>)>{
       PreferConstBorderRadiusRule(config),
   PreferCorrectIdentifierLength.ruleId: (config) =>
       PreferCorrectIdentifierLength(config),
+  PreferCorrectTypeName.ruleId: (config) => PreferCorrectTypeName(config),
   PreferExtractingCallbacksRule.ruleId: (config) =>
       PreferExtractingCallbacksRule(config),
   PreferFirstRule.ruleId: (config) => PreferFirstRule(config),

lib/src/analyzers/lint_analyzer/rules/rules_list/prefer_correct_type_name/prefer_correct_type_name.dart

@@ -0,0 +1,57 @@
+import 'package:analyzer/dart/ast/ast.dart';
+
+import '../../../../../utils/node_utils.dart';
+import '../../../lint_utils.dart';
+import '../../../metrics/scope_visitor.dart';
+import '../../../models/internal_resolved_unit_result.dart';
+import '../../../models/issue.dart';
+import '../../../models/severity.dart';
+import '../../models/common_rule.dart';
+import '../../models/rule_documentation.dart';
+import '../../rule_utils.dart';
+
+part 'utils/config_parser.dart';
+
+part 'validator.dart';
+
+part 'visitor.dart';
+
+class PreferCorrectTypeName extends CommonRule {
+  static const String ruleId = 'prefer-correct-type-name';
+  final _Validator _validator;
+
+  PreferCorrectTypeName([Map<String, Object> config = const {}])
+      : _validator = _Validator(
+          _ConfigParser.readMaxIdentifierLength(config),
+          _ConfigParser.readMinIdentifierLength(config),
+          _ConfigParser.readExcludes(config),
+        ),
+        super(
+          id: ruleId,
+          documentation: const RuleDocumentation(
+            name: 'Prefer correct type name',
+            brief:
+                'Type name should only contain alphanumeric characters, start with an uppercase character and span between min-length and max-length characters in length.',
+          ),
+          severity: readSeverity(config, Severity.style),
+          excludes: readExcludes(config),
+        );
+
+  @override
+  Iterable<Issue> check(InternalResolvedUnitResult source) {
+    final visitor = _Visitor(_validator);
+
+    source.unit.visitChildren(visitor);
+
+    return visitor.nodes
+        .map(
+          (node) => createIssue(
+            rule: this,
+            location: nodeLocation(node: node, source: source),
+            message:
+                "The '$node' name should only contain alphanumeric characters, start with an uppercase character and span between ${_validator.minLength} and ${_validator.maxLength} characters in length",
+          ),
+        )
+        .toList(growable: false);
+  }
+}

lib/src/analyzers/lint_analyzer/rules/rules_list/prefer_correct_type_name/utils/config_parser.dart

@@ -0,0 +1,34 @@
+part of '../prefer_correct_type_name.dart';
+
+const _defaultMinIdentifierLength = 3;
+const _defaultMaxIdentifierLength = 40;
+const _defaultExclude = <String>[];
+
+const _minIdentifierLengthLabel = 'min-length';
+const _maxIdentifierLengthLabel = 'max-length';
+const _excludeLabel = 'excluded';
+
+/// Parser for rule configuration
+class _ConfigParser {
+  /// Read min identifier length from config
+  static int readMinIdentifierLength(Map<String, Object> config) =>
+      _parseIntConfig(config[_minIdentifierLengthLabel]) ??
+      _defaultMinIdentifierLength;
+
+  /// Read max identifier length from config
+  static int readMaxIdentifierLength(Map<String, Object> config) =>
+      _parseIntConfig(config[_maxIdentifierLengthLabel]) ??
+      _defaultMaxIdentifierLength;
+
+  /// Read excludes list from config
+  static Iterable<String> readExcludes(Map<String, Object> config) =>
+      _isIterableOfStrings(config[_excludeLabel])
+          ? (config[_excludeLabel] as Iterable).cast<String>()
+          : _defaultExclude;
+
+  static int? _parseIntConfig(Object? value) =>
+      value != null ? int.tryParse(value.toString()) : null;
+
+  static bool _isIterableOfStrings(Object? object) =>
+      object is Iterable<Object> && object.every((node) => node is String);
+}

lib/src/analyzers/lint_analyzer/rules/rules_list/prefer_correct_type_name/validator.dart

@@ -0,0 +1,23 @@
+part of 'prefer_correct_type_name.dart';
+
+class _Validator {
+  final int maxLength;
+  final int minLength;
+  final Iterable<String> exceptions;
+
+  _Validator(this.maxLength, this.minLength, this.exceptions);
+
+  bool isValid(String name) =>
+      exceptions.contains(name) ||
+      (isUpperCase(name) &&
+          withoutUnderscore(name).length >= minLength &&
+          withoutUnderscore(name).length <= maxLength);
+
+  bool isUpperCase(String name) {
+    final className = withoutUnderscore(name);
+    return className[0] == className[0].toUpperCase();
+  }
+
+  String withoutUnderscore(String name) =>
+      name.startsWith('_') ? name.replaceFirst('_', '') : name;
+}

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

@@ -0,0 +1,46 @@
+part of 'prefer_correct_type_name.dart';
+
+class _Visitor extends ScopeVisitor {
+  final _nodes = <SimpleIdentifier>[];
+  final _Validator validator;
+
+  _Visitor(this.validator);
+
+  Iterable<SimpleIdentifier> get nodes => _nodes;
+
+  @override
+  void visitEnumDeclaration(EnumDeclaration node) {
+    super.visitEnumDeclaration(node);
+
+    if (!validator.isValid(node.name.name)) {
+      _nodes.add(node.name);
+    }
+  }
+
+  @override
+  void visitExtensionDeclaration(ExtensionDeclaration node) {
+    super.visitExtensionDeclaration(node);
+
+    if (node.name != null && !validator.isValid(node.name!.name)) {
+      _nodes.add(node.name!);
+    }
+  }
+
+  @override
+  void visitMixinDeclaration(MixinDeclaration node) {
+    super.visitMixinDeclaration(node);
+
+    if (!validator.isValid(node.name.name)) {
+      _nodes.add(node.name);
+    }
+  }
+
+  @override
+  void visitClassDeclaration(ClassDeclaration node) {
+    super.visitClassDeclaration(node);
+
+    if (!validator.isValid(node.name.name)) {
+      _nodes.add(node.name);
+    }
+  }
+}

test/analyzers/lint_analyzer/rules/rules_list/prefer_correct_type_name/examples/class_example.dart

@@ -0,0 +1,40 @@
+// LINT Check regular class without uppercase
+class example {
+  example();
+}
+
+// LINT Private class without uppercase
+class _example {
+  _example();
+}
+
+// LINT Private class with short name
+class _ex {
+  _ex();
+}
+
+// LINT Class with short name
+class ex {
+  _ex();
+}
+
+// LINT Private class with long name
+class _ExampleWithLongName {
+  _ExampleWithLongName();
+}
+
+// LINT Class with long name
+class ExampleWithLongName {
+  ExampleWithLongName();
+}
+
+// Check private class with name contained in exclude config
+class _exampleExclude {
+  _exampleExclude();
+}
+
+// Check regular class without error
+class Example {}
+
+// Check private class without error
+class _Example {}

test/analyzers/lint_analyzer/rules/rules_list/prefer_correct_type_name/examples/enum_example.dart

@@ -0,0 +1,53 @@
+// LINT Check regular enum without uppercase
+enum example {
+  param1,
+  param2,
+}
+
+// LINT Private enum without uppercase
+enum _example {
+  param1,
+  param2,
+}
+
+// LINT Private enum with short name
+enum _ex {
+  param1,
+  param2,
+}
+
+// LINT Enum with short name
+enum ex {
+  param1,
+  param2,
+}
+
+// LINT Private enum with long name
+enum _ExampleWithLongName {
+  param1,
+  param2,
+}
+
+// LINT Enum with long name
+enum ExampleWithLongName {
+  param1,
+  param2,
+}
+
+// Check private enum with name contained in exclude config
+enum _exampleExclude {
+  param1,
+  param2,
+}
+
+// Check regular enum without error
+enum Example {
+  param1,
+  param2,
+}
+
+// Check private enum without error
+enum _Example {
+  param1,
+  param2,
+}

test/analyzers/lint_analyzer/rules/rules_list/prefer_correct_type_name/examples/extension_example.dart

@@ -0,0 +1,26 @@
+// LINT Check regular class without uppercase
+extension example on String {}
+
+// LINT Private extension without uppercase
+extension _example on String {}
+
+// LINT Private extension with short name
+extension _ex on String {}
+
+// LINT Extension with short name
+extension ex on String {}
+
+// LINT Private extension with long name
+extension _ExampleWithLongName on String {}
+
+// LINT extension with long name
+extension ExampleWithLongName on String {}
+
+// Check private extension with name contained in exclude config
+extension _exampleExclude on String {}
+
+// Check regular extension without error
+extension Example on String {}
+
+// Check private enum without error
+extension _Example on String {}

test/analyzers/lint_analyzer/rules/rules_list/prefer_correct_type_name/examples/mixin_example.dart

@@ -0,0 +1,26 @@
+// LINT Check regular mixin without uppercase
+mixin example {}
+
+// LINT Private mixin without uppercase
+mixin _example {}
+
+// LINT Private mixin with short name
+mixin _ex {}
+
+// LINT mixin with short name
+mixin ex {}
+
+// LINT Private mixin with long name
+mixin _ExampleWithLongName {}
+
+// LINT Mixin with long name
+mixin ExampleWithLongName {}
+
+// Check private mixin with name contained in exclude config
+mixin _exampleExclude {}
+
+// Check regular mixin without error
+mixin Example {}
+
+// Check private mixin without error
+mixin _Example {}