[flake8-use-pathlib] Add autofixes for PTH203, PTH204, PTH205 (#18922)

<!--
Thank you for contributing to Ruff/ty! To help us out with reviewing,
please consider the following:

- Does this pull request include a summary of the change? (See below.)
- Does this pull request include a descriptive title? (Please prefix
with `[ty]` for ty pull
  requests.)
- Does this pull request include references to any relevant issues?
-->

## Summary
Part of #2331 |
[#18763](#18763 (comment))
<!-- What's the purpose of the change? What does it do, and why? -->

## Test Plan
update snapshots
<!-- How was it tested? -->

Author: chirizxc

crates/ruff_linter/resources/test/fixtures/flake8_use_pathlib/PTH203.py

@@ -1,4 +1,4 @@
-import os.path
+import os.path, pathlib
 from pathlib import Path
 from os.path import getatime
 
@@ -10,3 +10,26 @@
 getatime("filename")
 getatime(b"filename")
 getatime(Path("filename"))
+
+
+file = __file__
+
+os.path.getatime(file)
+os.path.getatime(filename="filename")
+os.path.getatime(filename=Path("filename"))
+
+os.path.getatime(  # comment 1
+    # comment 2
+    "filename"  # comment 3
+    # comment 4
+    ,  # comment 5
+    # comment 6
+)  # comment 7
+
+os.path.getatime("file" + "name")
+
+getatime(Path("filename").resolve())
+
+os.path.getatime(pathlib.Path("filename"))
+
+getatime(Path("dir") / "file.txt")

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

@@ -1062,9 +1062,6 @@ pub(crate) fn expression(expr: &Expr, checker: &Checker) {
                 Rule::OsPathSplitext,
                 Rule::BuiltinOpen,
                 Rule::PyPath,
-                Rule::OsPathGetatime,
-                Rule::OsPathGetmtime,
-                Rule::OsPathGetctime,
                 Rule::Glob,
                 Rule::OsListdir,
                 Rule::OsSymlink,
@@ -1074,6 +1071,15 @@ pub(crate) fn expression(expr: &Expr, checker: &Checker) {
             if checker.is_rule_enabled(Rule::OsPathGetsize) {
                 flake8_use_pathlib::rules::os_path_getsize(checker, call);
             }
+            if checker.is_rule_enabled(Rule::OsPathGetatime) {
+                flake8_use_pathlib::rules::os_path_getatime(checker, call);
+            }
+            if checker.is_rule_enabled(Rule::OsPathGetctime) {
+                flake8_use_pathlib::rules::os_path_getctime(checker, call);
+            }
+            if checker.is_rule_enabled(Rule::OsPathGetmtime) {
+                flake8_use_pathlib::rules::os_path_getmtime(checker, call);
+            }
             if checker.is_rule_enabled(Rule::PathConstructorCurrentDirectory) {
                 flake8_use_pathlib::rules::path_constructor_current_directory(checker, call);
             }

crates/ruff_linter/src/preview.rs

@@ -54,6 +54,20 @@ pub(crate) const fn is_fix_manual_list_comprehension_enabled(settings: &LinterSe
 pub(crate) const fn is_fix_os_path_getsize_enabled(settings: &LinterSettings) -> bool {
     settings.preview.is_enabled()
 }
+// https://github.com/astral-sh/ruff/pull/18922
+pub(crate) const fn is_fix_os_path_getmtime_enabled(settings: &LinterSettings) -> bool {
+    settings.preview.is_enabled()
+}
+
+// https://github.com/astral-sh/ruff/pull/18922
+pub(crate) const fn is_fix_os_path_getatime_enabled(settings: &LinterSettings) -> bool {
+    settings.preview.is_enabled()
+}
+
+// https://github.com/astral-sh/ruff/pull/18922
+pub(crate) const fn is_fix_os_path_getctime_enabled(settings: &LinterSettings) -> bool {
+    settings.preview.is_enabled()
+}
 
 // https://github.com/astral-sh/ruff/pull/11436
 // https://github.com/astral-sh/ruff/pull/11168

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

@@ -0,0 +1,72 @@
+use crate::checkers::ast::Checker;
+use crate::importer::ImportRequest;
+use crate::{Applicability, Edit, Fix, Violation};
+use ruff_python_ast::{Expr, ExprCall};
+use ruff_text_size::Ranged;
+
+pub(crate) fn is_path_call(checker: &Checker, expr: &Expr) -> bool {
+    expr.as_call_expr().is_some_and(|expr_call| {
+        checker
+            .semantic()
+            .resolve_qualified_name(&expr_call.func)
+            .is_some_and(|name| matches!(name.segments(), ["pathlib", "Path"]))
+    })
+}
+
+pub(crate) fn check_os_path_get_calls(
+    checker: &Checker,
+    call: &ExprCall,
+    fn_name: &str,
+    attr: &str,
+    fix_enabled: bool,
+    violation: impl Violation,
+) {
+    if checker
+        .semantic()
+        .resolve_qualified_name(&call.func)
+        .is_none_or(|qualified_name| qualified_name.segments() != ["os", "path", fn_name])
+    {
+        return;
+    }
+
+    if call.arguments.len() != 1 {
+        return;
+    }
+
+    let Some(arg) = call.arguments.find_argument_value("filename", 0) else {
+        return;
+    };
+
+    let arg_code = checker.locator().slice(arg.range());
+    let range = call.range();
+
+    let mut diagnostic = checker.report_diagnostic(violation, call.func.range());
+
+    if fix_enabled {
+        diagnostic.try_set_fix(|| {
+            let (import_edit, binding) = checker.importer().get_or_import_symbol(
+                &ImportRequest::import("pathlib", "Path"),
+                call.start(),
+                checker.semantic(),
+            )?;
+
+            let applicability = if checker.comment_ranges().intersects(range) {
+                Applicability::Unsafe
+            } else {
+                Applicability::Safe
+            };
+
+            let replacement = if is_path_call(checker, arg) {
+                format!("{arg_code}.stat().{attr}")
+            } else {
+                format!("{binding}({arg_code}).stat().{attr}")
+            };
+
+            Ok(Fix::applicable_edits(
+                Edit::range_replacement(replacement, range),
+                [import_edit],
+                applicability,
+            ))
+        });
+    }
+}

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

@@ -1,4 +1,5 @@
 //! Rules from [flake8-use-pathlib](https://pypi.org/project/flake8-use-pathlib/).
+mod helpers;
 pub(crate) mod rules;
 pub(crate) mod violations;
 
@@ -81,6 +82,9 @@ mod tests {
 
     #[test_case(Rule::OsPathGetsize, Path::new("PTH202.py"))]
     #[test_case(Rule::OsPathGetsize, Path::new("PTH202_2.py"))]
+    #[test_case(Rule::OsPathGetatime, Path::new("PTH203.py"))]
+    #[test_case(Rule::OsPathGetmtime, Path::new("PTH204.py"))]
+    #[test_case(Rule::OsPathGetctime, Path::new("PTH205.py"))]
     fn preview_flake8_use_pathlib(rule_code: Rule, path: &Path) -> Result<()> {
         let snapshot = format!(
             "preview__{}_{}",

crates/ruff_linter/src/rules/flake8_use_pathlib/rules/os_path_getatime.rs

@@ -1,6 +1,9 @@
+use crate::checkers::ast::Checker;
+use crate::preview::is_fix_os_path_getatime_enabled;
+use crate::rules::flake8_use_pathlib::helpers::check_os_path_get_calls;
+use crate::{FixAvailability, Violation};
 use ruff_macros::{ViolationMetadata, derive_message_formats};
-
-use crate::Violation;
+use ruff_python_ast::ExprCall;
 
 /// ## What it does
 /// Checks for uses of `os.path.getatime`.
@@ -32,6 +35,9 @@ use crate::Violation;
 /// it can be less performant than the lower-level alternatives that work directly with strings,
 /// especially on older versions of Python.
 ///
+/// ## Fix Safety
+/// This rule's fix is marked as unsafe if the replacement would remove comments attached to the original expression.
+///
 /// ## References
 /// - [Python documentation: `Path.stat`](https://docs.python.org/3/library/pathlib.html#pathlib.Path.stat)
 /// - [Python documentation: `os.path.getatime`](https://docs.python.org/3/library/os.path.html#os.path.getatime)
@@ -43,8 +49,25 @@ use crate::Violation;
 pub(crate) struct OsPathGetatime;
 
 impl Violation for OsPathGetatime {
+    const FIX_AVAILABILITY: FixAvailability = FixAvailability::Sometimes;
     #[derive_message_formats]
     fn message(&self) -> String {
         "`os.path.getatime` should be replaced by `Path.stat().st_atime`".to_string()
     }
+
+    fn fix_title(&self) -> Option<String> {
+        Some("Replace with `Path.stat(...).st_atime`".to_string())
+    }
+}
+
+/// PTH203
+pub(crate) fn os_path_getatime(checker: &Checker, call: &ExprCall) {
+    check_os_path_get_calls(
+        checker,
+        call,
+        "getatime",
+        "st_atime",
+        is_fix_os_path_getatime_enabled(checker.settings()),
+        OsPathGetatime,
+    );
 }

crates/ruff_linter/src/rules/flake8_use_pathlib/rules/os_path_getctime.rs

@@ -1,6 +1,9 @@
+use crate::checkers::ast::Checker;
+use crate::preview::is_fix_os_path_getctime_enabled;
+use crate::rules::flake8_use_pathlib::helpers::check_os_path_get_calls;
+use crate::{FixAvailability, Violation};
 use ruff_macros::{ViolationMetadata, derive_message_formats};
-
-use crate::Violation;
+use ruff_python_ast::ExprCall;
 
 /// ## What it does
 /// Checks for uses of `os.path.getctime`.
@@ -32,6 +35,9 @@ use crate::Violation;
 /// it can be less performant than the lower-level alternatives that work directly with strings,
 /// especially on older versions of Python.
 ///
+/// ## Fix Safety
+/// This rule's fix is marked as unsafe if the replacement would remove comments attached to the original expression.
+///
 /// ## References
 /// - [Python documentation: `Path.stat`](https://docs.python.org/3/library/pathlib.html#pathlib.Path.stat)
 /// - [Python documentation: `os.path.getctime`](https://docs.python.org/3/library/os.path.html#os.path.getctime)
@@ -43,8 +49,26 @@ use crate::Violation;
 pub(crate) struct OsPathGetctime;
 
 impl Violation for OsPathGetctime {
+    const FIX_AVAILABILITY: FixAvailability = FixAvailability::Sometimes;
+
     #[derive_message_formats]
     fn message(&self) -> String {
         "`os.path.getctime` should be replaced by `Path.stat().st_ctime`".to_string()
     }
+
+    fn fix_title(&self) -> Option<String> {
+        Some("Replace with `Path.stat(...).st_ctime`".to_string())
+    }
+}
+
+/// PTH205
+pub(crate) fn os_path_getctime(checker: &Checker, call: &ExprCall) {
+    check_os_path_get_calls(
+        checker,
+        call,
+        "getctime",
+        "st_ctime",
+        is_fix_os_path_getctime_enabled(checker.settings()),
+        OsPathGetctime,
+    );
 }

crates/ruff_linter/src/rules/flake8_use_pathlib/rules/os_path_getmtime.rs

@@ -1,6 +1,9 @@
+use crate::checkers::ast::Checker;
+use crate::preview::is_fix_os_path_getmtime_enabled;
+use crate::rules::flake8_use_pathlib::helpers::check_os_path_get_calls;
+use crate::{FixAvailability, Violation};
 use ruff_macros::{ViolationMetadata, derive_message_formats};
-
-use crate::Violation;
+use ruff_python_ast::ExprCall;
 
 /// ## What it does
 /// Checks for uses of `os.path.getmtime`.
@@ -32,6 +35,9 @@ use crate::Violation;
 /// it can be less performant than the lower-level alternatives that work directly with strings,
 /// especially on older versions of Python.
 ///
+/// ## Fix Safety
+/// This rule's fix is marked as unsafe if the replacement would remove comments attached to the original expression.
+///
 /// ## References
 /// - [Python documentation: `Path.stat`](https://docs.python.org/3/library/pathlib.html#pathlib.Path.stat)
 /// - [Python documentation: `os.path.getmtime`](https://docs.python.org/3/library/os.path.html#os.path.getmtime)
@@ -43,8 +49,26 @@ use crate::Violation;
 pub(crate) struct OsPathGetmtime;
 
 impl Violation for OsPathGetmtime {
+    const FIX_AVAILABILITY: FixAvailability = FixAvailability::Sometimes;
+
     #[derive_message_formats]
     fn message(&self) -> String {
         "`os.path.getmtime` should be replaced by `Path.stat().st_mtime`".to_string()
     }
+
+    fn fix_title(&self) -> Option<String> {
+        Some("Replace with `Path.stat(...).st_mtime`".to_string())
+    }
+}
+
+/// PTH204
+pub(crate) fn os_path_getmtime(checker: &Checker, call: &ExprCall) {
+    check_os_path_get_calls(
+        checker,
+        call,
+        "getmtime",
+        "st_mtime",
+        is_fix_os_path_getmtime_enabled(checker.settings()),
+        OsPathGetmtime,
+    );
 }