feat: add static code diagnostic avoid-initializing-in-on-mount

CHANGELOG.md

@@ -4,6 +4,7 @@
 
 * docs: remove old website
 * feat: add static code diagnostic [`correct-game-instantiating`](https://dcm.dev/docs/individuals/rules/flame/correct-game-instantiating).
+* feat: add static code diagnostic [`avoid-initializing-in-on-mount`](https://dcm.dev/docs/individuals/rules/flame/avoid-initializing-in-on-mount).
 
 ## 5.5.1
 

lib/src/analyzers/lint_analyzer/rules/models/flame_rule.dart

@@ -1,10 +1,9 @@
 import 'rule.dart';
 import 'rule_type.dart';
 
-/// Represents a base class for Flutter-specific rules.
+/// Represents a base class for Flame-specific rules.
+/// link: https://pub.dev/packages/flame
 abstract class FlameRule extends Rule {
-  static const link = 'https://pub.dev/packages/flame';
-
   const FlameRule({
     required super.id,
     required super.severity,

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

@@ -11,6 +11,7 @@ import 'rules_list/avoid_dynamic/avoid_dynamic_rule.dart';
 import 'rules_list/avoid_expanded_as_spacer/avoid_expanded_as_spacer_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_initializing_in_on_mount/avoid_initializing_in_on_mount_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';
@@ -88,6 +89,7 @@ final _implementedRules = <String, Rule Function(Map<String, Object>)>{
   AvoidDynamicRule.ruleId: AvoidDynamicRule.new,
   AvoidGlobalStateRule.ruleId: AvoidGlobalStateRule.new,
   AvoidIgnoringReturnValuesRule.ruleId: AvoidIgnoringReturnValuesRule.new,
+  AvoidInitializingInOnMountRule.ruleId: AvoidInitializingInOnMountRule.new,
   AvoidLateKeywordRule.ruleId: AvoidLateKeywordRule.new,
   AvoidMissingEnumConstantInMapRule.ruleId:
       AvoidMissingEnumConstantInMapRule.new,

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

@@ -37,10 +37,7 @@ class AvoidGlobalStateRule extends CommonRule {
     return visitor.declarations
         .map((declaration) => createIssue(
               rule: this,
-              location: nodeLocation(
-                node: declaration,
-                source: source,
-              ),
+              location: nodeLocation(node: declaration, source: source),
               message: _warning,
             ))
         .toList(growable: false);

lib/src/analyzers/lint_analyzer/rules/rules_list/avoid_initializing_in_on_mount/avoid_initializing_in_on_mount_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 'package:collection/collection.dart';
+
+import '../../../../../utils/flame_type_utils.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/flame_rule.dart';
+import '../../rule_utils.dart';
+
+part 'visitor.dart';
+
+class AvoidInitializingInOnMountRule extends FlameRule {
+  static const String ruleId = 'avoid-initializing-in-on-mount';
+
+  static const _warningMessage =
+      'Avoid initializing final late variables in onMount.';
+
+  AvoidInitializingInOnMountRule([Map<String, Object> config = const {}])
+      : super(
+          id: ruleId,
+          severity: readSeverity(config, Severity.warning),
+          excludes: readExcludes(config),
+          includes: readIncludes(config),
+        );
+
+  @override
+  Iterable<Issue> check(InternalResolvedUnitResult source) {
+    final visitor = _Visitor();
+
+    source.unit.visitChildren(visitor);
+
+    return visitor.expressions
+        .map((expression) => createIssue(
+              rule: this,
+              location: nodeLocation(node: expression, source: source),
+              message: _warningMessage,
+            ))
+        .toList(growable: false);
+  }
+}

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

@@ -0,0 +1,45 @@
+part of 'avoid_initializing_in_on_mount_rule.dart';
+
+class _Visitor extends SimpleAstVisitor<void> {
+  final _expressions = <AssignmentExpression>[];
+
+  Iterable<AssignmentExpression> get expressions => _expressions;
+
+  @override
+  void visitClassDeclaration(ClassDeclaration node) {
+    super.visitClassDeclaration(node);
+
+    final type = node.extendsClause?.superclass.type;
+    if (type == null || !isComponentOrSubclass(type)) {
+      return;
+    }
+
+    final onMountMethod = node.members.firstWhereOrNull((member) =>
+        member is MethodDeclaration &&
+        member.name.lexeme == 'onMount' &&
+        isOverride(member.metadata));
+
+    if (onMountMethod is MethodDeclaration) {
+      final visitor = _AssignmentExpressionVisitor();
+      onMountMethod.visitChildren(visitor);
+
+      _expressions.addAll(visitor.wrongAssignments);
+    }
+  }
+}
+
+class _AssignmentExpressionVisitor extends RecursiveAstVisitor<void> {
+  final wrongAssignments = <AssignmentExpression>{};
+
+  @override
+  void visitAssignmentExpression(AssignmentExpression node) {
+    super.visitAssignmentExpression(node);
+
+    final element = node.writeElement;
+    if (element is PropertyAccessorElement &&
+        element.variable.isFinal &&
+        element.variable.isLate) {
+      wrongAssignments.add(node);
+    }
+  }
+}

lib/src/utils/flame_type_utils.dart

@@ -0,0 +1,10 @@
+import 'package:analyzer/dart/element/type.dart';
+
+bool isComponentOrSubclass(DartType? type) =>
+    _isComponent(type) || _isSubclassOfComponent(type);
+
+bool _isComponent(DartType? type) =>
+    type?.getDisplayString(withNullability: false) == 'Component';
+
+bool _isSubclassOfComponent(DartType? type) =>
+    type is InterfaceType && type.allSupertypes.any(_isComponent);

test/src/analyzers/lint_analyzer/rules/rules_list/avoid_initializing_in_on_mount/avoid_initializing_in_on_mount_rule_test.dart

@@ -0,0 +1,37 @@
+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_initializing_in_on_mount/avoid_initializing_in_on_mount_rule.dart';
+import 'package:test/test.dart';
+
+import '../../../../../helpers/rule_test_helper.dart';
+
+const _examplePath = 'avoid_initializing_in_on_mount/examples/example.dart';
+
+void main() {
+  group('AvoidInitializingInOnMountRule', () {
+    test('initialization', () async {
+      final unit = await RuleTestHelper.resolveFromFile(_examplePath);
+      final issues = AvoidInitializingInOnMountRule().check(unit);
+
+      RuleTestHelper.verifyInitialization(
+        issues: issues,
+        ruleId: 'avoid-initializing-in-on-mount',
+        severity: Severity.warning,
+      );
+    });
+
+    test('reports about found issues', () async {
+      final unit = await RuleTestHelper.resolveFromFile(_examplePath);
+      final issues = AvoidInitializingInOnMountRule().check(unit);
+
+      RuleTestHelper.verifyIssues(
+        issues: issues,
+        startLines: [8],
+        startColumns: [5],
+        locationTexts: ['x = 1'],
+        messages: [
+          'Avoid initializing final late variables in onMount.',
+        ],
+      );
+    });
+  });
+}

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

@@ -0,0 +1,15 @@
+class MyComponent extends Component {
+  late final int x;
+
+  int y;
+
+  @override
+  void onMount() {
+    x = 1; // LINT
+    y = 2;
+  }
+}
+
+class Component {
+  void onMount() {}
+}