Switch to target-type new() for direct return values

Author: Sergio0694

CommunityToolkit.Diagnostics/Extensions/ValueTypeExtensions.cs

@@ -63,6 +63,6 @@ public static unsafe string ToHexString<T>(this T value)
             p[j] = (char)Unsafe.Add(ref rh, high);
         }
 
-        return new string(p, 0, bufferSize);
+        return new(p, 0, bufferSize);
     }
 }

CommunityToolkit.HighPerformance/Buffers/ArrayPoolBufferWriter{T}.cs

@@ -325,7 +325,7 @@ public override string ToString()
         if (typeof(T) == typeof(char) &&
             this.array is char[] chars)
         {
-            return new string(chars, 0, this.index);
+            return new(chars, 0, this.index);
         }
 
         // Same representation used in Span<T>

CommunityToolkit.HighPerformance/Buffers/Internals/ArrayMemoryManager{TFrom,TTo}.cs

@@ -86,7 +86,7 @@ public override unsafe MemoryHandle Pin(int elementIndex = 0)
         ref byte r2 = ref Unsafe.Add(ref r1, byteOffset);
         void* pi = Unsafe.AsPointer(ref r2);
 
-        return new MemoryHandle(pi, handle);
+        return new(pi, handle);
     }
 
     /// <inheritdoc/>

CommunityToolkit.HighPerformance/Buffers/Internals/RawObjectMemoryManager{T}.cs

@@ -72,7 +72,7 @@ public override unsafe MemoryHandle Pin(int elementIndex = 0)
         ref T r1 = ref Unsafe.Add(ref r0, (nint)(uint)elementIndex);
         void* p = Unsafe.AsPointer(ref r1);
 
-        return new MemoryHandle(p, handle);
+        return new(p, handle);
     }
 
     /// <inheritdoc/>

CommunityToolkit.HighPerformance/Buffers/Internals/StringMemoryManager{TTo}.cs

@@ -82,7 +82,7 @@ public override unsafe MemoryHandle Pin(int elementIndex = 0)
         ref byte r2 = ref Unsafe.Add(ref r1, byteOffset);
         void* pi = Unsafe.AsPointer(ref r2);
 
-        return new MemoryHandle(pi, handle);
+        return new(pi, handle);
     }
 
     /// <inheritdoc/>

CommunityToolkit.HighPerformance/Buffers/MemoryOwner{T}.cs

@@ -157,7 +157,7 @@ public Memory<T> Memory
                 ThrowObjectDisposedException();
             }
 
-            return new Memory<T>(array!, this.start, this.length);
+            return new(array!, this.start, this.length);
         }
     }
 
@@ -190,7 +190,7 @@ public Span<T> Span
             // especially if T is a value type, in which case the covariance check is JIT removed.
             return MemoryMarshal.CreateSpan(ref r0, this.length);
 #else
-            return new Span<T>(array!, this.start, this.length);
+            return new(array!, this.start, this.length);
 #endif
         }
     }
@@ -239,7 +239,7 @@ public ArraySegment<T> DangerousGetArray()
             ThrowObjectDisposedException();
         }
 
-        return new ArraySegment<T>(array!, this.start, this.length);
+        return new(array!, this.start, this.length);
     }
 
     /// <summary>
@@ -282,7 +282,7 @@ public MemoryOwner<T> Slice(int start, int length)
         // suppress the finalizer to reduce the overhead on the garbage collector.
         GC.SuppressFinalize(this);
 
-        return new MemoryOwner<T>(start, length, this.pool, array!);
+        return new(start, length, this.pool, array!);
     }
 
     /// <inheritdoc/>
@@ -312,7 +312,7 @@ public override string ToString()
         if (typeof(T) == typeof(char) &&
             this.array is char[] chars)
         {
-            return new string(chars, this.start, this.length);
+            return new(chars, this.start, this.length);
         }
 
         // Same representation used in Span<T>

CommunityToolkit.HighPerformance/Buffers/SpanOwner{T}.cs

@@ -146,7 +146,7 @@ public Span<T> Span
 
             return MemoryMarshal.CreateSpan(ref r0, this.length);
 #else
-            return new Span<T>(this.array, 0, this.length);
+            return new(this.array, 0, this.length);
 #endif
         }
     }
@@ -192,7 +192,7 @@ public override string ToString()
         if (typeof(T) == typeof(char) &&
             this.array is char[] chars)
         {
-            return new string(chars, 0, this.length);
+            return new(chars, 0, this.length);
         }
 
         // Same representation used in Span<T>

CommunityToolkit.HighPerformance/Enumerables/ReadOnlyRefEnumerable{T}.cs

@@ -98,7 +98,7 @@ public static ReadOnlyRefEnumerable<T> DangerousCreate(in T value, int length, i
 
         OverflowHelper.EnsureIsInNativeIntRange(length, 1, step);
 
-        return new ReadOnlyRefEnumerable<T>(in value, length, step);
+        return new(in value, length, step);
     }
 #else
     /// <summary>
@@ -182,9 +182,9 @@ public ref readonly T this[Index index]
     public Enumerator GetEnumerator()
     {
 #if NETSTANDARD2_1_OR_GREATER
-        return new Enumerator(this.span, this.step);
+        return new(this.span, this.step);
 #else
-        return new Enumerator(this.instance, this.offset, this.length, this.step);
+        return new(this.instance, this.offset, this.length, this.step);
 #endif
     }
 
@@ -342,9 +342,9 @@ public T[] ToArray()
     public static implicit operator ReadOnlyRefEnumerable<T>(RefEnumerable<T> enumerable)
     {
 #if NETSTANDARD2_1_OR_GREATER
-        return new ReadOnlyRefEnumerable<T>(enumerable.Span, enumerable.Step);
+        return new(enumerable.Span, enumerable.Step);
 #else
-        return new ReadOnlyRefEnumerable<T>(enumerable.Instance, enumerable.Offset, enumerable.Length, enumerable.Step);
+        return new(enumerable.Instance, enumerable.Offset, enumerable.Length, enumerable.Step);
 #endif
     }
 

CommunityToolkit.HighPerformance/Enumerables/ReadOnlySpanEnumerable{T}.cs

@@ -68,9 +68,9 @@ public readonly Item Current
             ref T ri = ref Unsafe.Add(ref r0, (nint)(uint)this.index);
 
             // See comment in SpanEnumerable<T> about this
-            return new Item(ref ri, this.index);
+            return new(ref ri, this.index);
 #else
-            return new Item(this.span, this.index);
+            return new(this.span, this.index);
 #endif
         }
     }

CommunityToolkit.HighPerformance/Enumerables/RefEnumerable{T}.cs

@@ -81,7 +81,7 @@ public static RefEnumerable<T> DangerousCreate(ref T value, int length, int step
 
         OverflowHelper.EnsureIsInNativeIntRange(length, 1, step);
 
-        return new RefEnumerable<T>(ref value, length, step);
+        return new(ref value, length, step);
     }
 #else
     /// <summary>
@@ -165,9 +165,9 @@ public ref T this[Index index]
     public Enumerator GetEnumerator()
     {
 #if NETSTANDARD2_1_OR_GREATER
-        return new Enumerator(this.Span, this.Step);
+        return new(this.Span, this.Step);
 #else
-        return new Enumerator(this.Instance, this.Offset, this.Length, this.Step);
+        return new(this.Instance, this.Offset, this.Length, this.Step);
 #endif
     }
 

CommunityToolkit.HighPerformance/Enumerables/SpanEnumerable{T}.cs

@@ -73,9 +73,9 @@ public readonly Item Current
             // first item as the target reference, and the length as a host for the
             // current original offset. This is not possible on eg. .NET Standard 2.0,
             // as we lack the API to create Span<T>-s from arbitrary references.
-            return new Item(ref ri, this.index);
+            return new(ref ri, this.index);
 #else
-            return new Item(this.span, this.index);
+            return new(this.span, this.index);
 #endif
         }
     }

CommunityToolkit.HighPerformance/Extensions/ArrayExtensions.2D.cs

@@ -136,12 +136,12 @@ public static RefEnumerable<T> GetRow<T>(this T[,] array, int row)
 #if NETSTANDARD2_1_OR_GREATER
         ref T r0 = ref array.DangerousGetReferenceAt(row, 0);
 
-        return new RefEnumerable<T>(ref r0, width, 1);
+        return new(ref r0, width, 1);
 #else
         ref T r0 = ref array.DangerousGetReferenceAt(row, 0);
         IntPtr offset = ObjectMarshal.DangerousGetObjectDataByteOffset(array, ref r0);
 
-        return new RefEnumerable<T>(array, offset, width, 1);
+        return new(array, offset, width, 1);
 #endif
     }
 
@@ -189,12 +189,12 @@ public static RefEnumerable<T> GetColumn<T>(this T[,] array, int column)
 #if NETSTANDARD2_1_OR_GREATER
         ref T r0 = ref array.DangerousGetReferenceAt(0, column);
 
-        return new RefEnumerable<T>(ref r0, height, width);
+        return new(ref r0, height, width);
 #else
         ref T r0 = ref array.DangerousGetReferenceAt(0, column);
         IntPtr offset = ObjectMarshal.DangerousGetObjectDataByteOffset(array, ref r0);
 
-        return new RefEnumerable<T>(array, offset, height, width);
+        return new(array, offset, height, width);
 #endif
     }
 

CommunityToolkit.HighPerformance/Extensions/StreamExtensions.cs

@@ -31,13 +31,13 @@ public static ValueTask<int> ReadAsync(this Stream stream, Memory<byte> buffer,
     {
         if (cancellationToken.IsCancellationRequested)
         {
-            return new ValueTask<int>(Task.FromCanceled<int>(cancellationToken));
+            return new(Task.FromCanceled<int>(cancellationToken));
         }
 
         // If the memory wraps an array, extract it and use it directly
         if (MemoryMarshal.TryGetArray(buffer, out ArraySegment<byte> segment))
         {
-            return new ValueTask<int>(stream.ReadAsync(segment.Array!, segment.Offset, segment.Count, cancellationToken));
+            return new(stream.ReadAsync(segment.Array!, segment.Offset, segment.Count, cancellationToken));
         }
 
         // Local function used as the fallback path. This happens when the input memory
@@ -68,7 +68,7 @@ static async Task<int> ReadAsyncFallback(Stream stream, Memory<byte> buffer, Can
             }
         }
 
-        return new ValueTask<int>(ReadAsyncFallback(stream, buffer, cancellationToken));
+        return new(ReadAsyncFallback(stream, buffer, cancellationToken));
     }
 
     /// <summary>
@@ -82,12 +82,12 @@ public static ValueTask WriteAsync(this Stream stream, ReadOnlyMemory<byte> buff
     {
         if (cancellationToken.IsCancellationRequested)
         {
-            return new ValueTask(Task.FromCanceled(cancellationToken));
+            return new(Task.FromCanceled(cancellationToken));
         }
 
         if (MemoryMarshal.TryGetArray(buffer, out ArraySegment<byte> segment))
         {
-            return new ValueTask(stream.WriteAsync(segment.Array!, segment.Offset, segment.Count, cancellationToken));
+            return new(stream.WriteAsync(segment.Array!, segment.Offset, segment.Count, cancellationToken));
         }
 
         // Local function, same idea as above
@@ -107,7 +107,7 @@ static async Task WriteAsyncFallback(Stream stream, ReadOnlyMemory<byte> buffer,
             }
         }
 
-        return new ValueTask(WriteAsyncFallback(stream, buffer, cancellationToken));
+        return new(WriteAsyncFallback(stream, buffer, cancellationToken));
     }
 
     /// <summary>

CommunityToolkit.HighPerformance/Memory/Memory2D{T}.cs

@@ -545,7 +545,7 @@ public static Memory2D<T> DangerousCreate(object instance, ref T value, int heig
 
         IntPtr offset = ObjectMarshal.DangerousGetObjectDataByteOffset(instance, ref value);
 
-        return new Memory2D<T>(instance, offset, height, width, pitch);
+        return new(instance, offset, height, width, pitch);
     }
 
     /// <summary>
@@ -605,16 +605,16 @@ public Span2D<T> Span
                     ref T r0 = ref memoryManager.GetSpan().DangerousGetReference();
                     ref T r1 = ref Unsafe.Add(ref r0, this.offset);
 
-                    return new Span2D<T>(ref r1, this.height, this.width, this.pitch);
+                    return new(ref r1, this.height, this.width, this.pitch);
                 }
                 else
                 {
                     ref T r0 = ref ObjectMarshal.DangerousGetObjectDataReferenceAt<T>(this.instance, this.offset);
 
-                    return new Span2D<T>(ref r0, this.height, this.width, this.pitch);
+                    return new(ref r0, this.height, this.width, this.pitch);
                 }
 #else
-                return new Span2D<T>(this.instance, this.offset, this.height, this.width, this.pitch);
+                return new(this.instance, this.offset, this.height, this.width, this.pitch);
 #endif
             }
 
@@ -684,7 +684,7 @@ public Memory2D<T> Slice(int row, int column, int height, int width)
 
         IntPtr offset = this.offset + (shift * Unsafe.SizeOf<T>());
 
-        return new Memory2D<T>(this.instance!, offset, height, width, pitch);
+        return new(this.instance!, offset, height, width, pitch);
     }
 
     /// <summary>
@@ -743,7 +743,7 @@ public unsafe MemoryHandle Pin()
 
             void* pointer = Unsafe.AsPointer(ref ObjectMarshal.DangerousGetObjectDataReferenceAt<T>(this.instance, this.offset));
 
-            return new MemoryHandle(pointer, handle);
+            return new(pointer, handle);
         }
 
         return default;

CommunityToolkit.HighPerformance/Memory/ReadOnlyMemory2D{T}.cs

@@ -557,7 +557,7 @@ public static ReadOnlyMemory2D<T> DangerousCreate(object instance, ref T value,
 
         IntPtr offset = ObjectMarshal.DangerousGetObjectDataByteOffset(instance, ref value);
 
-        return new ReadOnlyMemory2D<T>(instance, offset, height, width, pitch);
+        return new(instance, offset, height, width, pitch);
     }
 
     /// <summary>
@@ -617,17 +617,17 @@ public ReadOnlySpan2D<T> Span
                     ref T r0 = ref memoryManager.GetSpan().DangerousGetReference();
                     ref T r1 = ref Unsafe.Add(ref r0, this.offset);
 
-                    return new ReadOnlySpan2D<T>(in r1, this.height, this.width, this.pitch);
+                    return new(in r1, this.height, this.width, this.pitch);
                 }
                 else
                 {
                     // This handles both arrays and strings
                     ref T r0 = ref ObjectMarshal.DangerousGetObjectDataReferenceAt<T>(this.instance, this.offset);
 
-                    return new ReadOnlySpan2D<T>(in r0, this.height, this.width, this.pitch);
+                    return new(in r0, this.height, this.width, this.pitch);
                 }
 #else
-                return new ReadOnlySpan2D<T>(this.instance, this.offset, this.height, this.width, this.pitch);
+                return new(this.instance, this.offset, this.height, this.width, this.pitch);
 #endif
             }
 
@@ -697,7 +697,7 @@ public ReadOnlyMemory2D<T> Slice(int row, int column, int height, int width)
 
         IntPtr offset = this.offset + (shift * Unsafe.SizeOf<T>());
 
-        return new ReadOnlyMemory2D<T>(this.instance!, offset, height, width, pitch);
+        return new(this.instance!, offset, height, width, pitch);
     }
 
     /// <summary>
@@ -756,7 +756,7 @@ public unsafe MemoryHandle Pin()
 
             void* pointer = Unsafe.AsPointer(ref ObjectMarshal.DangerousGetObjectDataReferenceAt<T>(this.instance, this.offset));
 
-            return new MemoryHandle(pointer, handle);
+            return new(pointer, handle);
         }
 
         return default;

CommunityToolkit.HighPerformance/Memory/ReadOnlySpan2D{T}.Enumerator.cs

@@ -36,11 +36,11 @@ public ReadOnlyRefEnumerable<T> GetRow(int row)
         ref T r1 = ref Unsafe.Add(ref r0, startIndex);
 
 #if NETSTANDARD2_1_OR_GREATER
-        return new ReadOnlyRefEnumerable<T>(in r1, Width, 1);
+        return new(in r1, Width, 1);
 #else
         IntPtr offset = RuntimeHelpers.GetObjectDataOrReferenceByteOffset(this.instance, ref r1);
 
-        return new ReadOnlyRefEnumerable<T>(this.instance!, offset, this.width, 1);
+        return new(this.instance!, offset, this.width, 1);
 #endif
     }
 
@@ -62,11 +62,11 @@ public ReadOnlyRefEnumerable<T> GetColumn(int column)
         ref T r1 = ref Unsafe.Add(ref r0, (nint)(uint)column);
 
 #if NETSTANDARD2_1_OR_GREATER
-        return new ReadOnlyRefEnumerable<T>(in r1, Height, this.stride);
+        return new(in r1, Height, this.stride);
 #else
         IntPtr offset = RuntimeHelpers.GetObjectDataOrReferenceByteOffset(this.instance, ref r1);
 
-        return new ReadOnlyRefEnumerable<T>(this.instance!, offset, Height, this.stride);
+        return new(this.instance!, offset, Height, this.stride);
 #endif
     }