Rollup of 10 pull requests

config.example.toml

@@ -257,7 +257,7 @@ changelog-seen = 2
 #python = "python"
 
 # The path to the REUSE executable to use. Note that REUSE is not required in
-# most cases, as our tooling relies on a cached (and shrinked) copy of the
+# most cases, as our tooling relies on a cached (and shrunk) copy of the
 # REUSE output present in the git repository and in our source tarballs.
 #
 # REUSE is only needed if your changes caused the overall licensing of the

src/bootstrap/channel.rs

@@ -139,7 +139,7 @@ pub fn read_commit_info_file(root: &Path) -> Option<Info> {
  sha: sha.to_owned(),
  short_sha: short_sha.to_owned(),
  },
- _ => panic!("the `git-comit-info` file is malformed"),
+ _ => panic!("the `git-commit-info` file is malformed"),
  };
  Some(info)
  } else {

src/doc/style-guide/src/expressions.md

@@ -643,7 +643,7 @@ Examples:
 ```rust
 match foo {
  foo => bar,
- a_very_long_patten | another_pattern if an_expression() => {
+ a_very_long_pattern | another_pattern if an_expression() => {
  no_room_for_this_expression()
  }
  foo => {

src/doc/unstable-book/src/compiler-flags/dump-mono-stats-format.md

@@ -3,4 +3,4 @@
 --------------------
 
 The `-Z dump-mono-stats-format` compiler flag controls what file format to use for `-Z dump-mono-stats`.
-The default is markdown; currently JSON is also supported. JSON can be useful for programatically manipulating the results (e.g. to find the item that took the longest to compile).
+The default is markdown; currently JSON is also supported. JSON can be useful for programmatically manipulating the results (e.g. to find the item that took the longest to compile).

src/etc/installer/msi/rust.wxs

@@ -119,7 +119,7 @@
  <SetProperty Sequence="ui" Before="CostFinalize"
  Id="WixAppFolder" Value="WixPerUserFolder">NOT ALLUSERS</SetProperty>
 
- <!-- UI sets ALLUSERS per user selection; progagate this choice to MSIINSTALLPERUSER before executing installation actions -->
+ <!-- UI sets ALLUSERS per user selection; propagate this choice to MSIINSTALLPERUSER before executing installation actions -->
  <SetProperty Sequence="ui" Before="ExecuteAction"
  Id="MSIINSTALLPERUSER" Value="1">NOT ALLUSERS</SetProperty>
 

src/librustdoc/config.rs

@@ -230,7 +230,7 @@ pub(crate) struct RenderOptions {
  pub(crate) extension_css: Option<PathBuf>,
  /// A map of crate names to the URL to use instead of querying the crate's `html_root_url`.
  pub(crate) extern_html_root_urls: BTreeMap<String, String>,
- /// Whether to give precedence to `html_root_url` or `--exten-html-root-url`.
+ /// Whether to give precedence to `html_root_url` or `--extern-html-root-url`.
  pub(crate) extern_html_root_takes_precedence: bool,
  /// A map of the default settings (values are as for DOM storage API). Keys should lack the
  /// `rustdoc-` prefix.

src/librustdoc/html/format.rs

@@ -349,10 +349,10 @@ pub(crate) fn print_where_clause<'a, 'tcx: 'a>(
  let mut br_with_padding = String::with_capacity(6 * indent + 28);
  br_with_padding.push_str("\n");
 
- let padding_amout =
+ let padding_amount =
  if ending == Ending::Newline { indent + 4 } else { indent + "fn where ".len() };
 
- for _ in 0..padding_amout {
+ for _ in 0..padding_amount {
  br_with_padding.push_str(" ");
  }
  let where_preds = where_preds.to_string().replace('\n', &br_with_padding);

src/librustdoc/html/render/print_item.rs

@@ -1796,10 +1796,11 @@ fn render_struct(
  }
  match ty {
  None => {
- let where_diplayed = g.map(|g| print_where_clause_and_check(w, g, cx)).unwrap_or(false);
+ let where_displayed =
+ g.map(|g| print_where_clause_and_check(w, g, cx)).unwrap_or(false);
 
  // If there wasn't a `where` clause, we add a whitespace.
- if !where_diplayed {
+ if !where_displayed {
  w.write_str(" {");
  } else {
  w.write_str("{");

src/rustdoc-json-types/lib.rs

@@ -550,7 +550,7 @@ pub enum Type {
  DynTrait(DynTrait),
  /// Parameterized types
  Generic(String),
- /// Built in numberic (i*, u*, f*) types, bool, and char
+ /// Built in numeric (i*, u*, f*) types, bool, and char
  Primitive(String),
  /// `extern "ABI" fn`
  FunctionPointer(Box<FunctionPointer>),

src/tools/collect-license-metadata/src/path_tree.rs

@@ -10,8 +10,8 @@ use std::path::{Path, PathBuf};
 #[derive(serde::Serialize)]
 #[serde(rename_all = "kebab-case", tag = "type")]
 pub(crate) enum Node<L> {
- Root { childs: Vec<Node<L>> },
- Directory { name: PathBuf, childs: Vec<Node<L>>, license: Option<L> },
+ Root { children: Vec<Node<L>> },
+ Directory { name: PathBuf, children: Vec<Node<L>>, license: Option<L> },
  File { name: PathBuf, license: L },
  Group { files: Vec<PathBuf>, directories: Vec<PathBuf>, license: L },
  Empty,
@@ -48,14 +48,14 @@ impl Node<LicenseId> {
  /// ```
  fn merge_directories(&mut self) {
  match self {
- Node::Root { childs } | Node::Directory { childs, license: None, .. } => {
+ Node::Root { children } | Node::Directory { children, license: None, .. } => {
  let mut directories = BTreeMap::new();
  let mut files = Vec::new();
 
- for child in childs.drain(..) {
+ for child in children.drain(..) {
  match child {
- Node::Directory { name, mut childs, license: None } => {
- directories.entry(name).or_insert_with(Vec::new).append(&mut childs);
+ Node::Directory { name, mut children, license: None } => {
+ directories.entry(name).or_insert_with(Vec::new).append(&mut children);
  }
  file @ Node::File { .. } => {
  files.push(file);
@@ -73,14 +73,14 @@ impl Node<LicenseId> {
  }
  }
 
- childs.extend(directories.into_iter().map(|(name, childs)| Node::Directory {
+ children.extend(directories.into_iter().map(|(name, children)| Node::Directory {
  name,
- childs,
+ children,
  license: None,
  }));
- childs.append(&mut files);
+ children.append(&mut files);
 
- for child in &mut *childs {
+ for child in &mut *children {
  child.merge_directories();
  }
  }
@@ -105,13 +105,13 @@ impl Node<LicenseId> {
  /// our inclusion of LLVM.
  fn collapse_in_licensed_directories(&mut self) {
  match self {
- Node::Directory { childs, license, .. } => {
- for child in &mut *childs {
+ Node::Directory { children, license, .. } => {
+ for child in &mut *children {
  child.collapse_in_licensed_directories();
  }
 
  let mut licenses_count = BTreeMap::new();
- for child in &*childs {
+ for child in &*children {
  let Some(license) = child.license() else { continue };
  *licenses_count.entry(license).or_insert(0) += 1;
  }
@@ -122,12 +122,12 @@ impl Node<LicenseId> {
  .map(|(license, _)| license);
 
  if let Some(most_popular_license) = most_popular_license {
- childs.retain(|child| child.license() != Some(most_popular_license));
+ children.retain(|child| child.license() != Some(most_popular_license));
  *license = Some(most_popular_license);
  }
  }
- Node::Root { childs } => {
- for child in &mut *childs {
+ Node::Root { children } => {
+ for child in &mut *children {
  child.collapse_in_licensed_directories();
  }
  }
@@ -138,29 +138,29 @@ impl Node<LicenseId> {
  }
 
  /// Reduce the depth of the tree by merging subdirectories with the same license as their
- /// parent directory into their parent, and adjusting the paths of the childs accordingly.
+ /// parent directory into their parent, and adjusting the paths of the children accordingly.
  fn merge_directory_licenses(&mut self) {
  match self {
- Node::Root { childs } => {
- for child in &mut *childs {
+ Node::Root { children } => {
+ for child in &mut *children {
  child.merge_directory_licenses();
  }
  }
- Node::Directory { childs, license, .. } => {
+ Node::Directory { children, license, .. } => {
  let mut to_add = Vec::new();
- for child in &mut *childs {
+ for child in &mut *children {
  child.merge_directory_licenses();
 
  let Node::Directory {
  name: child_name,
- childs: child_childs,
+ children: child_children,
  license: child_license,
  } = child else { continue };
 
  if child_license != license {
  continue;
  }
- for mut child_child in child_childs.drain(..) {
+ for mut child_child in child_children.drain(..) {
  match &mut child_child {
  Node::Root { .. } => {
  panic!("can't have a root inside another element");
@@ -181,7 +181,7 @@ impl Node<LicenseId> {
 
  *child = Node::Empty;
  }
- childs.append(&mut to_add);
+ children.append(&mut to_add);
  }
  Node::Empty => {}
  Node::File { .. } => {}
@@ -203,14 +203,14 @@ impl Node<LicenseId> {
  directories: Vec<PathBuf>,
  }
  match self {
- Node::Root { childs } | Node::Directory { childs, .. } => {
+ Node::Root { children } | Node::Directory { children, .. } => {
  let mut grouped: BTreeMap<LicenseId, Grouped> = BTreeMap::new();
 
- for child in &mut *childs {
+ for child in &mut *children {
  child.merge_groups();
  match child {
- Node::Directory { name, childs, license: Some(license) } => {
- if childs.is_empty() {
+ Node::Directory { name, children, license: Some(license) } => {
+ if children.is_empty() {
  grouped
  .entry(*license)
  .or_insert_with(Grouped::default)
@@ -234,16 +234,16 @@ impl Node<LicenseId> {
  for (license, mut grouped) in grouped.into_iter() {
  if grouped.files.len() + grouped.directories.len() <= 1 {
  if let Some(name) = grouped.files.pop() {
- childs.push(Node::File { license, name });
+ children.push(Node::File { license, name });
  } else if let Some(name) = grouped.directories.pop() {
- childs.push(Node::Directory {
+ children.push(Node::Directory {
  name,
- childs: Vec::new(),
+ children: Vec::new(),
  license: Some(license),
  });
  }
  } else {
- childs.push(Node::Group {
+ children.push(Node::Group {
  license,
  files: grouped.files,
  directories: grouped.directories,
@@ -261,11 +261,11 @@ impl Node<LicenseId> {
  /// sure to remove them from the tree.
  fn remove_empty(&mut self) {
  match self {
- Node::Root { childs } | Node::Directory { childs, .. } => {
- for child in &mut *childs {
+ Node::Root { children } | Node::Directory { children, .. } => {
+ for child in &mut *children {
  child.remove_empty();
  }
- childs.retain(|child| !matches!(child, Node::Empty));
+ children.retain(|child| !matches!(child, Node::Empty));
  }
  Node::Group { .. } => {}
  Node::File { .. } => {}
@@ -275,7 +275,7 @@ impl Node<LicenseId> {
 
  fn license(&self) -> Option<LicenseId> {
  match self {
- Node::Directory { childs, license: Some(license), .. } if childs.is_empty() => {
+ Node::Directory { children, license: Some(license), .. } if children.is_empty() => {
  Some(*license)
  }
  Node::File { license, .. } => Some(*license),
@@ -285,7 +285,7 @@ impl Node<LicenseId> {
 }
 
 pub(crate) fn build(mut input: Vec<(PathBuf, LicenseId)>) -> Node<LicenseId> {
- let mut childs = Vec::new();
+ let mut children = Vec::new();
 
  // Ensure reproducibility of all future steps.
  input.sort();
@@ -295,15 +295,15 @@ pub(crate) fn build(mut input: Vec<(PathBuf, LicenseId)>) -> Node<LicenseId> {
  for component in path.parent().unwrap_or_else(|| Path::new(".")).components().rev() {
  node = Node::Directory {
  name: component.as_os_str().into(),
- childs: vec![node],
+ children: vec![node],
  license: None,
  };
  }
 
- childs.push(node);
+ children.push(node);
  }
 
- Node::Root { childs }
+ Node::Root { children }
 }
 
 /// Convert a `Node<LicenseId>` into a `Node<&License>`, expanding all interned license IDs with a
@@ -313,14 +313,14 @@ pub(crate) fn expand_interned_licenses(
  interner: &LicensesInterner,
 ) -> Node<&License> {
  match node {
- Node::Root { childs } => Node::Root {
- childs: childs
+ Node::Root { children } => Node::Root {
+ children: children
  .into_iter()
  .map(|child| expand_interned_licenses(child, interner))
  .collect(),
  },
- Node::Directory { name, childs, license } => Node::Directory {
- childs: childs
+ Node::Directory { name, children, license } => Node::Directory {
+ children: children
  .into_iter()
  .map(|child| expand_interned_licenses(child, interner))
  .collect(),

src/tools/generate-copyright/src/main.rs

@@ -20,17 +20,17 @@ fn render_recursive(node: &Node, buffer: &mut Vec<u8>, depth: usize) -> Result<(
  let prefix = std::iter::repeat("> ").take(depth + 1).collect::<String>();
 
  match node {
- Node::Root { childs } => {
- for child in childs {
+ Node::Root { children } => {
+ for child in children {
  render_recursive(child, buffer, depth)?;
  }
  }
- Node::Directory { name, childs, license } => {
+ Node::Directory { name, children, license } => {
  render_license(&prefix, std::iter::once(name), license, buffer)?;
- if !childs.is_empty() {
+ if !children.is_empty() {
  writeln!(buffer, "{prefix}")?;
  writeln!(buffer, "{prefix}*Exceptions:*")?;
- for child in childs {
+ for child in children {
  writeln!(buffer, "{prefix}")?;
  render_recursive(child, buffer, depth + 1)?;
  }
@@ -73,8 +73,8 @@ struct Metadata {
 #[derive(serde::Deserialize)]
 #[serde(rename_all = "kebab-case", tag = "type")]
 pub(crate) enum Node {
- Root { childs: Vec<Node> },
- Directory { name: String, childs: Vec<Node>, license: License },
+ Root { children: Vec<Node> },
+ Directory { name: String, children: Vec<Node>, license: License },
  File { name: String, license: License },
  Group { files: Vec<String>, directories: Vec<String>, license: License },
 }

src/tools/jsondocck/src/main.rs

@@ -237,7 +237,7 @@ fn check_command(command: Command, cache: &mut Cache) -> Result<(), CkError> {
 
  // Serde json doesn't implement Ord or Hash for Value, so we must
  // use a Vec here. While in theory that makes setwize equality
- // O(n^2), in practice n will never be large enought to matter.
+ // O(n^2), in practice n will never be large enough to matter.
  let expected_values =
  values.iter().map(|v| string_to_value(v, cache)).collect::<Vec<_>>();
  if expected_values.len() != got_values.len() {

src/tools/jsondoclint/src/item_kind.rs

@@ -1,6 +1,6 @@
 use rustdoc_json_types::{Item, ItemEnum, ItemKind, ItemSummary};
 
-/// A univeral way to represent an [`ItemEnum`] or [`ItemKind`]
+/// A universal way to represent an [`ItemEnum`] or [`ItemKind`]
 #[derive(Debug, Clone, Copy)]
 pub(crate) enum Kind {
  Module,
@@ -53,7 +53,7 @@ impl Kind {
  Primitive => true,
  ForeignType => true,
 
- // FIXME(adotinthevoid): I'm not sure if these are corrent
+ // FIXME(adotinthevoid): I'm not sure if these are correct
  Keyword => false,
  OpaqueTy => false,
  ProcAttribute => false,