}
        if let Err(e) = std::fs::rename(&former, &new) {
            error!("while renaming {:?} to {:?}: {:?}", former, new, e)

        std::fs::rename(&former, &new)?;

    work: Arc<crossbeam_deque::Injector<(OutputItem, String)>>,

    work: Arc<crossbeam_deque::Injector<(OutputItem, String, Option<String>)>>,

            Steal::Success((item, path)) => {

            Steal::Success((item, path, tmp)) => {

                info!("Outputting {:?}, on thread {}", path, t);

                info!("Outputting {:?} (tmp {:?}), on thread {}", path, tmp, t);
                let path = tmp.as_deref().unwrap_or(&path);

                    &path,

                    path,

                repo.set_permissions(&path, item.meta.permissions())

                repo.set_permissions(path, item.meta.permissions())

            None,

                if let Some(ref mut tmp) = output_item.tmp {
                    path::push(tmp, file_name);
                }

                let mut tmp = output_item.tmp.take();

                    &mut tmp,

                    repo.create_dir_all(&path)

                    let tmp_ = tmp.as_deref().unwrap_or(&path);
                    repo.create_dir_all(tmp_)

                            tmp.as_deref(),

                    repo.set_permissions(&path, output_item.meta.permissions())

                    repo.set_permissions(tmp_, output_item.meta.permissions())

                        work.push((output_item.clone(), path.clone()));

                        work.push((output_item.clone(), path.clone(), tmp.clone()));

    for (a, b) in actual_moves.iter() {
        repo.rename(a, b).map_err(OutputError::WorkingCopy)?
    }

    let o = output_loop(repo, changes, txn, channel, work, stop, 0);

    let o = output_loop(repo.clone(), changes, txn, channel, work, stop, 0);

    for (a, b) in actual_moves.iter() {
        repo.rename(a, b).map_err(OutputError::WorkingCopy)?
    }

    tmp: &mut Option<String>,

                if let Some(ref mut tmp) = tmp {
                    crate::path::push(tmp, &s);
                } else {
                    *tmp = Some(tmp_path.clone());
                }

    tmp: Option<String>,

    tmp: Option<&str>,

                tmp: tmp.map(String::from),

        None,

                        None,