Improve performance of LocalDate and YearMonth comparisons

- Avoid redundant calendar checks in comparison operators
- Use calendar ordinals for comparisons

For LocalDate, this improves CompareTo on my machine from 15ns to about 9n, and the less than operator from 24ns to 9ns.

Author: jskeet

src/NodaTime.Benchmarks/NodaTimeTests/LocalDateBenchmarks.cs

@@ -129,5 +129,11 @@ public IsoDayOfWeek DayOfWeek_BeforeEpoch()
 
         [Benchmark]
         public LocalDate FromDateTime_WithCalendar() => LocalDate.FromDateTime(SampleDateTime, CalendarSystem.Julian);
+        
+        [Benchmark]
+        public int CompareTo() => Sample.CompareTo(SampleBeforeEpoch);
+
+        [Benchmark]
+        public bool LessThanOperator() => Sample < SampleBeforeEpoch;
     }
 }

src/NodaTime/LocalDate.cs

@@ -140,7 +140,9 @@ public LocalDate(Era era, int yearOfEra, int month, int day, CalendarSystem cale
 
         /// <summary>Gets the calendar system associated with this local date.</summary>
         /// <value>The calendar system associated with this local date.</value>
-        public CalendarSystem Calendar => CalendarSystem.ForOrdinal(yearMonthDayCalendar.CalendarOrdinal);
+        public CalendarSystem Calendar => CalendarSystem.ForOrdinal(CalendarOrdinal);
+
+        private CalendarOrdinal CalendarOrdinal => yearMonthDayCalendar.CalendarOrdinal;
 
         /// <summary>Gets the year of this local date.</summary>
         /// <remarks>This returns the "absolute year", so, for the ISO calendar,
@@ -445,8 +447,8 @@ public static LocalDate FromYearMonthWeekAndDay(int year, int month, int occurre
         /// <returns>true if the <paramref name="lhs"/> is strictly earlier than <paramref name="rhs"/>, false otherwise.</returns>
         public static bool operator <(LocalDate lhs, LocalDate rhs)
         {
-            Preconditions.CheckArgument(lhs.Calendar.Equals(rhs.Calendar), nameof(rhs), "Only values in the same calendar can be compared");
-            return lhs.CompareTo(rhs) < 0;
+            Preconditions.CheckArgument(lhs.CalendarOrdinal == rhs.CalendarOrdinal, nameof(rhs), "Only values in the same calendar can be compared");
+            return lhs.TrustedCompareTo(rhs) < 0;
         }
 
         /// <summary>
@@ -460,8 +462,8 @@ public static LocalDate FromYearMonthWeekAndDay(int year, int month, int occurre
         /// <returns>true if the <paramref name="lhs"/> is earlier than or equal to <paramref name="rhs"/>, false otherwise.</returns>
         public static bool operator <=(LocalDate lhs, LocalDate rhs)
         {
-            Preconditions.CheckArgument(lhs.Calendar.Equals(rhs.Calendar), nameof(rhs), "Only values in the same calendar can be compared");
-            return lhs.CompareTo(rhs) <= 0;
+            Preconditions.CheckArgument(lhs.CalendarOrdinal == rhs.CalendarOrdinal, nameof(rhs), "Only values in the same calendar can be compared");
+            return lhs.TrustedCompareTo(rhs) <= 0;
         }
 
         /// <summary>
@@ -475,8 +477,8 @@ public static LocalDate FromYearMonthWeekAndDay(int year, int month, int occurre
         /// <returns>true if the <paramref name="lhs"/> is strictly later than <paramref name="rhs"/>, false otherwise.</returns>
         public static bool operator >(LocalDate lhs, LocalDate rhs)
         {
-            Preconditions.CheckArgument(lhs.Calendar.Equals(rhs.Calendar), nameof(rhs), "Only values in the same calendar can be compared");
-            return lhs.CompareTo(rhs) > 0;
+            Preconditions.CheckArgument(lhs.CalendarOrdinal == rhs.CalendarOrdinal, nameof(rhs), "Only values in the same calendar can be compared");
+            return lhs.TrustedCompareTo(rhs) > 0;
         }
 
         /// <summary>
@@ -490,8 +492,8 @@ public static LocalDate FromYearMonthWeekAndDay(int year, int month, int occurre
         /// <returns>true if the <paramref name="lhs"/> is later than or equal to <paramref name="rhs"/>, false otherwise.</returns>
         public static bool operator >=(LocalDate lhs, LocalDate rhs)
         {
-            Preconditions.CheckArgument(lhs.Calendar.Equals(rhs.Calendar), nameof(rhs), "Only values in the same calendar can be compared");
-            return lhs.CompareTo(rhs) >= 0;
+            Preconditions.CheckArgument(lhs.CalendarOrdinal == rhs.CalendarOrdinal, nameof(rhs), "Only values in the same calendar can be compared");
+            return lhs.TrustedCompareTo(rhs) >= 0;
         }
 
         /// <summary>
@@ -506,10 +508,16 @@ public static LocalDate FromYearMonthWeekAndDay(int year, int month, int occurre
         /// later than <paramref name="other"/>.</returns>
         public int CompareTo(LocalDate other)
         {
-            Preconditions.CheckArgument(Calendar.Equals(other.Calendar), nameof(other), "Only values with the same calendar system can be compared");
-            return Calendar.Compare(YearMonthDay, other.YearMonthDay);
+            Preconditions.CheckArgument(CalendarOrdinal == other.CalendarOrdinal, nameof(other), "Only values with the same calendar system can be compared");
+            return TrustedCompareTo(other);
         }
 
+        /// <summary>
+        /// Performs a comparison with another date, trusting that the calendar of the other date is already correct.
+        /// This avoids duplicate calendar checks.
+        /// </summary>
+        private int TrustedCompareTo([Trusted] LocalDate other) => Calendar.Compare(YearMonthDay, other.YearMonthDay);
+
         /// <summary>
         /// Implementation of <see cref="IComparable.CompareTo"/> to compare two LocalDates.
         /// See the type documentation for a description of ordering semantics.

src/NodaTime/YearMonth.cs

@@ -3,6 +3,7 @@
 // as found in the LICENSE.txt file.
 
 using JetBrains.Annotations;
+using NodaTime.Annotations;
 using NodaTime.Calendars;
 using NodaTime.Text;
 using NodaTime.Utility;
@@ -40,7 +41,9 @@ public struct YearMonth : IEquatable<YearMonth>, IComparable<YearMonth>, ICompar
 
         /// <summary>Gets the calendar system associated with this year/month.</summary>
         /// <value>The calendar system associated with this year/month.</value>
-        public CalendarSystem Calendar => CalendarSystem.ForOrdinal(startOfMonth.CalendarOrdinal);
+        public CalendarSystem Calendar => CalendarSystem.ForOrdinal(CalendarOrdinal);
+
+        private CalendarOrdinal CalendarOrdinal => startOfMonth.CalendarOrdinal;
 
         /// <summary>Gets the year of this year/month.</summary>
         /// <remarks>This returns the "absolute year", so, for the ISO calendar,
@@ -167,10 +170,16 @@ public LocalDate OnDayOfMonth(int day)
         /// later than <paramref name="other"/>.</returns>
         public int CompareTo(YearMonth other)
         {
-            Preconditions.CheckArgument(Calendar.Equals(other.Calendar), nameof(other), "Only values with the same calendar system can be compared");
-            return Calendar.Compare(YearMonthDay, other.YearMonthDay);
+            Preconditions.CheckArgument(CalendarOrdinal == other.CalendarOrdinal, nameof(other), "Only values with the same calendar system can be compared");
+            return TrustedCompareTo(other);
         }
 
+        /// <summary>
+        /// Performs a comparison with another YearMonth, trusting that the calendar of the other date is already correct.
+        /// This avoids duplicate calendar checks.
+        /// </summary>
+        private int TrustedCompareTo([Trusted] YearMonth other) => Calendar.Compare(YearMonthDay, other.YearMonthDay);
+
         /// <summary>
         /// Implementation of <see cref="IComparable.CompareTo"/> to compare two YearMonth values.
         /// See the type documentation for a description of ordering semantics.
@@ -205,8 +214,8 @@ int IComparable.CompareTo(object obj)
         /// <returns>true if the <paramref name="lhs"/> is strictly earlier than <paramref name="rhs"/>, false otherwise.</returns>
         public static bool operator <(YearMonth lhs, YearMonth rhs)
         {
-            Preconditions.CheckArgument(lhs.Calendar.Equals(rhs.Calendar), nameof(rhs), "Only values in the same calendar can be compared");
-            return lhs.CompareTo(rhs) < 0;
+            Preconditions.CheckArgument(lhs.CalendarOrdinal == rhs.CalendarOrdinal, nameof(rhs), "Only values in the same calendar can be compared");
+            return lhs.TrustedCompareTo(rhs) < 0;
         }
 
         /// <summary>
@@ -220,8 +229,8 @@ int IComparable.CompareTo(object obj)
         /// <returns>true if the <paramref name="lhs"/> is earlier than or equal to <paramref name="rhs"/>, false otherwise.</returns>
         public static bool operator <=(YearMonth lhs, YearMonth rhs)
         {
-            Preconditions.CheckArgument(lhs.Calendar.Equals(rhs.Calendar), nameof(rhs), "Only values in the same calendar can be compared");
-            return lhs.CompareTo(rhs) <= 0;
+            Preconditions.CheckArgument(lhs.CalendarOrdinal == rhs.CalendarOrdinal, nameof(rhs), "Only values in the same calendar can be compared");
+            return lhs.TrustedCompareTo(rhs) <= 0;
         }
 
         /// <summary>
@@ -235,8 +244,8 @@ int IComparable.CompareTo(object obj)
         /// <returns>true if the <paramref name="lhs"/> is strictly later than <paramref name="rhs"/>, false otherwise.</returns>
         public static bool operator >(YearMonth lhs, YearMonth rhs)
         {
-            Preconditions.CheckArgument(lhs.Calendar.Equals(rhs.Calendar), nameof(rhs), "Only values in the same calendar can be compared");
-            return lhs.CompareTo(rhs) > 0;
+            Preconditions.CheckArgument(lhs.CalendarOrdinal == rhs.CalendarOrdinal, nameof(rhs), "Only values in the same calendar can be compared");
+            return lhs.TrustedCompareTo(rhs) > 0;
         }
 
         /// <summary>
@@ -250,8 +259,8 @@ int IComparable.CompareTo(object obj)
         /// <returns>true if the <paramref name="lhs"/> is later than or equal to <paramref name="rhs"/>, false otherwise.</returns>
         public static bool operator >=(YearMonth lhs, YearMonth rhs)
         {
-            Preconditions.CheckArgument(lhs.Calendar.Equals(rhs.Calendar), nameof(rhs), "Only values in the same calendar can be compared");
-            return lhs.CompareTo(rhs) >= 0;
+            Preconditions.CheckArgument(lhs.CalendarOrdinal == rhs.CalendarOrdinal, nameof(rhs), "Only values in the same calendar can be compared");
+            return lhs.TrustedCompareTo(rhs) >= 0;
         }
 
         /// <summary>