removed [MethodImpl(MethodImplOptions.AggressiveInlining)] attributes

Author: petesramek

src/PolylineAlgorithm/Abstraction/AbstractPolylineEncoder.cs

@@ -119,17 +119,14 @@ public TPolyline Encode(IEnumerable<TCoordinate> coordinates) {
 
         return CreatePolyline(buffer[..position].ToString().AsMemory());
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static int GetCount(IEnumerable<TCoordinate> coordinates) => coordinates switch {
             ICollection collection => collection.Count,
             _ => coordinates.Count(),
         };
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static int GetRequiredLength(CoordinateVariance variance) =>
             PolylineEncoding.GetCharCount(variance.Latitude) + PolylineEncoding.GetCharCount(variance.Longitude);
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static int GetRemainingBufferSize(int position, int length) {
             Debug.Assert(length > 0, "Buffer length must be greater than zero.");
             Debug.Assert(position >= 0, "Position must be non-negative.");
@@ -139,8 +136,7 @@ static int GetRemainingBufferSize(int position, int length) {
             return length - position;
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        int GetBufferLength(int count) {
+        int GetMaxBufferLength(int count) {
             Debug.Assert(count > 0, "Count must be greater than zero.");
 
             int requestedBufferLength = count * Defaults.Polyline.Block.Length.Max;
@@ -180,7 +176,6 @@ static void ValidateEmptyCoordinates(ILogger<AbstractPolylineDecoder<TPolyline,
             }
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static void ValidateBuffer(ILogger<AbstractPolylineDecoder<TPolyline, TCoordinate>> logger, CoordinateVariance variance, int position, Span<char> buffer) {
             if (GetRemainingBufferSize(position, buffer.Length) < GetRequiredLength(variance)) {
                 logger
@@ -201,7 +196,7 @@ static void ValidateBuffer(ILogger<AbstractPolylineDecoder<TPolyline, TCoordinat
     /// <returns>
     /// An instance of <typeparamref name="TPolyline"/> representing the encoded polyline.
     /// </returns>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    
     protected abstract TPolyline CreatePolyline(ReadOnlyMemory<char> polyline);
 
     /// <summary>
@@ -211,7 +206,7 @@ static void ValidateBuffer(ILogger<AbstractPolylineDecoder<TPolyline, TCoordinat
     /// <returns>
     /// The longitude value as a <see cref="double"/>.
     /// </returns>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    
     protected abstract double GetLongitude(TCoordinate? current);
 
     /// <summary>
@@ -221,7 +216,7 @@ static void ValidateBuffer(ILogger<AbstractPolylineDecoder<TPolyline, TCoordinat
     /// <returns>
     /// The latitude value as a <see cref="double"/>.
     /// </returns>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    
     protected abstract double GetLatitude(TCoordinate? current);
 }
 

src/PolylineAlgorithm/Internal/CoordinateVariance.cs

@@ -41,7 +41,7 @@ public CoordinateVariance() {
     /// </summary>
     /// <param name="latitude">The next latitude value.</param>
     /// <param name="longitude">The next longitude value.</param>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    
     public void Next(int latitude, int longitude) {
         Latitude = Variance(_current.Latitude, latitude);
         Longitude = Variance(_current.Longitude, longitude);
@@ -58,7 +58,7 @@ public void Next(int latitude, int longitude) {
     /// <param name="initial">The previous coordinate value.</param>
     /// <param name="next">The next coordinate value.</param>
     /// <returns>The computed variance between <paramref name="initial"/> and <paramref name="next"/>.</returns>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    
     private static int Variance(int initial, int next) => (initial, next) switch {
         (0, 0) => 0,
         (0, _) => next,

src/PolylineAlgorithm/PolylineDecoder.cs

@@ -19,7 +19,7 @@ public PolylineDecoder(PolylineEncodingOptions options)
         : base(options) { }
 
     /// <inheritdoc />
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    
     protected override Coordinate CreateCoordinate(double latitude, double longitude) {
         return new(latitude, longitude);
     }

src/PolylineAlgorithm/PolylineEncoder.cs

@@ -19,19 +19,19 @@ public PolylineEncoder(PolylineEncodingOptions options)
         : base(options) { }
 
     /// <inheritdoc />
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    
     protected override double GetLatitude(Coordinate coordinate) {
         return coordinate.Latitude;
     }
 
     /// <inheritdoc />
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    
     protected override double GetLongitude(Coordinate coordinate) {
         return coordinate.Longitude;
     }
 
     /// <inheritdoc />
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    
     protected override Polyline CreatePolyline(ReadOnlyMemory<char> polyline) {
         return Polyline.FromMemory(polyline);
     }

src/PolylineAlgorithm/PolylineEncoding.cs

@@ -37,7 +37,7 @@ public static class PolylineEncoding {
     /// <see langword="true"/> if a value was successfully read and the end of the buffer was not reached; otherwise, <see
     /// langword="false"/>.
     /// </returns>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    
     public static bool TryReadValue(ref int variance, ref ReadOnlyMemory<char> buffer, ref int position) {
         // Validate that the position is within the bounds of the buffer.
         if (position == buffer.Length) {
@@ -88,7 +88,7 @@ public static bool TryReadValue(ref int variance, ref ReadOnlyMemory<char> buffe
     /// <exception cref="ArgumentOutOfRangeException">
     /// Thrown when <paramref name="value"/> is outside the valid range for the specified <paramref name="type"/>.
     /// </exception>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    
     public static double Denormalize(int value, CoordinateValueType type) {
         // Validate that the type is not None, as it does not represent a valid coordinate value type.
         if (type == CoordinateValueType.None) {
@@ -130,7 +130,7 @@ public static double Denormalize(int value, CoordinateValueType type) {
     /// <returns>
     /// <see langword="true"/> if the value was successfully written to the buffer; otherwise, <see langword="false"/>.
     /// </returns>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    
     public static bool TryWriteValue(int variance, ref Span<char> buffer, ref int position) {
         // Validate that the position and required space for write is within the bounds of the buffer.
         if (buffer.Length < position + GetCharCount(variance)) {
@@ -177,7 +177,7 @@ public static bool TryWriteValue(int variance, ref Span<char> buffer, ref int po
     /// Thrown when <paramref name="value"/> is not a finite number or is outside the valid range for the specified
     /// <paramref name="type"/>.
     /// </exception>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    
     public static int Normalize(double value, CoordinateValueType type) {
         // Validate that the type is not None, as it does not represent a valid coordinate value type.
         if (type == CoordinateValueType.None) {
@@ -219,7 +219,7 @@ public static int Normalize(double value, CoordinateValueType type) {
     /// The number of characters required to represent the <paramref name="variance"/> value,  based on its magnitude.
     /// Returns a value between 1 and 6 inclusive.
     /// </returns>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    
     public static int GetCharCount(int variance) => variance switch {
         // DO NOT CHANGE THE ORDER. We are skipping inside exclusive ranges as those are covered by previous statements.
         >= -16 and <= +15 => 1,