feat: and-chain for use-setstate-synchronously

Author: Desdaemon

lib/src/analyzers/lint_analyzer/rules/rules_list/avoid_async_setstate/avoid_async_setstate_rule.dart

@@ -2,6 +2,7 @@ import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 
+import '../../../../../utils/flutter_types_utils.dart';
 import '../../../../../utils/node_utils.dart';
 import '../../../lint_utils.dart';
 import '../../../models/internal_resolved_unit_result.dart';

lib/src/analyzers/lint_analyzer/rules/rules_list/avoid_async_setstate/helpers.dart

@@ -1,43 +1,43 @@
 part of 'avoid_async_setstate_rule.dart';
 
-@pragma('vm:prefer-inline')
-bool _isIdentifier(Expression node, String ident) =>
-    node is Identifier && node.name == ident;
-
-@pragma('vm:prefer-inline')
-bool _isDivergent(Statement node) =>
-    node is ReturnStatement ||
-    node is ExpressionStatement && node.expression is ThrowExpression;
-
-Expression _thisOr(Expression node) {
-  if (node is PropertyAccess && node.target is ThisExpression) {
-    return node.propertyName;
-  }
-
-  return node;
-}
-
 /// If null, the check was not indicative of whether mounted was true.
-bool? _extractMountedCheck(Expression condition) {
+bool? _extractMountedCheck(Expression node) {
   // ![this.]mounted
-  if (condition is PrefixExpression &&
-      condition.operator.type == TokenType.BANG &&
-      _isIdentifier(_thisOr(condition.operand), 'mounted')) {
+  if (node is PrefixExpression &&
+      node.operator.type == TokenType.BANG &&
+      _isIdentifier(_thisOr(node.operand), 'mounted')) {
     return false;
   }
 
   // [this.]mounted
-  if (_isIdentifier(_thisOr(condition), 'mounted')) {
+  if (_isIdentifier(_thisOr(node), 'mounted')) {
     return true;
   }
 
+  // mounted && ..
+  if (node is BinaryExpression &&
+      node.operator.type == TokenType.AMPERSAND_AMPERSAND) {
+    return _extractMountedCheck(node.leftOperand) ??
+        _extractMountedCheck(node.rightOperand);
+  }
+
   return null;
 }
 
-bool _blockDiverges(Statement block) {
-  if (block is! Block) {
-    return _isDivergent(block);
-  }
+@pragma('vm:prefer-inline')
+bool _isIdentifier(Expression node, String ident) =>
+    node is Identifier && node.name == ident;
 
-  return block.statements.any(_isDivergent);
-}
+@pragma('vm:prefer-inline')
+bool _isDivergent(Statement node) =>
+    node is ReturnStatement ||
+    node is ExpressionStatement && node.expression is ThrowExpression;
+
+@pragma('vm:prefer-inline')
+Expression _thisOr(Expression node) =>
+    node is PropertyAccess && node.target is ThisExpression
+        ? node.propertyName
+        : node;
+
+bool _blockDiverges(Statement block) =>
+    block is Block ? block.statements.any(_isDivergent) : _isDivergent(block);

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

@@ -5,33 +5,30 @@ class _Visitor extends RecursiveAstVisitor<void> {
 
   @override
   void visitClassDeclaration(ClassDeclaration node) {
-    if (node.extendsClause?.superclass.name.name == 'State') {
-      node.visitChildren(this);
-    }
-  }
-
-  @override
-  void visitBlockFunctionBody(BlockFunctionBody node) {
-    if (node.isAsynchronous) {
+    if (isWidgetStateOrSubclass(node.extendsClause?.superclass.type)) {
       final visitor = _AsyncSetStateVisitor();
       node.visitChildren(visitor);
       nodes.addAll(visitor.nodes);
-
-      return;
     }
-
-    node.visitChildren(this);
   }
 }
 
 class _AsyncSetStateVisitor extends RecursiveAstVisitor<void> {
   bool shouldBeMounted = true;
   final nodes = <SimpleIdentifier>[];
 
+  @override
+  void visitBlockFunctionBody(BlockFunctionBody node) {
+    final oldMounted = shouldBeMounted;
+    shouldBeMounted = true;
+    node.visitChildren(this);
+    shouldBeMounted = oldMounted;
+  }
+
   @override
   void visitAwaitExpression(AwaitExpression node) {
     shouldBeMounted = false;
-    node.visitChildren(this);
+    super.visitAwaitExpression(node);
   }
 
   @override
@@ -43,13 +40,12 @@ class _AsyncSetStateVisitor extends RecursiveAstVisitor<void> {
       nodes.add(node.methodName);
     }
 
-    node.visitChildren(this);
+    super.visitMethodInvocation(node);
   }
 
   @override
   void visitIfStatement(IfStatement node) {
     node.condition.visitChildren(this);
-
     final oldMounted = shouldBeMounted;
     final newMounted = _extractMountedCheck(node.condition);
     shouldBeMounted = newMounted ?? shouldBeMounted;

test/src/analyzers/lint_analyzer/rules/rules_list/avoid_async_setstate/avoid_async_setstate_rule_test.dart

@@ -25,7 +25,7 @@ void main() {
 
       RuleTestHelper.verifyIssues(
         issues: issues,
-        startLines: [6, 11, 18, 33, 41],
+        startLines: [6, 11, 18, 33, 48],
         startColumns: [10, 7, 7, 5, 9],
         locationTexts: [
           'setState',

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

@@ -31,6 +31,13 @@ class _FooState extends State<StatefulWidget> {
       return;
     }
     setState(() {}); // LINT
+
+    if (mounted && foo) {
+      setState(() {});
+    }
+
+    if (foo && !this.mounted) return;
+    setState(() {});
   }
 
   Widget build(context) {
@@ -45,3 +52,5 @@ class _FooState extends State<StatefulWidget> {
     );
   }
 }
+
+class State {}

website/docs/rules/flutter/avoid-async-setstate.mdx

@@ -16,12 +16,11 @@ does not make use of [`mounted`], but rather revolves around refactoring your st
 
 :::info
 
-Only these conditionals are considered for mounted-ness:
+Only these patterns are considered for mounted-ness:
 
-- `if ([this.]mounted)`
-- `if (![this.]mounted)`
-- `while ([this.]mounted)`
-- `while (![this.]mounted)`
+- `if (mounted)`
+- `if (!mounted)`
+- `if (mounted && ..)`
 
 If a `!mounted` check diverges, i.e. ends in a `return` or `throw`, the outer scope is considered mounted and vice versa: