Revert "More clippy" (#7461)

Reverts #7459 before it bitrots so we can discuss this.

Author: sffc

Cargo.toml

@@ -355,9 +355,7 @@ clippy.negative_feature_names = "warn"
 clippy.same_functions_in_if_condition = "warn"
 clippy.todo = "warn"
 clippy.trivially_copy_pass_by_ref = "deny"
-clippy.use_self = "warn"
 clippy.wildcard_dependencies = "warn"
-clippy.redundant_type_annotations = "warn"
 rust.missing_debug_implementations = "deny"
 rust.trivial_numeric_casts = "deny"
 rust.unexpected_cfgs = { level = "warn", check-cfg = [
@@ -385,6 +383,7 @@ rust.unused_macro_rules = "warn"
 # clippy.default_trait_access = "warn"
 # clippy.missing_assert_message = "warn"
 # clippy.redundant_feature_names = "warn"
+# clippy.use_self = "warn"
 # rust.unreachable_pub = "warn"
 # rust.unused_qualifications = "warn"
 # rust.unsafe_op_in_unsafe_fn = "forbid"

components/calendar/src/any_calendar.rs

@@ -90,11 +90,11 @@ impl Date<Buddhist> {
     /// assert_eq!(date_buddhist.month().ordinal, 1);
     /// assert_eq!(date_buddhist.day_of_month().0, 2);
     /// ```
-    pub fn try_new_buddhist(year: i32, month: u8, day: u8) -> Result<Self, RangeError> {
+    pub fn try_new_buddhist(year: i32, month: u8, day: u8) -> Result<Date<Buddhist>, RangeError> {
         ArithmeticDate::from_year_month_day(year, month, day, &AbstractGregorian(BuddhistEra))
             .map(ArithmeticDate::cast)
             .map(BuddhistDateInner)
-            .map(|i| Self::from_raw(i, Buddhist))
+            .map(|i| Date::from_raw(i, Buddhist))
     }
 }
 

components/calendar/src/cal/buddhist.rs

@@ -88,7 +88,7 @@ impl DateFieldsResolver for Coptic {
         month: types::Month,
         day: u8,
     ) -> Result<Self::YearInfo, EcmaReferenceYearError> {
-        Self::reference_year_from_month_day(month, day)
+        Coptic::reference_year_from_month_day(month, day)
     }
 
     fn to_rata_die_inner(year: Self::YearInfo, month: u8, day: u8) -> RataDie {
@@ -250,10 +250,10 @@ impl Date<Coptic> {
     /// assert_eq!(date_coptic.month().ordinal, 5);
     /// assert_eq!(date_coptic.day_of_month().0, 6);
     /// ```
-    pub fn try_new_coptic(year: i32, month: u8, day: u8) -> Result<Self, RangeError> {
+    pub fn try_new_coptic(year: i32, month: u8, day: u8) -> Result<Date<Coptic>, RangeError> {
         ArithmeticDate::from_year_month_day(year, month, day, &Coptic)
             .map(CopticDateInner)
-            .map(|inner| Self::from_raw(inner, Coptic))
+            .map(|inner| Date::from_raw(inner, Coptic))
     }
 }
 

components/calendar/src/cal/coptic.rs

@@ -484,15 +484,15 @@ impl<A: AsCalendar<Calendar = KoreanTraditional>> Date<A> {
         ordinal_month: u8,
         day: u8,
         calendar: A,
-    ) -> Result<Self, DateError> {
+    ) -> Result<Date<A>, DateError> {
         ArithmeticDate::from_year_month_day(
             related_iso_year,
             ordinal_month,
             day,
             calendar.as_calendar(),
         )
         .map(ChineseDateInner)
-        .map(|inner| Self::from_raw(inner, calendar))
+        .map(|inner| Date::from_raw(inner, calendar))
         .map_err(Into::into)
     }
 }
@@ -522,7 +522,7 @@ impl<R: Rules> Ord for ChineseDateInner<R> {
 impl ChineseTraditional {
     /// Creates a new [`ChineseTraditional`] calendar.
     pub const fn new() -> Self {
-        Self(China)
+        EastAsianTraditional(China)
     }
 
     #[cfg(feature = "serde")]
@@ -801,15 +801,15 @@ impl<A: AsCalendar<Calendar = ChineseTraditional>> Date<A> {
         ordinal_month: u8,
         day: u8,
         calendar: A,
-    ) -> Result<Self, DateError> {
+    ) -> Result<Date<A>, DateError> {
         ArithmeticDate::from_year_month_day(
             related_iso_year,
             ordinal_month,
             day,
             calendar.as_calendar(),
         )
         .map(ChineseDateInner)
-        .map(|inner| Self::from_raw(inner, calendar))
+        .map(|inner| Date::from_raw(inner, calendar))
         .map_err(Into::into)
     }
 }
@@ -888,7 +888,9 @@ impl EastAsianTraditionalYear {
             })
     }
 
-    fn calendrical_calculations<CB: chinese_based::ChineseBased>(related_iso: i32) -> Self {
+    fn calendrical_calculations<CB: chinese_based::ChineseBased>(
+        related_iso: i32,
+    ) -> EastAsianTraditionalYear {
         let mid_year = calendrical_calculations::gregorian::fixed_from_gregorian(related_iso, 7, 1);
         let year_bounds = chinese_based::YearBounds::compute::<CB>(mid_year);
 
@@ -900,7 +902,7 @@ impl EastAsianTraditionalYear {
         let (month_lengths, leap_month) =
             chinese_based::month_structure_for_year::<CB>(new_year, next_new_year);
 
-        Self {
+        EastAsianTraditionalYear {
             packed: PackedEastAsianTraditionalYearData::new(
                 related_iso,
                 month_lengths,

components/calendar/src/cal/east_asian_traditional.rs

@@ -72,13 +72,13 @@ impl core::ops::Add<Milliseconds> for LocalMoment {
     }
 }
 
-impl EastAsianTraditionalYear {
+impl super::EastAsianTraditionalYear {
     /// A fast approximation for the Chinese calendar, inspired by the _píngqì_ (平氣) rule
     /// used in the Ming dynasty.
     ///
     /// Stays anchored in the Gregorian calendar, even as the Gregorian calendar drifts
     /// from the seasons in the distant future and distant past.
-    pub(super) fn simple(utc_offset: Milliseconds, related_iso: i32) -> Self {
+    pub(super) fn simple(utc_offset: Milliseconds, related_iso: i32) -> EastAsianTraditionalYear {
         /// calculates the largest moment such that `moment = base_moment + n * duration` lands on `rata_die` (< `rata_die + 1`)
         fn periodic_duration_on_or_before(
             rata_die: RataDie,
@@ -166,7 +166,7 @@ impl EastAsianTraditionalYear {
 
         debug_assert_eq!(solar_term, 12);
 
-        Self {
+        EastAsianTraditionalYear {
             packed: PackedEastAsianTraditionalYearData::new(
                 related_iso,
                 month_lengths,

components/calendar/src/cal/east_asian_traditional/simple.rs

@@ -303,12 +303,12 @@ impl Date<Ethiopian> {
         year: i32,
         month: u8,
         day: u8,
-    ) -> Result<Self, RangeError> {
+    ) -> Result<Date<Ethiopian>, RangeError> {
         ArithmeticDate::from_year_month_day(year, month, day, &Ethiopian(era_style))
             .map(ArithmeticDate::cast)
             .map(CopticDateInner)
             .map(EthiopianDateInner)
-            .map(|inner| Self::from_raw(inner, Ethiopian(era_style)))
+            .map(|inner| Date::from_raw(inner, Ethiopian(era_style)))
     }
 }
 

components/calendar/src/cal/ethiopian.rs

@@ -136,11 +136,11 @@ impl Date<Gregorian> {
     /// assert_eq!(date_gregorian.month().ordinal, 1);
     /// assert_eq!(date_gregorian.day_of_month().0, 2);
     /// ```
-    pub fn try_new_gregorian(year: i32, month: u8, day: u8) -> Result<Self, RangeError> {
+    pub fn try_new_gregorian(year: i32, month: u8, day: u8) -> Result<Date<Gregorian>, RangeError> {
         ArithmeticDate::from_year_month_day(year, month, day, &AbstractGregorian(CeBce))
             .map(ArithmeticDate::cast)
             .map(GregorianDateInner)
-            .map(|i| Self::from_raw(i, Gregorian))
+            .map(|i| Date::from_raw(i, Gregorian))
     }
 }
 

components/calendar/src/cal/gregorian.rs

@@ -59,7 +59,7 @@ pub struct HebrewDateInner(ArithmeticDate<Hebrew>);
 impl Hebrew {
     /// Construct a new [`Hebrew`]
     pub fn new() -> Self {
-        Self
+        Hebrew
     }
 }
 
@@ -354,10 +354,14 @@ impl Date<Hebrew> {
     ///
     /// Use [`Date::try_new_from_codes`]
     #[deprecated(since = "2.1.0", note = "use `Date::try_new_from_codes`")]
-    pub fn try_new_hebrew(year: i32, ordinal_month: u8, day: u8) -> Result<Self, RangeError> {
+    pub fn try_new_hebrew(
+        year: i32,
+        ordinal_month: u8,
+        day: u8,
+    ) -> Result<Date<Hebrew>, RangeError> {
         ArithmeticDate::from_year_month_day(year, ordinal_month, day, &Hebrew)
             .map(HebrewDateInner)
-            .map(|inner| Self::from_raw(inner, Hebrew))
+            .map(|inner| Date::from_raw(inner, Hebrew))
     }
 }
 

components/calendar/src/cal/hebrew.rs

@@ -450,7 +450,7 @@ impl Hijri<TabularAlgorithm> {
     /// Use [`Self::new_tabular`]
     #[deprecated(since = "2.1.0", note = "use `Hijri::new_tabular`")]
     pub const fn new(leap_years: TabularAlgorithmLeapYears, epoch: TabularAlgorithmEpoch) -> Self {
-        Self::new_tabular(leap_years, epoch)
+        Hijri::new_tabular(leap_years, epoch)
     }
 
     /// Creates a [`Hijri`] calendar with tabular rules and the given leap year rule and epoch.
@@ -707,8 +707,8 @@ impl<A: AsCalendar<Calendar = Hijri<AstronomicalSimulation>>> Date<A> {
         month: u8,
         day: u8,
         calendar: A,
-    ) -> Result<Self, RangeError> {
-        Self::try_new_hijri_with_calendar(year, month, day, calendar)
+    ) -> Result<Date<A>, RangeError> {
+        Date::try_new_hijri_with_calendar(year, month, day, calendar)
     }
 }
 
@@ -991,15 +991,15 @@ impl<A: AsCalendar<Calendar = Hijri<R>>, R: Rules> Date<A> {
     ) -> Result<Self, RangeError> {
         ArithmeticDate::from_year_month_day(year, month, day, calendar.as_calendar())
             .map(HijriDateInner)
-            .map(|inner| Self::from_raw(inner, calendar))
+            .map(|inner| Date::from_raw(inner, calendar))
     }
 }
 
 impl Date<Hijri<UmmAlQura>> {
     /// Deprecated
     #[deprecated(since = "2.1.0", note = "use `Date::try_new_hijri_with_calendar")]
     pub fn try_new_ummalqura(year: i32, month: u8, day: u8) -> Result<Self, RangeError> {
-        Self::try_new_hijri_with_calendar(year, month, day, Hijri::new_umm_al_qura())
+        Date::try_new_hijri_with_calendar(year, month, day, Hijri::new_umm_al_qura())
     }
 }
 
@@ -1011,8 +1011,8 @@ impl<A: AsCalendar<Calendar = Hijri<TabularAlgorithm>>> Date<A> {
         month: u8,
         day: u8,
         calendar: A,
-    ) -> Result<Self, RangeError> {
-        Self::try_new_hijri_with_calendar(year, month, day, calendar)
+    ) -> Result<Date<A>, RangeError> {
+        Date::try_new_hijri_with_calendar(year, month, day, calendar)
     }
 }