Stabilize round_char_boundary feature

okaneco · okaneco · commit c5c652050bc3 · 2025-08-22T13:23:45.000-04:00
diff --git a/compiler/rustc_middle/src/lib.rs b/compiler/rustc_middle/src/lib.rs
@@ -29,6 +29,7 @@
 #![allow(rustc::diagnostic_outside_of_impl)]
 #![allow(rustc::direct_use_of_rustc_type_ir)]
 #![allow(rustc::untranslatable_diagnostic)]
+#![cfg_attr(bootstrap, feature(round_char_boundary))]
 #![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
 #![doc(rust_logo)]
 #![feature(allocator_api)]
@@ -51,7 +52,6 @@
 #![feature(negative_impls)]
 #![feature(never_type)]
 #![feature(ptr_alignment_type)]
-#![feature(round_char_boundary)]
 #![feature(rustc_attrs)]
 #![feature(rustdoc_internals)]
 #![feature(sized_hierarchy)]
diff --git a/compiler/rustc_span/src/lib.rs b/compiler/rustc_span/src/lib.rs
@@ -17,6 +17,7 @@
 
 // tidy-alphabetical-start
 #![allow(internal_features)]
+#![cfg_attr(bootstrap, feature(round_char_boundary))]
 #![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
 #![doc(rust_logo)]
 #![feature(array_windows)]
@@ -26,7 +27,6 @@
 #![feature(map_try_insert)]
 #![feature(negative_impls)]
 #![feature(read_buf)]
-#![feature(round_char_boundary)]
 #![feature(rustc_attrs)]
 #![feature(rustdoc_internals)]
 // tidy-alphabetical-end
diff --git a/library/alloctests/tests/lib.rs b/library/alloctests/tests/lib.rs
@@ -23,7 +23,6 @@
 #![feature(inplace_iteration)]
 #![feature(iter_advance_by)]
 #![feature(iter_next_chunk)]
-#![feature(round_char_boundary)]
 #![feature(slice_partition_dedup)]
 #![feature(string_from_utf8_lossy_owned)]
 #![feature(string_remove_matches)]
diff --git a/library/core/src/str/mod.rs b/library/core/src/str/mod.rs
@@ -396,7 +396,6 @@ impl str {
     /// # Examples
     ///
     /// ```
-    /// #![feature(round_char_boundary)]
     /// let s = "❤️🧡💛💚💙💜";
     /// assert_eq!(s.len(), 26);
     /// assert!(!s.is_char_boundary(13));
@@ -405,7 +404,8 @@ impl str {
     /// assert_eq!(closest, 10);
     /// assert_eq!(&s[..closest], "❤️🧡");
     /// ```
-    #[unstable(feature = "round_char_boundary", issue = "93743")]
+    #[stable(feature = "round_char_boundary", since = "CURRENT_RUSTC_VERSION")]
+    #[rustc_const_stable(feature = "round_char_boundary", since = "CURRENT_RUSTC_VERSION")]
     #[inline]
     pub const fn floor_char_boundary(&self, index: usize) -> usize {
         if index >= self.len() {
@@ -439,7 +439,6 @@ impl str {
     /// # Examples
     ///
     /// ```
-    /// #![feature(round_char_boundary)]
     /// let s = "❤️🧡💛💚💙💜";
     /// assert_eq!(s.len(), 26);
     /// assert!(!s.is_char_boundary(13));
@@ -448,7 +447,8 @@ impl str {
     /// assert_eq!(closest, 14);
     /// assert_eq!(&s[..closest], "❤️🧡💛");
     /// ```
-    #[unstable(feature = "round_char_boundary", issue = "93743")]
+    #[stable(feature = "round_char_boundary", since = "CURRENT_RUSTC_VERSION")]
+    #[rustc_const_stable(feature = "round_char_boundary", since = "CURRENT_RUSTC_VERSION")]
     #[inline]
     pub const fn ceil_char_boundary(&self, index: usize) -> usize {
         if index >= self.len() {
diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs
@@ -263,7 +263,6 @@
     all(target_vendor = "fortanix", target_env = "sgx"),
     feature(slice_index_methods, coerce_unsized, sgx_platform)
 )]
-#![cfg_attr(any(windows, target_os = "uefi"), feature(round_char_boundary))]
 #![cfg_attr(target_family = "wasm", feature(stdarch_wasm_atomic_wait))]
 #![cfg_attr(target_arch = "wasm64", feature(simd_wasm64))]
 //
diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs
@@ -12,7 +12,6 @@
 #![feature(format_args_nl)]
 #![feature(if_let_guard)]
 #![feature(iter_intersperse)]
-#![feature(round_char_boundary)]
 #![feature(rustc_private)]
 #![feature(test)]
 #![warn(rustc::internal)]
diff --git a/src/tools/clippy/clippy_lints/src/lib.rs b/src/tools/clippy/clippy_lints/src/lib.rs
@@ -7,7 +7,7 @@
 #![feature(iter_intersperse)]
 #![feature(iter_partition_in_place)]
 #![feature(never_type)]
-#![feature(round_char_boundary)]
+#![cfg_attr(bootstrap, feature(round_char_boundary))]
 #![feature(rustc_private)]
 #![feature(stmt_expr_attributes)]
 #![feature(unwrap_infallible)]
diff --git a/src/tools/clippy/tests/ui/char_indices_as_byte_indices.fixed b/src/tools/clippy/tests/ui/char_indices_as_byte_indices.fixed
@@ -1,4 +1,3 @@
-#![feature(round_char_boundary)]
 #![warn(clippy::char_indices_as_byte_indices)]
 
 trait StrExt {
diff --git a/src/tools/clippy/tests/ui/char_indices_as_byte_indices.rs b/src/tools/clippy/tests/ui/char_indices_as_byte_indices.rs
@@ -1,4 +1,3 @@
-#![feature(round_char_boundary)]
 #![warn(clippy::char_indices_as_byte_indices)]
 
 trait StrExt {
diff --git a/src/tools/clippy/tests/ui/char_indices_as_byte_indices.stderr b/src/tools/clippy/tests/ui/char_indices_as_byte_indices.stderr
@@ -1,12 +1,12 @@
 error: indexing into a string with a character position where a byte index is expected
-  --> tests/ui/char_indices_as_byte_indices.rs:13:24
+  --> tests/ui/char_indices_as_byte_indices.rs:12:24
    |
 LL |         let _ = prim[..idx];
    |                        ^^^
    |
    = note: a character can take up more than one byte, so they are not interchangeable
 note: position comes from the enumerate iterator
-  --> tests/ui/char_indices_as_byte_indices.rs:12:10
+  --> tests/ui/char_indices_as_byte_indices.rs:11:10
    |
 LL |     for (idx, _) in prim.chars().enumerate() {
    |          ^^^                     ^^^^^^^^^^^
@@ -19,14 +19,14 @@ LL +     for (idx, _) in prim.char_indices() {
    |
 
 error: passing a character position to a method that expects a byte index
-  --> tests/ui/char_indices_as_byte_indices.rs:15:23
+  --> tests/ui/char_indices_as_byte_indices.rs:14:23
    |
 LL |         prim.split_at(idx);
    |                       ^^^
    |
    = note: a character can take up more than one byte, so they are not interchangeable
 note: position comes from the enumerate iterator
-  --> tests/ui/char_indices_as_byte_indices.rs:12:10
+  --> tests/ui/char_indices_as_byte_indices.rs:11:10
    |
 LL |     for (idx, _) in prim.chars().enumerate() {
    |          ^^^                     ^^^^^^^^^^^
@@ -37,14 +37,14 @@ LL +     for (idx, _) in prim.char_indices() {
    |
 
 error: passing a character position to a method that expects a byte index
-  --> tests/ui/char_indices_as_byte_indices.rs:19:49
+  --> tests/ui/char_indices_as_byte_indices.rs:18:49
    |
 LL |         let _ = prim[..prim.floor_char_boundary(idx)];
    |                                                 ^^^
    |
    = note: a character can take up more than one byte, so they are not interchangeable
 note: position comes from the enumerate iterator
-  --> tests/ui/char_indices_as_byte_indices.rs:12:10
+  --> tests/ui/char_indices_as_byte_indices.rs:11:10
    |
 LL |     for (idx, _) in prim.chars().enumerate() {
    |          ^^^                     ^^^^^^^^^^^
@@ -55,14 +55,14 @@ LL +     for (idx, _) in prim.char_indices() {
    |
 
 error: indexing into a string with a character position where a byte index is expected
-  --> tests/ui/char_indices_as_byte_indices.rs:29:24
+  --> tests/ui/char_indices_as_byte_indices.rs:28:24
    |
 LL |         let _ = prim[..c.0];
    |                        ^^^
    |
    = note: a character can take up more than one byte, so they are not interchangeable
 note: position comes from the enumerate iterator
-  --> tests/ui/char_indices_as_byte_indices.rs:28:9
+  --> tests/ui/char_indices_as_byte_indices.rs:27:9
    |
 LL |     for c in prim.chars().enumerate() {
    |         ^                 ^^^^^^^^^^^
@@ -73,14 +73,14 @@ LL +     for c in prim.char_indices() {
    |
 
 error: passing a character position to a method that expects a byte index
-  --> tests/ui/char_indices_as_byte_indices.rs:31:23
+  --> tests/ui/char_indices_as_byte_indices.rs:30:23
    |
 LL |         prim.split_at(c.0);
    |                       ^^^
    |
    = note: a character can take up more than one byte, so they are not interchangeable
 note: position comes from the enumerate iterator
-  --> tests/ui/char_indices_as_byte_indices.rs:28:9
+  --> tests/ui/char_indices_as_byte_indices.rs:27:9
    |
 LL |     for c in prim.chars().enumerate() {
    |         ^                 ^^^^^^^^^^^
@@ -91,14 +91,14 @@ LL +     for c in prim.char_indices() {
    |
 
 error: indexing into a string with a character position where a byte index is expected
-  --> tests/ui/char_indices_as_byte_indices.rs:36:26
+  --> tests/ui/char_indices_as_byte_indices.rs:35:26
    |
 LL |         let _ = string[..idx];
    |                          ^^^
    |
    = note: a character can take up more than one byte, so they are not interchangeable
 note: position comes from the enumerate iterator
-  --> tests/ui/char_indices_as_byte_indices.rs:35:10
+  --> tests/ui/char_indices_as_byte_indices.rs:34:10
    |
 LL |     for (idx, _) in string.chars().enumerate() {
    |          ^^^                       ^^^^^^^^^^^
@@ -109,14 +109,14 @@ LL +     for (idx, _) in string.char_indices() {
    |
 
 error: passing a character position to a method that expects a byte index
-  --> tests/ui/char_indices_as_byte_indices.rs:38:25
+  --> tests/ui/char_indices_as_byte_indices.rs:37:25
    |
 LL |         string.split_at(idx);
    |                         ^^^
    |
    = note: a character can take up more than one byte, so they are not interchangeable
 note: position comes from the enumerate iterator
-  --> tests/ui/char_indices_as_byte_indices.rs:35:10
+  --> tests/ui/char_indices_as_byte_indices.rs:34:10
    |
 LL |     for (idx, _) in string.chars().enumerate() {
    |          ^^^                       ^^^^^^^^^^^

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,3 @@`
`1`		`-#![feature(round_char_boundary)]`
`2`	`1`	`#![warn(clippy::char_indices_as_byte_indices)]`
`3`	`2`
`4`	`3`	`trait StrExt {`
Original file line number	Diff line number	Diff line change
`@@ -1,12 +1,12 @@`
`1`	`1`	`error: indexing into a string with a character position where a byte index is expected`
`2`		`- --> tests/ui/char_indices_as_byte_indices.rs:13:24`
	`2`	`+ --> tests/ui/char_indices_as_byte_indices.rs:12:24`
`3`	`3`	`\|`
`4`	`4`	`LL \| let _ = prim[..idx];`
`5`	`5`	`\| ^^^`
`6`	`6`	`\|`
`7`	`7`	`= note: a character can take up more than one byte, so they are not interchangeable`
`8`	`8`	`note: position comes from the enumerate iterator`
`9`		`- --> tests/ui/char_indices_as_byte_indices.rs:12:10`
	`9`	`+ --> tests/ui/char_indices_as_byte_indices.rs:11:10`
`10`	`10`	`\|`
`11`	`11`	`LL \| for (idx, _) in prim.chars().enumerate() {`
`12`	`12`	`\| ^^^ ^^^^^^^^^^^`
`@@ -19,14 +19,14 @@ LL + for (idx, _) in prim.char_indices() {`
`19`	`19`	`\|`
`20`	`20`
`21`	`21`	`error: passing a character position to a method that expects a byte index`
`22`		`- --> tests/ui/char_indices_as_byte_indices.rs:15:23`
	`22`	`+ --> tests/ui/char_indices_as_byte_indices.rs:14:23`
`23`	`23`	`\|`
`24`	`24`	`LL \| prim.split_at(idx);`
`25`	`25`	`\| ^^^`
`26`	`26`	`\|`
`27`	`27`	`= note: a character can take up more than one byte, so they are not interchangeable`
`28`	`28`	`note: position comes from the enumerate iterator`
`29`		`- --> tests/ui/char_indices_as_byte_indices.rs:12:10`
	`29`	`+ --> tests/ui/char_indices_as_byte_indices.rs:11:10`
`30`	`30`	`\|`
`31`	`31`	`LL \| for (idx, _) in prim.chars().enumerate() {`
`32`	`32`	`\| ^^^ ^^^^^^^^^^^`
`@@ -37,14 +37,14 @@ LL + for (idx, _) in prim.char_indices() {`
`37`	`37`	`\|`
`38`	`38`
`39`	`39`	`error: passing a character position to a method that expects a byte index`
`40`		`- --> tests/ui/char_indices_as_byte_indices.rs:19:49`
	`40`	`+ --> tests/ui/char_indices_as_byte_indices.rs:18:49`
`41`	`41`	`\|`
`42`	`42`	`LL \| let _ = prim[..prim.floor_char_boundary(idx)];`
`43`	`43`	`\| ^^^`
`44`	`44`	`\|`
`45`	`45`	`= note: a character can take up more than one byte, so they are not interchangeable`
`46`	`46`	`note: position comes from the enumerate iterator`
`47`		`- --> tests/ui/char_indices_as_byte_indices.rs:12:10`
	`47`	`+ --> tests/ui/char_indices_as_byte_indices.rs:11:10`
`48`	`48`	`\|`
`49`	`49`	`LL \| for (idx, _) in prim.chars().enumerate() {`
`50`	`50`	`\| ^^^ ^^^^^^^^^^^`
`@@ -55,14 +55,14 @@ LL + for (idx, _) in prim.char_indices() {`
`55`	`55`	`\|`
`56`	`56`
`57`	`57`	`error: indexing into a string with a character position where a byte index is expected`
`58`		`- --> tests/ui/char_indices_as_byte_indices.rs:29:24`
	`58`	`+ --> tests/ui/char_indices_as_byte_indices.rs:28:24`
`59`	`59`	`\|`
`60`	`60`	`LL \| let _ = prim[..c.0];`
`61`	`61`	`\| ^^^`
`62`	`62`	`\|`
`63`	`63`	`= note: a character can take up more than one byte, so they are not interchangeable`
`64`	`64`	`note: position comes from the enumerate iterator`
`65`		`- --> tests/ui/char_indices_as_byte_indices.rs:28:9`
	`65`	`+ --> tests/ui/char_indices_as_byte_indices.rs:27:9`
`66`	`66`	`\|`
`67`	`67`	`LL \| for c in prim.chars().enumerate() {`
`68`	`68`	`\| ^ ^^^^^^^^^^^`
`@@ -73,14 +73,14 @@ LL + for c in prim.char_indices() {`
`73`	`73`	`\|`
`74`	`74`
`75`	`75`	`error: passing a character position to a method that expects a byte index`
`76`		`- --> tests/ui/char_indices_as_byte_indices.rs:31:23`
	`76`	`+ --> tests/ui/char_indices_as_byte_indices.rs:30:23`
`77`	`77`	`\|`
`78`	`78`	`LL \| prim.split_at(c.0);`
`79`	`79`	`\| ^^^`
`80`	`80`	`\|`
`81`	`81`	`= note: a character can take up more than one byte, so they are not interchangeable`
`82`	`82`	`note: position comes from the enumerate iterator`
`83`		`- --> tests/ui/char_indices_as_byte_indices.rs:28:9`
	`83`	`+ --> tests/ui/char_indices_as_byte_indices.rs:27:9`
`84`	`84`	`\|`
`85`	`85`	`LL \| for c in prim.chars().enumerate() {`
`86`	`86`	`\| ^ ^^^^^^^^^^^`
`@@ -91,14 +91,14 @@ LL + for c in prim.char_indices() {`
`91`	`91`	`\|`
`92`	`92`
`93`	`93`	`error: indexing into a string with a character position where a byte index is expected`
`94`		`- --> tests/ui/char_indices_as_byte_indices.rs:36:26`
	`94`	`+ --> tests/ui/char_indices_as_byte_indices.rs:35:26`
`95`	`95`	`\|`
`96`	`96`	`LL \| let _ = string[..idx];`
`97`	`97`	`\| ^^^`
`98`	`98`	`\|`
`99`	`99`	`= note: a character can take up more than one byte, so they are not interchangeable`
`100`	`100`	`note: position comes from the enumerate iterator`
`101`		`- --> tests/ui/char_indices_as_byte_indices.rs:35:10`
	`101`	`+ --> tests/ui/char_indices_as_byte_indices.rs:34:10`
`102`	`102`	`\|`
`103`	`103`	`LL \| for (idx, _) in string.chars().enumerate() {`
`104`	`104`	`\| ^^^ ^^^^^^^^^^^`
`@@ -109,14 +109,14 @@ LL + for (idx, _) in string.char_indices() {`
`109`	`109`	`\|`
`110`	`110`
`111`	`111`	`error: passing a character position to a method that expects a byte index`
`112`		`- --> tests/ui/char_indices_as_byte_indices.rs:38:25`
	`112`	`+ --> tests/ui/char_indices_as_byte_indices.rs:37:25`
`113`	`113`	`\|`
`114`	`114`	`LL \| string.split_at(idx);`
`115`	`115`	`\| ^^^`
`116`	`116`	`\|`
`117`	`117`	`= note: a character can take up more than one byte, so they are not interchangeable`
`118`	`118`	`note: position comes from the enumerate iterator`
`119`		`- --> tests/ui/char_indices_as_byte_indices.rs:35:10`
	`119`	`+ --> tests/ui/char_indices_as_byte_indices.rs:34:10`
`120`	`120`	`\|`
`121`	`121`	`LL \| for (idx, _) in string.chars().enumerate() {`
`122`	`122`	`\| ^^^ ^^^^^^^^^^^`