diff --git a/src/libcore/convert/mod.rs b/src/libcore/convert/mod.rs
index 8ff1ced53b071..d2023b402c1c6 100644
--- a/src/libcore/convert/mod.rs
+++ b/src/libcore/convert/mod.rs
@@ -674,7 +674,7 @@ impl AsRef<str> for str {
///
///
/// However there is one case where `!` syntax can be used
-/// before `!` is stabilized as a full-fleged type: in the position of a function’s return type.
+/// before `!` is stabilized as a full-fledged type: in the position of a function’s return type.
/// Specifically, it is possible implementations for two different function pointer types:
///
/// ```
diff --git a/src/libcore/hash/sip.rs b/src/libcore/hash/sip.rs
index f2bbf646f3272..a9882d54de4f1 100644
--- a/src/libcore/hash/sip.rs
+++ b/src/libcore/hash/sip.rs
@@ -43,7 +43,7 @@ struct SipHasher24 {
///
/// SipHash is a general-purpose hashing function: it runs at a good
/// speed (competitive with Spooky and City) and permits strong _keyed_
-/// hashing. This lets you key your hashtables from a strong RNG, such as
+/// hashing. This lets you key your hash tables from a strong RNG, such as
/// [`rand::os::OsRng`](https://doc.rust-lang.org/rand/rand/os/struct.OsRng.html).
///
/// Although the SipHash algorithm is considered to be generally strong,
diff --git a/src/libcore/intrinsics.rs b/src/libcore/intrinsics.rs
index b3e43cd799405..f1a7fab313d97 100644
--- a/src/libcore/intrinsics.rs
+++ b/src/libcore/intrinsics.rs
@@ -15,7 +15,7 @@
//!
//! If an intrinsic is supposed to be used from a `const fn` with a `rustc_const_stable` attribute,
//! the intrinsic's attribute must be `rustc_const_stable`, too. Such a change should not be done
-//! without T-lang consulation, because it bakes a feature into the language that cannot be
+//! without T-lang consultation, because it bakes a feature into the language that cannot be
//! replicated in user code without compiler support.
//!
//! # Volatiles
@@ -993,7 +993,7 @@ extern "rust-intrinsic" {
/// [`std::mem::align_of`](../../std/mem/fn.align_of.html).
#[rustc_const_stable(feature = "const_min_align_of", since = "1.40.0")]
pub fn min_align_of<T>() -> usize;
- /// The prefered alignment of a type.
+ /// The preferred alignment of a type.
///
/// This intrinsic does not have a stable counterpart.
#[rustc_const_unstable(feature = "const_pref_align_of", issue = "none")]
@@ -1245,14 +1245,14 @@ extern "rust-intrinsic" {
/// assert!(mid <= len);
/// unsafe {
/// let slice2 = mem::transmute::<&mut [T], &mut [T]>(slice);
- /// // first: transmute is not typesafe; all it checks is that T and
+ /// // first: transmute is not type safe; all it checks is that T and
/// // U are of the same size. Second, right here, you have two
/// // mutable references pointing to the same memory.
/// (&mut slice[0..mid], &mut slice2[mid..len])
/// }
/// }
///
- /// // This gets rid of the typesafety problems; `&mut *` will *only* give
+ /// // This gets rid of the type safety problems; `&mut *` will *only* give
/// // you an `&mut T` from an `&mut T` or `*mut T`.
/// fn split_at_mut_casts<T>(slice: &mut [T], mid: usize)
/// -> (&mut [T], &mut [T]) {
diff --git a/src/libcore/iter/traits/iterator.rs b/src/libcore/iter/traits/iterator.rs
index ce4be973140e5..6ea5965cf8ccf 100644
--- a/src/libcore/iter/traits/iterator.rs
+++ b/src/libcore/iter/traits/iterator.rs
@@ -1082,7 +1082,7 @@ pub trait Iterator {
/// let vec = iter.collect::<Vec<_>>();
///
/// // We have more elements which could fit in u32 (4, 5), but `map_while` returned `None` for `-3`
- /// // (as the `predicate` returned `None`) and `collect` stops at the first `None` entcountered.
+ /// // (as the `predicate` returned `None`) and `collect` stops at the first `None` encountered.
/// assert_eq!(vec, vec![0, 1, 2]);
/// ```
///
diff --git a/src/libcore/macros/mod.rs b/src/libcore/macros/mod.rs
index 17f7349bac233..7a74485a78b89 100644
--- a/src/libcore/macros/mod.rs
+++ b/src/libcore/macros/mod.rs
@@ -1044,7 +1044,7 @@ pub(crate) mod builtin {
};
}
- /// Includes a utf8-encoded file as a string.
+ /// Includes a UTF-8 encoded file as a string.
///
/// The file is located relative to the current file (similarly to how
/// modules are found). The provided path is interpreted in a platform-specific
diff --git a/src/libcore/mem/mod.rs b/src/libcore/mem/mod.rs
index 0a976a4ca00c9..db2b3eeca5281 100644
--- a/src/libcore/mem/mod.rs
+++ b/src/libcore/mem/mod.rs
@@ -348,11 +348,11 @@ pub fn size_of_val<T: ?Sized>(val: &T) -> usize {
///
/// - If `T` is `Sized`, this function is always safe to call.
/// - If the unsized tail of `T` is:
-/// - a [slice], then the length of the slice tail must be an intialized
+/// - a [slice], then the length of the slice tail must be an initialized
/// integer, and the size of the *entire value*
/// (dynamic tail length + statically sized prefix) must fit in `isize`.
/// - a [trait object], then the vtable part of the pointer must point
-/// to a valid vtable acquired by an unsizing coersion, and the size
+/// to a valid vtable acquired by an unsizing coercion, and the size
/// of the *entire value* (dynamic tail length + statically sized prefix)
/// must fit in `isize`.
/// - an (unstable) [extern type], then this function is always safe to
@@ -483,11 +483,11 @@ pub fn align_of_val<T: ?Sized>(val: &T) -> usize {
///
/// - If `T` is `Sized`, this function is always safe to call.
/// - If the unsized tail of `T` is:
-/// - a [slice], then the length of the slice tail must be an intialized
+/// - a [slice], then the length of the slice tail must be an initialized
/// integer, and the size of the *entire value*
/// (dynamic tail length + statically sized prefix) must fit in `isize`.
/// - a [trait object], then the vtable part of the pointer must point
-/// to a valid vtable acquired by an unsizing coersion, and the size
+/// to a valid vtable acquired by an unsizing coercion, and the size
/// of the *entire value* (dynamic tail length + statically sized prefix)
/// must fit in `isize`.
/// - an (unstable) [extern type], then this function is always safe to
diff --git a/src/libcore/num/f64.rs b/src/libcore/num/f64.rs
index b0df4d64f6ee1..ad9a576d15cd6 100644
--- a/src/libcore/num/f64.rs
+++ b/src/libcore/num/f64.rs
@@ -687,7 +687,7 @@ impl f64 {
/// signaling NaNs on MIPS are quiet NaNs on x86, and vice-versa.
///
/// Rather than trying to preserve signaling-ness cross-platform, this
- /// implementation favours preserving the exact bits. This means that
+ /// implementation favors preserving the exact bits. This means that
/// any payloads encoded in NaNs will be preserved even if the result of
/// this method is sent over the network from an x86 machine to a MIPS one.
///
@@ -696,7 +696,7 @@ impl f64 {
///
/// If the input isn't NaN, then there is no portability concern.
///
- /// If you don't care about signalingness (very likely), then there is no
+ /// If you don't care about signaling-ness (very likely), then there is no
/// portability concern.
///
/// Note that this function is distinct from `as` casting, which attempts to
diff --git a/src/libcore/pin.rs b/src/libcore/pin.rs
index da299f026f8f1..9bcacd8ddcf77 100644
--- a/src/libcore/pin.rs
+++ b/src/libcore/pin.rs
@@ -128,7 +128,7 @@
//!
//! Crucially, we have to be able to rely on [`drop`] being called. If an element
//! could be deallocated or otherwise invalidated without calling [`drop`], the pointers into it
-//! from its neighbouring elements would become invalid, which would break the data structure.
+//! from its neighboring elements would become invalid, which would break the data structure.
//!
//! Therefore, pinning also comes with a [`drop`]-related guarantee.
//!
diff --git a/src/libcore/ptr/const_ptr.rs b/src/libcore/ptr/const_ptr.rs
index d1d7a71523822..afaf371d9588f 100644
--- a/src/libcore/ptr/const_ptr.rs
+++ b/src/libcore/ptr/const_ptr.rs
@@ -331,13 +331,13 @@ impl<T: ?Sized> *const T {
intrinsics::ptr_guaranteed_eq(self, other)
}
- /// Returns whether two pointers are guaranteed to be inequal.
+ /// Returns whether two pointers are guaranteed to be unequal.
///
/// At runtime this function behaves like `self != other`.
/// However, in some contexts (e.g., compile-time evaluation),
/// it is not always possible to determine the inequality of two pointers, so this function may
- /// spuriously return `false` for pointers that later actually turn out to be inequal.
- /// But when it returns `true`, the pointers are guaranteed to be inequal.
+ /// spuriously return `false` for pointers that later actually turn out to be unequal.
+ /// But when it returns `true`, the pointers are guaranteed to be unequal.
///
/// This function is the mirror of [`guaranteed_eq`], but not its inverse. There are pointer
/// comparisons for which both functions return `false`.
diff --git a/src/libcore/ptr/mut_ptr.rs b/src/libcore/ptr/mut_ptr.rs
index 7d4b6339b511f..180bad73b342b 100644
--- a/src/libcore/ptr/mut_ptr.rs
+++ b/src/libcore/ptr/mut_ptr.rs
@@ -312,13 +312,13 @@ impl<T: ?Sized> *mut T {
intrinsics::ptr_guaranteed_eq(self as *const _, other as *const _)
}
- /// Returns whether two pointers are guaranteed to be inequal.
+ /// Returns whether two pointers are guaranteed to be unequal.
///
/// At runtime this function behaves like `self != other`.
/// However, in some contexts (e.g., compile-time evaluation),
/// it is not always possible to determine the inequality of two pointers, so this function may
- /// spuriously return `false` for pointers that later actually turn out to be inequal.
- /// But when it returns `true`, the pointers are guaranteed to be inequal.
+ /// spuriously return `false` for pointers that later actually turn out to be unequal.
+ /// But when it returns `true`, the pointers are guaranteed to be unequal.
///
/// This function is the mirror of [`guaranteed_eq`], but not its inverse. There are pointer
/// comparisons for which both functions return `false`.
diff --git a/src/libcore/ptr/non_null.rs b/src/libcore/ptr/non_null.rs
index c2d31bfb6a4ee..47f4c1595b154 100644
--- a/src/libcore/ptr/non_null.rs
+++ b/src/libcore/ptr/non_null.rs
@@ -171,7 +171,7 @@ impl<T> NonNull<[T]> {
/// assert_eq!(unsafe { slice.as_ref()[2] }, 7);
/// ```
///
- /// (Note that this example artifically demonstrates a use of this method,
+ /// (Note that this example artificially demonstrates a use of this method,
/// but `let slice = NonNull::from(&x[..]);` would be a better way to write code like this.)
#[unstable(feature = "nonnull_slice_from_raw_parts", issue = "71941")]
#[rustc_const_unstable(feature = "const_nonnull_slice_from_raw_parts", issue = "71941")]
diff --git a/src/libstd/f32.rs b/src/libstd/f32.rs
index b392d6e7226d2..c905bcf5e3db4 100644
--- a/src/libstd/f32.rs
+++ b/src/libstd/f32.rs
@@ -1500,7 +1500,7 @@ mod tests {
assert_approx_eq!(f32::from_bits(0x44a72000), 1337.0);
assert_approx_eq!(f32::from_bits(0xc1640000), -14.25);
- // Check that NaNs roundtrip their bits regardless of signalingness
+ // Check that NaNs roundtrip their bits regardless of signaling-ness
// 0xA is 0b1010; 0x5 is 0b0101 -- so these two together clobbers all the mantissa bits
let masked_nan1 = f32::NAN.to_bits() ^ 0x002A_AAAA;
let masked_nan2 = f32::NAN.to_bits() ^ 0x0055_5555;
diff --git a/src/libstd/f64.rs b/src/libstd/f64.rs
index 72268d2cc2f98..f09fc8d790b28 100644
--- a/src/libstd/f64.rs
+++ b/src/libstd/f64.rs
@@ -1523,7 +1523,7 @@ mod tests {
assert_approx_eq!(f64::from_bits(0x4094e40000000000), 1337.0);
assert_approx_eq!(f64::from_bits(0xc02c800000000000), -14.25);
- // Check that NaNs roundtrip their bits regardless of signalingness
+ // Check that NaNs roundtrip their bits regardless of signaling-ness
// 0xA is 0b1010; 0x5 is 0b0101 -- so these two together clobbers all the mantissa bits
let masked_nan1 = f64::NAN.to_bits() ^ 0x000A_AAAA_AAAA_AAAA;
let masked_nan2 = f64::NAN.to_bits() ^ 0x0005_5555_5555_5555;
diff --git a/src/libstd/os/linux/fs.rs b/src/libstd/os/linux/fs.rs
index d22b44a066662..657737394ab82 100644
--- a/src/libstd/os/linux/fs.rs
+++ b/src/libstd/os/linux/fs.rs
@@ -285,7 +285,7 @@ pub trait MetadataExt {
/// ```
#[stable(feature = "metadata_ext2", since = "1.8.0")]
fn st_ctime_nsec(&self) -> i64;
- /// Returns the "preferred" blocksize for efficient filesystem I/O.
+ /// Returns the "preferred" block size for efficient filesystem I/O.
///
/// # Examples
///
diff --git a/src/libstd/os/redox/fs.rs b/src/libstd/os/redox/fs.rs
index 6c87df534bdc6..61b5bff380518 100644
--- a/src/libstd/os/redox/fs.rs
+++ b/src/libstd/os/redox/fs.rs
@@ -289,7 +289,7 @@ pub trait MetadataExt {
/// ```
#[stable(feature = "metadata_ext2", since = "1.8.0")]
fn st_ctime_nsec(&self) -> i64;
- /// Returns the "preferred" blocksize for efficient filesystem I/O.
+ /// Returns the "preferred" block size for efficient filesystem I/O.
///
/// # Examples
///
diff --git a/src/libstd/sys/sgx/fd.rs b/src/libstd/sys/sgx/fd.rs
index 90158030c7fbe..e5dc5b5adaa93 100644
--- a/src/libstd/sys/sgx/fd.rs
+++ b/src/libstd/sys/sgx/fd.rs
@@ -19,7 +19,7 @@ impl FileDesc {
self.fd
}
- /// Extracts the actual filedescriptor without closing it.
+ /// Extracts the actual file descriptor without closing it.
pub fn into_raw(self) -> Fd {
let fd = self.fd;
mem::forget(self);
diff --git a/src/libstd/sys/unix/ext/fs.rs b/src/libstd/sys/unix/ext/fs.rs
index 2b2bbc6e9d6ae..f174a59b49a6b 100644
--- a/src/libstd/sys/unix/ext/fs.rs
+++ b/src/libstd/sys/unix/ext/fs.rs
@@ -624,7 +624,7 @@ pub trait MetadataExt {
/// ```
#[stable(feature = "metadata_ext", since = "1.1.0")]
fn ctime_nsec(&self) -> i64;
- /// Returns the blocksize for filesystem I/O.
+ /// Returns the block size for filesystem I/O.
///
/// # Examples
///
@@ -635,7 +635,7 @@ pub trait MetadataExt {
///
/// fn main() -> io::Result<()> {
/// let meta = fs::metadata("some_file")?;
- /// let blocksize = meta.blksize();
+ /// let block_size = meta.blksize();
/// Ok(())
/// }
/// ```
diff --git a/src/libstd/sys/vxworks/fd.rs b/src/libstd/sys/vxworks/fd.rs
index 7fa86f0db043f..7384cbae3a14c 100644
--- a/src/libstd/sys/vxworks/fd.rs
+++ b/src/libstd/sys/vxworks/fd.rs
@@ -29,7 +29,7 @@ impl FileDesc {
self.fd
}
- /// Extracts the actual filedescriptor without closing it.
+ /// Extracts the actual file descriptor without closing it.
pub fn into_raw(self) -> c_int {
let fd = self.fd;
mem::forget(self);
diff --git a/src/libstd/sys/wasi/fs.rs b/src/libstd/sys/wasi/fs.rs
index 793daea43c215..2eed9e436a956 100644
--- a/src/libstd/sys/wasi/fs.rs
+++ b/src/libstd/sys/wasi/fs.rs
@@ -597,14 +597,14 @@ fn open_at(fd: &WasiFd, path: &Path, opts: &OpenOptions) -> io::Result<File> {
///
/// WASI has no fundamental capability to do this. All syscalls and operations
/// are relative to already-open file descriptors. The C library, however,
-/// manages a map of preopened file descriptors to their path, and then the C
+/// manages a map of pre-opened file descriptors to their path, and then the C
/// library provides an API to look at this. In other words, when you want to
/// open a path `p`, you have to find a previously opened file descriptor in a
/// global table and then see if `p` is relative to that file descriptor.
///
/// This function, if successful, will return two items:
///
-/// * The first is a `ManuallyDrop<WasiFd>`. This represents a preopened file
+/// * The first is a `ManuallyDrop<WasiFd>`. This represents a pre-opened file
/// descriptor which we don't have ownership of, but we can use. You shouldn't
/// actually drop the `fd`.
///
@@ -619,7 +619,7 @@ fn open_at(fd: &WasiFd, path: &Path, opts: &OpenOptions) -> io::Result<File> {
/// appropriate rights for performing `rights` actions.
///
/// Note that this can fail if `p` doesn't look like it can be opened relative
-/// to any preopened file descriptor.
+/// to any pre-opened file descriptor.
fn open_parent(p: &Path) -> io::Result<(ManuallyDrop<WasiFd>, PathBuf)> {
let p = CString::new(p.as_os_str().as_bytes())?;
unsafe {
@@ -627,7 +627,7 @@ fn open_parent(p: &Path) -> io::Result<(ManuallyDrop<WasiFd>, PathBuf)> {
let fd = __wasilibc_find_relpath(p.as_ptr(), &mut ret);
if fd == -1 {
let msg = format!(
- "failed to find a preopened file descriptor \
+ "failed to find a pre-opened file descriptor \
through which {:?} could be opened",
p
);