[flake8-use-pathlib] Add autofixes for PTH100, PTH106, PTH107, PTH108, PTH110, PTH111, PTH112, PTH113, PTH114, PTH115, PTH117, PTH119, PTH120

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

@@ -1037,27 +1037,14 @@ pub(crate) fn expression(expr: &Expr, checker: &Checker) {
                 flake8_simplify::rules::zip_dict_keys_and_values(checker, call);
             }
             if checker.any_rule_enabled(&[
-                Rule::OsPathAbspath,
                 Rule::OsChmod,
                 Rule::OsMkdir,
                 Rule::OsMakedirs,
                 Rule::OsRename,
                 Rule::OsReplace,
-                Rule::OsRmdir,
-                Rule::OsRemove,
-                Rule::OsUnlink,
                 Rule::OsGetcwd,
-                Rule::OsPathExists,
-                Rule::OsPathExpanduser,
-                Rule::OsPathIsdir,
-                Rule::OsPathIsfile,
-                Rule::OsPathIslink,
-                Rule::OsReadlink,
                 Rule::OsStat,
-                Rule::OsPathIsabs,
                 Rule::OsPathJoin,
-                Rule::OsPathBasename,
-                Rule::OsPathDirname,
                 Rule::OsPathSamefile,
                 Rule::OsPathSplitext,
                 Rule::BuiltinOpen,
@@ -1068,21 +1055,66 @@ pub(crate) fn expression(expr: &Expr, checker: &Checker) {
             ]) {
                 flake8_use_pathlib::rules::replaceable_by_pathlib(checker, call);
             }
-            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);
+            if let Some(qualified_name) = checker.semantic().resolve_qualified_name(&call.func) {
+                let segments = qualified_name.segments();
+                if checker.is_rule_enabled(Rule::OsPathGetsize) {
+                    flake8_use_pathlib::rules::os_path_getsize(checker, call, segments);
+                }
+                if checker.is_rule_enabled(Rule::OsPathGetatime) {
+                    flake8_use_pathlib::rules::os_path_getatime(checker, call, segments);
+                }
+                if checker.is_rule_enabled(Rule::OsPathGetctime) {
+                    flake8_use_pathlib::rules::os_path_getctime(checker, call, segments);
+                }
+                if checker.is_rule_enabled(Rule::OsPathGetmtime) {
+                    flake8_use_pathlib::rules::os_path_getmtime(checker, call, segments);
+                }
+                if checker.is_rule_enabled(Rule::OsPathAbspath) {
+                    flake8_use_pathlib::rules::os_path_abspath(checker, call, segments);
+                }
+                if checker.is_rule_enabled(Rule::OsRmdir) {
+                    flake8_use_pathlib::rules::os_rmdir(checker, call, segments);
+                }
+                if checker.is_rule_enabled(Rule::OsRemove) {
+                    flake8_use_pathlib::rules::os_remove(checker, call, segments);
+                }
+                if checker.is_rule_enabled(Rule::OsUnlink) {
+                    flake8_use_pathlib::rules::os_unlink(checker, call, segments);
+                }
+                if checker.is_rule_enabled(Rule::OsPathExists) {
+                    flake8_use_pathlib::rules::os_path_exists(checker, call, segments);
+                }
+                if checker.is_rule_enabled(Rule::OsPathExpanduser) {
+                    flake8_use_pathlib::rules::os_path_expanduser(checker, call, segments);
+                }
+                if checker.is_rule_enabled(Rule::OsPathBasename) {
+                    flake8_use_pathlib::rules::os_path_basename(checker, call, segments);
+                }
+                if checker.is_rule_enabled(Rule::OsPathDirname) {
+                    flake8_use_pathlib::rules::os_path_dirname(checker, call, segments);
+                }
+                if checker.is_rule_enabled(Rule::OsPathIsabs) {
+                    flake8_use_pathlib::rules::os_path_isabs(checker, call, segments);
+                }
+                if checker.is_rule_enabled(Rule::OsPathIsdir) {
+                    flake8_use_pathlib::rules::os_path_isdir(checker, call, segments);
+                }
+                if checker.is_rule_enabled(Rule::OsPathIsfile) {
+                    flake8_use_pathlib::rules::os_path_isfile(checker, call, segments);
+                }
+                if checker.is_rule_enabled(Rule::OsPathIslink) {
+                    flake8_use_pathlib::rules::os_path_islink(checker, call, segments);
+                }
+                if checker.is_rule_enabled(Rule::OsReadlink) {
+                    flake8_use_pathlib::rules::os_readlink(checker, call, segments);
+                }
+                if checker.is_rule_enabled(Rule::PathConstructorCurrentDirectory) {
+                    flake8_use_pathlib::rules::path_constructor_current_directory(
+                        checker, call, segments,
+                    );
+                }
             }
+
             if checker.is_rule_enabled(Rule::OsSepSplit) {
                 flake8_use_pathlib::rules::os_sep_split(checker, call);
             }

crates/ruff_linter/src/codes.rs

@@ -919,27 +919,27 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Tryceratops, "401") => (RuleGroup::Stable, rules::tryceratops::rules::VerboseLogMessage),
 
         // flake8-use-pathlib
-        (Flake8UsePathlib, "100") => (RuleGroup::Stable, rules::flake8_use_pathlib::violations::OsPathAbspath),
+        (Flake8UsePathlib, "100") => (RuleGroup::Stable, rules::flake8_use_pathlib::rules::OsPathAbspath),
         (Flake8UsePathlib, "101") => (RuleGroup::Stable, rules::flake8_use_pathlib::violations::OsChmod),
         (Flake8UsePathlib, "102") => (RuleGroup::Stable, rules::flake8_use_pathlib::violations::OsMkdir),
         (Flake8UsePathlib, "103") => (RuleGroup::Stable, rules::flake8_use_pathlib::violations::OsMakedirs),
         (Flake8UsePathlib, "104") => (RuleGroup::Stable, rules::flake8_use_pathlib::violations::OsRename),
         (Flake8UsePathlib, "105") => (RuleGroup::Stable, rules::flake8_use_pathlib::violations::OsReplace),
-        (Flake8UsePathlib, "106") => (RuleGroup::Stable, rules::flake8_use_pathlib::violations::OsRmdir),
-        (Flake8UsePathlib, "107") => (RuleGroup::Stable, rules::flake8_use_pathlib::violations::OsRemove),
-        (Flake8UsePathlib, "108") => (RuleGroup::Stable, rules::flake8_use_pathlib::violations::OsUnlink),
+        (Flake8UsePathlib, "106") => (RuleGroup::Stable, rules::flake8_use_pathlib::rules::OsRmdir),
+        (Flake8UsePathlib, "107") => (RuleGroup::Stable, rules::flake8_use_pathlib::rules::OsRemove),
+        (Flake8UsePathlib, "108") => (RuleGroup::Stable, rules::flake8_use_pathlib::rules::OsUnlink),
         (Flake8UsePathlib, "109") => (RuleGroup::Stable, rules::flake8_use_pathlib::violations::OsGetcwd),
-        (Flake8UsePathlib, "110") => (RuleGroup::Stable, rules::flake8_use_pathlib::violations::OsPathExists),
-        (Flake8UsePathlib, "111") => (RuleGroup::Stable, rules::flake8_use_pathlib::violations::OsPathExpanduser),
-        (Flake8UsePathlib, "112") => (RuleGroup::Stable, rules::flake8_use_pathlib::violations::OsPathIsdir),
-        (Flake8UsePathlib, "113") => (RuleGroup::Stable, rules::flake8_use_pathlib::violations::OsPathIsfile),
-        (Flake8UsePathlib, "114") => (RuleGroup::Stable, rules::flake8_use_pathlib::violations::OsPathIslink),
-        (Flake8UsePathlib, "115") => (RuleGroup::Stable, rules::flake8_use_pathlib::violations::OsReadlink),
+        (Flake8UsePathlib, "110") => (RuleGroup::Stable, rules::flake8_use_pathlib::rules::OsPathExists),
+        (Flake8UsePathlib, "111") => (RuleGroup::Stable, rules::flake8_use_pathlib::rules::OsPathExpanduser),
+        (Flake8UsePathlib, "112") => (RuleGroup::Stable, rules::flake8_use_pathlib::rules::OsPathIsdir),
+        (Flake8UsePathlib, "113") => (RuleGroup::Stable, rules::flake8_use_pathlib::rules::OsPathIsfile),
+        (Flake8UsePathlib, "114") => (RuleGroup::Stable, rules::flake8_use_pathlib::rules::OsPathIslink),
+        (Flake8UsePathlib, "115") => (RuleGroup::Stable, rules::flake8_use_pathlib::rules::OsReadlink),
         (Flake8UsePathlib, "116") => (RuleGroup::Stable, rules::flake8_use_pathlib::violations::OsStat),
-        (Flake8UsePathlib, "117") => (RuleGroup::Stable, rules::flake8_use_pathlib::violations::OsPathIsabs),
+        (Flake8UsePathlib, "117") => (RuleGroup::Stable, rules::flake8_use_pathlib::rules::OsPathIsabs),
         (Flake8UsePathlib, "118") => (RuleGroup::Stable, rules::flake8_use_pathlib::violations::OsPathJoin),
-        (Flake8UsePathlib, "119") => (RuleGroup::Stable, rules::flake8_use_pathlib::violations::OsPathBasename),
-        (Flake8UsePathlib, "120") => (RuleGroup::Stable, rules::flake8_use_pathlib::violations::OsPathDirname),
+        (Flake8UsePathlib, "119") => (RuleGroup::Stable, rules::flake8_use_pathlib::rules::OsPathBasename),
+        (Flake8UsePathlib, "120") => (RuleGroup::Stable, rules::flake8_use_pathlib::rules::OsPathDirname),
         (Flake8UsePathlib, "121") => (RuleGroup::Stable, rules::flake8_use_pathlib::violations::OsPathSamefile),
         (Flake8UsePathlib, "122") => (RuleGroup::Stable, rules::flake8_use_pathlib::violations::OsPathSplitext),
         (Flake8UsePathlib, "123") => (RuleGroup::Stable, rules::flake8_use_pathlib::violations::BuiltinOpen),

crates/ruff_linter/src/preview.rs

@@ -69,6 +69,71 @@ pub(crate) const fn is_fix_os_path_getctime_enabled(settings: &LinterSettings) -
     settings.preview.is_enabled()
 }
 
+// https://github.com/astral-sh/ruff/pull/19213
+pub(crate) const fn is_fix_os_path_abspath_enabled(settings: &LinterSettings) -> bool {
+    settings.preview.is_enabled()
+}
+
+// https://github.com/astral-sh/ruff/pull/19213
+pub(crate) const fn is_fix_os_rmdir_enabled(settings: &LinterSettings) -> bool {
+    settings.preview.is_enabled()
+}
+
+// https://github.com/astral-sh/ruff/pull/19213
+pub(crate) const fn is_fix_os_unlink_enabled(settings: &LinterSettings) -> bool {
+    settings.preview.is_enabled()
+}
+
+// https://github.com/astral-sh/ruff/pull/19213
+pub(crate) const fn is_fix_os_remove_enabled(settings: &LinterSettings) -> bool {
+    settings.preview.is_enabled()
+}
+
+// https://github.com/astral-sh/ruff/pull/19213
+pub(crate) const fn is_fix_os_path_exists_enabled(settings: &LinterSettings) -> bool {
+    settings.preview.is_enabled()
+}
+
+// https://github.com/astral-sh/ruff/pull/19213
+pub(crate) const fn is_fix_os_path_expanduser_enabled(settings: &LinterSettings) -> bool {
+    settings.preview.is_enabled()
+}
+
+// https://github.com/astral-sh/ruff/pull/19213
+pub(crate) const fn is_fix_os_path_isdir_enabled(settings: &LinterSettings) -> bool {
+    settings.preview.is_enabled()
+}
+
+// https://github.com/astral-sh/ruff/pull/19213
+pub(crate) const fn is_fix_os_path_isfile_enabled(settings: &LinterSettings) -> bool {
+    settings.preview.is_enabled()
+}
+
+// https://github.com/astral-sh/ruff/pull/19213
+pub(crate) const fn is_fix_os_path_islink_enabled(settings: &LinterSettings) -> bool {
+    settings.preview.is_enabled()
+}
+
+// https://github.com/astral-sh/ruff/pull/19213
+pub(crate) const fn is_fix_os_path_isabs_enabled(settings: &LinterSettings) -> bool {
+    settings.preview.is_enabled()
+}
+
+// https://github.com/astral-sh/ruff/pull/19213
+pub(crate) const fn is_fix_os_readlink_enabled(settings: &LinterSettings) -> bool {
+    settings.preview.is_enabled()
+}
+
+// https://github.com/astral-sh/ruff/pull/19213
+pub(crate) const fn is_fix_os_path_basename_enabled(settings: &LinterSettings) -> bool {
+    settings.preview.is_enabled()
+}
+
+// https://github.com/astral-sh/ruff/pull/19213
+pub(crate) const fn is_fix_os_path_dirname_enabled(settings: &LinterSettings) -> bool {
+    settings.preview.is_enabled()
+}
+
 // https://github.com/astral-sh/ruff/pull/11436
 // https://github.com/astral-sh/ruff/pull/11168
 pub(crate) const fn is_dunder_init_fix_unused_import_enabled(settings: &LinterSettings) -> bool {

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

@@ -1,10 +1,17 @@
 use crate::checkers::ast::Checker;
 use crate::importer::ImportRequest;
 use crate::{Applicability, Edit, Fix, Violation};
+use ruff_python_ast::{self as ast};
 use ruff_python_ast::{Expr, ExprCall};
 use ruff_text_size::Ranged;
 
-pub(crate) fn is_path_call(checker: &Checker, expr: &Expr) -> bool {
+pub(crate) fn is_keyword_only_argument_non_default(arguments: &ast::Arguments, name: &str) -> bool {
+    arguments
+        .find_keyword(name)
+        .is_some_and(|keyword| !keyword.value.is_none_literal_expr())
+}
+
+pub(crate) fn is_pathlib_path_call(checker: &Checker, expr: &Expr) -> bool {
     expr.as_call_expr().is_some_and(|expr_call| {
         checker
             .semantic()
@@ -13,27 +20,22 @@ pub(crate) fn is_path_call(checker: &Checker, expr: &Expr) -> bool {
     })
 }
 
-pub(crate) fn check_os_path_get_calls(
+/// We check functions that take only 1 argument,  this does not apply to functions
+/// with `dir_fd` argument, because `dir_fd` is not supported by pathlib,
+/// so check if it's set to non-default values
+pub(crate) fn check_os_pathlib_single_arg_calls(
     checker: &Checker,
     call: &ExprCall,
-    fn_name: &str,
     attr: &str,
+    fn_argument: &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 {
+    let Some(arg) = call.arguments.find_argument_value(fn_argument, 0) else {
         return;
     };
 
@@ -56,10 +58,10 @@ pub(crate) fn check_os_path_get_calls(
                 Applicability::Safe
             };
 
-            let replacement = if is_path_call(checker, arg) {
-                format!("{arg_code}.stat().{attr}")
+            let replacement = if is_pathlib_path_call(checker, arg) {
+                format!("{arg_code}.{attr}")
             } else {
-                format!("{binding}({arg_code}).stat().{attr}")
+                format!("{binding}({arg_code}).{attr}")
             };
 
             Ok(Fix::applicable_edits(

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

@@ -80,6 +80,48 @@ mod tests {
         Ok(())
     }
 
+    #[test_case(Path::new("full_name.py"))]
+    #[test_case(Path::new("import_as.py"))]
+    #[test_case(Path::new("import_from_as.py"))]
+    #[test_case(Path::new("import_from.py"))]
+    fn preview_rules(path: &Path) -> Result<()> {
+        let snapshot = format!("preview_{}", path.to_string_lossy());
+        let diagnostics = test_path(
+            Path::new("flake8_use_pathlib").join(path).as_path(),
+            &settings::LinterSettings {
+                preview: PreviewMode::Enabled,
+                ..settings::LinterSettings::for_rules(vec![
+                    Rule::OsPathAbspath,
+                    Rule::OsChmod,
+                    Rule::OsMkdir,
+                    Rule::OsMakedirs,
+                    Rule::OsRename,
+                    Rule::OsReplace,
+                    Rule::OsRmdir,
+                    Rule::OsRemove,
+                    Rule::OsUnlink,
+                    Rule::OsGetcwd,
+                    Rule::OsPathExists,
+                    Rule::OsPathExpanduser,
+                    Rule::OsPathIsdir,
+                    Rule::OsPathIsfile,
+                    Rule::OsPathIslink,
+                    Rule::OsReadlink,
+                    Rule::OsStat,
+                    Rule::OsPathIsabs,
+                    Rule::OsPathJoin,
+                    Rule::OsPathBasename,
+                    Rule::OsPathDirname,
+                    Rule::OsPathSamefile,
+                    Rule::OsPathSplitext,
+                    Rule::BuiltinOpen,
+                ])
+            },
+        )?;
+        assert_diagnostics!(snapshot, diagnostics);
+        Ok(())
+    }
+
     #[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"))]

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

@@ -1,19 +1,45 @@
 pub(crate) use glob_rule::*;
 pub(crate) use invalid_pathlib_with_suffix::*;
+pub(crate) use os_path_abspath::*;
+pub(crate) use os_path_basename::*;
+pub(crate) use os_path_dirname::*;
+pub(crate) use os_path_exists::*;
+pub(crate) use os_path_expanduser::*;
 pub(crate) use os_path_getatime::*;
 pub(crate) use os_path_getctime::*;
 pub(crate) use os_path_getmtime::*;
 pub(crate) use os_path_getsize::*;
+pub(crate) use os_path_isabs::*;
+pub(crate) use os_path_isdir::*;
+pub(crate) use os_path_isfile::*;
+pub(crate) use os_path_islink::*;
+pub(crate) use os_readlink::*;
+pub(crate) use os_remove::*;
+pub(crate) use os_rmdir::*;
 pub(crate) use os_sep_split::*;
+pub(crate) use os_unlink::*;
 pub(crate) use path_constructor_current_directory::*;
 pub(crate) use replaceable_by_pathlib::*;
 
 mod glob_rule;
 mod invalid_pathlib_with_suffix;
+mod os_path_abspath;
+mod os_path_basename;
+mod os_path_dirname;
+mod os_path_exists;
+mod os_path_expanduser;
 mod os_path_getatime;
 mod os_path_getctime;
 mod os_path_getmtime;
 mod os_path_getsize;
+mod os_path_isabs;
+mod os_path_isdir;
+mod os_path_isfile;
+mod os_path_islink;
+mod os_readlink;
+mod os_remove;
+mod os_rmdir;
 mod os_sep_split;
+mod os_unlink;
 mod path_constructor_current_directory;
 mod replaceable_by_pathlib;