Merge remote-tracking branch 'upstream/main' into codegen-multiline-s…

…tring

README.md

@@ -129,7 +129,7 @@ and with [a variety of other package managers](https://docs.astral.sh/ruff/insta
 To run Ruff as a linter, try any of the following:
 
 ```shell
-ruff check .                        # Lint all files in the current directory (and any subdirectories).
+ruff check                          # Lint all files in the current directory (and any subdirectories).
 ruff check path/to/code/            # Lint all files in `/path/to/code` (and any subdirectories).
 ruff check path/to/code/*.py        # Lint all `.py` files in `/path/to/code`.
 ruff check path/to/code/to/file.py  # Lint `file.py`.
@@ -139,7 +139,7 @@ ruff check @arguments.txt           # Lint using an input file, treating its con
 Or, to run Ruff as a formatter:
 
 ```shell
-ruff format .                        # Format all files in the current directory (and any subdirectories).
+ruff format                          # Format all files in the current directory (and any subdirectories).
 ruff format path/to/code/            # Format all files in `/path/to/code` (and any subdirectories).
 ruff format path/to/code/*.py        # Format all `.py` files in `/path/to/code`.
 ruff format path/to/code/to/file.py  # Format `file.py`.

crates/ruff_linter/resources/test/fixtures/pyflakes/F811_28.py

@@ -0,0 +1,6 @@
+"""Regression test for: https://github.com/astral-sh/ruff/issues/10384"""
+
+import datetime
+from datetime import datetime
+
+datetime(1, 2, 3)

crates/ruff_linter/resources/test/fixtures/pylint/invalid_return_type_bool.py

@@ -0,0 +1,37 @@
+# These testcases should raise errors
+
+class Float:
+    def __bool__(self):
+        return 3.05  # [invalid-bool-return]
+
+class Int:
+    def __bool__(self):
+        return 0  # [invalid-bool-return]
+
+
+class Str:
+    def __bool__(self):
+        x = "ruff"
+        return x  # [invalid-bool-return]
+
+# TODO: Once Ruff has better type checking
+def return_int():
+    return 3
+
+class ComplexReturn:
+    def __bool__(self):
+        return return_int()  # [invalid-bool-return]
+
+
+
+# These testcases should NOT raise errors
+
+class Bool:
+    def __bool__(self):
+        return True
+
+
+class Bool2:
+    def __bool__(self):
+        x = True
+        return x

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

@@ -259,23 +259,29 @@ pub(crate) fn deferred_scopes(checker: &mut Checker) {
                         diagnostic.set_parent(range.start());
                     }
 
-                    if let Some(import) = binding.as_any_import() {
-                        if let Some(source) = binding.source {
-                            diagnostic.try_set_fix(|| {
-                                let statement = checker.semantic().statement(source);
-                                let parent = checker.semantic().parent_statement(source);
-                                let edit = fix::edits::remove_unused_imports(
-                                    std::iter::once(import.member_name().as_ref()),
-                                    statement,
-                                    parent,
-                                    checker.locator(),
-                                    checker.stylist(),
-                                    checker.indexer(),
-                                )?;
-                                Ok(Fix::safe_edit(edit).isolate(Checker::isolation(
-                                    checker.semantic().parent_statement_id(source),
-                                )))
-                            });
+                    // Remove the import if the binding and the shadowed binding are both imports,
+                    // and both point to the same qualified name.
+                    if let Some(shadowed_import) = shadowed.as_any_import() {
+                        if let Some(import) = binding.as_any_import() {
+                            if shadowed_import.qualified_name() == import.qualified_name() {
+                                if let Some(source) = binding.source {
+                                    diagnostic.try_set_fix(|| {
+                                        let statement = checker.semantic().statement(source);
+                                        let parent = checker.semantic().parent_statement(source);
+                                        let edit = fix::edits::remove_unused_imports(
+                                            std::iter::once(import.member_name().as_ref()),
+                                            statement,
+                                            parent,
+                                            checker.locator(),
+                                            checker.stylist(),
+                                            checker.indexer(),
+                                        )?;
+                                        Ok(Fix::safe_edit(edit).isolate(Checker::isolation(
+                                            checker.semantic().parent_statement_id(source),
+                                        )))
+                                    });
+                                }
+                            }
                         }
                     }
 

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

@@ -91,6 +91,9 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
                     checker.diagnostics.push(diagnostic);
                 }
             }
+            if checker.enabled(Rule::InvalidBoolReturnType) {
+                pylint::rules::invalid_bool_return(checker, name, body);
+            }
             if checker.enabled(Rule::InvalidStrReturnType) {
                 pylint::rules::invalid_str_return(checker, name, body);
             }

crates/ruff_linter/src/checkers/ast/mod.rs

@@ -44,10 +44,10 @@ use ruff_python_ast::helpers::{
 };
 use ruff_python_ast::identifier::Identifier;
 use ruff_python_ast::name::QualifiedName;
-use ruff_python_ast::str::trailing_quote;
+use ruff_python_ast::str::Quote;
 use ruff_python_ast::visitor::{walk_except_handler, walk_f_string_element, walk_pattern, Visitor};
 use ruff_python_ast::{helpers, str, visitor, PySourceType};
-use ruff_python_codegen::{Generator, Quote, Stylist};
+use ruff_python_codegen::{Generator, Stylist};
 use ruff_python_index::Indexer;
 use ruff_python_parser::typing::{parse_type_annotation, AnnotationKind};
 use ruff_python_semantic::analyze::{imports, typing, visibility};
@@ -228,16 +228,11 @@ impl<'a> Checker<'a> {
         }
 
         // Find the quote character used to start the containing f-string.
-        let expr = self.semantic.current_expression()?;
-        let string_range = self.indexer.fstring_ranges().innermost(expr.start())?;
-        let trailing_quote = trailing_quote(self.locator.slice(string_range))?;
-
-        // Invert the quote character, if it's a single quote.
-        match trailing_quote {
-            "'" => Some(Quote::Double),
-            "\"" => Some(Quote::Single),
-            _ => None,
-        }
+        let ast::ExprFString { value, .. } = self
+            .semantic
+            .current_expressions()
+            .find_map(|expr| expr.as_f_string_expr())?;
+        Some(value.iter().next()?.quote_style().opposite())
     }
 
     /// Returns the [`SourceRow`] for the given offset.

crates/ruff_linter/src/codes.rs

@@ -240,6 +240,7 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Pylint, "E0237") => (RuleGroup::Stable, rules::pylint::rules::NonSlotAssignment),
         (Pylint, "E0241") => (RuleGroup::Stable, rules::pylint::rules::DuplicateBases),
         (Pylint, "E0302") => (RuleGroup::Stable, rules::pylint::rules::UnexpectedSpecialMethodSignature),
+        (Pylint, "E0304") => (RuleGroup::Preview, rules::pylint::rules::InvalidBoolReturnType),
         (Pylint, "E0307") => (RuleGroup::Stable, rules::pylint::rules::InvalidStrReturnType),
         (Pylint, "E0604") => (RuleGroup::Stable, rules::pylint::rules::InvalidAllObject),
         (Pylint, "E0605") => (RuleGroup::Stable, rules::pylint::rules::InvalidAllFormat),

crates/ruff_linter/src/rules/flake8_quotes/settings.rs

@@ -22,11 +22,11 @@ impl Default for Quote {
     }
 }
 
-impl From<ruff_python_ast::str::QuoteStyle> for Quote {
-    fn from(value: ruff_python_ast::str::QuoteStyle) -> Self {
+impl From<ruff_python_ast::str::Quote> for Quote {
+    fn from(value: ruff_python_ast::str::Quote) -> Self {
         match value {
-            ruff_python_ast::str::QuoteStyle::Double => Self::Double,
-            ruff_python_ast::str::QuoteStyle::Single => Self::Single,
+            ruff_python_ast::str::Quote::Double => Self::Double,
+            ruff_python_ast::str::Quote::Single => Self::Single,
         }
     }
 }

crates/ruff_linter/src/rules/pydocstyle/rules/triple_quotes.rs

@@ -1,6 +1,6 @@
 use ruff_diagnostics::{Diagnostic, Edit, Fix, FixAvailability, Violation};
 use ruff_macros::{derive_message_formats, violation};
-use ruff_python_codegen::Quote;
+use ruff_python_ast::str::Quote;
 use ruff_text_size::Ranged;
 
 use crate::checkers::ast::Checker;

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

@@ -124,6 +124,7 @@ mod tests {
     #[test_case(Rule::RedefinedWhileUnused, Path::new("F811_25.py"))]
     #[test_case(Rule::RedefinedWhileUnused, Path::new("F811_26.py"))]
     #[test_case(Rule::RedefinedWhileUnused, Path::new("F811_27.py"))]
+    #[test_case(Rule::RedefinedWhileUnused, Path::new("F811_28.py"))]
     #[test_case(Rule::UndefinedName, Path::new("F821_0.py"))]
     #[test_case(Rule::UndefinedName, Path::new("F821_1.py"))]
     #[test_case(Rule::UndefinedName, Path::new("F821_2.py"))]

crates/ruff_linter/src/rules/pyflakes/snapshots/ruff_linter__rules__pyflakes__tests__F811_F811_1.py.snap

@@ -1,15 +1,9 @@
 ---
 source: crates/ruff_linter/src/rules/pyflakes/mod.rs
 ---
-F811_1.py:1:25: F811 [*] Redefinition of unused `FU` from line 1
+F811_1.py:1:25: F811 Redefinition of unused `FU` from line 1
   |
 1 | import fu as FU, bar as FU
   |                         ^^ F811
   |
   = help: Remove definition: `FU`
-
-ℹ Safe fix
-1   |-import fu as FU, bar as FU
-  1 |+import fu as FU
-
-

crates/ruff_linter/src/rules/pyflakes/snapshots/ruff_linter__rules__pyflakes__tests__F811_F811_12.py.snap

@@ -1,7 +1,7 @@
 ---
 source: crates/ruff_linter/src/rules/pyflakes/mod.rs
 ---
-F811_12.py:6:20: F811 [*] Redefinition of unused `mixer` from line 2
+F811_12.py:6:20: F811 Redefinition of unused `mixer` from line 2
   |
 4 |     pass
 5 | else:
@@ -10,13 +10,3 @@ F811_12.py:6:20: F811 [*] Redefinition of unused `mixer` from line 2
 7 | mixer(123)
   |
   = help: Remove definition: `mixer`
-
-ℹ Safe fix
-3 3 | except ImportError:
-4 4 |     pass
-5 5 | else:
-6   |-    from bb import mixer
-  6 |+    pass
-7 7 | mixer(123)
-
-

crates/ruff_linter/src/rules/pyflakes/snapshots/ruff_linter__rules__pyflakes__tests__F811_F811_2.py.snap

@@ -1,15 +1,9 @@
 ---
 source: crates/ruff_linter/src/rules/pyflakes/mod.rs
 ---
-F811_2.py:1:34: F811 [*] Redefinition of unused `FU` from line 1
+F811_2.py:1:34: F811 Redefinition of unused `FU` from line 1
   |
 1 | from moo import fu as FU, bar as FU
   |                                  ^^ F811
   |
   = help: Remove definition: `FU`
-
-ℹ Safe fix
-1   |-from moo import fu as FU, bar as FU
-  1 |+from moo import fu as FU
-
-

crates/ruff_linter/src/rules/pyflakes/snapshots/ruff_linter__rules__pyflakes__tests__F811_F811_23.py.snap

@@ -1,18 +1,10 @@
 ---
 source: crates/ruff_linter/src/rules/pyflakes/mod.rs
 ---
-F811_23.py:4:15: F811 [*] Redefinition of unused `foo` from line 3
+F811_23.py:4:15: F811 Redefinition of unused `foo` from line 3
   |
 3 | import foo as foo
 4 | import bar as foo
   |               ^^^ F811
   |
   = help: Remove definition: `foo`
-
-ℹ Safe fix
-1 1 | """Test that shadowing an explicit re-export produces a warning."""
-2 2 | 
-3 3 | import foo as foo
-4   |-import bar as foo
-
-

crates/ruff_linter/src/rules/pyflakes/snapshots/ruff_linter__rules__pyflakes__tests__F811_F811_28.py.snap

@@ -0,0 +1,12 @@
+---
+source: crates/ruff_linter/src/rules/pyflakes/mod.rs
+---
+F811_28.py:4:22: F811 Redefinition of unused `datetime` from line 3
+  |
+3 | import datetime
+4 | from datetime import datetime
+  |                      ^^^^^^^^ F811
+5 | 
+6 | datetime(1, 2, 3)
+  |
+  = help: Remove definition: `datetime`

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

@@ -71,6 +71,7 @@ mod tests {
     #[test_case(Rule::ImportSelf, Path::new("import_self/module.py"))]
     #[test_case(Rule::InvalidAllFormat, Path::new("invalid_all_format.py"))]
     #[test_case(Rule::InvalidAllObject, Path::new("invalid_all_object.py"))]
+    #[test_case(Rule::InvalidBoolReturnType, Path::new("invalid_return_type_bool.py"))]
     #[test_case(Rule::InvalidStrReturnType, Path::new("invalid_return_type_str.py"))]
     #[test_case(Rule::DuplicateBases, Path::new("duplicate_bases.py"))]
     #[test_case(Rule::InvalidCharacterBackspace, Path::new("invalid_characters.py"))]

crates/ruff_linter/src/rules/pylint/rules/invalid_bool_return.rs

@@ -0,0 +1,78 @@
+use ruff_diagnostics::{Diagnostic, Violation};
+use ruff_macros::{derive_message_formats, violation};
+use ruff_python_ast::helpers::ReturnStatementVisitor;
+use ruff_python_ast::visitor::Visitor;
+use ruff_python_ast::Stmt;
+use ruff_python_semantic::analyze::type_inference::{NumberLike, PythonType, ResolvedPythonType};
+use ruff_text_size::Ranged;
+
+use crate::checkers::ast::Checker;
+
+/// ## What it does
+/// Checks for `__bool__` implementations that return a type other than `bool`.
+///
+/// ## Why is this bad?
+/// The `__bool__` method should return a `bool` object. Returning a different
+/// type may cause unexpected behavior.
+///
+/// ## Example
+/// ```python
+/// class Foo:
+///     def __bool__(self):
+///         return 2
+/// ```
+///
+/// Use instead:
+/// ```python
+/// class Foo:
+///     def __bool__(self):
+///         return True
+/// ```
+///
+/// ## References
+/// - [Python documentation: The `__bool__` method](https://docs.python.org/3/reference/datamodel.html#object.__bool__)
+#[violation]
+pub struct InvalidBoolReturnType;
+
+impl Violation for InvalidBoolReturnType {
+    #[derive_message_formats]
+    fn message(&self) -> String {
+        format!("`__bool__` does not return `bool`")
+    }
+}
+
+/// E0307
+pub(crate) fn invalid_bool_return(checker: &mut Checker, name: &str, body: &[Stmt]) {
+    if name != "__bool__" {
+        return;
+    }
+
+    if !checker.semantic().current_scope().kind.is_class() {
+        return;
+    }
+
+    let returns = {
+        let mut visitor = ReturnStatementVisitor::default();
+        visitor.visit_body(body);
+        visitor.returns
+    };
+
+    for stmt in returns {
+        if let Some(value) = stmt.value.as_deref() {
+            if !matches!(
+                ResolvedPythonType::from(value),
+                ResolvedPythonType::Unknown
+                    | ResolvedPythonType::Atom(PythonType::Number(NumberLike::Bool))
+            ) {
+                checker
+                    .diagnostics
+                    .push(Diagnostic::new(InvalidBoolReturnType, value.range()));
+            }
+        } else {
+            // Disallow implicit `None`.
+            checker
+                .diagnostics
+                .push(Diagnostic::new(InvalidBoolReturnType, stmt.range()));
+        }
+    }
+}

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

@@ -25,6 +25,7 @@ pub(crate) use import_private_name::*;
 pub(crate) use import_self::*;
 pub(crate) use invalid_all_format::*;
 pub(crate) use invalid_all_object::*;
+pub(crate) use invalid_bool_return::*;
 pub(crate) use invalid_envvar_default::*;
 pub(crate) use invalid_envvar_value::*;
 pub(crate) use invalid_str_return::*;
@@ -113,6 +114,7 @@ mod import_private_name;
 mod import_self;
 mod invalid_all_format;
 mod invalid_all_object;
+mod invalid_bool_return;
 mod invalid_envvar_default;
 mod invalid_envvar_value;
 mod invalid_str_return;