rust/hg-core/src/dirstate/status.rs

44896:dc60ba32d43b

fn walk_explicit<'a>(
    files: Option<&'a HashSet<&HgPath>>,
    dmap: &'a DirstateMap,
    root_dir: impl AsRef<Path> + Sync + Send + 'a,
    options: StatusOptions,
) -> impl ParallelIterator<Item = IoResult<(&'a HgPath, Dispatch)>> {
    files
        .unwrap_or(&DEFAULT_WORK)
        .par_iter()
        .map(move |filename| {

                            )));
                        }
                        Some(Ok((normalized, Dispatch::Unknown)))
                    } else {
                        if file_type.is_dir() {
                            Some(Ok((
                                normalized,
                                Dispatch::Directory {
                                    was_file: in_dmap.is_some(),
                                },

    /// Whether we are on a filesystem with UNIX-like exec flags
    pub check_exec: bool,
    pub list_clean: bool,
    pub list_unknown: bool,
    pub list_ignored: bool,
}

/// Dispatch a single entry (file, folder, symlink...) found during `traverse`.
/// If the entry is a folder that needs to be traversed, it will be handled
/// in a separate thread.

    ignore_fn: &'a IgnoreFnType,
    dir_ignore_fn: &'a IgnoreFnType,
    options: StatusOptions,
    filename: HgPathBuf,
    dir_entry: DirEntry,
) -> IoResult<()> {
    let file_type = dir_entry.file_type()?;
    let entry_option = dmap.get(&filename);

    if filename.as_bytes() == b".hg" {

            ignore_fn,
            dir_ignore_fn,
            options,
            entry_option,
            filename,
        );
    } else if file_type.is_file() || file_type.is_symlink() {
        if let Some(entry) = entry_option {
            if matcher.matches_everything() || matcher.matches(&filename) {
                let metadata = dir_entry.metadata()?;

    ignore_fn: &'a IgnoreFnType,
    dir_ignore_fn: &'a IgnoreFnType,
    options: StatusOptions,
    entry_option: Option<&'a DirstateEntry>,
    directory: HgPathBuf,
) {
    scope.spawn(move |_| {
        // Nested `if` until `rust-lang/rust#53668` is stable
        if let Some(entry) = entry_option {
            // Used to be a file, is now a folder

                directory,
                &old_results,
                ignore_fn,
                dir_ignore_fn,
                options,
            )
            .unwrap_or_else(|e| files_sender.send(Err(e)).unwrap())
        }
    });
}

    directory: impl AsRef<HgPath>,
    old_results: &FastHashMap<Cow<'a, HgPath>, Dispatch>,
    ignore_fn: &IgnoreFnType,
    dir_ignore_fn: &IgnoreFnType,
    options: StatusOptions,
) -> IoResult<()> {
    let directory = directory.as_ref();

    let visit_entries = match matcher.visit_children_set(directory) {
        VisitChildrenSet::Empty => return Ok(()),
        VisitChildrenSet::This | VisitChildrenSet::Recursive => None,
        VisitChildrenSet::Set(set) => Some(set),

                    ignore_fn,
                    dir_ignore_fn,
                    options,
                    filename,
                    dir_entry,
                )?;
            }
        }
        Ok(())
    })

    old_results: &FastHashMap<Cow<'a, HgPath>, Dispatch>,
    ignore_fn: &IgnoreFnType,
    dir_ignore_fn: &IgnoreFnType,
    options: StatusOptions,
    results: &mut Vec<(Cow<'a, HgPath>, Dispatch)>,
) -> IoResult<()> {
    let root_dir = root_dir.as_ref();

    // The traversal is done in parallel, so use a channel to gather entries.
    // `crossbeam::Sender` is `Send`, while `mpsc::Sender` is not.

        path,
        &old_results,
        &ignore_fn,
        &dir_ignore_fn,
        options,
    )?;

    // Disconnect the channel so the receiver stops waiting
    drop(files_transmitter);

    pub deleted: Vec<Cow<'a, HgPath>>,
    pub clean: Vec<Cow<'a, HgPath>>,
    pub ignored: Vec<Cow<'a, HgPath>>,
    pub unknown: Vec<Cow<'a, HgPath>>,
    pub bad: Vec<(Cow<'a, HgPath>, BadMatch)>,
}

#[timed]
fn build_response<'a>(
    results: impl IntoIterator<Item = (Cow<'a, HgPath>, Dispatch)>,
) -> (Vec<Cow<'a, HgPath>>, DirstateStatus<'a>) {
    let mut lookup = vec![];
    let mut modified = vec![];
    let mut added = vec![];
    let mut removed = vec![];

            deleted,
            clean,
            ignored,
            unknown,
            bad,
        },
    )
}

#[derive(Debug)]

        (Box::new(|&_| true), vec![])
    };

    let files = matcher.file_set();

    // Step 1: check the files explicitly mentioned by the user
    let explicit = walk_explicit(files, &dmap, root_dir, options);

    // Collect results into a `Vec` because we do very few lookups in most
    // cases.
    let (work, mut results): (Vec<_>, Vec<_>) = explicit
        .filter_map(Result::ok)

                            &old_results,
                            &ignore_fn,
                            &dir_ignore_fn,
                            options,
                            &mut results,
                        )?;
                    }
                }
                _ => unreachable!("There can only be directories in `work`"),
            }

            // and check everything we missed.
            extend_from_dmap(&dmap, root_dir, options, &mut results);
        }
    }

    Ok((build_response(results), warnings))
}

44897:c802ec4f7196

fn walk_explicit<'a>(
    files: Option<&'a HashSet<&HgPath>>,
    dmap: &'a DirstateMap,
    root_dir: impl AsRef<Path> + Sync + Send + 'a,
    options: StatusOptions,
    traversed_sender: crossbeam::Sender<HgPathBuf>,
) -> impl ParallelIterator<Item = IoResult<(&'a HgPath, Dispatch)>> {
    files
        .unwrap_or(&DEFAULT_WORK)
        .par_iter()
        .map(move |filename| {

                            )));
                        }
                        Some(Ok((normalized, Dispatch::Unknown)))
                    } else {
                        if file_type.is_dir() {
                            if options.collect_traversed_dirs {
                                // The receiver always outlives the sender,
                                // so unwrap.
                                traversed_sender
                                    .send(normalized.to_owned())
                                    .unwrap()
                            }
                            Some(Ok((
                                normalized,
                                Dispatch::Directory {
                                    was_file: in_dmap.is_some(),
                                },

    /// Whether we are on a filesystem with UNIX-like exec flags
    pub check_exec: bool,
    pub list_clean: bool,
    pub list_unknown: bool,
    pub list_ignored: bool,
    /// Whether to collect traversed dirs for applying a callback later.
    /// Used by `hg purge` for example.
    pub collect_traversed_dirs: bool,
}

/// Dispatch a single entry (file, folder, symlink...) found during `traverse`.
/// If the entry is a folder that needs to be traversed, it will be handled
/// in a separate thread.

    ignore_fn: &'a IgnoreFnType,
    dir_ignore_fn: &'a IgnoreFnType,
    options: StatusOptions,
    filename: HgPathBuf,
    dir_entry: DirEntry,
    traversed_sender: crossbeam::Sender<HgPathBuf>,
) -> IoResult<()> {
    let file_type = dir_entry.file_type()?;
    let entry_option = dmap.get(&filename);

    if filename.as_bytes() == b".hg" {

            ignore_fn,
            dir_ignore_fn,
            options,
            entry_option,
            filename,
            traversed_sender,
        );
    } else if file_type.is_file() || file_type.is_symlink() {
        if let Some(entry) = entry_option {
            if matcher.matches_everything() || matcher.matches(&filename) {
                let metadata = dir_entry.metadata()?;

    ignore_fn: &'a IgnoreFnType,
    dir_ignore_fn: &'a IgnoreFnType,
    options: StatusOptions,
    entry_option: Option<&'a DirstateEntry>,
    directory: HgPathBuf,
    traversed_sender: crossbeam::Sender<HgPathBuf>,
) {
    scope.spawn(move |_| {
        // Nested `if` until `rust-lang/rust#53668` is stable
        if let Some(entry) = entry_option {
            // Used to be a file, is now a folder

                directory,
                &old_results,
                ignore_fn,
                dir_ignore_fn,
                options,
                traversed_sender,
            )
            .unwrap_or_else(|e| files_sender.send(Err(e)).unwrap())
        }
    });
}

    directory: impl AsRef<HgPath>,
    old_results: &FastHashMap<Cow<'a, HgPath>, Dispatch>,
    ignore_fn: &IgnoreFnType,
    dir_ignore_fn: &IgnoreFnType,
    options: StatusOptions,
    traversed_sender: crossbeam::Sender<HgPathBuf>,
) -> IoResult<()> {
    let directory = directory.as_ref();

    if options.collect_traversed_dirs {
        // The receiver always outlives the sender, so unwrap.
        traversed_sender.send(directory.to_owned()).unwrap()
    }

    let visit_entries = match matcher.visit_children_set(directory) {
        VisitChildrenSet::Empty => return Ok(()),
        VisitChildrenSet::This | VisitChildrenSet::Recursive => None,
        VisitChildrenSet::Set(set) => Some(set),

                    ignore_fn,
                    dir_ignore_fn,
                    options,
                    filename,
                    dir_entry,
                    traversed_sender.clone(),
                )?;
            }
        }
        Ok(())
    })

    old_results: &FastHashMap<Cow<'a, HgPath>, Dispatch>,
    ignore_fn: &IgnoreFnType,
    dir_ignore_fn: &IgnoreFnType,
    options: StatusOptions,
    results: &mut Vec<(Cow<'a, HgPath>, Dispatch)>,
    traversed_sender: crossbeam::Sender<HgPathBuf>,
) -> IoResult<()> {
    let root_dir = root_dir.as_ref();

    // The traversal is done in parallel, so use a channel to gather entries.
    // `crossbeam::Sender` is `Send`, while `mpsc::Sender` is not.

        path,
        &old_results,
        &ignore_fn,
        &dir_ignore_fn,
        options,
        traversed_sender,
    )?;

    // Disconnect the channel so the receiver stops waiting
    drop(files_transmitter);

    pub deleted: Vec<Cow<'a, HgPath>>,
    pub clean: Vec<Cow<'a, HgPath>>,
    pub ignored: Vec<Cow<'a, HgPath>>,
    pub unknown: Vec<Cow<'a, HgPath>>,
    pub bad: Vec<(Cow<'a, HgPath>, BadMatch)>,
    /// Only filled if `collect_traversed_dirs` is `true`
    pub traversed: Vec<HgPathBuf>,
}

#[timed]
fn build_response<'a>(
    results: impl IntoIterator<Item = (Cow<'a, HgPath>, Dispatch)>,
    traversed: Vec<HgPathBuf>,
) -> (Vec<Cow<'a, HgPath>>, DirstateStatus<'a>) {
    let mut lookup = vec![];
    let mut modified = vec![];
    let mut added = vec![];
    let mut removed = vec![];

            deleted,
            clean,
            ignored,
            unknown,
            bad,
            traversed,
        },
    )
}

#[derive(Debug)]

        (Box::new(|&_| true), vec![])
    };

    let files = matcher.file_set();

    // `crossbeam::Sender` is `Send`, while `mpsc::Sender` is not.
    let (traversed_sender, traversed_recv) = crossbeam::channel::unbounded();

    // Step 1: check the files explicitly mentioned by the user
    let explicit = walk_explicit(
        files,
        &dmap,
        root_dir,
        options,
        traversed_sender.clone(),
    );

    // Collect results into a `Vec` because we do very few lookups in most
    // cases.
    let (work, mut results): (Vec<_>, Vec<_>) = explicit
        .filter_map(Result::ok)

                            &old_results,
                            &ignore_fn,
                            &dir_ignore_fn,
                            options,
                            &mut results,
                            traversed_sender.clone(),
                        )?;
                    }
                }
                _ => unreachable!("There can only be directories in `work`"),
            }

            // and check everything we missed.
            extend_from_dmap(&dmap, root_dir, options, &mut results);
        }
    }

    // Close the channel
    drop(traversed_sender);
    let traversed_dirs = traversed_recv.into_iter().collect();

    Ok((build_response(results, traversed_dirs), warnings))
}