chore: Address typos

Author: Muscraft

crates/cargo-test-support/src/paths.rs

@@ -357,7 +357,7 @@ fn build_dir_ignored_path_patterns() -> Vec<String> {
         // Ignore MacOS debug symbols as there are many files/directories that would clutter up
         // tests few not a lot of benefit.
         "[..].dSYM/[..]",
-        // Ignore Windows debub symbols files (.pdb)
+        // Ignore Windows debug symbols files (.pdb)
         "[..].pdb",
     ]
     .into_iter()

crates/cargo-util-schemas/src/lockfile.rs

@@ -110,7 +110,7 @@ impl TomlLockfileSourceId {
             .ok_or_else(|| TomlLockfileSourceIdErrorKind::InvalidSource(source.clone()))?;
 
         // Sparse URLs store the kind prefix (sparse+) in the URL. Therefore, for sparse kinds, we
-        // want to use the raw `source` instead of the splitted `url`.
+        // want to use the raw `source` instead of the split `url`.
         let url = Url::parse(if kind == "sparse" { &source } else { url }).map_err(|msg| {
             TomlLockfileSourceIdErrorKind::InvalidUrl {
                 url: url.to_string(),

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

@@ -235,16 +235,16 @@ impl<'a, 'gctx: 'a> CompilationFiles<'a, 'gctx> {
     /// Note that some units may share the same directory, so care should be
     /// taken in those cases!
     fn pkg_dir(&self, unit: &Unit) -> String {
-        let seperator = match self.ws.gctx().cli_unstable().build_dir_new_layout {
+        let separator = match self.ws.gctx().cli_unstable().build_dir_new_layout {
             true => "/",
             false => "-",
         };
         let name = unit.pkg.package_id().name();
         let meta = self.metas[unit];
         if let Some(c_extra_filename) = meta.c_extra_filename() {
-            format!("{}{}{}", name, seperator, c_extra_filename)
+            format!("{}{}{}", name, separator, c_extra_filename)
         } else {
-            format!("{}{}{}", name, seperator, self.target_short_hash(unit))
+            format!("{}{}{}", name, separator, self.target_short_hash(unit))
         }
     }
 

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

@@ -1031,18 +1031,18 @@ impl Fingerprint {
                 }
                 (
                     LocalFingerprint::CheckDepInfo {
-                        dep_info: adep,
+                        dep_info: a_dep,
                         checksum: checksum_a,
                     },
                     LocalFingerprint::CheckDepInfo {
-                        dep_info: bdep,
+                        dep_info: b_dep,
                         checksum: checksum_b,
                     },
                 ) => {
-                    if adep != bdep {
+                    if a_dep != b_dep {
                         return DirtyReason::DepInfoOutputChanged {
-                            old: bdep.clone(),
-                            new: adep.clone(),
+                            old: b_dep.clone(),
+                            new: a_dep.clone(),
                         };
                     }
                     if checksum_a != checksum_b {
@@ -1051,48 +1051,48 @@ impl Fingerprint {
                 }
                 (
                     LocalFingerprint::RerunIfChanged {
-                        output: aout,
-                        paths: apaths,
+                        output: a_out,
+                        paths: a_paths,
                     },
                     LocalFingerprint::RerunIfChanged {
-                        output: bout,
-                        paths: bpaths,
+                        output: b_out,
+                        paths: b_paths,
                     },
                 ) => {
-                    if aout != bout {
+                    if a_out != b_out {
                         return DirtyReason::RerunIfChangedOutputFileChanged {
-                            old: bout.clone(),
-                            new: aout.clone(),
+                            old: b_out.clone(),
+                            new: a_out.clone(),
                         };
                     }
-                    if apaths != bpaths {
+                    if a_paths != b_paths {
                         return DirtyReason::RerunIfChangedOutputPathsChanged {
-                            old: bpaths.clone(),
-                            new: apaths.clone(),
+                            old: b_paths.clone(),
+                            new: a_paths.clone(),
                         };
                     }
                 }
                 (
                     LocalFingerprint::RerunIfEnvChanged {
-                        var: akey,
-                        val: avalue,
+                        var: a_key,
+                        val: a_value,
                     },
                     LocalFingerprint::RerunIfEnvChanged {
-                        var: bkey,
-                        val: bvalue,
+                        var: b_key,
+                        val: b_value,
                     },
                 ) => {
-                    if *akey != *bkey {
+                    if *a_key != *b_key {
                         return DirtyReason::EnvVarsChanged {
-                            old: bkey.clone(),
-                            new: akey.clone(),
+                            old: b_key.clone(),
+                            new: a_key.clone(),
                         };
                     }
-                    if *avalue != *bvalue {
+                    if *a_value != *b_value {
                         return DirtyReason::EnvVarChanged {
-                            name: akey.clone(),
-                            old_value: bvalue.clone(),
-                            new_value: avalue.clone(),
+                            name: a_key.clone(),
+                            old_value: b_value.clone(),
+                            new_value: a_value.clone(),
                         };
                     }
                 }

src/cargo/core/compiler/mod.rs

@@ -1675,7 +1675,7 @@ fn build_deps_args(
     if build_runner.bcx.gctx.cli_unstable().build_dir_new_layout {
         let mut map = BTreeMap::new();
 
-        // Recursively add all depenendency args to rustc process
+        // Recursively add all dependency args to rustc process
         add_dep_arg(&mut map, build_runner, unit);
 
         let paths = map.into_iter().map(|(_, path)| path).sorted_unstable();

src/cargo/core/compiler/timings.rs

@@ -618,7 +618,7 @@ impl<'gctx> Timings<'gctx> {
                     AggregatedSections::Sections(mut sections) => {
                         // We draw the sections in the pipeline graph in a way where the frontend
                         // section has the "default" build color, and then additional sections
-                        // (codegen, link) are overlayed on top with a different color.
+                        // (codegen, link) are overlaid on top with a different color.
                         // However, there might be some time after the final (usually link) section,
                         // which definitely shouldn't be classified as "Frontend". We thus try to
                         // detect this situation and add a final "Other" section.

src/cargo/core/shell.rs

@@ -364,7 +364,7 @@ impl Shell {
     fn file_hyperlink(&mut self, path: &std::path::Path) -> Option<url::Url> {
         let mut url = url::Url::from_file_path(path).ok()?;
         // Do a best-effort of setting the host in the URL to avoid issues with opening a link
-        // scoped to the computer you've SSHed into
+        // scoped to the computer you've SSH'ed into
         let hostname = if cfg!(windows) {
             // Not supported correctly on windows
             None

src/cargo/core/workspace.rs

@@ -1327,7 +1327,7 @@ impl<'gctx> Workspace<'gctx> {
 
         // This is a short term hack to allow `blanket_hint_mostly_unused`
         // to run without requiring `-Zcargo-lints`, which should hopefully
-        // improve the testing expierience while we are collecting feedback
+        // improve the testing experience while we are collecting feedback
         if self.gctx.cli_unstable().profile_hint_mostly_unused {
             blanket_hint_mostly_unused(
                 self.root_maybe(),

src/cargo/ops/cargo_compile/compile_filter.rs

@@ -102,12 +102,12 @@ impl CompileFilter {
         lib_only: bool,
         bins: Vec<String>,
         all_bins: bool,
-        tsts: Vec<String>,
-        all_tsts: bool,
-        exms: Vec<String>,
-        all_exms: bool,
-        bens: Vec<String>,
-        all_bens: bool,
+        tests: Vec<String>,
+        all_tests: bool,
+        examples: Vec<String>,
+        all_examples: bool,
+        benches: Vec<String>,
+        all_benches: bool,
         all_targets: bool,
     ) -> CompileFilter {
         if all_targets {
@@ -119,34 +119,34 @@ impl CompileFilter {
             LibRule::False
         };
         let rule_bins = FilterRule::new(bins, all_bins);
-        let rule_tsts = FilterRule::new(tsts, all_tsts);
-        let rule_exms = FilterRule::new(exms, all_exms);
-        let rule_bens = FilterRule::new(bens, all_bens);
+        let rule_tests = FilterRule::new(tests, all_tests);
+        let rule_examples = FilterRule::new(examples, all_examples);
+        let rule_benches = FilterRule::new(benches, all_benches);
 
-        CompileFilter::new(rule_lib, rule_bins, rule_tsts, rule_exms, rule_bens)
+        CompileFilter::new(rule_lib, rule_bins, rule_tests, rule_examples, rule_benches)
     }
 
     /// Constructs a filter from underlying primitives.
     pub fn new(
         rule_lib: LibRule,
         rule_bins: FilterRule,
-        rule_tsts: FilterRule,
-        rule_exms: FilterRule,
-        rule_bens: FilterRule,
+        rule_tests: FilterRule,
+        rule_examples: FilterRule,
+        rule_benches: FilterRule,
     ) -> CompileFilter {
         if rule_lib == LibRule::True
             || rule_bins.is_specific()
-            || rule_tsts.is_specific()
-            || rule_exms.is_specific()
-            || rule_bens.is_specific()
+            || rule_tests.is_specific()
+            || rule_examples.is_specific()
+            || rule_benches.is_specific()
         {
             CompileFilter::Only {
                 all_targets: false,
                 lib: rule_lib,
                 bins: rule_bins,
-                examples: rule_exms,
-                benches: rule_bens,
-                tests: rule_tsts,
+                examples: rule_examples,
+                benches: rule_benches,
+                tests: rule_tests,
             }
         } else {
             CompileFilter::Default {

src/cargo/util/context/de.rs

@@ -198,7 +198,7 @@ impl<'de, 'gctx> de::Deserializer<'de> for Deserializer<'gctx> {
             let vals: Vec<String> = res
                 .into_iter()
                 .map(|val| match val {
-                    CV::String(s, _defintion) => Ok(s),
+                    CV::String(s, _definition) => Ok(s),
                     other => Err(ConfigError::expected(&self.key, "string", &other)),
                 })
                 .collect::<Result<_, _>>()?;