Fix nightly clippy (#5094)

Author: robertbastian

components/datetime/src/external_loaders.rs

@@ -35,35 +35,6 @@ pub(crate) trait AnyCalendarLoader {
     fn load(&self, locale: &DataLocale) -> Result<AnyCalendar, DataError>;
 }
 
-/// Helper for type resolution with optional loader arguments
-pub(crate) struct PhantomLoader {
-    _not_constructible: core::convert::Infallible,
-}
-
-impl FixedDecimalFormatterLoader for PhantomLoader {
-    fn load(
-        &self,
-        _locale: &DataLocale,
-        _options: FixedDecimalFormatterOptions,
-    ) -> Result<FixedDecimalFormatter, DataError> {
-        unreachable!() // not constructible
-    }
-}
-
-impl WeekCalculatorLoader for PhantomLoader {
-    #[inline]
-    fn load(&self, _locale: &DataLocale) -> Result<WeekCalculator, DataError> {
-        unreachable!() // not constructible
-    }
-}
-
-impl AnyCalendarLoader for PhantomLoader {
-    #[inline]
-    fn load(&self, _locale: &DataLocale) -> Result<AnyCalendar, DataError> {
-        unreachable!() // not constructible
-    }
-}
-
 /// Loader for types from other crates using compiled data.
 #[cfg(feature = "compiled_data")]
 pub(crate) struct ExternalLoaderCompiledData;

components/datetime/src/neo.rs

@@ -1286,7 +1286,7 @@ impl<R: DateTimeMarkers> NeoFormatter<R> {
     /// ```
     pub fn convert_and_format<'a, I>(&'a self, datetime: &I) -> FormattedNeoDateTime
     where
-        I: ?Sized + ConvertCalendar,
+        I: ConvertCalendar,
         I::Converted<'a>: NeoGetField<<R::D as DateMarkers>::YearInput>
             + NeoGetField<<R::D as DateMarkers>::MonthInput>
             + NeoGetField<<R::D as DateMarkers>::DayOfMonthInput>

components/experimental/src/transliterate/compile/pass1.rs

@@ -49,11 +49,11 @@
 //! ### Cursors (`|@@@ rest`, `rest @@@|`, `rest | rest`)
 //! There are three kinds of cursors.
 //! * `|@@@ rest`: The cursor is at the beginning of the replacement and has placeholders. We call
-//!  this a cursor with _right_ placeholders, because they are on the right of the cursor.
+//!   this a cursor with _right_ placeholders, because they are on the right of the cursor.
 //! * `rest @@@|`: The cursor is at the end of the replacement and has placeholders. We call this
-//!  a cursor with _left_ placeholders, because they are on the left of the cursor.
+//!   a cursor with _left_ placeholders, because they are on the left of the cursor.
 //! * `rest | rest`: The cursor is in the middle of the replacement and has no placeholders. We call
-//!  this a pure cursor.
+//!   this a pure cursor.
 //!
 //! Pure cursors get a reserved code point that is inlined into the replacement encoding where the
 //! cursor appears. Cursors with placeholders are encoded like back references, so two more

components/experimental/src/unicodeset_parse/parse.rs

@@ -1430,9 +1430,9 @@ where
 /// # Limitations
 ///
 /// * Currently, we only support the [ECMA-262 properties](https://tc39.es/ecma262/#table-nonbinary-unicode-properties).
-/// The property names must match the exact spelling listed in ECMA-262. Note that we do support UTS35 syntax for elided `General_Category`
-/// and `Script` property names, i.e., `[:Latn:]` and `[:Ll:]` are both valid, with the former implying the `Script` property, and the latter the
-/// `General_Category` property.
+///   The property names must match the exact spelling listed in ECMA-262. Note that we do support UTS35 syntax for elided `General_Category`
+///   and `Script` property names, i.e., `[:Latn:]` and `[:Ll:]` are both valid, with the former implying the `Script` property, and the latter the
+///   `General_Category` property.
 /// * We do not support `\N{Unicode code point name}` character escaping. Use any other escape method described in UTS35.
 ///
 /// ✨ *Enabled with the `compiled_data` Cargo feature.*

components/experimental/src/units/ratio.rs

@@ -348,6 +348,7 @@ impl FromStr for IcuRatio {
         /// - Simple fractions: e.g., "1/2".
         /// - Decimals: e.g., "1.5".
         /// - Mixed fractions: e.g., "1.5/6", "1.4/5.6".
+        ///
         /// Note: Scientific notation is not supported.
         fn parse_fraction(decimal: &str) -> Result<IcuRatio, RatioFromStrError> {
             let mut components = decimal.split('/');
@@ -375,10 +376,13 @@ impl FromStr for IcuRatio {
         }
 
         /// Parses a decimal number from a string input.
+        ///
         /// Accepts input in various decimal formats, including:
         /// - Whole numbers: "1"
         /// - Decimal numbers: "1.5"
+        ///
         /// An empty string input is interpreted as "0".
+        ///
         /// Note: Fractional inputs are not supported in this context.
         fn parse_decimal(decimal: &str) -> Result<IcuRatio, RatioFromStrError> {
             let is_negative = decimal.starts_with('-');

components/locale_core/benches/fixtures/mod.rs

@@ -5,12 +5,14 @@
 use serde::Deserialize;
 
 #[derive(Deserialize)]
+#[allow(dead_code)]
 pub struct SubtagData {
     pub valid: Vec<String>,
     pub invalid: Vec<String>,
 }
 
 #[derive(Deserialize)]
+#[allow(dead_code)]
 pub struct Subtags {
     pub language: SubtagData,
     pub script: SubtagData,
@@ -19,6 +21,7 @@ pub struct Subtags {
 }
 
 #[derive(Deserialize)]
+#[allow(dead_code)]
 pub struct LocaleList {
     pub canonicalized: Vec<String>,
     pub casing: Vec<String>,

components/locale_core/src/langid.rs

@@ -315,7 +315,7 @@ impl LanguageIdentifier {
     /// regions. However, this differs from [RFC6497 (BCP 47 Extension T)], which specifies:
     ///
     /// > _The canonical form for all subtags in the extension is lowercase, with the fields
-    /// ordered by the separators, alphabetically._
+    /// > ordered by the separators, alphabetically._
     ///
     /// Hence, this method is used inside [`Transform Extensions`] to be able to get the correct
     /// canonicalization of the language identifier.
@@ -350,7 +350,7 @@ impl LanguageIdentifier {
     /// regions. However, this differs from [RFC6497 (BCP 47 Extension T)], which specifies:
     ///
     /// > _The canonical form for all subtags in the extension is lowercase, with the fields
-    /// ordered by the separators, alphabetically._
+    /// > ordered by the separators, alphabetically._
     ///
     /// Hence, this method is used inside [`Transform Extensions`] to be able to get the correct
     /// canonicalization of the language identifier.

components/locale_core/src/subtags/mod.rs

@@ -6,7 +6,7 @@
 //! which represent different fields of the structure.
 //!
 //! * [`Language`] is the only mandatory field, which when empty,
-//! takes the value `und`.
+//!   takes the value `und`.
 //! * [`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

components/plurals/benches/fixtures/mod.rs

@@ -8,6 +8,7 @@ use icu_plurals::PluralCategory;
 use serde::Deserialize;
 
 #[derive(Deserialize)]
+#[allow(dead_code)]
 pub struct NumbersFixture {
     pub isize: Vec<i64>,
     pub usize: Vec<u64>,
@@ -17,13 +18,15 @@ pub struct NumbersFixture {
 }
 
 #[derive(Debug, Deserialize)]
+#[allow(dead_code)]
 pub struct PluralsFixture {
     pub langs: Vec<LanguageIdentifier>,
 }
 
 /// Describes a number to construct from plural operands, as `value * 10^(exponent)`.  Construction
 /// from value and exponent is because sometimes we want to preserve trailing zeros.
 #[derive(Deserialize)]
+#[allow(dead_code)]
 pub struct FromFixedDecimals {
     pub value: i64,
     pub exponent: i16,

components/plurals/tests/fixtures/mod.rs

@@ -10,6 +10,7 @@ use serde::Deserialize;
 
 /// Defines the data-driven test sets for the operands.
 #[derive(Deserialize)]
+#[allow(dead_code)]
 pub struct OperandsTestSet {
     pub string: Vec<OperandsTest<String>>,
     pub int: Vec<OperandsTest<isize>>,
@@ -20,6 +21,7 @@ pub struct OperandsTestSet {
 /// A single test case verifying the conversion from [FixedDecimal] into
 /// [PluralOperands].
 #[derive(Debug, Deserialize)]
+#[allow(dead_code)]
 pub struct FromTestCase {
     /// The [FixedDecimal] input
     pub input: FixedDecimalInput,
@@ -99,12 +101,14 @@ impl From<PluralOperandsInput> for PluralOperands {
 }
 
 #[derive(Debug, Clone, Deserialize)]
+#[allow(dead_code)]
 pub struct OperandsTest<T> {
     pub input: T,
     pub output: PluralOperandsInput,
 }
 
 #[derive(Deserialize)]
+#[allow(dead_code)]
 pub struct RuleTest {
     pub rule: String,
     pub input: PluralOperandsInput,
@@ -113,12 +117,14 @@ pub struct RuleTest {
 
 #[derive(Deserialize)]
 #[serde(untagged)]
+#[allow(dead_code)]
 pub enum RuleTestOutput {
     Value(bool),
     Error(String),
 }
 
 #[derive(Deserialize)]
+#[allow(dead_code)]
 pub struct RuleTestSet(pub Vec<RuleTest>);
 
 #[derive(Clone, Copy, Debug, Deserialize)]
@@ -162,6 +168,7 @@ impl PartialEq<PluralCategory> for &PluralCategoryInput {
 }
 
 #[derive(Deserialize)]
+#[allow(dead_code)]
 pub struct CategoriesTest {
     pub langid: String,
     pub plural_type: PluralRuleTypeInput,

provider/bikeshed/src/decimal/decimal_pattern.rs

@@ -44,7 +44,7 @@ impl FromStr for DecimalSubPattern {
         // TODO(#567): Handle quoted literals in prefix and suffix.
         // i = boundary between prefix and body
         // j = boundary between body and suffix
-        let i = subpattern.find(|c: char| matches!(c, '#' | '0' | ',' | '.'));
+        let i = subpattern.find(['#', '0', ',', '.']);
         let i = match i {
             Some(i) => i,
             None => return Err(Error::NoBodyInSubpattern),

provider/icu4x-datagen/src/main.rs

@@ -635,7 +635,7 @@ macro_rules! cb {
                     $marker,
                 )+
                 $(
-                    #[cfg(feature = "experimental_components")]
+                    #[cfg(feature = "experimental")]
                     $emarker,
                 )+
             ]

tools/bakeddata-scripts/src/main.rs

@@ -102,7 +102,7 @@ fn main() {
 
         let _ = std::fs::remove_dir_all(&path);
         for dir in ["", "src", "data"] {
-            std::fs::create_dir(&path.join(dir)).unwrap();
+            std::fs::create_dir(path.join(dir)).unwrap();
         }
         for (file, template) in [
             ("build.rs", include_str!("../template/build.rs.template")),

tools/benchmark/memory/src/main.rs

@@ -83,11 +83,11 @@ fn extract_bytes_from_log_line(preamble: &str, text: &str) -> u64 {
 ///
 /// 1. Process the CLI arguments to get the os, and examples.
 /// 2. Loop through each example and:
-///   a. Create the directory for the benchmarks to go in.
-///   b. Run `cargo run --example {example}` with the appropriate settings.
-///   c. Extract the dhat stderr, and process out the interesting bytes.
-///   d. Add the output to an `ndjson` file.
-///   e. Move the dhat-heap.json file to the benchmark folder.
+///    a. Create the directory for the benchmarks to go in.
+///    b. Run `cargo run --example {example}` with the appropriate settings.
+///    c. Extract the dhat stderr, and process out the interesting bytes.
+///    d. Add the output to an `ndjson` file.
+///    e. Move the dhat-heap.json file to the benchmark folder.
 fn main() {
     let ProcessedArgs { os, examples } = process_cli_args();
 

utils/calendrical_calculations/src/chinese_based.rs

@@ -13,9 +13,9 @@ const MAX_ITERS_FOR_MONTHS_OF_YEAR: u8 = 14;
 /// To do so, calendars should:
 ///
 /// - Implement `fn location` by providing a location at which observations of the moon are recorded, which
-/// may change over time (the zone is important, long, lat, and elevation are not relevant for these calculations)
+///   may change over time (the zone is important, long, lat, and elevation are not relevant for these calculations)
 /// - Define `const EPOCH` as a `RataDie` marking the start date of the era of the Calendar for internal use,
-/// which may not accurately reflect how years or eras are marked traditionally or seen by end-users
+///   which may not accurately reflect how years or eras are marked traditionally or seen by end-users
 pub trait ChineseBased {
     /// Given a fixed date, return the location used for observations of the new moon in order to
     /// calculate the beginning of months. For multiple Chinese-based lunar calendars, this has

utils/litemap/benches/litemap.rs

@@ -57,9 +57,6 @@ fn overview_bench(c: &mut Criterion) {
     bench_deserialize_large(c);
     bench_lookup(c);
     bench_lookup_large(c);
-
-    #[cfg(feature = "generate")]
-    generate_test_data();
 }
 
 fn build_litemap(large: bool) -> LiteMap<String, String> {

utils/zerovec/src/map/map.rs

@@ -323,9 +323,8 @@ where
 
 impl<'a, K, V> ZeroMap<'a, K, V>
 where
-    K: ZeroMapKV<'a, Container = ZeroVec<'a, K>> + ?Sized,
+    K: AsULE + ZeroMapKV<'a, Container = ZeroVec<'a, K>>,
     V: ZeroMapKV<'a> + ?Sized,
-    K: AsULE,
 {
     /// Cast a `ZeroMap<K, V>` to `ZeroMap<P, V>` where `K` and `P` are [`AsULE`] types
     /// with the same representation.
@@ -335,7 +334,7 @@ where
     /// If `K` and `P` have different ordering semantics, unexpected behavior may occur.
     pub fn cast_zv_k_unchecked<P>(self) -> ZeroMap<'a, P, V>
     where
-        P: AsULE<ULE = K::ULE> + ZeroMapKV<'a, Container = ZeroVec<'a, P>> + ?Sized,
+        P: AsULE<ULE = K::ULE> + ZeroMapKV<'a, Container = ZeroVec<'a, P>>,
     {
         ZeroMap {
             keys: self.keys.cast(),
@@ -355,7 +354,7 @@ where
     /// Panics if `K::ULE` and `P::ULE` are not the same size.
     pub fn try_convert_zv_k_unchecked<P>(self) -> Result<ZeroMap<'a, P, V>, ZeroVecError>
     where
-        P: AsULE + ZeroMapKV<'a, Container = ZeroVec<'a, P>> + ?Sized,
+        P: AsULE + ZeroMapKV<'a, Container = ZeroVec<'a, P>>,
     {
         Ok(ZeroMap {
             keys: self.keys.try_into_converted()?,
@@ -367,8 +366,7 @@ where
 impl<'a, K, V> ZeroMap<'a, K, V>
 where
     K: ZeroMapKV<'a> + ?Sized,
-    V: ZeroMapKV<'a, Container = ZeroVec<'a, V>> + ?Sized,
-    V: AsULE,
+    V: AsULE + ZeroMapKV<'a, Container = ZeroVec<'a, V>>,
 {
     /// Cast a `ZeroMap<K, V>` to `ZeroMap<K, P>` where `V` and `P` are [`AsULE`] types
     /// with the same representation.
@@ -378,7 +376,7 @@ where
     /// If `V` and `P` have different ordering semantics, unexpected behavior may occur.
     pub fn cast_zv_v_unchecked<P>(self) -> ZeroMap<'a, K, P>
     where
-        P: AsULE<ULE = V::ULE> + ZeroMapKV<'a, Container = ZeroVec<'a, P>> + ?Sized,
+        P: AsULE<ULE = V::ULE> + ZeroMapKV<'a, Container = ZeroVec<'a, P>>,
     {
         ZeroMap {
             keys: self.keys,
@@ -398,7 +396,7 @@ where
     /// Panics if `V::ULE` and `P::ULE` are not the same size.
     pub fn try_convert_zv_v_unchecked<P>(self) -> Result<ZeroMap<'a, K, P>, ZeroVecError>
     where
-        P: AsULE + ZeroMapKV<'a, Container = ZeroVec<'a, P>> + ?Sized,
+        P: AsULE + ZeroMapKV<'a, Container = ZeroVec<'a, P>>,
     {
         Ok(ZeroMap {
             keys: self.keys,
@@ -468,8 +466,7 @@ where
 impl<'a, K, V> ZeroMap<'a, K, V>
 where
     K: ZeroMapKV<'a> + ?Sized + Ord,
-    V: ZeroMapKV<'a> + ?Sized,
-    V: Copy,
+    V: Copy + ZeroMapKV<'a>,
 {
     /// For cases when `V` is fixed-size, obtain a direct copy of `V` instead of `V::ULE`.
     ///
@@ -523,8 +520,7 @@ where
 impl<'a, K, V> ZeroMap<'a, K, V>
 where
     K: ZeroMapKV<'a> + ?Sized,
-    V: ZeroMapKV<'a, Container = ZeroVec<'a, V>> + ?Sized,
-    V: AsULE + Copy,
+    V: AsULE + ZeroMapKV<'a, Container = ZeroVec<'a, V>>,
 {
     /// Similar to [`Self::iter()`] except it returns a direct copy of the values instead of references
     /// to `V::ULE`, in cases when `V` is fixed-size
@@ -544,10 +540,8 @@ where
 
 impl<'a, K, V> ZeroMap<'a, K, V>
 where
-    K: ZeroMapKV<'a, Container = ZeroVec<'a, K>> + ?Sized,
-    V: ZeroMapKV<'a, Container = ZeroVec<'a, V>> + ?Sized,
-    K: AsULE + Copy,
-    V: AsULE + Copy,
+    K: AsULE + ZeroMapKV<'a, Container = ZeroVec<'a, K>>,
+    V: AsULE + ZeroMapKV<'a, Container = ZeroVec<'a, V>>,
 {
     /// Similar to [`Self::iter()`] except it returns a direct copy of the keys values instead of references
     /// to `K::ULE` and `V::ULE`, in cases when `K` and `V` are fixed-size

utils/zerovec/src/yoke_impls.rs

@@ -20,7 +20,7 @@ use yoke::*;
 
 // This impl is similar to the impl on Cow and is safe for the same reasons
 /// This impl requires enabling the optional `yoke` Cargo feature of the `zerovec` crate
-unsafe impl<'a, T: 'static + AsULE + ?Sized> Yokeable<'a> for ZeroVec<'static, T> {
+unsafe impl<'a, T: 'static + AsULE> Yokeable<'a> for ZeroVec<'static, T> {
     type Output = ZeroVec<'a, T>;
     #[inline]
     fn transform(&'a self) -> &'a Self::Output {