Make IoSlice and IoSliceMut methods unstably const

thaliaarchi · thaliaarchi · commit 3cf5b88c27cc · 2025-09-11T19:50:26.000-06:00
diff --git a/library/std/src/io/mod.rs b/library/std/src/io/mod.rs
@@ -1338,8 +1338,9 @@ impl<'a> IoSliceMut<'a> {
     ///
     /// Panics on Windows if the slice is larger than 4GB.
     #[stable(feature = "iovec", since = "1.36.0")]
+    #[rustc_const_unstable(feature = "io_slice_const", issue = "146459")]
     #[inline]
-    pub fn new(buf: &'a mut [u8]) -> IoSliceMut<'a> {
+    pub const fn new(buf: &'a mut [u8]) -> IoSliceMut<'a> {
         IoSliceMut(sys::io::IoSliceMut::new(buf))
     }
 
@@ -1366,8 +1367,9 @@ impl<'a> IoSliceMut<'a> {
     /// assert_eq!(buf.deref(), [1; 5].as_ref());
     /// ```
     #[stable(feature = "io_slice_advance", since = "1.81.0")]
+    #[rustc_const_unstable(feature = "io_slice_const", issue = "146459")]
     #[inline]
-    pub fn advance(&mut self, n: usize) {
+    pub const fn advance(&mut self, n: usize) {
         self.0.advance(n)
     }
 
@@ -1496,9 +1498,10 @@ impl<'a> IoSlice<'a> {
     ///
     /// Panics on Windows if the slice is larger than 4GB.
     #[stable(feature = "iovec", since = "1.36.0")]
+    #[rustc_const_unstable(feature = "io_slice_const", issue = "146459")]
     #[must_use]
     #[inline]
-    pub fn new(buf: &'a [u8]) -> IoSlice<'a> {
+    pub const fn new(buf: &'a [u8]) -> IoSlice<'a> {
         IoSlice(sys::io::IoSlice::new(buf))
     }
 
@@ -1525,8 +1528,9 @@ impl<'a> IoSlice<'a> {
     /// assert_eq!(buf.deref(), [1; 5].as_ref());
     /// ```
     #[stable(feature = "io_slice_advance", since = "1.81.0")]
+    #[rustc_const_unstable(feature = "io_slice_const", issue = "146459")]
     #[inline]
-    pub fn advance(&mut self, n: usize) {
+    pub const fn advance(&mut self, n: usize) {
         self.0.advance(n)
     }
 
diff --git a/library/std/src/sys/io/io_slice/iovec.rs b/library/std/src/sys/io/io_slice/iovec.rs
@@ -18,15 +18,15 @@ pub struct IoSlice<'a> {
 
 impl<'a> IoSlice<'a> {
     #[inline]
-    pub fn new(buf: &'a [u8]) -> IoSlice<'a> {
+    pub const fn new(buf: &'a [u8]) -> IoSlice<'a> {
         IoSlice {
             vec: iovec { iov_base: buf.as_ptr() as *mut u8 as *mut c_void, iov_len: buf.len() },
             _p: PhantomData,
         }
     }
 
     #[inline]
-    pub fn advance(&mut self, n: usize) {
+    pub const fn advance(&mut self, n: usize) {
         if self.vec.iov_len < n {
             panic!("advancing IoSlice beyond its length");
         }
@@ -51,15 +51,15 @@ pub struct IoSliceMut<'a> {
 
 impl<'a> IoSliceMut<'a> {
     #[inline]
-    pub fn new(buf: &'a mut [u8]) -> IoSliceMut<'a> {
+    pub const fn new(buf: &'a mut [u8]) -> IoSliceMut<'a> {
         IoSliceMut {
             vec: iovec { iov_base: buf.as_mut_ptr() as *mut c_void, iov_len: buf.len() },
             _p: PhantomData,
         }
     }
 
     #[inline]
-    pub fn advance(&mut self, n: usize) {
+    pub const fn advance(&mut self, n: usize) {
         if self.vec.iov_len < n {
             panic!("advancing IoSliceMut beyond its length");
         }
@@ -71,7 +71,7 @@ impl<'a> IoSliceMut<'a> {
     }
 
     #[inline]
-    pub fn as_slice(&self) -> &[u8] {
+    pub const fn as_slice(&self) -> &[u8] {
         unsafe { slice::from_raw_parts(self.vec.iov_base as *mut u8, self.vec.iov_len) }
     }
 
@@ -81,7 +81,7 @@ impl<'a> IoSliceMut<'a> {
     }
 
     #[inline]
-    pub fn as_mut_slice(&mut self) -> &mut [u8] {
+    pub const fn as_mut_slice(&mut self) -> &mut [u8] {
         unsafe { slice::from_raw_parts_mut(self.vec.iov_base as *mut u8, self.vec.iov_len) }
     }
 }
diff --git a/library/std/src/sys/io/io_slice/unsupported.rs b/library/std/src/sys/io/io_slice/unsupported.rs
@@ -5,12 +5,12 @@ pub struct IoSlice<'a>(&'a [u8]);
 
 impl<'a> IoSlice<'a> {
     #[inline]
-    pub fn new(buf: &'a [u8]) -> IoSlice<'a> {
+    pub const fn new(buf: &'a [u8]) -> IoSlice<'a> {
         IoSlice(buf)
     }
 
     #[inline]
-    pub fn advance(&mut self, n: usize) {
+    pub const fn advance(&mut self, n: usize) {
         self.0 = &self.0[n..]
     }
 
@@ -24,19 +24,19 @@ pub struct IoSliceMut<'a>(&'a mut [u8]);
 
 impl<'a> IoSliceMut<'a> {
     #[inline]
-    pub fn new(buf: &'a mut [u8]) -> IoSliceMut<'a> {
+    pub const fn new(buf: &'a mut [u8]) -> IoSliceMut<'a> {
         IoSliceMut(buf)
     }
 
     #[inline]
-    pub fn advance(&mut self, n: usize) {
+    pub const fn advance(&mut self, n: usize) {
         let slice = mem::take(&mut self.0);
         let (_, remaining) = slice.split_at_mut(n);
         self.0 = remaining;
     }
 
     #[inline]
-    pub fn as_slice(&self) -> &[u8] {
+    pub const fn as_slice(&self) -> &[u8] {
         self.0
     }
 
@@ -46,7 +46,7 @@ impl<'a> IoSliceMut<'a> {
     }
 
     #[inline]
-    pub fn as_mut_slice(&mut self) -> &mut [u8] {
+    pub const fn as_mut_slice(&mut self) -> &mut [u8] {
         self.0
     }
 }
diff --git a/library/std/src/sys/io/io_slice/wasi.rs b/library/std/src/sys/io/io_slice/wasi.rs
@@ -10,12 +10,12 @@ pub struct IoSlice<'a> {
 
 impl<'a> IoSlice<'a> {
     #[inline]
-    pub fn new(buf: &'a [u8]) -> IoSlice<'a> {
+    pub const fn new(buf: &'a [u8]) -> IoSlice<'a> {
         IoSlice { vec: wasi::Ciovec { buf: buf.as_ptr(), buf_len: buf.len() }, _p: PhantomData }
     }
 
     #[inline]
-    pub fn advance(&mut self, n: usize) {
+    pub const fn advance(&mut self, n: usize) {
         if self.vec.buf_len < n {
             panic!("advancing IoSlice beyond its length");
         }
@@ -40,15 +40,15 @@ pub struct IoSliceMut<'a> {
 
 impl<'a> IoSliceMut<'a> {
     #[inline]
-    pub fn new(buf: &'a mut [u8]) -> IoSliceMut<'a> {
+    pub const fn new(buf: &'a mut [u8]) -> IoSliceMut<'a> {
         IoSliceMut {
             vec: wasi::Iovec { buf: buf.as_mut_ptr(), buf_len: buf.len() },
             _p: PhantomData,
         }
     }
 
     #[inline]
-    pub fn advance(&mut self, n: usize) {
+    pub const fn advance(&mut self, n: usize) {
         if self.vec.buf_len < n {
             panic!("advancing IoSlice beyond its length");
         }
@@ -60,7 +60,7 @@ impl<'a> IoSliceMut<'a> {
     }
 
     #[inline]
-    pub fn as_slice(&self) -> &[u8] {
+    pub const fn as_slice(&self) -> &[u8] {
         unsafe { slice::from_raw_parts(self.vec.buf as *const u8, self.vec.buf_len) }
     }
 
@@ -70,7 +70,7 @@ impl<'a> IoSliceMut<'a> {
     }
 
     #[inline]
-    pub fn as_mut_slice(&mut self) -> &mut [u8] {
+    pub const fn as_mut_slice(&mut self) -> &mut [u8] {
         unsafe { slice::from_raw_parts_mut(self.vec.buf as *mut u8, self.vec.buf_len) }
     }
 }
diff --git a/library/std/src/sys/io/io_slice/windows.rs b/library/std/src/sys/io/io_slice/windows.rs
@@ -11,7 +11,7 @@ pub struct IoSlice<'a> {
 
 impl<'a> IoSlice<'a> {
     #[inline]
-    pub fn new(buf: &'a [u8]) -> IoSlice<'a> {
+    pub const fn new(buf: &'a [u8]) -> IoSlice<'a> {
         assert!(buf.len() <= u32::MAX as usize);
         IoSlice {
             vec: c::WSABUF { len: buf.len() as u32, buf: buf.as_ptr() as *mut u8 },
@@ -20,7 +20,7 @@ impl<'a> IoSlice<'a> {
     }
 
     #[inline]
-    pub fn advance(&mut self, n: usize) {
+    pub const fn advance(&mut self, n: usize) {
         if (self.vec.len as usize) < n {
             panic!("advancing IoSlice beyond its length");
         }
@@ -45,7 +45,7 @@ pub struct IoSliceMut<'a> {
 
 impl<'a> IoSliceMut<'a> {
     #[inline]
-    pub fn new(buf: &'a mut [u8]) -> IoSliceMut<'a> {
+    pub const fn new(buf: &'a mut [u8]) -> IoSliceMut<'a> {
         assert!(buf.len() <= u32::MAX as usize);
         IoSliceMut {
             vec: c::WSABUF { len: buf.len() as u32, buf: buf.as_mut_ptr() },
@@ -54,7 +54,7 @@ impl<'a> IoSliceMut<'a> {
     }
 
     #[inline]
-    pub fn advance(&mut self, n: usize) {
+    pub const fn advance(&mut self, n: usize) {
         if (self.vec.len as usize) < n {
             panic!("advancing IoSliceMut beyond its length");
         }
@@ -66,7 +66,7 @@ impl<'a> IoSliceMut<'a> {
     }
 
     #[inline]
-    pub fn as_slice(&self) -> &[u8] {
+    pub const fn as_slice(&self) -> &[u8] {
         unsafe { slice::from_raw_parts(self.vec.buf, self.vec.len as usize) }
     }
 
@@ -76,7 +76,7 @@ impl<'a> IoSliceMut<'a> {
     }
 
     #[inline]
-    pub fn as_mut_slice(&mut self) -> &mut [u8] {
+    pub const fn as_mut_slice(&mut self) -> &mut [u8] {
         unsafe { slice::from_raw_parts_mut(self.vec.buf, self.vec.len as usize) }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -18,15 +18,15 @@ pub struct IoSlice<'a> {`
`18`	`18`
`19`	`19`	`impl<'a> IoSlice<'a> {`
`20`	`20`	`#[inline]`
`21`		`- pub fn new(buf: &'a [u8]) -> IoSlice<'a> {`
	`21`	`+ pub const fn new(buf: &'a [u8]) -> IoSlice<'a> {`
`22`	`22`	`IoSlice {`
`23`	`23`	`vec: iovec { iov_base: buf.as_ptr() as mut u8 as mut c_void, iov_len: buf.len() },`
`24`	`24`	`_p: PhantomData,`
`25`	`25`	`}`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`#[inline]`
`29`		`- pub fn advance(&mut self, n: usize) {`
	`29`	`+ pub const fn advance(&mut self, n: usize) {`
`30`	`30`	`if self.vec.iov_len < n {`
`31`	`31`	`panic!("advancing IoSlice beyond its length");`
`32`	`32`	`}`
`@@ -51,15 +51,15 @@ pub struct IoSliceMut<'a> {`
`51`	`51`
`52`	`52`	`impl<'a> IoSliceMut<'a> {`
`53`	`53`	`#[inline]`
`54`		`- pub fn new(buf: &'a mut [u8]) -> IoSliceMut<'a> {`
	`54`	`+ pub const fn new(buf: &'a mut [u8]) -> IoSliceMut<'a> {`
`55`	`55`	`IoSliceMut {`
`56`	`56`	`vec: iovec { iov_base: buf.as_mut_ptr() as *mut c_void, iov_len: buf.len() },`
`57`	`57`	`_p: PhantomData,`
`58`	`58`	`}`
`59`	`59`	`}`
`60`	`60`
`61`	`61`	`#[inline]`
`62`		`- pub fn advance(&mut self, n: usize) {`
	`62`	`+ pub const fn advance(&mut self, n: usize) {`
`63`	`63`	`if self.vec.iov_len < n {`
`64`	`64`	`panic!("advancing IoSliceMut beyond its length");`
`65`	`65`	`}`
`@@ -71,7 +71,7 @@ impl<'a> IoSliceMut<'a> {`
`71`	`71`	`}`
`72`	`72`
`73`	`73`	`#[inline]`
`74`		`- pub fn as_slice(&self) -> &[u8] {`
	`74`	`+ pub const fn as_slice(&self) -> &[u8] {`
`75`	`75`	`unsafe { slice::from_raw_parts(self.vec.iov_base as *mut u8, self.vec.iov_len) }`
`76`	`76`	`}`
`77`	`77`
`@@ -81,7 +81,7 @@ impl<'a> IoSliceMut<'a> {`
`81`	`81`	`}`
`82`	`82`
`83`	`83`	`#[inline]`
`84`		`- pub fn as_mut_slice(&mut self) -> &mut [u8] {`
	`84`	`+ pub const fn as_mut_slice(&mut self) -> &mut [u8] {`
`85`	`85`	`unsafe { slice::from_raw_parts_mut(self.vec.iov_base as *mut u8, self.vec.iov_len) }`
`86`	`86`	`}`
`87`	`87`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,12 +5,12 @@ pub struct IoSlice<'a>(&'a [u8]);`
`5`	`5`
`6`	`6`	`impl<'a> IoSlice<'a> {`
`7`	`7`	`#[inline]`
`8`		`- pub fn new(buf: &'a [u8]) -> IoSlice<'a> {`
	`8`	`+ pub const fn new(buf: &'a [u8]) -> IoSlice<'a> {`
`9`	`9`	`IoSlice(buf)`
`10`	`10`	`}`
`11`	`11`
`12`	`12`	`#[inline]`
`13`		`- pub fn advance(&mut self, n: usize) {`
	`13`	`+ pub const fn advance(&mut self, n: usize) {`
`14`	`14`	`self.0 = &self.0[n..]`
`15`	`15`	`}`
`16`	`16`
`@@ -24,19 +24,19 @@ pub struct IoSliceMut<'a>(&'a mut [u8]);`
`24`	`24`
`25`	`25`	`impl<'a> IoSliceMut<'a> {`
`26`	`26`	`#[inline]`
`27`		`- pub fn new(buf: &'a mut [u8]) -> IoSliceMut<'a> {`
	`27`	`+ pub const fn new(buf: &'a mut [u8]) -> IoSliceMut<'a> {`
`28`	`28`	`IoSliceMut(buf)`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`#[inline]`
`32`		`- pub fn advance(&mut self, n: usize) {`
	`32`	`+ pub const fn advance(&mut self, n: usize) {`
`33`	`33`	`let slice = mem::take(&mut self.0);`
`34`	`34`	`let (_, remaining) = slice.split_at_mut(n);`
`35`	`35`	`self.0 = remaining;`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`#[inline]`
`39`		`- pub fn as_slice(&self) -> &[u8] {`
	`39`	`+ pub const fn as_slice(&self) -> &[u8] {`
`40`	`40`	`self.0`
`41`	`41`	`}`
`42`	`42`
`@@ -46,7 +46,7 @@ impl<'a> IoSliceMut<'a> {`
`46`	`46`	`}`
`47`	`47`
`48`	`48`	`#[inline]`
`49`		`- pub fn as_mut_slice(&mut self) -> &mut [u8] {`
	`49`	`+ pub const fn as_mut_slice(&mut self) -> &mut [u8] {`
`50`	`50`	`self.0`
`51`	`51`	`}`
`52`	`52`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,12 +10,12 @@ pub struct IoSlice<'a> {`
`10`	`10`
`11`	`11`	`impl<'a> IoSlice<'a> {`
`12`	`12`	`#[inline]`
`13`		`- pub fn new(buf: &'a [u8]) -> IoSlice<'a> {`
	`13`	`+ pub const fn new(buf: &'a [u8]) -> IoSlice<'a> {`
`14`	`14`	`IoSlice { vec: wasi::Ciovec { buf: buf.as_ptr(), buf_len: buf.len() }, _p: PhantomData }`
`15`	`15`	`}`
`16`	`16`
`17`	`17`	`#[inline]`
`18`		`- pub fn advance(&mut self, n: usize) {`
	`18`	`+ pub const fn advance(&mut self, n: usize) {`
`19`	`19`	`if self.vec.buf_len < n {`
`20`	`20`	`panic!("advancing IoSlice beyond its length");`
`21`	`21`	`}`
`@@ -40,15 +40,15 @@ pub struct IoSliceMut<'a> {`
`40`	`40`
`41`	`41`	`impl<'a> IoSliceMut<'a> {`
`42`	`42`	`#[inline]`
`43`		`- pub fn new(buf: &'a mut [u8]) -> IoSliceMut<'a> {`
	`43`	`+ pub const fn new(buf: &'a mut [u8]) -> IoSliceMut<'a> {`
`44`	`44`	`IoSliceMut {`
`45`	`45`	`vec: wasi::Iovec { buf: buf.as_mut_ptr(), buf_len: buf.len() },`
`46`	`46`	`_p: PhantomData,`
`47`	`47`	`}`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`#[inline]`
`51`		`- pub fn advance(&mut self, n: usize) {`
	`51`	`+ pub const fn advance(&mut self, n: usize) {`
`52`	`52`	`if self.vec.buf_len < n {`
`53`	`53`	`panic!("advancing IoSlice beyond its length");`
`54`	`54`	`}`
`@@ -60,7 +60,7 @@ impl<'a> IoSliceMut<'a> {`
`60`	`60`	`}`
`61`	`61`
`62`	`62`	`#[inline]`
`63`		`- pub fn as_slice(&self) -> &[u8] {`
	`63`	`+ pub const fn as_slice(&self) -> &[u8] {`
`64`	`64`	`unsafe { slice::from_raw_parts(self.vec.buf as *const u8, self.vec.buf_len) }`
`65`	`65`	`}`
`66`	`66`
`@@ -70,7 +70,7 @@ impl<'a> IoSliceMut<'a> {`
`70`	`70`	`}`
`71`	`71`
`72`	`72`	`#[inline]`
`73`		`- pub fn as_mut_slice(&mut self) -> &mut [u8] {`
	`73`	`+ pub const fn as_mut_slice(&mut self) -> &mut [u8] {`
`74`	`74`	`unsafe { slice::from_raw_parts_mut(self.vec.buf as *mut u8, self.vec.buf_len) }`
`75`	`75`	`}`
`76`	`76`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@ pub struct IoSlice<'a> {`
`11`	`11`
`12`	`12`	`impl<'a> IoSlice<'a> {`
`13`	`13`	`#[inline]`
`14`		`- pub fn new(buf: &'a [u8]) -> IoSlice<'a> {`
	`14`	`+ pub const fn new(buf: &'a [u8]) -> IoSlice<'a> {`
`15`	`15`	`assert!(buf.len() <= u32::MAX as usize);`
`16`	`16`	`IoSlice {`
`17`	`17`	`vec: c::WSABUF { len: buf.len() as u32, buf: buf.as_ptr() as *mut u8 },`
`@@ -20,7 +20,7 @@ impl<'a> IoSlice<'a> {`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`#[inline]`
`23`		`- pub fn advance(&mut self, n: usize) {`
	`23`	`+ pub const fn advance(&mut self, n: usize) {`
`24`	`24`	`if (self.vec.len as usize) < n {`
`25`	`25`	`panic!("advancing IoSlice beyond its length");`
`26`	`26`	`}`
`@@ -45,7 +45,7 @@ pub struct IoSliceMut<'a> {`
`45`	`45`
`46`	`46`	`impl<'a> IoSliceMut<'a> {`
`47`	`47`	`#[inline]`
`48`		`- pub fn new(buf: &'a mut [u8]) -> IoSliceMut<'a> {`
	`48`	`+ pub const fn new(buf: &'a mut [u8]) -> IoSliceMut<'a> {`
`49`	`49`	`assert!(buf.len() <= u32::MAX as usize);`
`50`	`50`	`IoSliceMut {`
`51`	`51`	`vec: c::WSABUF { len: buf.len() as u32, buf: buf.as_mut_ptr() },`
`@@ -54,7 +54,7 @@ impl<'a> IoSliceMut<'a> {`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`#[inline]`
`57`		`- pub fn advance(&mut self, n: usize) {`
	`57`	`+ pub const fn advance(&mut self, n: usize) {`
`58`	`58`	`if (self.vec.len as usize) < n {`
`59`	`59`	`panic!("advancing IoSliceMut beyond its length");`
`60`	`60`	`}`
`@@ -66,7 +66,7 @@ impl<'a> IoSliceMut<'a> {`
`66`	`66`	`}`
`67`	`67`
`68`	`68`	`#[inline]`
`69`		`- pub fn as_slice(&self) -> &[u8] {`
	`69`	`+ pub const fn as_slice(&self) -> &[u8] {`
`70`	`70`	`unsafe { slice::from_raw_parts(self.vec.buf, self.vec.len as usize) }`
`71`	`71`	`}`
`72`	`72`
`@@ -76,7 +76,7 @@ impl<'a> IoSliceMut<'a> {`
`76`	`76`	`}`
`77`	`77`
`78`	`78`	`#[inline]`
`79`		`- pub fn as_mut_slice(&mut self) -> &mut [u8] {`
	`79`	`+ pub const fn as_mut_slice(&mut self) -> &mut [u8] {`
`80`	`80`	`unsafe { slice::from_raw_parts_mut(self.vec.buf, self.vec.len as usize) }`
`81`	`81`	`}`
`82`	`82`	`}`