Merging upstream version 1.75.0+dfsg1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

4 files changed, 29 insertions, 33 deletions

diff --git a/vendor/icu_provider_adapters/src/fork/by_error.rs b/vendor/icu_provider_adapters/src/fork/by_error.rs
index aae996761..5d25ce207 100644
--- a/vendor/icu_provider_adapters/src/fork/by_error.rs
+++ b/vendor/icu_provider_adapters/src/fork/by_error.rs
@@ -174,7 +174,7 @@ where
         key: DataKey,
         req: DataRequest,
     ) -> Result<DataResponse<BufferMarker>, DataError> {
-        let mut last_error = DataErrorKind::MissingDataKey.with_key(key);
+        let mut last_error = F::UNIT_ERROR.with_key(key);
         for provider in self.providers.iter() {
             let result = provider.load_buffer(key, req);
             match result {
@@ -193,7 +193,7 @@ where
     F: ForkByErrorPredicate,
 {
     fn load_any(&self, key: DataKey, req: DataRequest) -> Result<AnyResponse, DataError> {
-        let mut last_error = DataErrorKind::MissingDataKey.with_key(key);
+        let mut last_error = F::UNIT_ERROR.with_key(key);
         for provider in self.providers.iter() {
             let result = provider.load_any(key, req);
             match result {
@@ -213,7 +213,7 @@ where
     F: ForkByErrorPredicate,
 {
     fn load_data(&self, key: DataKey, req: DataRequest) -> Result<DataResponse<M>, DataError> {
-        let mut last_error = DataErrorKind::MissingDataKey.with_key(key);
+        let mut last_error = F::UNIT_ERROR.with_key(key);
         for provider in self.providers.iter() {
             let result = provider.load_data(key, req);
             match result {
@@ -234,7 +234,7 @@ where
     F: ForkByErrorPredicate,
 {
     fn supported_locales_for_key(&self, key: DataKey) -> Result<Vec<DataLocale>, DataError> {
-        let mut last_error = DataErrorKind::MissingDataKey.with_key(key);
+        let mut last_error = F::UNIT_ERROR.with_key(key);
         for provider in self.providers.iter() {
             let result = provider.supported_locales_for_key(key);
             match result {
@@ -260,7 +260,7 @@ where
         key: DataKey,
         mut from: DataPayload<MFrom>,
     ) -> Result<DataPayload<MTo>, (DataPayload<MFrom>, DataError)> {
-        let mut last_error = DataErrorKind::MissingDataKey.with_key(key);
+        let mut last_error = F::UNIT_ERROR.with_key(key);
         for provider in self.providers.iter() {
             let result = provider.convert(key, from);
             match result {
diff --git a/vendor/icu_provider_adapters/src/fork/macros.rs b/vendor/icu_provider_adapters/src/fork/macros.rs
index 7c18a9ba3..eb98ec693 100644
--- a/vendor/icu_provider_adapters/src/fork/macros.rs
+++ b/vendor/icu_provider_adapters/src/fork/macros.rs
@@ -11,27 +11,23 @@
 /// use icu_provider_adapters::fork::ForkByKeyProvider;
 ///
 /// // Some empty example providers:
-/// #[derive(Default, PartialEq, Debug)]
+/// #[derive(PartialEq, Debug)]
 /// struct Provider1;
-/// #[derive(Default, PartialEq, Debug)]
+/// #[derive(PartialEq, Debug)]
 /// struct Provider2;
-/// #[derive(Default, PartialEq, Debug)]
+/// #[derive(PartialEq, Debug)]
 /// struct Provider3;
 ///
 /// // Combine them into one:
 /// let forking1 = icu_provider_adapters::make_forking_provider!(
 ///     ForkByKeyProvider::new,
-///     [
-///         Provider1::default(),
-///         Provider2::default(),
-///         Provider3::default(),
-///     ]
+///     [Provider1, Provider2, Provider3,]
 /// );
 ///
 /// // This is equivalent to:
 /// let forking2 = ForkByKeyProvider::new(
-///     Provider1::default(),
-///     ForkByKeyProvider::new(Provider2::default(), Provider3::default()),
+///     Provider1,
+///     ForkByKeyProvider::new(Provider2, Provider3),
 /// );
 ///
 /// assert_eq!(forking1, forking2);
@@ -50,22 +46,15 @@ macro_rules! make_forking_provider {
 
 #[cfg(test)]
 mod test {
-    #[derive(Default)]
     struct Provider1;
-    #[derive(Default)]
     struct Provider2;
-    #[derive(Default)]
     struct Provider3;
 
     #[test]
     fn test_make_forking_provider() {
         make_forking_provider!(
             crate::fork::ForkByKeyProvider::new,
-            [
-                Provider1::default(),
-                Provider2::default(),
-                Provider3::default(),
-            ]
+            [Provider1, Provider2, Provider3,]
         );
     }
 }
diff --git a/vendor/icu_provider_adapters/src/fork/mod.rs b/vendor/icu_provider_adapters/src/fork/mod.rs
index 05ba5fd19..a15c742c6 100644
--- a/vendor/icu_provider_adapters/src/fork/mod.rs
+++ b/vendor/icu_provider_adapters/src/fork/mod.rs
@@ -80,9 +80,9 @@ use predicates::MissingDataKeyPredicate;
 ///     HelloWorldProvider.into_json_provider(),
 /// );
 ///
-/// let data_provider = forking_provider.as_deserializing();
+/// let provider = forking_provider.as_deserializing();
 ///
-/// let german_hello_world: DataPayload<HelloWorldV1Marker> = data_provider
+/// let german_hello_world: DataPayload<HelloWorldV1Marker> = provider
 ///     .load(DataRequest {
 ///         locale: &locale!("de").into(),
 ///         metadata: Default::default(),
@@ -97,7 +97,7 @@ use predicates::MissingDataKeyPredicate;
 /// Stops at the first provider supporting a key, even if the locale is not supported:
 ///
 /// ```
-/// use icu_locid::{subtags_language as language, locale};
+/// use icu_locid::{subtags::language, locale};
 /// use icu_provider::hello_world::*;
 /// use icu_provider::prelude::*;
 /// use icu_provider_adapters::filter::Filterable;
@@ -114,11 +114,11 @@ use predicates::MissingDataKeyPredicate;
 ///         .filter_by_langid(|langid| langid.language == language!("de")),
 /// );
 ///
-/// let data_provider: &dyn DataProvider<HelloWorldV1Marker> =
+/// let provider: &dyn DataProvider<HelloWorldV1Marker> =
 ///     &forking_provider.as_deserializing();
 ///
 /// // Chinese is the first provider, so this succeeds
-/// let chinese_hello_world = data_provider
+/// let chinese_hello_world = provider
 ///     .load(DataRequest {
 ///         locale: &locale!("zh").into(),
 ///         metadata: Default::default(),
@@ -130,7 +130,7 @@ use predicates::MissingDataKeyPredicate;
 /// assert_eq!("你好世界", chinese_hello_world.get().message);
 ///
 /// // German is shadowed by Chinese, so this fails
-/// data_provider
+/// provider
 ///     .load(DataRequest {
 ///         locale: &locale!("de").into(),
 ///         metadata: Default::default(),
@@ -166,7 +166,7 @@ impl<P0, P1> ForkByKeyProvider<P0, P1> {
 /// # Examples
 ///
 /// ```
-/// use icu_locid::{subtags_language as language, locale};
+/// use icu_locid::{subtags::language, locale};
 /// use icu_provider::hello_world::*;
 /// use icu_provider::prelude::*;
 /// use icu_provider_adapters::filter::Filterable;
@@ -185,11 +185,11 @@ impl<P0, P1> ForkByKeyProvider<P0, P1> {
 ///     ],
 /// );
 ///
-/// let data_provider: &dyn DataProvider<HelloWorldV1Marker> =
+/// let provider: &dyn DataProvider<HelloWorldV1Marker> =
 ///     &forking_provider.as_deserializing();
 ///
 /// // Chinese is the first provider, so this succeeds
-/// let chinese_hello_world = data_provider
+/// let chinese_hello_world = provider
 ///     .load(DataRequest {
 ///         locale: &locale!("zh").into(),
 ///         metadata: Default::default(),
@@ -201,7 +201,7 @@ impl<P0, P1> ForkByKeyProvider<P0, P1> {
 /// assert_eq!("你好世界", chinese_hello_world.get().message);
 ///
 /// // German is shadowed by Chinese, so this fails
-/// data_provider
+/// provider
 ///     .load(DataRequest {
 ///         locale: &locale!("de").into(),
 ///         metadata: Default::default(),
diff --git a/vendor/icu_provider_adapters/src/fork/predicates.rs b/vendor/icu_provider_adapters/src/fork/predicates.rs
index 0fefe5704..58ffa7416 100644
--- a/vendor/icu_provider_adapters/src/fork/predicates.rs
+++ b/vendor/icu_provider_adapters/src/fork/predicates.rs
@@ -10,6 +10,9 @@ use icu_provider::prelude::*;
 ///
 /// [`ForkByErrorProvider`]: super::ForkByErrorProvider
 pub trait ForkByErrorPredicate {
+    /// The error to return if there are zero providers.
+    const UNIT_ERROR: DataErrorKind = DataErrorKind::MissingDataKey;
+
     /// This function is called when a data request fails and there are additional providers
     /// that could possibly fulfill the request.
     ///
@@ -43,6 +46,8 @@ pub trait ForkByErrorPredicate {
 pub struct MissingDataKeyPredicate;
 
 impl ForkByErrorPredicate for MissingDataKeyPredicate {
+    const UNIT_ERROR: DataErrorKind = DataErrorKind::MissingDataKey;
+
     #[inline]
     fn test(&self, _: DataKey, _: Option<DataRequest>, err: DataError) -> bool {
         matches!(
@@ -125,6 +130,8 @@ impl ForkByErrorPredicate for MissingDataKeyPredicate {
 pub struct MissingLocalePredicate;
 
 impl ForkByErrorPredicate for MissingLocalePredicate {
+    const UNIT_ERROR: DataErrorKind = DataErrorKind::MissingLocale;
+
     #[inline]
     fn test(&self, _: DataKey, _: Option<DataRequest>, err: DataError) -> bool {
         matches!(