Bump toolchain to 1.86 (#6412)

Author: robertbastian

components/collator/src/elements.rs

@@ -1968,7 +1968,7 @@ where
 
                                         // Set the exponent. 4 pairs->132, 5 pairs->133, ..., 127 pairs->255.
                                         let mut len = head.len();
-                                        let num_pairs = (len as u32 + 1) / 2; // as u32 OK, because capped to 254
+                                        let num_pairs = (len as u32).div_ceil(2); // as u32 OK, because capped to 254
                                         let mut primary =
                                             numeric_primary | ((132 - 4 + num_pairs) << 16);
                                         // Find the length without trailing 00 pairs.

components/datetime/src/provider/skeleton/helpers.rs

@@ -129,9 +129,9 @@ fn naively_apply_time_zone_name(
 /// * `length_patterns` - Contains information on how to combine date and time patterns.
 /// * `fields` - The desired fields to match against.
 /// * `prefer_matched_pattern` - This algorithm does some extra steps of trying to respect
-///         the desired fields, even if the provider data doesn't completely match. This
-///         configuration option makes it so that the final pattern won't have additional work
-///         done to mutate it to match the fields. It will prefer the actual matched pattern.
+///   the desired fields, even if the provider data doesn't completely match. This
+///   configuration option makes it so that the final pattern won't have additional work
+///   done to mutate it to match the fields. It will prefer the actual matched pattern.
 pub fn create_best_pattern_for_fields<'data>(
     skeletons: &DateSkeletonPatterns<'data>,
     length_patterns: &GenericLengthPatterns<'data>,
@@ -375,9 +375,9 @@ fn apply_subseconds(pattern: &mut runtime::Pattern, subseconds: Option<Subsecond
 ///  * Compute a score based on the best possible match for the given fields.
 ///  * Select the skeleton with highest score.
 ///  * Modify the resulting pattern to have fields of the same length. For example requesting
-///      a skeleton "yMMMMd" can have a best match of ["yMMMd", "d MMM y"]. This pattern should
-///      then be modified to use the requested length to produce a pattern "d MMMM y".
-///      However, fields should not be changed from numeric to text.
+///    a skeleton "yMMMMd" can have a best match of ["yMMMd", "d MMM y"]. This pattern should
+///    then be modified to use the requested length to produce a pattern "d MMMM y".
+///    However, fields should not be changed from numeric to text.
 ///
 /// The following is not implemented:
 ///

components/experimental/src/duration/provider.rs

@@ -20,7 +20,6 @@ icu_provider::data_marker!(
 #[cfg_attr(feature = "datagen", derive(serde::Serialize, databake::Bake))]
 #[cfg_attr(feature = "datagen", databake(path = icu_experimental::duration::provider))]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize))]
-
 /// A struct containing digital duration data (durationUnit-type-* patterns).
 pub struct DigitalDurationData<'data> {
     /// The separator between the hour, minute, and second fields.

components/experimental/src/personnames/specifications/pattern_regex_selector.rs

@@ -54,10 +54,7 @@ impl PersonNamePattern<'_> {
             }
         });
         let missing_fields = self.name_fields.iter().fold(0, |count, (name_field, _)| {
-            if available_name_fields
-                .iter()
-                .any(|&field| field == name_field)
-            {
+            if available_name_fields.contains(&name_field) {
                 count
             } else {
                 count + 1

components/experimental/src/transliterate/transliterator/hardcoded.rs

@@ -51,7 +51,7 @@ impl HexTransliterator {
 
             let c_u32 = c as u32;
             // rounding-up division by 4
-            let length = (u32::BITS - c_u32.leading_zeros() + 3) / 4;
+            let length = (u32::BITS - c_u32.leading_zeros()).div_ceil(4);
             let padding = self.min_length.saturating_sub(length as u8);
             dest.apply_size_hint(
                 self.prefix.len() + padding as usize + length as usize + self.suffix.len(),

components/experimental/src/transliterate/transliterator/mod.rs

@@ -515,9 +515,9 @@ impl Transliterator {
 
 impl RuleBasedTransliterator<'_> {
     /// Transliteration using rules works as follows:
-    ///  1. Split the input modifiable range of the Replaceable according into runs according to self.filter
-    ///  2. Transliterate each run in sequence
-    ///      i. Transliterate the first id_group, then the first rule_group, then the second id_group, etc.
+    /// 1. Split the input modifiable range of the Replaceable according into runs according to self.filter
+    /// 2. Transliterate each run in sequence
+    ///     1. Transliterate the first id_group, then the first rule_group, then the second id_group, etc.
     fn transliterate(&self, mut rep: Replaceable, env: &Env) {
         // assumes the cursor is at the right position.
 

components/icu/README.md

@@ -99,11 +99,11 @@
 //! functionality are compiled. These features are:
 //!
 //! - `compiled_data` (default): Whether to include compiled data. Without this flag, only constructors with
-//!    explicit `provider` arguments are available.
+//!   explicit `provider` arguments are available.
 //! - `datagen`: Whether to implement functionality that is only required during data generation.
 //! - `logging`: Enables logging through the `log` crate.
 //! - `serde`: Activates `serde` implementations for core library types, such as [`Locale`], as well
-//!    as `*_with_buffer_provider` constructors for runtime data management.
+//!   as `*_with_buffer_provider` constructors for runtime data management.
 //! - `sync`: makes most ICU4X objects implement `Send + Sync`. Has a small performance impact when used with runtime data.
 //!
 //! # Experimental modules

components/icu/src/lib.rs

@@ -10,7 +10,7 @@
 //! * [`Script`] is an optional field representing the written script used by the locale.
 //! * [`Region`] is the region used by the locale.
 //! * [`Variants`] is a list of optional [`Variant`] subtags containing information about the
-//!                variant adjustments used by the locale.
+//!   variant adjustments used by the locale.
 //!
 //! Subtags can be used in isolation, and all basic operations such as parsing, syntax normalization
 //! and serialization are supported on each individual subtag, but most commonly

components/locale_core/src/subtags/mod.rs

@@ -2753,7 +2753,7 @@ impl write16::Write16 for IsNormalizedSinkUtf16<'_> {
         // an indexing failure would be a code bug rather than
         // an input or data issue.
         #[allow(clippy::indexing_slicing)]
-        if s.as_ptr() == self.expect.as_ptr() {
+        if core::ptr::eq(s.as_ptr(), self.expect.as_ptr()) {
             self.expect = &self.expect[s.len()..];
             Ok(())
         } else {
@@ -2795,7 +2795,7 @@ impl core::fmt::Write for IsNormalizedSinkUtf8<'_> {
         // an indexing failure would be a code bug rather than
         // an input or data issue.
         #[allow(clippy::indexing_slicing)]
-        if s.as_ptr() == self.expect.as_ptr() {
+        if core::ptr::eq(s.as_ptr(), self.expect.as_ptr()) {
             self.expect = &self.expect[s.len()..];
             Ok(())
         } else {
@@ -2834,7 +2834,7 @@ impl core::fmt::Write for IsNormalizedSinkStr<'_> {
         // an indexing failure would be a code bug rather than
         // an input or data issue.
         #[allow(clippy::indexing_slicing)]
-        if s.as_ptr() == self.expect.as_ptr() {
+        if core::ptr::eq(s.as_ptr(), self.expect.as_ptr()) {
             self.expect = &self.expect[s.len()..];
             Ok(())
         } else {

components/normalizer/src/lib.rs

@@ -133,12 +133,11 @@
 //!
 //! `ICU4X` provides two sets of rules AST and APIs to manage it:
 //!  * `reference` is the canonical implementation of the specification intended for
-//!                tooling and testing to use.
-//!                This module provides APIs for parsing, editing and serialization
-//!                of the rules.
-//!  * `runtime`   is a non-public, non-mutable runtime version optimized for
-//!                performance and low memory overhead. This version provides
-//!                runtime resolver used by the `PluralRules` itself.
+//!    tooling and testing to use.
+//!    This module provides APIs for parsing, editing and serialization of the rules.
+//!  * `runtime` is a non-public, non-mutable runtime version optimized for
+//!    performance and low memory overhead. This version provides
+//!    runtime resolver used by the `PluralRules` itself.
 //!
 //! [`PluralCategory`]: super::PluralCategory
 //! [`PluralCategories`]: super::PluralCategory

components/plurals/src/provider/rules/mod.rs

@@ -227,16 +227,16 @@ impl CodePointSetData {
     ///
     /// - `Script` and `General_Category`: handle these directly using property values parsed via
     ///   [`PropertyParser<GeneralCategory>`] and [`PropertyParser<Script>`]
-    ///    if necessary.
+    ///   if necessary.
     /// - `Script_Extensions`: handle this directly using APIs from [`crate::script::ScriptWithExtensions`]
     /// - `General_Category` mask values: Handle this alongside `General_Category` using [`GeneralCategoryGroup`],
-    ///    using property values parsed via [`PropertyParser<GeneralCategory>`] if necessary
+    ///   using property values parsed via [`PropertyParser<GeneralCategory>`] if necessary
     /// - `Assigned`, `All`, and `ASCII` pseudoproperties: Handle these using their equivalent sets:
     ///    - `Any` can be expressed as the range `[\u{0}-\u{10FFFF}]`
     ///    - `Assigned` can be expressed as the inverse of the set `gc=Cn` (i.e., `\P{gc=Cn}`).
     ///    - `ASCII` can be expressed as the range `[\u{0}-\u{7F}]`
     /// - `General_Category` property values can themselves be treated like properties using a shorthand in ECMA262,
-    ///    simply create the corresponding `GeneralCategory` set.
+    ///   simply create the corresponding `GeneralCategory` set.
     ///
     /// ✨ *Enabled with the `compiled_data` Cargo feature.*
     ///

components/properties/src/runtime.rs

@@ -41,8 +41,8 @@ pub trait RuleBreakType<'s>: crate::private::Sealed {
 ///
 /// - `'l` = lifetime of the segmenter object from which this iterator was created
 /// - `'data` = lifetime of data borrowed by segmenter object
-///          (this largely exists because segmenter data is invariant due to ZeroMap constraints,
-///           think of it as a second 'l)
+///   (this largely exists because segmenter data is invariant due to ZeroMap constraints,
+///   think of it as a second 'l)
 /// - `'s` = lifetime of the string being segmented
 ///
 /// The [`Iterator::Item`] is an [`usize`] representing index of a code unit

components/segmenter/src/rule_segmenter.rs

@@ -21,7 +21,7 @@ pub trait ForkByErrorPredicate {
     /// - `&self` = Reference to the struct implementing the trait (for data capture)
     /// - `marker` = The [`DataMarkerInfo`] associated with the request
     /// - `req` = The [`DataRequest`]. This may be `None` if there is no request, such as
-    ///           inside [`IterableDynamicDataProvider`].
+    ///   inside [`IterableDynamicDataProvider`].
     /// - `err` = The error that occurred.
     ///
     /// Return value:

provider/adapters/src/fork/predicates.rs

@@ -287,9 +287,11 @@ impl AbstractFs {
                 .entries_with_seek()
                 .and_then(|e| {
                     for e in e {
-                        let e = e?;
+                        let mut e = e?;
                         if e.path()?.as_os_str() == path {
-                            return e.bytes().collect::<Result<Vec<_>, std::io::Error>>();
+                            let mut vec = vec![];
+                            e.read_to_end(&mut vec)?;
+                            return Ok(vec);
                         }
                     }
                     Err(std::io::ErrorKind::NotFound.into())

provider/source/src/source.rs

@@ -3,5 +3,5 @@
 # (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
 
 [toolchain]
-# Version updated on 2025-02-20
-channel = "1.85"
+# Version updated on 2025-04-03
+channel = "1.86"

rust-toolchain.toml

@@ -35,12 +35,12 @@
 //! # Cargo features
 //!
 //! This crate has several optional Cargo features:
-//!  -  `serde`: Allows serializing and deserializing `zerovec`'s abstractions via [`serde`](https://docs.rs/serde)
-//!  -   `yoke`: Enables implementations of `Yokeable` from the [`yoke`](https://docs.rs/yoke/) crate, which is also useful
-//!              in situations involving a lot of zero-copy deserialization.
+//!  - `serde`: Allows serializing and deserializing `zerovec`'s abstractions via [`serde`](https://docs.rs/serde)
+//!  - `yoke`: Enables implementations of `Yokeable` from the [`yoke`](https://docs.rs/yoke/) crate, which is also useful
+//!    in situations involving a lot of zero-copy deserialization.
 //!  - `derive`: Makes it easier to use custom types in these collections by providing the [`#[make_ule]`](crate::make_ule) and
-//!     [`#[make_varule]`](crate::make_varule) proc macros, which generate appropriate [`ULE`](crate::ule::ULE) and
-//!     [`VarULE`](crate::ule::VarULE)-conformant types for a given "normal" type.
+//!    [`#[make_varule]`](crate::make_varule) proc macros, which generate appropriate [`ULE`](crate::ule::ULE) and
+//!    [`VarULE`](crate::ule::VarULE)-conformant types for a given "normal" type.
 //!  - `std`: Enabled `std::Error` implementations for error types. This crate is by default `no_std` with a dependency on `alloc`.
 //!
 //! [`ZeroVec<'a, T>`]: ZeroVec

utils/zerovec/README.md

@@ -1088,7 +1088,7 @@ impl<T: AsULE> FromIterator<T> for ZeroVec<'_, T> {
 ///
 /// * `$aligned` - The type of an element in its canonical, aligned form, e.g., `char`.
 /// * `$convert` - A const function that converts an `$aligned` into its unaligned equivalent, e.g.,
-///                 `const fn from_aligned(a: CanonicalType) -> CanonicalType::ULE`.
+///   const fn from_aligned(a: CanonicalType) -> CanonicalType::ULE`.
 /// * `$x` - The elements that the `ZeroSlice` will hold.
 ///
 /// # Examples