feat: add avoid-unrelated-type-assertions rule (#604)

* feat: add avoid-unrelated-type-assertions rule

* chore: fix rule name in the docs

* refactor: remove offsets checking from tests (#605)

* fix: update edge cases checks

* chore: cleanup

* fix: fix generics edge case

* fix: add support for new cases

* fix: add support for new cases

* test: add test case

* test: add test case

* test: add additional test cases

Co-authored-by: Dmitry Krutskikh <dmitry.krutskikh@gmail.com>

Author: incendial

CHANGELOG.md

@@ -1,6 +1,5 @@
 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';
@@ -12,6 +11,8 @@ import 'rules_list/avoid_returning_widgets/avoid_returning_widgets_rule.dart';
 import 'rules_list/avoid_throw_in_catch_block/avoid_throw_in_catch_block_rule.dart';
 import 'rules_list/avoid_unnecessary_setstate/avoid_unnecessary_setstate_rule.dart';
 import 'rules_list/avoid_unnecessary_type_assertions/avoid_unnecessary_type_assertions_rule.dart';
+import 'rules_list/avoid_unnecessary_type_casts/avoid_unnecessary_type_casts_rule.dart';
+import 'rules_list/avoid_unrelated_type_assertions/avoid_unrelated_type_assertions_rule.dart';
 import 'rules_list/avoid_unused_parameters/avoid_unused_parameters_rule.dart';
 import 'rules_list/avoid_wrapping_in_padding/avoid_wrapping_in_padding_rule.dart';
 import 'rules_list/binary_expression_operand_order/binary_expression_operand_order_rule.dart';
@@ -42,8 +43,6 @@ import 'rules_list/provide_correct_intl_args/provide_correct_intl_args_rule.dart
 
 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),
@@ -64,6 +63,10 @@ final _implementedRules = <String, Rule Function(Map<String, Object>)>{
       AvoidUnnecessarySetStateRule(config),
   AvoidUnnecessaryTypeAssertionsRule.ruleId: (config) =>
       AvoidUnnecessaryTypeAssertionsRule(config),
+  AvoidUnnecessaryTypeCastsRule.ruleId: (config) =>
+      AvoidUnnecessaryTypeCastsRule(config),
+  AvoidUnrelatedTypeAssertionsRule.ruleId: (config) =>
+      AvoidUnnecessaryTypeAssertionsRule(config),
   AvoidUnusedParametersRule.ruleId: (config) =>
       AvoidUnusedParametersRule(config),
   AvoidWrappingInPaddingRule.ruleId: (config) =>

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

@@ -21,7 +21,7 @@ class AvoidUnnecessaryTypeAssertionsRule extends CommonRule {
   AvoidUnnecessaryTypeAssertionsRule([Map<String, Object> config = const {}])
       : super(
           id: ruleId,
-          severity: readSeverity(config, Severity.style),
+          severity: readSeverity(config, Severity.warning),
           excludes: readExcludes(config),
         );
 

lib/src/analyzers/lint_analyzer/rules/rules_list/avoid_unnecessary_type_assertions/avoid_unnecessary_type_assertions_rule.dart

@@ -20,7 +20,7 @@ class AvoidUnnecessaryTypeCastsRule extends CommonRule {
   AvoidUnnecessaryTypeCastsRule([Map<String, Object> config = const {}])
       : super(
           id: ruleId,
-          severity: readSeverity(config, Severity.style),
+          severity: readSeverity(config, Severity.warning),
           excludes: readExcludes(config),
         );
 

lib/src/analyzers/lint_analyzer/rules/rules_list/avoid-unnecessary-type-casts/avoid_unnecessary_type_casts_rule.dart renamed to lib/src/analyzers/lint_analyzer/rules/rules_list/avoid_unnecessary_type_casts/avoid_unnecessary_type_casts_rule.dart

@@ -0,0 +1,44 @@
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/visitor.dart';
+import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/dart/element/type.dart';
+import 'package:collection/collection.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 AvoidUnrelatedTypeAssertionsRule extends CommonRule {
+  static const String ruleId = 'avoid-unrelated-type-assertions';
+
+  AvoidUnrelatedTypeAssertionsRule([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.expressions.entries
+        .map(
+          (node) => createIssue(
+            rule: this,
+            location: nodeLocation(node: node.key, source: source),
+            message:
+                'Avoid unrelated "is" assertion. The result is always "false".',
+          ),
+        )
+        .toList(growable: false);
+  }
+}

lib/src/analyzers/lint_analyzer/rules/rules_list/avoid-unnecessary-type-casts/visitor.dart renamed to lib/src/analyzers/lint_analyzer/rules/rules_list/avoid_unnecessary_type_casts/visitor.dart

@@ -0,0 +1,118 @@
+part of 'avoid_unrelated_type_assertions_rule.dart';
+
+class _Visitor extends RecursiveAstVisitor<void> {
+  final _expressions = <IsExpression, String>{};
+
+  Map<IsExpression, String> get expressions => _expressions;
+
+  @override
+  void visitIsExpression(IsExpression node) {
+    super.visitIsExpression(node);
+
+    if (node.notOperator != null || node.type.type is TypeParameterType) {
+      return;
+    }
+
+    final objectType = node.expression.staticType;
+    final castedType = node.type.type;
+
+    if (_isUnrelatedTypeCheck(objectType, castedType)) {
+      _expressions[node] =
+          '${node.isOperator.keyword?.lexeme ?? ''}${node.notOperator ?? ''}';
+    }
+  }
+
+  bool _isUnrelatedTypeCheck(DartType? objectType, DartType? castedType) {
+    if (objectType == null || castedType == null) {
+      return false;
+    }
+
+    if (objectType.isDynamic || castedType.isDynamic) {
+      return false;
+    }
+
+    if (objectType is! ParameterizedType || castedType is! ParameterizedType) {
+      return false;
+    }
+
+    final objectCastedType =
+        _foundCastedTypeInObjectTypeHierarchy(objectType, castedType);
+    final castedObjectType =
+        _foundCastedTypeInObjectTypeHierarchy(castedType, objectType);
+    if (objectCastedType == null && castedObjectType == null) {
+      return true;
+    }
+
+    if (objectCastedType != null &&
+        _checkGenerics(objectCastedType, castedType) &&
+        castedObjectType != null &&
+        _checkGenerics(castedObjectType, objectType)) {
+      return true;
+    }
+
+    return false;
+  }
+
+  DartType? _foundCastedTypeInObjectTypeHierarchy(
+    DartType objectType,
+    DartType castedType,
+  ) {
+    if (_isFutureOrAndFuture(objectType, castedType)) {
+      return objectType;
+    }
+
+    final correctObjectType =
+        objectType is InterfaceType && objectType.isDartAsyncFutureOr
+            ? objectType.typeArguments.first
+            : objectType;
+
+    if ((correctObjectType.element == castedType.element) ||
+        castedType.isDynamic ||
+        correctObjectType.isDynamic ||
+        _isObjectAndEnum(correctObjectType, castedType)) {
+      return correctObjectType;
+    }
+
+    if (correctObjectType is InterfaceType) {
+      return correctObjectType.allSupertypes
+          .firstWhereOrNull((value) => value.element == castedType.element);
+    }
+
+    return null;
+  }
+
+  bool _checkGenerics(DartType objectType, DartType castedType) {
+    if (objectType.isDynamic || castedType.isDynamic) {
+      return false;
+    }
+
+    if (objectType is! ParameterizedType || castedType is! ParameterizedType) {
+      return false;
+    }
+
+    if (objectType.typeArguments.length != castedType.typeArguments.length) {
+      return false;
+    }
+
+    for (var argumentIndex = 0;
+        argumentIndex < objectType.typeArguments.length;
+        argumentIndex++) {
+      final objectGenericType = objectType.typeArguments[argumentIndex];
+      final castedGenericType = castedType.typeArguments[argumentIndex];
+
+      if (_isUnrelatedTypeCheck(objectGenericType, castedGenericType) &&
+          _isUnrelatedTypeCheck(castedGenericType, objectGenericType)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  bool _isFutureOrAndFuture(DartType objectType, DartType castedType) =>
+      objectType.isDartAsyncFutureOr && castedType.isDartAsyncFuture;
+
+  bool _isObjectAndEnum(DartType objectType, DartType castedType) =>
+      objectType.isDartCoreObject &&
+      castedType.element?.kind == ElementKind.ENUM;
+}

lib/src/analyzers/lint_analyzer/rules/rules_list/avoid_unrelated_type_assertions/avoid_unrelated_type_assertions_rule.dart

@@ -1,4 +1,3 @@
-@TestOn('vm')
 import 'package:analyzer/dart/analysis/results.dart';
 import 'package:analyzer_plugin/protocol/protocol_common.dart';
 import 'package:dart_code_metrics/src/analyzer_plugin/analyzer_plugin_utils.dart';

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

@@ -1,4 +1,3 @@
-@TestOn('vm')
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:dart_code_metrics/src/analyzers/lint_analyzer/anti_patterns/anti_patterns_list/long_method.dart';
 import 'package:dart_code_metrics/src/analyzers/lint_analyzer/metrics/metrics_list/source_lines_of_code/source_lines_of_code_metric.dart';

test/src/analyzer_plugin/analyzer_plugin_utils_test.dart

@@ -1,4 +1,3 @@
-@TestOn('vm')
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:dart_code_metrics/src/analyzers/lint_analyzer/anti_patterns/anti_patterns_list/long_parameter_list.dart';
 import 'package:dart_code_metrics/src/analyzers/lint_analyzer/metrics/metrics_list/number_of_parameters_metric.dart';