feat: implement supoort for path.open in furb103

Signed-off-by: 11happy <[email protected]>

Author: 11happy

crates/ruff_linter/resources/test/fixtures/refurb/FURB103.py

@@ -152,4 +152,22 @@ def bar(x):
 data = {"price": 100}
 
 with open("test.json", "wb") as f:
-    f.write(json.dumps(data, indent=4).encode("utf-8"))
+    f.write(json.dumps(data, indent=4).encode("utf-8"))
+
+with Path("file.txt").open("w") as f:
+    f.write("test")
+
+with Path("file.txt").open("wb") as f:
+    f.write(b"test")
+
+with Path("file.txt").open(mode="w") as f:
+    f.write("test")
+
+with Path("file.txt").open("w", encoding="utf8") as f:
+    f.write("test")
+
+with Path("file.txt").open("w", errors="ignore") as f:
+    f.write("test")
+
+with Path(foo()).open("w") as f:
+    f.write("test")

crates/ruff_linter/src/rules/refurb/helpers.rs

@@ -127,6 +127,8 @@ pub(super) struct FileOpen<'a> {
     pub(super) keywords: Vec<&'a ast::Keyword>,
     /// We only check `open` operations whose file handles are used exactly once.
     pub(super) reference: &'a ResolvedReference,
+    /// `Path().open()` call
+    pub(super) path_obj: Option<&'a Expr>,
 }
 
 impl FileOpen<'_> {
@@ -146,7 +148,10 @@ pub(super) fn find_file_opens<'a>(
 ) -> Vec<FileOpen<'a>> {
     with.items
         .iter()
-        .filter_map(|item| find_file_open(item, with, semantic, read_mode, python_version))
+        .filter_map(|item| {
+            find_file_open(item, with, semantic, read_mode, python_version)
+                .or_else(|| find_path_open(item, with, semantic, read_mode, python_version))
+        })
         .collect()
 }
 
@@ -238,6 +243,79 @@ fn find_file_open<'a>(
         mode,
         keywords,
         reference,
+        path_obj: None,
+    })
+}
+
+fn find_path_open<'a>(
+    item: &'a ast::WithItem,
+    with: &'a ast::StmtWith,
+    semantic: &'a SemanticModel<'a>,
+    read_mode: bool,
+    python_version: PythonVersion,
+) -> Option<FileOpen<'a>> {
+    let ast::ExprCall {
+        func,
+        arguments: ast::Arguments { args, keywords, .. },
+        ..
+    } = item.context_expr.as_call_expr()?;
+    let attr = func.as_attribute_expr()?;
+    if attr.attr.as_str() != "open" {
+        return None;
+    }
+    let path_call = attr.value.as_call_expr()?;
+    let path_func = path_call.func.as_name_expr()?;
+    if path_func.id.as_str() != "Path" {
+        return None;
+    }
+    let filename = path_call.arguments.args.first()?;
+    let mode = if args.is_empty() {
+        OpenMode::ReadText
+    } else {
+        match_open_mode(args.first()?)?
+    };
+    let (keywords, kw_mode) = match_open_keywords(keywords, read_mode, python_version)?;
+    let mode = kw_mode.unwrap_or(mode);
+    match mode {
+        OpenMode::ReadText | OpenMode::ReadBytes => {
+            if !read_mode {
+                return None;
+            }
+        }
+        OpenMode::WriteText | OpenMode::WriteBytes => {
+            if read_mode {
+                return None;
+            }
+        }
+    }
+    if matches!(mode, OpenMode::ReadBytes | OpenMode::WriteBytes) && !keywords.is_empty() {
+        return None;
+    }
+    let var = item.optional_vars.as_deref()?.as_name_expr()?;
+    let scope = semantic.current_scope();
+    let bindings: Vec<_> = scope.get_all(var.id.as_str()).collect();
+    let binding = bindings
+        .iter()
+        .map(|id| semantic.binding(*id))
+        .find(|binding| binding.range() == var.range())?;
+
+    let references: Vec<&ResolvedReference> = binding
+        .references
+        .iter()
+        .map(|id| semantic.reference(*id))
+        .filter(|reference| with.range().contains_range(reference.range()))
+        .collect();
+
+    let [reference] = references.as_slice() else {
+        return None;
+    };
+    Some(FileOpen {
+        item,
+        filename,
+        mode,
+        keywords,
+        reference,
+        path_obj: Some(attr.value.as_ref()),
     })
 }
 

crates/ruff_linter/src/rules/refurb/rules/write_whole_file.rs

@@ -47,6 +47,7 @@ use crate::{FixAvailability, Violation};
 pub(crate) struct WriteWholeFile {
     filename: SourceCodeSnippet,
     suggestion: SourceCodeSnippet,
+    is_path_open: bool,
 }
 
 impl Violation for WriteWholeFile {
@@ -56,7 +57,13 @@ impl Violation for WriteWholeFile {
     fn message(&self) -> String {
         let filename = self.filename.truncated_display();
         let suggestion = self.suggestion.truncated_display();
-        format!("`open` and `write` should be replaced by `Path({filename}).{suggestion}`")
+        if self.is_path_open {
+            format!(
+                "`Path.open()` followed by `write()` can be replaced by `Path({filename}).{suggestion}`"
+            )
+        } else {
+            format!("`open` and `write` should be replaced by `Path({filename}).{suggestion}`")
+        }
     }
     fn fix_title(&self) -> Option<String> {
         Some(format!(
@@ -137,6 +144,7 @@ impl<'a> Visitor<'a> for WriteMatcher<'a, '_> {
                                 &self.checker.generator().expr(open.filename),
                             ),
                             suggestion: SourceCodeSnippet::from_str(&suggestion),
+                            is_path_open: open.path_obj.is_some(),
                         },
                         open.item.range(),
                     );
@@ -221,7 +229,13 @@ fn generate_fix(
         )
         .ok()?;
 
-    let replacement = format!("{binding}({filename_code}).{suggestion}");
+    let target = if let Some(path_obj) = open.path_obj {
+        locator.slice(path_obj.range()).to_string()
+    } else {
+        format!("{binding}({filename_code})")
+    };
+
+    let replacement = format!("{target}.{suggestion}");
 
     let applicability = if checker.comment_ranges().intersects(with_stmt.range()) {
         Applicability::Unsafe