diff --git a/alloc/src/boxed/thin.rs b/alloc/src/boxed/thin.rs
index 8b145b67bf186..e9bfecba160a0 100644
--- a/alloc/src/boxed/thin.rs
+++ b/alloc/src/boxed/thin.rs
@@ -1,6 +1,7 @@
-// Based on
-// https://github.com/matthieu-m/rfc2580/blob/b58d1d3cba0d4b5e859d3617ea2d0943aaa31329/examples/thin.rs
-// by matthieu-m
+//! Based on
+//! <https://github.com/matthieu-m/rfc2580/blob/b58d1d3cba0d4b5e859d3617ea2d0943aaa31329/examples/thin.rs>
+//! by matthieu-m
+
 use crate::alloc::{self, Layout, LayoutError};
 use core::error::Error;
 use core::fmt::{self, Debug, Display, Formatter};
diff --git a/alloc/src/vec/in_place_collect.rs b/alloc/src/vec/in_place_collect.rs
index 22541a2b9d82f..0dc193d82c535 100644
--- a/alloc/src/vec/in_place_collect.rs
+++ b/alloc/src/vec/in_place_collect.rs
@@ -154,6 +154,7 @@
 //! }
 //! vec.truncate(write_idx);
 //! ```
+
 use crate::alloc::{handle_alloc_error, Global};
 use core::alloc::Allocator;
 use core::alloc::Layout;
diff --git a/core/src/option.rs b/core/src/option.rs
index 4d6ba2fa3b38c..8ec7716012f59 100644
--- a/core/src/option.rs
+++ b/core/src/option.rs
@@ -797,7 +797,8 @@ impl<T> Option<T> {
     #[inline]
     #[must_use]
     #[stable(feature = "option_as_slice", since = "1.75.0")]
-    pub fn as_slice(&self) -> &[T] {
+    #[rustc_const_unstable(feature = "const_option_ext", issue = "91930")]
+    pub const fn as_slice(&self) -> &[T] {
         // SAFETY: When the `Option` is `Some`, we're using the actual pointer
         // to the payload, with a length of 1, so this is equivalent to
         // `slice::from_ref`, and thus is safe.
@@ -811,7 +812,7 @@ impl<T> Option<T> {
         unsafe {
             slice::from_raw_parts(
                 (self as *const Self).byte_add(core::mem::offset_of!(Self, Some.0)).cast(),
-                usize::from(self.is_some()),
+                self.is_some() as usize,
             )
         }
     }
@@ -851,7 +852,8 @@ impl<T> Option<T> {
     #[inline]
     #[must_use]
     #[stable(feature = "option_as_slice", since = "1.75.0")]
-    pub fn as_mut_slice(&mut self) -> &mut [T] {
+    #[rustc_const_unstable(feature = "const_option_ext", issue = "91930")]
+    pub const fn as_mut_slice(&mut self) -> &mut [T] {
         // SAFETY: When the `Option` is `Some`, we're using the actual pointer
         // to the payload, with a length of 1, so this is equivalent to
         // `slice::from_mut`, and thus is safe.
@@ -867,7 +869,7 @@ impl<T> Option<T> {
         unsafe {
             slice::from_raw_parts_mut(
                 (self as *mut Self).byte_add(core::mem::offset_of!(Self, Some.0)).cast(),
-                usize::from(self.is_some()),
+                self.is_some() as usize,
             )
         }
     }
diff --git a/core/src/str/count.rs b/core/src/str/count.rs
index d8667864fe554..b5d7aaf05d4bd 100644
--- a/core/src/str/count.rs
+++ b/core/src/str/count.rs
@@ -17,6 +17,7 @@
 //! Note: Because the term "leading byte" can sometimes be ambiguous (for
 //! example, it could also refer to the first byte of a slice), we'll often use
 //! the term "non-continuation byte" to refer to these bytes in the code.
+
 use core::intrinsics::unlikely;
 
 const USIZE_SIZE: usize = core::mem::size_of::<usize>();
diff --git a/core/tests/iter/adapters/map_windows.rs b/core/tests/iter/adapters/map_windows.rs
index 7fb2408f8acb7..6744eff3fa26f 100644
--- a/core/tests/iter/adapters/map_windows.rs
+++ b/core/tests/iter/adapters/map_windows.rs
@@ -3,6 +3,7 @@ use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
 #[cfg(not(panic = "abort"))]
 mod drop_checks {
     //! These tests mainly make sure the elements are correctly dropped.
+
     use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering::SeqCst};
 
     #[derive(Debug)]
diff --git a/core/tests/net/parser.rs b/core/tests/net/parser.rs
index 36b87d7c1f5e0..e03959ac77c35 100644
--- a/core/tests/net/parser.rs
+++ b/core/tests/net/parser.rs
@@ -1,4 +1,5 @@
 // FIXME: These tests are all excellent candidates for AFL fuzz testing
+
 use core::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6};
 use core::str::FromStr;
 
diff --git a/core/tests/num/ieee754.rs b/core/tests/num/ieee754.rs
index 48ab75b6f17a5..b0f6a7545aa93 100644
--- a/core/tests/num/ieee754.rs
+++ b/core/tests/num/ieee754.rs
@@ -27,6 +27,7 @@
 //! standard. That is why they accept wildly diverse inputs or may seem to duplicate other tests.
 //! Please consider this carefully when adding, removing, or reorganizing these tests. They are
 //! here so that it is clear what tests are required by the standard and what can be changed.
+
 use ::core::str::FromStr;
 
 // IEEE 754 for many tests is applied to specific bit patterns.
diff --git a/core/tests/option.rs b/core/tests/option.rs
index b1b9492f182e0..336a79a02ceeb 100644
--- a/core/tests/option.rs
+++ b/core/tests/option.rs
@@ -574,4 +574,13 @@ fn as_slice() {
     assert_eq!(Some(43).as_mut_slice(), &[43]);
     assert_eq!(None::<i32>.as_slice(), &[]);
     assert_eq!(None::<i32>.as_mut_slice(), &[]);
+
+    const A: &[u32] = Some(44).as_slice();
+    const B: &[u32] = None.as_slice();
+    const _: () = {
+        let [45] = Some(45).as_mut_slice() else { panic!() };
+        let []: &[u32] = None.as_mut_slice() else { panic!() };
+    };
+    assert_eq!(A, &[44]);
+    assert_eq!(B, &[]);
 }
diff --git a/core/tests/pin_macro.rs b/core/tests/pin_macro.rs
index 79c8c166c58d9..57485ef3974cc 100644
--- a/core/tests/pin_macro.rs
+++ b/core/tests/pin_macro.rs
@@ -1,4 +1,5 @@
 // edition:2021
+
 use core::{
     marker::PhantomPinned,
     mem::{drop as stuff, transmute},
diff --git a/panic_unwind/src/miri.rs b/panic_unwind/src/miri.rs
index 4d21e846010e9..695adadd59b55 100644
--- a/panic_unwind/src/miri.rs
+++ b/panic_unwind/src/miri.rs
@@ -1,4 +1,5 @@
 //! Unwinding panics for Miri.
+
 use alloc::boxed::Box;
 use core::any::Any;
 
diff --git a/portable-simd/crates/core_simd/examples/dot_product.rs b/portable-simd/crates/core_simd/examples/dot_product.rs
index f047010a65c16..75d152ae7f0e3 100644
--- a/portable-simd/crates/core_simd/examples/dot_product.rs
+++ b/portable-simd/crates/core_simd/examples/dot_product.rs
@@ -1,6 +1,5 @@
-// Code taken from the `packed_simd` crate
-// Run this code with `cargo test --example dot_product`
-//use std::iter::zip;
+//! Code taken from the `packed_simd` crate.
+//! Run this code with `cargo test --example dot_product`.
 
 #![feature(array_chunks)]
 #![feature(slice_as_chunks)]
diff --git a/portable-simd/crates/core_simd/src/ops/assign.rs b/portable-simd/crates/core_simd/src/ops/assign.rs
index 0e87785025a38..d21d867de26d6 100644
--- a/portable-simd/crates/core_simd/src/ops/assign.rs
+++ b/portable-simd/crates/core_simd/src/ops/assign.rs
@@ -1,4 +1,5 @@
 //! Assignment operators
+
 use super::*;
 use core::ops::{AddAssign, MulAssign}; // commutative binary op-assignment
 use core::ops::{BitAndAssign, BitOrAssign, BitXorAssign}; // commutative bit binary op-assignment
diff --git a/portable-simd/crates/core_simd/src/ops/deref.rs b/portable-simd/crates/core_simd/src/ops/deref.rs
index 89a60ba114146..0ff76cfba39bb 100644
--- a/portable-simd/crates/core_simd/src/ops/deref.rs
+++ b/portable-simd/crates/core_simd/src/ops/deref.rs
@@ -2,6 +2,7 @@
 //! Ideally, Rust would take care of this itself,
 //! and method calls usually handle the LHS implicitly.
 //! But this is not the case with arithmetic ops.
+
 use super::*;
 
 macro_rules! deref_lhs {
diff --git a/std/src/hash/random.rs b/std/src/hash/random.rs
index a1ccbb25369bf..0adf91e14ac6e 100644
--- a/std/src/hash/random.rs
+++ b/std/src/hash/random.rs
@@ -6,6 +6,7 @@
 //! outside this crate.
 //!
 //! [`collections`]: crate::collections
+
 #[allow(deprecated)]
 use super::{BuildHasher, Hasher, SipHasher13};
 use crate::cell::Cell;
diff --git a/std/src/io/buffered/bufreader/buffer.rs b/std/src/io/buffered/bufreader/buffer.rs
index e9e29d60ca282..796137c0123e7 100644
--- a/std/src/io/buffered/bufreader/buffer.rs
+++ b/std/src/io/buffered/bufreader/buffer.rs
@@ -1,13 +1,14 @@
-///! An encapsulation of `BufReader`'s buffer management logic.
-///
-/// This module factors out the basic functionality of `BufReader` in order to protect two core
-/// invariants:
-/// * `filled` bytes of `buf` are always initialized
-/// * `pos` is always <= `filled`
-/// Since this module encapsulates the buffer management logic, we can ensure that the range
-/// `pos..filled` is always a valid index into the initialized region of the buffer. This means
-/// that user code which wants to do reads from a `BufReader` via `buffer` + `consume` can do so
-/// without encountering any runtime bounds checks.
+//! An encapsulation of `BufReader`'s buffer management logic.
+//!
+//! This module factors out the basic functionality of `BufReader` in order to protect two core
+//! invariants:
+//! * `filled` bytes of `buf` are always initialized
+//! * `pos` is always <= `filled`
+//! Since this module encapsulates the buffer management logic, we can ensure that the range
+//! `pos..filled` is always a valid index into the initialized region of the buffer. This means
+//! that user code which wants to do reads from a `BufReader` via `buffer` + `consume` can do so
+//! without encountering any runtime bounds checks.
+
 use crate::cmp;
 use crate::io::{self, BorrowedBuf, Read};
 use crate::mem::MaybeUninit;
diff --git a/std/src/sys/os_str/wtf8.rs b/std/src/sys/os_str/wtf8.rs
index dfff4dd4fb023..96690f8c44e9c 100644
--- a/std/src/sys/os_str/wtf8.rs
+++ b/std/src/sys/os_str/wtf8.rs
@@ -1,5 +1,6 @@
-/// The underlying OsString/OsStr implementation on Windows is a
-/// wrapper around the "WTF-8" encoding; see the `wtf8` module for more.
+//! The underlying OsString/OsStr implementation on Windows is a
+//! wrapper around the "WTF-8" encoding; see the `wtf8` module for more.
+
 use crate::borrow::Cow;
 use crate::collections::TryReserveError;
 use crate::fmt;
diff --git a/std/src/sys/pal/itron/thread.rs b/std/src/sys/pal/itron/thread.rs
index 205226ce1da80..a0c8217128f39 100644
--- a/std/src/sys/pal/itron/thread.rs
+++ b/std/src/sys/pal/itron/thread.rs
@@ -1,5 +1,6 @@
 //! Thread implementation backed by μITRON tasks. Assumes `acre_tsk` and
 //! `exd_tsk` are available.
+
 use super::{
     abi,
     error::{expect_success, expect_success_aborting, ItronError},
diff --git a/std/src/sys/pal/solid/abi/fs.rs b/std/src/sys/pal/solid/abi/fs.rs
index 49526f4c9cd4d..75efaaac2a948 100644
--- a/std/src/sys/pal/solid/abi/fs.rs
+++ b/std/src/sys/pal/solid/abi/fs.rs
@@ -1,4 +1,5 @@
 //! `solid_fs.h`
+
 use crate::os::raw::{c_char, c_int, c_uchar};
 pub use libc::{
     ino_t, off_t, stat, time_t, O_APPEND, O_CREAT, O_EXCL, O_RDONLY, O_RDWR, O_TRUNC, O_WRONLY,
diff --git a/std/src/sys/pal/unix/process/process_unsupported/wait_status.rs b/std/src/sys/pal/unix/process/process_unsupported/wait_status.rs
index e6dfadcf4a4cf..973188b1f2b27 100644
--- a/std/src/sys/pal/unix/process/process_unsupported/wait_status.rs
+++ b/std/src/sys/pal/unix/process/process_unsupported/wait_status.rs
@@ -1,6 +1,7 @@
 //! Emulated wait status for non-Unix #[cfg(unix) platforms
 //!
 //! Separate module to facilitate testing against a real Unix implementation.
+
 use crate::ffi::c_int;
 use crate::fmt;
 use crate::num::NonZero;
diff --git a/std/src/sys/pal/unix/thread.rs b/std/src/sys/pal/unix/thread.rs
index 1ab54ec57c3b7..3ebf1cfd33f8f 100644
--- a/std/src/sys/pal/unix/thread.rs
+++ b/std/src/sys/pal/unix/thread.rs
@@ -475,6 +475,7 @@ mod cgroups {
     //! * cgroup v2 in non-standard mountpoints
     //! * paths containing control characters or spaces, since those would be escaped in procfs
     //!   output and we don't unescape
+
     use crate::borrow::Cow;
     use crate::ffi::OsString;
     use crate::fs::{try_exists, File};
diff --git a/std/src/sys/sync/condvar/itron.rs b/std/src/sys/sync/condvar/itron.rs
index 9b64d241efd12..3a3039889e98b 100644
--- a/std/src/sys/sync/condvar/itron.rs
+++ b/std/src/sys/sync/condvar/itron.rs
@@ -1,4 +1,5 @@
 //! POSIX conditional variable implementation based on user-space wait queues.
+
 use crate::sys::pal::itron::{
     abi, error::expect_success_aborting, spin::SpinMutex, task, time::with_tmos_strong,
 };
diff --git a/std/src/sys/sync/mutex/itron.rs b/std/src/sys/sync/mutex/itron.rs
index a134eb2d1beca..4ba32a8fbcd69 100644
--- a/std/src/sys/sync/mutex/itron.rs
+++ b/std/src/sys/sync/mutex/itron.rs
@@ -1,5 +1,6 @@
 //! Mutex implementation backed by μITRON mutexes. Assumes `acre_mtx` and
 //! `TA_INHERIT` are available.
+
 use crate::sys::pal::itron::{
     abi,
     error::{expect_success, expect_success_aborting, fail, ItronError},
diff --git a/std/src/sys/sync/rwlock/solid.rs b/std/src/sys/sync/rwlock/solid.rs
index 9bf6f5dbb731e..7558eee8edd33 100644
--- a/std/src/sys/sync/rwlock/solid.rs
+++ b/std/src/sys/sync/rwlock/solid.rs
@@ -1,4 +1,5 @@
 //! A readers-writer lock implementation backed by the SOLID kernel extension.
+
 use crate::sys::pal::{
     abi,
     itron::{
diff --git a/std/tests/create_dir_all_bare.rs b/std/tests/create_dir_all_bare.rs
index fd2a7f906f839..79c3c8f528efa 100644
--- a/std/tests/create_dir_all_bare.rs
+++ b/std/tests/create_dir_all_bare.rs
@@ -2,6 +2,7 @@
 
 //! Note that this test changes the current directory so
 //! should not be in the same process as other tests.
+
 use std::env;
 use std::fs;
 use std::path::{Path, PathBuf};
diff --git a/test/src/bench.rs b/test/src/bench.rs
index 64ca13c0d4ed3..9f34f54c3d60a 100644
--- a/test/src/bench.rs
+++ b/test/src/bench.rs
@@ -1,4 +1,5 @@
 //! Benchmarking module.
+
 use super::{
     event::CompletedTest,
     options::BenchMode,
diff --git a/test/src/helpers/concurrency.rs b/test/src/helpers/concurrency.rs
index b395adcf885ce..1854c6a76524d 100644
--- a/test/src/helpers/concurrency.rs
+++ b/test/src/helpers/concurrency.rs
@@ -1,5 +1,6 @@
 //! Helper module which helps to determine amount of threads to be used
 //! during tests execution.
+
 use std::{env, num::NonZero, thread};
 
 pub fn get_concurrency() -> usize {
diff --git a/test/src/helpers/metrics.rs b/test/src/helpers/metrics.rs
index f77a23e6875b2..bc38969cefb8d 100644
--- a/test/src/helpers/metrics.rs
+++ b/test/src/helpers/metrics.rs
@@ -1,4 +1,5 @@
 //! Benchmark metrics.
+
 use std::collections::BTreeMap;
 
 #[derive(Clone, PartialEq, Debug, Copy)]