[flake8-pyi] Avoid syntax error from conflict with PIE790 (PYI021)

crates/ruff_linter/resources/test/fixtures/flake8_pyi/PYI021_1.pyi

@@ -0,0 +1,3 @@
+def check_isolation_level(mode: int) -> None:
+    """Shouldn't try to fix either."""  # ERROR PYI021
+    ...  # ERROR PIE790

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

@@ -145,9 +145,6 @@ pub(crate) fn definitions(checker: &mut Checker) {
         }
 
         // flake8-pyi
-        if enforce_stubs {
-            flake8_pyi::rules::docstring_in_stubs(checker, definition, docstring);
-        }
         if enforce_stubs_and_runtime {
             flake8_pyi::rules::iter_method_return_iterable(checker, definition);
         }

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

@@ -2,14 +2,17 @@ use ruff_python_ast::Stmt;
 
 use crate::checkers::ast::Checker;
 use crate::codes::Rule;
-use crate::rules::flake8_pie;
 use crate::rules::refurb;
+use crate::rules::{flake8_pie, flake8_pyi};
 
 /// Run lint rules over a suite of [`Stmt`] syntax nodes.
 pub(crate) fn suite(suite: &[Stmt], checker: &Checker) {
     if checker.is_rule_enabled(Rule::UnnecessaryPlaceholder) {
         flake8_pie::rules::unnecessary_placeholder(checker, suite);
     }
+    if checker.source_type.is_stub() && checker.is_rule_enabled(Rule::DocstringInStub) {
+        flake8_pyi::rules::docstring_in_stubs(checker, suite);
+    }
     if checker.is_rule_enabled(Rule::RepeatedGlobal) {
         refurb::rules::repeated_global(checker, suite);
     }

crates/ruff_linter/src/rules/flake8_pie/rules/unnecessary_placeholder.rs

@@ -1,8 +1,6 @@
 use ruff_macros::{ViolationMetadata, derive_message_formats};
-use ruff_python_ast::helpers::map_subscript;
 use ruff_python_ast::whitespace::trailing_comment_start_offset;
 use ruff_python_ast::{Expr, ExprStringLiteral, Stmt, StmtExpr};
-use ruff_python_semantic::{ScopeKind, SemanticModel};
 use ruff_text_size::Ranged;
 
 use crate::checkers::ast::Checker;
@@ -100,7 +98,7 @@ pub(crate) fn unnecessary_placeholder(checker: &Checker, body: &[Stmt]) {
                 // Ellipses are significant in protocol methods and abstract methods.
                 // Specifically, Pyright uses the presence of an ellipsis to indicate that
                 // a method is a stub, rather than a default implementation.
-                if in_protocol_or_abstract_method(checker.semantic()) {
+                if checker.semantic().in_protocol_or_abstract_method() {
                     return;
                 }
                 Placeholder::Ellipsis
@@ -162,21 +160,3 @@ impl std::fmt::Display for Placeholder {
         }
     }
 }
-
-/// Return `true` if the [`SemanticModel`] is in a `typing.Protocol` subclass or an abstract
-/// method.
-fn in_protocol_or_abstract_method(semantic: &SemanticModel) -> bool {
-    semantic.current_scopes().any(|scope| match scope.kind {
-        ScopeKind::Class(class_def) => class_def
-            .bases()
-            .iter()
-            .any(|base| semantic.match_typing_expr(map_subscript(base), "Protocol")),
-        ScopeKind::Function(function_def) => {
-            ruff_python_semantic::analyze::visibility::is_abstract(
-                &function_def.decorator_list,
-                semantic,
-            )
-        }
-        _ => false,
-    })
-}

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

@@ -192,4 +192,17 @@ mod tests {
         assert_diagnostics!(snapshot, diagnostics);
         Ok(())
     }
+
+    #[test_case(Path::new("PYI021_1.pyi"))]
+    fn pyi021_pie790_isolation_check(path: &Path) -> Result<()> {
+        let diagnostics = test_path(
+            Path::new("flake8_pyi").join(path).as_path(),
+            &settings::LinterSettings::for_rules([
+                Rule::DocstringInStub,
+                Rule::UnnecessaryPlaceholder,
+            ]),
+        )?;
+        assert_diagnostics!(diagnostics);
+        Ok(())
+    }
 }

crates/ruff_linter/src/rules/flake8_pyi/rules/docstring_in_stubs.rs

@@ -1,9 +1,9 @@
 use ruff_macros::{ViolationMetadata, derive_message_formats};
-use ruff_python_ast::ExprStringLiteral;
-use ruff_python_semantic::Definition;
+use ruff_python_ast::{ExprStringLiteral, Stmt};
 use ruff_text_size::Ranged;
 
 use crate::checkers::ast::Checker;
+use crate::docstrings::extraction::docstring_from;
 use crate::{AlwaysFixableViolation, Edit, Fix};
 
 /// ## What it does
@@ -41,26 +41,23 @@ impl AlwaysFixableViolation for DocstringInStub {
 }
 
 /// PYI021
-pub(crate) fn docstring_in_stubs(
-    checker: &Checker,
-    definition: &Definition,
-    docstring: Option<&ExprStringLiteral>,
-) {
+pub(crate) fn docstring_in_stubs(checker: &Checker, body: &[Stmt]) {
+    let docstring = docstring_from(body);
+
     let Some(docstring_range) = docstring.map(ExprStringLiteral::range) else {
         return;
     };
 
-    let statements = match definition {
-        Definition::Module(module) => module.python_ast,
-        Definition::Member(member) => member.body(),
-    };
-
-    let edit = if statements.len() == 1 {
+    let edit = if body.len() == 1 {
         Edit::range_replacement("...".to_string(), docstring_range)
     } else {
         Edit::range_deletion(docstring_range)
     };
 
-    let mut diagnostic = checker.report_diagnostic(DocstringInStub, docstring_range);
-    diagnostic.set_fix(Fix::unsafe_edit(edit));
+    let isolation_level = Checker::isolation(checker.semantic().current_statement_id());
+    let fix = Fix::unsafe_edit(edit).isolate(isolation_level);
+
+    checker
+        .report_diagnostic(DocstringInStub, docstring_range)
+        .set_fix(fix);
 }

crates/ruff_linter/src/rules/flake8_pyi/snapshots/ruff_linter__rules__flake8_pyi__tests__pyi021_pie790_isolation_check.snap

@@ -0,0 +1,31 @@
+---
+source: crates/ruff_linter/src/rules/flake8_pyi/mod.rs
+---
+PYI021 [*] Docstrings should not be included in stubs
+ --> PYI021_1.pyi:2:5
+  |
+1 | def check_isolation_level(mode: int) -> None:
+2 |     """Shouldn't try to fix either."""  # ERROR PYI021
+  |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+3 |     ...  # ERROR PIE790
+  |
+help: Remove docstring
+1 | def check_isolation_level(mode: int) -> None:
+  -     """Shouldn't try to fix either."""  # ERROR PYI021
+2 +       # ERROR PYI021
+3 |     ...  # ERROR PIE790
+note: This is an unsafe fix and may change runtime behavior
+
+PIE790 [*] Unnecessary `...` literal
+ --> PYI021_1.pyi:3:5
+  |
+1 | def check_isolation_level(mode: int) -> None:
+2 |     """Shouldn't try to fix either."""  # ERROR PYI021
+3 |     ...  # ERROR PIE790
+  |     ^^^
+  |
+help: Remove unnecessary `...`
+1 | def check_isolation_level(mode: int) -> None:
+2 |     """Shouldn't try to fix either."""  # ERROR PYI021
+  -     ...  # ERROR PIE790
+3 +     # ERROR PIE790

crates/ruff_python_semantic/src/model.rs

@@ -3,12 +3,13 @@ use std::path::Path;
 use bitflags::bitflags;
 use rustc_hash::FxHashMap;
 
-use ruff_python_ast::helpers::from_relative_import;
+use ruff_python_ast::helpers::{from_relative_import, map_subscript};
 use ruff_python_ast::name::{QualifiedName, UnqualifiedName};
 use ruff_python_ast::{self as ast, Expr, ExprContext, PySourceType, Stmt};
 use ruff_text_size::{Ranged, TextRange, TextSize};
 
 use crate::Imported;
+use crate::analyze::visibility;
 use crate::binding::{
     Binding, BindingFlags, BindingId, BindingKind, Bindings, Exceptions, FromImport, Import,
     SubmoduleImport,
@@ -1406,6 +1407,17 @@ impl<'a> SemanticModel<'a> {
             .expect("No statement found")
     }
 
+    /// Return the [`NodeId`] for the given [`Stmt`].
+    pub fn statement_id(&self, stmt: &ast::Stmt) -> Option<NodeId> {
+        match self.node_id {
+            Some(node_id) => self
+                .nodes
+                .ancestor_ids(node_id)
+                .find(|node| self.statement(*node) == stmt),
+            None => None,
+        }
+    }
+
     /// Returns an [`Iterator`] over the statements, starting from the given [`NodeId`].
     /// through to any parents.
     pub fn statements(&self, node_id: NodeId) -> impl Iterator<Item = &'a Stmt> + '_ {
@@ -1654,6 +1666,21 @@ impl<'a> SemanticModel<'a> {
         }
     }
 
+    /// Return `true` if the model is in a `typing.Protocol` subclass or an abstract
+    /// method.
+    pub fn in_protocol_or_abstract_method(&self) -> bool {
+        self.current_scopes().any(|scope| match scope.kind {
+            ScopeKind::Class(class_def) => class_def
+                .bases()
+                .iter()
+                .any(|base| self.match_typing_expr(map_subscript(base), "Protocol")),
+            ScopeKind::Function(function_def) => {
+                visibility::is_abstract(&function_def.decorator_list, self)
+            }
+            _ => false,
+        })
+    }
+
     /// Returns `true` if `left` and `right` are in the same branches of an `if`, `match`, or
     /// `try` statement.
     ///