What if we have sorted?

Note that all non-changed `.sort` calls are marked with `// no
change`.

There 15 changed and 5 non changed occurrences of .sort

src/bin/cargo/main.rs

@@ -112,12 +112,12 @@ fn find_closest(config: &Config, cmd: &str) -> Option<String> {
    let cmds = list_commands(config);
    // Only consider candidates with a lev_distance of 3 or less so we don't
    // suggest out-of-the-blue options.
    let mut filtered = cmds.iter()
    cmds.iter()
        .map(|&(ref c, _)| (lev_distance(c, cmd), c))
        .filter(|&(d, _)| d < 4)
        .collect::<Vec<_>>();
    filtered.sort_by(|a, b| a.0.cmp(&b.0));
    filtered.get(0).map(|slot| slot.1.clone())
        .collect::<Vec<_>>()
        .sorted_by(|a, b| a.0.cmp(&b.0))
        .get(0).map(|slot| slot.1.clone())
}

fn execute_external_subcommand(config: &Config, cmd: &str, args: &[&str]) -> CliResult {

src/cargo/core/compiler/build_context/mod.rs

@@ -295,8 +295,7 @@ fn env_args(
            // ordering through sorting for now. We may perhaps one day wish to
            // ensure a deterministic ordering via the order keys were defined
            // in files perhaps.
            let mut cfgs = cfgs.collect::<Vec<_>>();
            cfgs.sort();
            let cfgs = cfgs.collect::<Vec<_>>().sorted();

            for n in cfgs {
                let key = format!("target.{}.{}", n, name);

src/cargo/core/compiler/context/compilation_files.rs

@@ -414,14 +414,12 @@ fn compute_metadata<'a, 'cfg>(
        .hash(&mut hasher);

    // Mix in the target-metadata of all the dependencies of this target
    {
        let mut deps_metadata = cx.dep_targets(unit)
            .iter()
            .map(|dep| metadata_of(dep, cx, metas))
            .collect::<Vec<_>>();
        deps_metadata.sort();
        deps_metadata.hash(&mut hasher);
    }
    cx.dep_targets(unit)
        .iter()
        .map(|dep| metadata_of(dep, cx, metas))
        .collect::<Vec<_>>()
        .sorted()
        .hash(&mut hasher);

    // Throw in the profile we're compiling with. This helps caching
    // panic=abort and panic=unwind artifacts, additionally with various

src/cargo/core/compiler/custom_build.rs

@@ -591,8 +591,7 @@ pub fn build_map<'b, 'cfg>(cx: &mut Context<'b, 'cfg>, units: &[Unit<'b>]) -> Ca
        // to rustc invocation caching schemes, so be sure to generate the same
        // set of build script dependency orderings via sorting the targets that
        // come out of the `Context`.
        let mut targets = cx.dep_targets(unit);
        targets.sort_by_key(|u| u.pkg.package_id());
        let targets = cx.dep_targets(unit).sorted_by_key(|u| u.pkg.package_id());

        for unit in targets.iter() {
            let dep_scripts = build(out, cx, unit)?;

src/cargo/core/compiler/fingerprint.rs

@@ -447,8 +447,7 @@ fn calculate<'a, 'cfg>(
        let fingerprint = pkg_fingerprint(&cx.bcx, unit.pkg)?;
        LocalFingerprint::Precalculated(fingerprint)
    };
    let mut deps = deps;
    deps.sort_by(|&(ref a, _, _), &(ref b, _, _)| a.cmp(b));
    let deps = deps.sorted_by(|&(ref a, _, _), &(ref b, _, _)| a.cmp(b));
    let extra_flags = if unit.mode.is_doc() {
        bcx.rustdocflags_args(unit)?
    } else {

src/cargo/core/compiler/mod.rs

@@ -198,6 +198,7 @@ impl TargetConfig {
            for (k, value) in value.table(&lib_name)?.0 {
                pairs.push((k, value));
            }
            // no change
            pairs.sort_by_key(|p| p.0);
            for (k, value) in pairs {
                let key = format!("{}.{}", key, k);

src/cargo/core/resolver/context.rs

@@ -111,19 +111,17 @@ impl Context {

        // Next, transform all dependencies into a list of possible candidates
        // which can satisfy that dependency.
        let mut deps = deps.into_iter()
        let deps = deps.into_iter()
            .map(|(dep, features)| {
                let candidates = registry.query(&dep)?;
                Ok((dep, candidates, Rc::new(features)))
            })
            .collect::<CargoResult<Vec<DepInfo>>>()?;

        // Attempt to resolve dependencies with fewer candidates before trying
        // dependencies with more candidates.  This way if the dependency with
        // only one candidate can't be resolved we don't have to do a bunch of
        // work before we figure that out.
        deps.sort_by_key(|&(_, ref a, _)| a.len());

            .collect::<CargoResult<Vec<DepInfo>>>()?
            // Attempt to resolve dependencies with fewer candidates before trying
            // dependencies with more candidates.  This way if the dependency with
            // only one candidate can't be resolved we don't have to do a bunch of
            // work before we figure that out.
            .sorted_by_key(|&(_, ref a, _)| a.len());
        Ok(deps)
    }

src/cargo/core/resolver/encode.rs

@@ -346,8 +346,7 @@ impl<'a, 'cfg> ser::Serialize for WorkspaceResolve<'a, 'cfg> {
    where
        S: ser::Serializer,
    {
        let mut ids: Vec<_> = self.resolve.iter().collect();
        ids.sort();
        let ids: Vec<_> = self.resolve.iter().collect().sorted();

        let encodable = ids.iter()
            .filter_map(|&id| Some(encodable_resolve_node(id, self.resolve)))
@@ -396,11 +395,11 @@ fn encodable_resolve_node(id: &PackageId, resolve: &Resolve) -> EncodableDepende
    let (replace, deps) = match resolve.replacement(id) {
        Some(id) => (Some(encodable_package_id(id)), None),
        None => {
            let mut deps = resolve
            let deps = resolve
                .deps_not_replaced(id)
                .map(encodable_package_id)
                .collect::<Vec<_>>();
            deps.sort();
                .collect::<Vec<_>>()
                .sorted();
            (None, Some(deps))
        }
    };

src/cargo/core/resolver/mod.rs

@@ -883,9 +883,10 @@ fn activation_error(
            .collect::<Vec<_>>()
            .join(", "));

        let mut conflicting_activations: Vec<_> = conflicting_activations.iter().collect();
        conflicting_activations.sort_unstable();
        let (links_errors, mut other_errors): (Vec<_>, Vec<_>) = conflicting_activations
            .iter()
            .collect::<Vec<_>>()
            .sorted_unstable()
            .drain(..)
            .rev()
            .partition(|&(_, r)| r.is_links());
@@ -951,11 +952,10 @@ fn activation_error(
    let all_req = semver::VersionReq::parse("*").unwrap();
    let mut new_dep = dep.clone();
    new_dep.set_version_req(all_req);
    let mut candidates = match registry.query_vec(&new_dep) {
        Ok(candidates) => candidates,
    let candidates = match registry.query_vec(&new_dep) {
        Ok(candidates) => candidates.sorted_unstable_by(|a, b| b.version().cmp(a.version())),
        Err(e) => return e,
    };
    candidates.sort_unstable_by(|a, b| b.version().cmp(a.version()));

    let mut msg = if !candidates.is_empty() {
        let versions = {

src/cargo/core/resolver/resolve.rs

@@ -192,9 +192,8 @@ unable to verify that `{0}` is the same as when the lockfile was generated
    }

    pub fn features_sorted(&self, pkg: &PackageId) -> Vec<&str> {
        let mut v = Vec::from_iter(self.features(pkg).iter().map(|s| s.as_ref()));
        v.sort();
        v
        Vec::from_iter(self.features(pkg).iter().map(|s| s.as_ref()))
            .sorted()
    }

    pub fn query(&self, spec: &str) -> CargoResult<&PackageId> {

src/cargo/core/resolver/types.rs

@@ -128,6 +128,7 @@ impl<'a> RegistryQueryer<'a> {
        // sorted fashion to pick the "best candidates" first. Currently we try
        // prioritized summaries (those in `try_to_use`) and failing that we
        // list everything from the maximum version to the lowest version.
        // no change
        ret.sort_unstable_by(|a, b| {
            let a_in_previous = self.try_to_use.contains(a.summary.package_id());
            let b_in_previous = self.try_to_use.contains(b.summary.package_id());

src/cargo/ops/cargo_generate_lockfile.rs

@@ -199,6 +199,7 @@ pub fn update_lockfile(ws: &Workspace, opts: &UpdateOptions) -> CargoResult<()>

        for v in changes.values_mut() {
            let (ref mut old, ref mut new) = *v;
            // no change
            old.sort();
            new.sort();
            let removed = vec_subtract(old, new);

src/cargo/ops/cargo_install.rs

@@ -518,14 +518,14 @@ where
            };
            return Ok((pkg.clone(), Box::new(source)));

            fn multi_err(kind: &str, mut pkgs: Vec<&Package>) -> String {
                pkgs.sort_by(|a, b| a.name().cmp(&b.name()));
            fn multi_err(kind: &str, pkgs: Vec<&Package>) -> String {
                format!(
                    "multiple packages with {} found: {}",
                    kind,
                    pkgs.iter()
                        .map(|p| p.name().as_str())
                        .collect::<Vec<_>>()
                        .sorted()
                        .join(", ")
                )
            }

src/cargo/ops/cargo_package.rs

@@ -51,6 +51,7 @@ pub fn package(ws: &Workspace, opts: &PackageOpts) -> CargoResult<Option<FileLoc
        if include_lockfile(pkg) {
            list.push("Cargo.lock".into());
        }
        // no change
        list.sort();
        for file in list.iter() {
            println!("{}", file.display());

src/cargo/ops/cargo_test.rs

@@ -80,6 +80,7 @@ fn compile_tests<'a>(
    let mut compilation = ops::compile(ws, &options.compile_opts)?;
    compilation
        .tests
        // no change
        .sort_by(|a, b| (a.0.package_id(), &a.1, &a.2).cmp(&(b.0.package_id(), &b.1, &b.2)));
    Ok(compilation)
}

src/cargo/sources/path.rs

@@ -447,8 +447,8 @@ impl<'cfg> PathSource<'cfg> {
        // TODO: Drop collect and sort after transition period and dropping warning tests.
        // See <https://github.com/rust-lang/cargo/issues/4268>
        // and <https://github.com/rust-lang/cargo/pull/4270>
        let mut entries: Vec<fs::DirEntry> = fs::read_dir(path)?.map(|e| e.unwrap()).collect();
        entries.sort_by(|a, b| a.path().as_os_str().cmp(b.path().as_os_str()));
        let entries: Vec<fs::DirEntry> = fs::read_dir(path)?.map(|e| e.unwrap()).collect()
            .sorted_by(|a, b| a.path().as_os_str().cmp(b.path().as_os_str()));
        for entry in entries {
            let path = entry.path();
            let name = path.file_name().and_then(|s| s.to_str());

src/cargo/util/rustc.rs

@@ -238,8 +238,8 @@ fn rustc_fingerprint(path: &Path, rustup_rustc: &Path) -> CargoResult<u64> {
fn process_fingerprint(cmd: &ProcessBuilder) -> u64 {
    let mut hasher = SipHasher::new_with_keys(0, 0);
    cmd.get_args().hash(&mut hasher);
    let mut env = cmd.get_envs().iter().collect::<Vec<_>>();
    env.sort();
    env.hash(&mut hasher);
    cmd.get_envs().iter().collect::<Vec<_>>()
        .sorted()
        .hash(&mut hasher);
    hasher.finish()
}