Detect unused-asyncio-dangling-task (RUF006) on unused assignments

crates/ruff_linter/resources/test/fixtures/ruff/RUF006.py

@@ -63,9 +63,21 @@ def f():
     tasks = [asyncio.create_task(task) for task in tasks]
 
 
-# OK (false negative)
+# Error
+def f():
+    task = asyncio.create_task(coordinator.ws_connect())
+
+
+# OK (potential false negative)
 def f():
     task = asyncio.create_task(coordinator.ws_connect())
+    background_tasks.add(task)
+
+
+# OK
+async def f():
+    task = asyncio.create_task(coordinator.ws_connect())
+    await task
 
 
 # OK (potential false negative)

crates/ruff_linter/src/checkers/ast/analyze/deferred_scopes.rs

@@ -5,7 +5,9 @@ use ruff_text_size::Ranged;
 
 use crate::checkers::ast::Checker;
 use crate::codes::Rule;
-use crate::rules::{flake8_pyi, flake8_type_checking, flake8_unused_arguments, pyflakes, pylint};
+use crate::rules::{
+    flake8_pyi, flake8_type_checking, flake8_unused_arguments, pyflakes, pylint, ruff,
+};
 
 /// Run lint rules over all deferred scopes in the [`SemanticModel`].
 pub(crate) fn deferred_scopes(checker: &mut Checker) {
@@ -31,6 +33,7 @@ pub(crate) fn deferred_scopes(checker: &mut Checker) {
         Rule::UnusedPrivateTypedDict,
         Rule::UnusedStaticMethodArgument,
         Rule::UnusedVariable,
+        Rule::AsyncioDanglingTask,
         Rule::NoSelfUse,
     ]) {
         return;
@@ -294,6 +297,10 @@ pub(crate) fn deferred_scopes(checker: &mut Checker) {
             }
         }
 
+        if checker.enabled(Rule::AsyncioDanglingTask) {
+            ruff::rules::asyncio_dangling_task_unused(checker, scope, &mut diagnostics);
+        }
+
         if matches!(scope.kind, ScopeKind::Function(_) | ScopeKind::Module) {
             if enforce_typing_imports {
                 let runtime_imports: Vec<&Binding> = checker

crates/ruff_linter/src/checkers/ast/analyze/statement.rs

@@ -1560,7 +1560,9 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
                 pylint::rules::named_expr_without_context(checker, value);
             }
             if checker.enabled(Rule::AsyncioDanglingTask) {
-                ruff::rules::asyncio_dangling_task(checker, value);
+                let mut diagnostics: Vec<Diagnostic> = vec![];
+                ruff::rules::asyncio_dangling_task(checker, value, &mut diagnostics);
+                checker.diagnostics.extend(diagnostics);
             }
             if checker.enabled(Rule::RepeatedAppend) {
                 refurb::rules::repeated_append(checker, stmt);

crates/ruff_linter/src/rules/ruff/rules/asyncio_dangling_task.rs

@@ -1,10 +1,11 @@
 use std::fmt;
 
+use ast::Stmt;
 use ruff_python_ast::{self as ast, Expr};
 
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
-use ruff_python_semantic::analyze::typing;
+use ruff_python_semantic::{analyze::typing, Scope};
 use ruff_text_size::Ranged;
 
 use crate::checkers::ast::Checker;
@@ -66,7 +67,11 @@ impl Violation for AsyncioDanglingTask {
 }
 
 /// RUF006
-pub(crate) fn asyncio_dangling_task(checker: &mut Checker, expr: &Expr) {
+pub(crate) fn asyncio_dangling_task(
+    checker: &Checker,
+    expr: &Expr,
+    diagnostics: &mut Vec<Diagnostic>,
+) {
     let Expr::Call(ast::ExprCall { func, .. }) = expr else {
         return;
     };
@@ -81,7 +86,7 @@ pub(crate) fn asyncio_dangling_task(checker: &mut Checker, expr: &Expr) {
             _ => None,
         })
     {
-        checker.diagnostics.push(Diagnostic::new(
+        diagnostics.push(Diagnostic::new(
             AsyncioDanglingTask { method },
             expr.range(),
         ));
@@ -94,7 +99,7 @@ pub(crate) fn asyncio_dangling_task(checker: &mut Checker, expr: &Expr) {
             if typing::resolve_assignment(value, checker.semantic()).is_some_and(|call_path| {
                 matches!(call_path.as_slice(), ["asyncio", "get_running_loop"])
             }) {
-                checker.diagnostics.push(Diagnostic::new(
+                diagnostics.push(Diagnostic::new(
                     AsyncioDanglingTask {
                         method: Method::CreateTask,
                     },
@@ -105,6 +110,27 @@ pub(crate) fn asyncio_dangling_task(checker: &mut Checker, expr: &Expr) {
     }
 }
 
+pub(crate) fn asyncio_dangling_task_unused(
+    checker: &Checker,
+    scope: &Scope,
+    diagnostics: &mut Vec<Diagnostic>,
+) {
+    for binding in scope
+        .binding_ids()
+        .map(|binding_id| checker.semantic().binding(binding_id))
+        .filter(|binding| binding.kind.is_assignment() && !binding.is_used())
+    {
+        let Some(source) = binding.source else {
+            continue;
+        };
+        let Stmt::Assign(ast::StmtAssign { value, .. }) = checker.semantic().statement(source)
+        else {
+            continue;
+        };
+        asyncio_dangling_task(checker, value, diagnostics);
+    }
+}
+
 #[derive(Debug, PartialEq, Eq, Copy, Clone)]
 enum Method {
     CreateTask,

crates/ruff_linter/src/rules/ruff/snapshots/ruff_linter__rules__ruff__tests__RUF006_RUF006.py.snap

@@ -17,11 +17,19 @@ RUF006.py:11:5: RUF006 Store a reference to the return value of `asyncio.ensure_
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ RUF006
    |
 
-RUF006.py:79:5: RUF006 Store a reference to the return value of `asyncio.create_task`
+RUF006.py:68:12: RUF006 Store a reference to the return value of `asyncio.create_task`
    |
-77 | def f():
-78 |     loop = asyncio.get_running_loop()
-79 |     loop.create_task(coordinator.ws_connect())  # Error
+66 | # Error
+67 | def f():
+68 |     task = asyncio.create_task(coordinator.ws_connect())
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ RUF006
+   |
+
+RUF006.py:91:5: RUF006 Store a reference to the return value of `asyncio.create_task`
+   |
+89 | def f():
+90 |     loop = asyncio.get_running_loop()
+91 |     loop.create_task(coordinator.ws_connect())  # Error
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ RUF006
    |