Add flake8-trio support

crates/ruff_linter/resources/test/fixtures/flake8_trio/TRIO100.py

@@ -0,0 +1,18 @@
+import trio
+
+
+async def foo():
+    with trio.fail_after():
+        ...
+
+async def foo():
+    with trio.fail_at():
+        await ...
+
+async def foo():
+    with trio.move_on_after():
+        ...
+
+async def foo():
+    with trio.move_at():
+        await ...

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

@@ -12,8 +12,8 @@ use crate::rules::{
     airflow, flake8_bandit, flake8_boolean_trap, flake8_bugbear, flake8_builtins, flake8_debugger,
     flake8_django, flake8_errmsg, flake8_import_conventions, flake8_pie, flake8_pyi,
     flake8_pytest_style, flake8_raise, flake8_return, flake8_simplify, flake8_slots,
-    flake8_tidy_imports, flake8_type_checking, mccabe, pandas_vet, pep8_naming, perflint,
-    pycodestyle, pyflakes, pygrep_hooks, pylint, pyupgrade, refurb, ruff, tryceratops,
+    flake8_tidy_imports, flake8_trio, flake8_type_checking, mccabe, pandas_vet, pep8_naming,
+    perflint, pycodestyle, pyflakes, pygrep_hooks, pylint, pyupgrade, refurb, ruff, tryceratops,
 };
 use crate::settings::types::PythonVersion;
 
@@ -1195,6 +1195,9 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
             if checker.enabled(Rule::UselessWithLock) {
                 pylint::rules::useless_with_lock(checker, with_stmt);
             }
+            if checker.enabled(Rule::TimeoutWithoutAwait) {
+                flake8_trio::rules::timeout_without_await(checker, with_stmt, items);
+            }
         }
         Stmt::While(ast::StmtWhile { body, orelse, .. }) => {
             if checker.enabled(Rule::FunctionUsesLoopVariable) {

crates/ruff_linter/src/codes.rs

@@ -290,6 +290,9 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Flake8Async, "101") => (RuleGroup::Stable, rules::flake8_async::rules::OpenSleepOrSubprocessInAsyncFunction),
         (Flake8Async, "102") => (RuleGroup::Stable, rules::flake8_async::rules::BlockingOsCallInAsyncFunction),
 
+        // flake8-trio
+        (Flake8Trio, "100") => (RuleGroup::Preview, rules::flake8_trio::rules::TimeoutWithoutAwait),
+
         // flake8-builtins
         (Flake8Builtins, "001") => (RuleGroup::Stable, rules::flake8_builtins::rules::BuiltinVariableShadowing),
         (Flake8Builtins, "002") => (RuleGroup::Stable, rules::flake8_builtins::rules::BuiltinArgumentShadowing),

crates/ruff_linter/src/registry.rs

@@ -64,6 +64,9 @@ pub enum Linter {
     /// [flake8-async](https://pypi.org/project/flake8-async/)
     #[prefix = "ASYNC"]
     Flake8Async,
+    /// [flake8-trio](https://pypi.org/project/flake8-trio/)
+    #[prefix = "TRIO"]
+    Flake8Trio,
     /// [flake8-bandit](https://pypi.org/project/flake8-bandit/)
     #[prefix = "S"]
     Flake8Bandit,

crates/ruff_linter/src/rules/flake8_trio/mod.rs

@@ -0,0 +1,26 @@
+//! Rules from [flake8-trio](https://pypi.org/project/flake8-trio/).
+pub(crate) mod rules;
+
+#[cfg(test)]
+mod tests {
+    use std::path::Path;
+
+    use anyhow::Result;
+    use test_case::test_case;
+
+    use crate::assert_messages;
+    use crate::registry::Rule;
+    use crate::settings::LinterSettings;
+    use crate::test::test_path;
+
+    #[test_case(Rule::TimeoutWithoutAwait, Path::new("TRIO100.py"))]
+    fn rules(rule_code: Rule, path: &Path) -> Result<()> {
+        let snapshot = format!("{}_{}", rule_code.noqa_code(), path.to_string_lossy());
+        let diagnostics = test_path(
+            Path::new("flake8_trio").join(path).as_path(),
+            &LinterSettings::for_rule(rule_code),
+        )?;
+        assert_messages!(snapshot, diagnostics);
+        Ok(())
+    }
+}

crates/ruff_linter/src/rules/flake8_trio/rules/mod.rs

@@ -0,0 +1,3 @@
+pub(crate) use timeout_without_await::*;
+
+mod timeout_without_await;

crates/ruff_linter/src/rules/flake8_trio/rules/timeout_without_await.rs

@@ -0,0 +1,108 @@
+use ruff_python_ast::visitor::{walk_expr, Visitor};
+use ruff_python_ast::{Expr, ExprAwait, ExprCall, StmtWith, WithItem};
+
+use ruff_diagnostics::{Diagnostic, Violation};
+use ruff_macros::{derive_message_formats, violation};
+
+use crate::checkers::ast::Checker;
+
+/// ## What it does
+/// Checks for trio functions that should contain await but don't.
+///
+/// ## Why is this bad?
+///
+/// Some trio context managers, such as 'trio.fail_after' and
+/// 'trio.move_on_after', have no impact when there is no await statement in them.
+///
+/// ## Example
+/// ```python
+/// async def f():
+///     with trio.move_on_after(2):
+///         do_something()
+/// ```
+///
+/// Use instead:
+/// ```python
+/// async def f():
+///     with trio.move_on_after(2):
+///         do_something()
+///         await awaitable()
+/// ```
+#[violation]
+pub struct TimeoutWithoutAwait {
+    method_name: String,
+}
+
+impl Violation for TimeoutWithoutAwait {
+    #[derive_message_formats]
+    fn message(&self) -> String {
+        format!("{} context contains no checkpoints, remove the context or add `await trio.lowlevel.checkpoint()`", self.method_name)
+    }
+}
+
+struct AwaitVisitor {
+    await_visited: bool,
+}
+
+impl Visitor<'_> for AwaitVisitor {
+    fn visit_expr(&mut self, expr: &'_ ruff_python_ast::Expr) {
+        if let Expr::Await(ExprAwait { .. }) = expr {
+            self.await_visited = true;
+        } else {
+            walk_expr(self, expr);
+        }
+    }
+}
+
+/// TRIO100
+pub(crate) fn timeout_without_await(
+    checker: &mut Checker,
+    with_stmt: &StmtWith,
+    with_items: &[WithItem],
+) {
+    let mut visitor = AwaitVisitor {
+        await_visited: false,
+    };
+
+    for item in with_items {
+        if let Expr::Call(ExprCall {
+            func,
+            range: _,
+            arguments: _,
+        }) = &item.context_expr
+        {
+            if let Some(method_name) = checker
+                .semantic()
+                .resolve_call_path(func.as_ref())
+                .and_then(|path| {
+                    if matches!(
+                        path.as_slice(),
+                        [
+                            "trio",
+                            "move_on_after"
+                                | "move_on_at"
+                                | "fail_after"
+                                | "fail_at"
+                                | "CancelScope"
+                        ]
+                    ) {
+                        Some(path.join("."))
+                    } else {
+                        None
+                    }
+                })
+            {
+                for stmt in &with_stmt.body {
+                    visitor.visit_stmt(stmt);
+                }
+
+                if !visitor.await_visited {
+                    checker.diagnostics.push(Diagnostic::new(
+                        TimeoutWithoutAwait { method_name },
+                        with_stmt.range,
+                    ));
+                }
+            }
+        }
+    }
+}

crates/ruff_linter/src/rules/flake8_trio/snapshots/ruff_linter__rules__flake8_trio__tests__TRIO100_TRIO100.py.snap

@@ -0,0 +1,26 @@
+---
+source: crates/ruff_linter/src/rules/flake8_trio/mod.rs
+---
+TRIO100.py:5:5: TRIO100 trio.fail_after context contains no checkpoints, remove the context or add `await trio.lowlevel.checkpoint()`
+  |
+4 |   async def foo():
+5 |       with trio.fail_after():
+  |  _____^
+6 | |         ...
+  | |___________^ TRIO100
+7 |   
+8 |   async def foo():
+  |
+
+TRIO100.py:13:5: TRIO100 trio.move_on_after context contains no checkpoints, remove the context or add `await trio.lowlevel.checkpoint()`
+   |
+12 |   async def foo():
+13 |       with trio.move_on_after():
+   |  _____^
+14 | |         ...
+   | |___________^ TRIO100
+15 |   
+16 |   async def foo():
+   |
+
+

crates/ruff_linter/src/rules/mod.rs

@@ -37,6 +37,7 @@ pub mod flake8_simplify;
 pub mod flake8_slots;
 pub mod flake8_tidy_imports;
 pub mod flake8_todos;
+pub mod flake8_trio;
 pub mod flake8_type_checking;
 pub mod flake8_unused_arguments;
 pub mod flake8_use_pathlib;