rewrite user_error/info/warn to conform to the syntax supported by xlat!

this is a more restricted, subset of what format_args accepts; if in the
future we get clippy lints about this, we should be prepared to silence them

Author: squell

src/exec/mod.rs

@@ -137,7 +137,11 @@ pub fn run_command(
         unsafe {
             command.pre_exec(move || {
                 if let Err(err) = env::set_current_dir(&path) {
-                    user_error!("unable to change directory to {}: {}", path.display(), err);
+                    user_error!(
+                        "unable to change directory to {path}: {error}",
+                        path = path.display(),
+                        error = err
+                    );
                     if is_chdir {
                         return Err(err);
                     }

src/su/context.rs

@@ -144,8 +144,8 @@ impl SuContext {
         // taken into account, unless su is called by root.
         if is_restricted(user_shell.as_path()) && !is_current_root {
             user_warn!(
-                "using restricted shell {}",
-                user_shell.as_os_str().to_string_lossy()
+                "using restricted shell {path}",
+                path = user_shell.as_os_str().to_string_lossy()
             );
             command = user_shell;
         }

src/sudo/cli/mod.rs

@@ -676,7 +676,8 @@ impl SudoOptions {
                     }
                     "-E" | "--preserve-env" => {
                         user_warn!(
-                            "preserving the entire environment is not supported, `{flag}` is ignored"
+                            "preserving the entire environment is not supported, '{flag}' is ignored",
+                            flag = flag
                         )
                     }
                     "-e" | "--edit" if !invoked_as_sudoedit => {

src/sudo/edit.rs

@@ -142,7 +142,7 @@ pub(super) fn edit_files(
         let data = file.new_data.expect("filled in above");
         if data == file.old_data {
             // File unchanged. No need to write it again.
-            user_info!("{} unchanged", file.path.display());
+            user_info!("{path} unchanged", path = file.path.display());
             continue;
         }
 
@@ -181,8 +181,9 @@ impl Drop for TempDirDropGuard {
     fn drop(&mut self) {
         if let Err(e) = std::fs::remove_dir_all(&self.0) {
             user_error!(
-                "failed to remove temporary directory {}: {e}",
-                self.0.display(),
+                "failed to remove temporary directory {path}: {error}",
+                path = self.0.display(),
+                error = e
             );
         };
     }
@@ -192,7 +193,7 @@ fn handle_child(editor: &Path, file: Vec<ChildFileInfo<'_>>) -> ! {
     match handle_child_inner(editor, file) {
         Ok(()) => process::exit(0),
         Err(err) => {
-            user_error!("{err}");
+            user_error!("{error}", error = err);
             process::exit(1);
         }
     }
@@ -308,7 +309,7 @@ fn handle_child_inner(editor: &Path, mut files: Vec<ChildFileInfo<'_>>) -> Resul
             ) {
                 Ok(b'y') => {}
                 _ => {
-                    user_info!("not overwriting {}", file.path.display());
+                    user_info!("not overwriting {path}", path = file.path.display());
 
                     // Parent ignores write when new data matches old data
                     write_stream(&mut file.new_data_tx, &file.old_data)

src/sudo/pipeline/edit.rs

@@ -34,12 +34,17 @@ pub fn run_edit(edit_opts: SudoEditOptions) -> Result<(), Error> {
                 Ok(file) => opened_files.push((path, file)),
                 // ErrorKind::FilesystemLoop was only stabilized in 1.83
                 Err(error) if error.raw_os_error() == Some(libc::ELOOP) => {
-                    user_error!("{arg}: editing symbolic links is not permitted")
+                    user_error!(
+                        "{path}: editing symbolic links is not permitted",
+                        path = arg
+                    )
+                }
+                Err(error) => {
+                    user_error!("error opening {path}: {error}", path = arg, error = error)
                 }
-                Err(error) => user_error!("error opening {arg}: {error}"),
             }
         } else {
-            user_error!("invalid path: {arg}");
+            user_error!("invalid path: {path}", path = arg);
         }
     }