Merge branch 'master' into avoid-redundant-async-normal-completion

Author: incendial

CHANGELOG.md

@@ -3,10 +3,15 @@
 ## Unreleased
 
 * fix: partially handle normal completion function body for [`avoid-redundant-async`](https://dartcodemetrics.dev/docs/rules/common/avoid-redundant-async).
+* fix: ignore enum constant arguments for [`no-magic-number`](https://dartcodemetrics.dev/docs/rules/common/no-magic-number).
+* fix: correctly handle prefixed enums and static instance fields for [`prefer-moving-to-variable`](https://dartcodemetrics.dev/docs/rules/common/prefer-moving-to-variable).
 * feat: add static code diagnostic [`prefer-provide-intl-description`](https://dartcodemetrics.dev/docs/rules/intl/prefer-provide-intl-description).
 * feat: exclude `.freezed.dart` files by default.
 * fix: handle try and switch statements for [`use-setstate-synchronously`](https://dartcodemetrics.dev/docs/rules/flutter/use-setstate-synchronously)
 * chore: restrict `analyzer` version to `>=5.1.0 <5.4.0`.
+* fix: ignore method invocations in a variable declaration for [`prefer-moving-to-variable`](https://dartcodemetrics.dev/docs/rules/common/prefer-moving-to-variable).
+* feat: add `allow-initialized` option to [`avoid-late-keyword`](https://dartcodemetrics.dev/docs/rules/common/avoid-late-keyword).
+* feat: add `ignored-types` option to [`avoid-late-keyword`](https://dartcodemetrics.dev/docs/rules/common/avoid-late-keyword).
 
 ## 5.4.0
 

lib/src/analyzers/lint_analyzer/rules/rules_list/avoid_late_keyword/avoid_late_keyword_rule.dart

@@ -11,24 +11,39 @@ import '../../../models/severity.dart';
 import '../../models/common_rule.dart';
 import '../../rule_utils.dart';
 
+part 'config_parser.dart';
 part 'visitor.dart';
 
 class AvoidLateKeywordRule extends CommonRule {
   static const String ruleId = 'avoid-late-keyword';
 
   static const _warning = "Avoid using 'late' keyword.";
 
+  final bool _allowInitialized;
+  final Iterable<String> _ignoredTypes;
+
   AvoidLateKeywordRule([Map<String, Object> config = const {}])
-      : super(
+      : _allowInitialized = _ConfigParser.parseAllowInitialized(config),
+        _ignoredTypes = _ConfigParser.parseIgnoredTypes(config),
+        super(
           id: ruleId,
           severity: readSeverity(config, Severity.warning),
           excludes: readExcludes(config),
           includes: readIncludes(config),
         );
 
+  @override
+  Map<String, Object?> toJson() {
+    final json = super.toJson();
+    json[_ConfigParser._allowInitializedConfig] = _allowInitialized;
+    json[_ConfigParser._ignoredTypesConfig] = _ignoredTypes.toList();
+
+    return json;
+  }
+
   @override
   Iterable<Issue> check(InternalResolvedUnitResult source) {
-    final visitor = _Visitor();
+    final visitor = _Visitor(_allowInitialized, _ignoredTypes);
 
     source.unit.visitChildren(visitor);
 

lib/src/analyzers/lint_analyzer/rules/rules_list/avoid_late_keyword/config_parser.dart

@@ -0,0 +1,15 @@
+part of 'avoid_late_keyword_rule.dart';
+
+class _ConfigParser {
+  static const _allowInitializedConfig = 'allow-initialized';
+  static const _ignoredTypesConfig = 'ignored-types';
+
+  static bool parseAllowInitialized(Map<String, Object> config) =>
+      config[_allowInitializedConfig] as bool? ?? false;
+
+  static Iterable<String> parseIgnoredTypes(Map<String, Object> config) =>
+      config.containsKey(_ignoredTypesConfig) &&
+              config[_ignoredTypesConfig] is Iterable
+          ? List<String>.from(config[_ignoredTypesConfig] as Iterable)
+          : <String>['AnimationController'];
+}

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

@@ -1,18 +1,34 @@
 part of 'avoid_late_keyword_rule.dart';
 
 class _Visitor extends RecursiveAstVisitor<void> {
+  final bool allowInitialized;
+  final Iterable<String> ignoredTypes;
+
   final _declarations = <AstNode>[];
 
   Iterable<AstNode> get declarations => _declarations;
 
+  // ignore: avoid_positional_boolean_parameters
+  _Visitor(this.allowInitialized, this.ignoredTypes);
+
   @override
   void visitVariableDeclaration(VariableDeclaration node) {
     super.visitVariableDeclaration(node);
 
     if (node.isLate && node.parent != null) {
       final parent = node.parent;
 
-      _declarations.add(parent ?? node);
+      if (!_allowsInitialized(node) && !_hasIgnoredType(node)) {
+        _declarations.add(parent ?? node);
+      }
     }
   }
+
+  bool _allowsInitialized(VariableDeclaration node) =>
+      allowInitialized && node.initializer != null;
+
+  bool _hasIgnoredType(VariableDeclaration node) => ignoredTypes.contains(
+        // ignore: deprecated_member_use
+        node.declaredElement2?.type.getDisplayString(withNullability: false),
+      );
 }

lib/src/analyzers/lint_analyzer/rules/rules_list/no_magic_number/no_magic_number_rule.dart

@@ -53,6 +53,7 @@ class NoMagicNumberRule extends CommonRule {
         .where(_isNotInsideConstConstructor)
         .where(_isNotInDateTime)
         .where(_isNotInsideIndexExpression)
+        .where(_isNotInsideEnumConstantArguments)
         .map((lit) => createIssue(
               rule: this,
               location: nodeLocation(node: lit, source: source),
@@ -80,6 +81,14 @@ class NoMagicNumberRule extends CommonRule {
       ) ==
       null;
 
+  bool _isNotInsideEnumConstantArguments(Literal l) {
+    final node = l.thisOrAncestorMatching(
+      (ancestor) => ancestor is EnumConstantArguments,
+    );
+
+    return node == null;
+  }
+
   bool _isNotInsideCollectionLiteral(Literal l) => l.parent is! TypedLiteral;
 
   bool _isNotInsideConstMap(Literal l) {

lib/src/analyzers/lint_analyzer/rules/rules_list/prefer_moving_to_variable/prefer_moving_to_variable_rule.dart

@@ -2,6 +2,7 @@
 
 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';

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

@@ -40,10 +40,18 @@ class _BlockVisitor extends RecursiveAstVisitor<void> {
 
   @override
   void visitPropertyAccess(PropertyAccess node) {
-    if (node.target == null) {
+    final target = node.target;
+    if (target == null) {
       return;
     }
 
+    if (target is PrefixedIdentifier) {
+      final element = target.identifier.staticElement;
+      if (element is EnumElement || element is ClassElement) {
+        return;
+      }
+    }
+
     final hasDuplicates = _checkForDuplicates(node, node.target);
     if (!hasDuplicates) {
       super.visitPropertyAccess(node);
@@ -53,6 +61,7 @@ class _BlockVisitor extends RecursiveAstVisitor<void> {
   @override
   void visitMethodInvocation(MethodInvocation node) {
     if (node.parent is CascadeExpression ||
+        node.parent is VariableDeclaration ||
         (node.staticType?.isVoid ?? false)) {
       return;
     }

test/src/analyzers/lint_analyzer/rules/rules_list/avoid_late_keyword/avoid_late_keyword_rule_test.dart

@@ -29,7 +29,7 @@ void main() {
         startColumns: [3, 3, 5, 5, 1, 1],
         locationTexts: [
           "late final field = 'string'",
-          'late String uninitializedField',
+          'late int uninitializedField',
           "late final variable = 'string'",
           'late String uninitializedVariable',
           "late final topLevelVariable = 'string'",
@@ -45,5 +45,46 @@ void main() {
         ],
       );
     });
+
+    test('reports about found issues with allow initialized config', () async {
+      final unit = await RuleTestHelper.resolveFromFile(_examplePath);
+      final issues =
+          AvoidLateKeywordRule({'allow-initialized': true}).check(unit);
+
+      RuleTestHelper.verifyIssues(
+        issues: issues,
+        startLines: [8, 17, 23],
+        startColumns: [3, 5, 1],
+        locationTexts: [
+          'late int uninitializedField',
+          'late String uninitializedVariable',
+          'late String topLevelUninitializedVariable',
+        ],
+        messages: [
+          "Avoid using 'late' keyword.",
+          "Avoid using 'late' keyword.",
+          "Avoid using 'late' keyword.",
+        ],
+      );
+    });
+
+    test('reports about found issues with ignored types config', () async {
+      final unit = await RuleTestHelper.resolveFromFile(_examplePath);
+      final issues = AvoidLateKeywordRule({
+        'ignored-types': ['String'],
+      }).check(unit);
+
+      RuleTestHelper.verifyIssues(
+        issues: issues,
+        startLines: [8],
+        startColumns: [3],
+        locationTexts: [
+          'late int uninitializedField',
+        ],
+        messages: [
+          "Avoid using 'late' keyword.",
+        ],
+      );
+    });
   });
 }

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

@@ -5,7 +5,7 @@ class Test {
 
   String? nullableField;
 
-  late String uninitializedField; // LINT
+  late int uninitializedField; // LINT
 
   void method() {
     late final variable = 'string'; // LINT

test/src/analyzers/lint_analyzer/rules/rules_list/no_magic_number/examples/enum_example.dart

@@ -0,0 +1,17 @@
+enum ExampleMagicNumbers {
+  second(2),
+  third(3);
+
+  final int value;
+
+  const ExampleMagicNumbers(this.value);
+}
+
+enum ExampleNamedMagicNumbers {
+  second(value: 2),
+  third(value: 3);
+
+  final int value;
+
+  const ExampleNamedMagicNumbers({required this.value});
+}

test/src/analyzers/lint_analyzer/rules/rules_list/no_magic_number/no_magic_number_rule_test.dart

@@ -9,6 +9,7 @@ const _incorrectExamplePath = 'no_magic_number/examples/incorrect_example.dart';
 const _exceptionsExamplePath =
     'no_magic_number/examples/exceptions_example.dart';
 const _arrayExamplePath = 'no_magic_number/examples/array_example.dart';
+const _enumExamplePath = 'no_magic_number/examples/enum_example.dart';
 
 void main() {
   group('NoMagicNumberRule', () {
@@ -42,6 +43,13 @@ void main() {
       RuleTestHelper.verifyNoIssues(issues);
     });
 
+    test("doesn't report enum arguments", () async {
+      final unit = await RuleTestHelper.resolveFromFile(_enumExamplePath);
+      final issues = NoMagicNumberRule().check(unit);
+
+      RuleTestHelper.verifyNoIssues(issues);
+    });
+
     test("doesn't report exceptional code", () async {
       final unit = await RuleTestHelper.resolveFromFile(_exceptionsExamplePath);
       final issues = NoMagicNumberRule().check(unit);

test/src/analyzers/lint_analyzer/rules/rules_list/prefer_moving_to_variable/examples/assignment_example.dart

@@ -0,0 +1,8 @@
+void main() {
+  final var1 = someFunction();
+  final var2 = someFunction();
+}
+
+String someFunction() {
+  return 'qwe';
+}

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

@@ -56,3 +56,18 @@ class Theme {
 }
 
 String getValue() => 'hello';
+
+enum SomeValue {
+  firstValue,
+  secondValue,
+  entry1,
+  entry2,
+}
+
+class SomeClass {
+  static final value = '10';
+
+  final field = 11;
+}
+
+final instance = SomeClass();

test/src/analyzers/lint_analyzer/rules/rules_list/prefer_moving_to_variable/examples/generics_example.dart

@@ -12,3 +12,8 @@ class GetIt {
 
   T call<T extends Object>() => get<T>;
 }
+
+enum AnotherEnum {
+  firstValue,
+  anotherValue,
+}

test/src/analyzers/lint_analyzer/rules/rules_list/prefer_moving_to_variable/examples/prefix_example.dart

@@ -0,0 +1,19 @@
+import 'example.dart' as prefix;
+import 'generics_example.dart';
+
+void main() {
+  AnotherEnum.anotherValue;
+  AnotherEnum.anotherValue;
+  AnotherEnum.firstValue;
+
+  prefix.SomeValue.firstValue;
+  prefix.SomeValue.firstValue;
+  prefix.SomeValue.secondValue;
+
+  prefix.SomeClass.value;
+  prefix.SomeClass.value;
+  prefix.instance.field;
+
+  print(prefix.SomeValue.entry1);
+  print(prefix.SomeValue.entry2);
+}

test/src/analyzers/lint_analyzer/rules/rules_list/prefer_moving_to_variable/prefer_moving_to_variable_rule_test.dart

@@ -15,6 +15,10 @@ const _cascadeExamplePath =
     'prefer_moving_to_variable/examples/cascade_example.dart';
 const _genericsExamplePath =
     'prefer_moving_to_variable/examples/generics_example.dart';
+const _assignmentExamplePath =
+    'prefer_moving_to_variable/examples/assignment_example.dart';
+const _prefixExamplePath =
+    'prefer_moving_to_variable/examples/prefix_example.dart';
 
 void main() {
   group('PreferMovingToVariableRule', () {
@@ -215,13 +219,27 @@ void main() {
       RuleTestHelper.verifyNoIssues(issues);
     });
 
+    test('reports no issues for assignments', () async {
+      final unit = await RuleTestHelper.resolveFromFile(_assignmentExamplePath);
+      final issues = PreferMovingToVariableRule().check(unit);
+
+      RuleTestHelper.verifyNoIssues(issues);
+    });
+
     test('reports no issues for generics', () async {
       final unit = await RuleTestHelper.resolveFromFile(_genericsExamplePath);
       final issues = PreferMovingToVariableRule().check(unit);
 
       RuleTestHelper.verifyNoIssues(issues);
     });
 
+    test('reports no issues for prefix imports', () async {
+      final unit = await RuleTestHelper.resolveFromFile(_prefixExamplePath);
+      final issues = PreferMovingToVariableRule().check(unit);
+
+      RuleTestHelper.verifyNoIssues(issues);
+    });
+
     test('reports issues with custom config', () async {
       final unit = await RuleTestHelper.resolveFromFile(_examplePath);
       final config = {

website/docs/rules/common/avoid-late-keyword.mdx

@@ -12,6 +12,19 @@ Use this rule if you want to avoid unexpected runtime exceptions.
 
 :::
 
+Use `allow-initialized` configuration (default is `false`), if you want to allow initialized late variable declarations.
+
+### ⚙️ Config example {#config-example}
+
+```yaml
+dart_code_metrics:
+  ...
+  rules:
+    ...
+    - avoid-late-keyword:
+        allow-initialized: true
+```
+
 ### Example {#example}
 
 **❌ Bad:**

website/docs/rules/index.mdx

@@ -112,6 +112,7 @@ Rules are grouped by category to help you understand their purpose. Each rule ha
   type="common"
   severity="warning"
   version="3.2.0"
+  hasConfig
 >
   Warns when a field or variable is declared with a <code>late</code> keyword.
 </RuleEntry>