fix suggestions

Author: merelymyself

clippy_lints/src/path_from_format.rs

@@ -1,6 +1,6 @@
-use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::macros::{root_macro_call, FormatArgsExpn};
-use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
@@ -45,46 +45,44 @@ impl<'tcx> LateLintPass<'tcx> for PathFromFormat {
             if let Some(macro_call) = root_macro_call(args[0].span);
             if cx.tcx.item_name(macro_call.def_id) == sym::format;
             if let Some(format_args) = FormatArgsExpn::find_nested(cx, &args[0], macro_call.expn);
-            let mut applicability = Applicability::MachineApplicable;
-            let format_args_snip = snippet_with_applicability(cx, format_args.inputs_span(), "..", &mut applicability);
-            if let Some(end_of_literal) = format_args_snip.find("\",");
+            let format_string_parts = format_args.format_string_parts;
+            let format_value_args = format_args.value_args;
             then {
-                let (literal, vars) = format_args_snip.split_at(end_of_literal);
-                let mut literal = literal.to_string();
-                literal.remove(0);
-                let v: Vec<&str> = literal.split("{}").collect();
-                let real_vars = vars.strip_prefix("\", ").unwrap_or(vars);
-                if v.len() != 2 || real_vars.contains(',') {
-                    span_lint_and_help(
-                        cx,
-                        PATH_FROM_FORMAT,
-                        expr.span,
-                        "`format!(..)` used to form `PathBuf`",
-                        None,
-                        "consider using `.join()` to avoid the extra allocation",
-                    );
-                    return;
-                }
-                let sugg = {
-                    if v[0].is_empty() {
-                        let mut str1 = v[1].to_string();
-                        if str1.starts_with('\\') || str1.starts_with('/') {
-                            str1.remove(0);
+                let mut string_parts: Vec<&str> = format_string_parts.iter().map(|x| x.as_str()).collect();
+                string_parts.push("");
+                let mut applicability = Applicability::MachineApplicable;
+                let real_vars: Vec<Sugg<'_>> = format_value_args.iter().map(|x| Sugg::hir_with_applicability(cx, x, "..", &mut applicability)).collect();
+                let order_of_real_vars: Vec<usize> = format_args.formatters.iter().map(|(x, _)| x.clone()).collect();
+                let mut sugg = String::new();
+                for n in 0..real_vars.len() {
+                    if n == 0 {
+                        if string_parts[0].is_empty() {
+                            sugg = format!("Path::new({})", real_vars[order_of_real_vars[0]]);
+                        }
+                        else {
+                            sugg = format!("Path::new(\"{}\").join({y})", string_parts[0], y = real_vars[order_of_real_vars[0]]);
                         }
-                        format!("Path::new({real_vars}).join(\"{str1}\")")
-                    }
-                    else if v[1].is_empty() {
-                        let str1 = v[0].to_string();
-                        format!("Path::new(\"{str1}\").join({real_vars})")
                     }
                     else {
-                        let (str1, mut str2) = (v[0].to_string(), v[1].to_string());
-                        if str2.starts_with('\\') || str2.starts_with('/') {
-                            str2.remove(0);
+                        if string_parts[n].is_empty() {
+                            sugg = format!("{sugg}.join({})", real_vars[order_of_real_vars[n]]);
+                        }
+                        else {
+                            let mut string = String::from(string_parts[n]);
+                            if string.starts_with('/') || string.starts_with('\\') {
+                                string.remove(0);
+                            }
+                            sugg = format!("{sugg}.join(\"{}\").join({y})", string, y = real_vars[order_of_real_vars[n]]);
                         }
-                        format!("Path::new(\"{str1}\").join({real_vars}).join(\"{str2}\")")
                     }
-                };
+                }
+                if !string_parts[real_vars.len()].is_empty() {
+                    let mut string = String::from(string_parts[real_vars.len()]);
+                    if string.starts_with('/') || string.starts_with('\\') {
+                        string.remove(0);
+                    }
+                    sugg = format!("{sugg}.join(\"{}\")", string);
+                }
                 span_lint_and_sugg(
                     cx,
                     PATH_FROM_FORMAT,

tests/ui/path_from_format.rs

@@ -8,4 +8,5 @@ fn main() {
     PathBuf::from(format!("/foo/bar/{}", base_path1));
     PathBuf::from(format!("/foo/{}/bar", base_path1));
     PathBuf::from(format!("foo/{}/bar", base_path1));
+    PathBuf::from(format!("foo/{base_path1}/bar"));
 }

tests/ui/path_from_format.stderr

@@ -24,5 +24,11 @@ error: `format!(..)` used to form `PathBuf`
 LL |     PathBuf::from(format!("foo/{}/bar", base_path1));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.join()` to avoid the extra allocation: `Path::new("foo/").join(base_path1).join("bar")`
 
-error: aborting due to 4 previous errors
+error: `format!(..)` used to form `PathBuf`
+  --> $DIR/path_from_format.rs:11:5
+   |
+LL |     PathBuf::from(format!("foo/{base_path1}/bar"));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.join()` to avoid the extra allocation: `Path::new("foo/").join(base_path1).join("bar")`
+
+error: aborting due to 5 previous errors