Removed redundant modifiers

Author: sakno

src/DotNext.Benchmarks/Net/Cluster/Consensus/Raft/PersistentStateBenchmark.cs

@@ -45,9 +45,9 @@ public async ValueTask<long> ReadAsync<TEntryImpl, TList>(TList entries, long? s
             where TList : notnull, IReadOnlyList<TEntryImpl>
         {
             var result = 0L;
-            foreach (var entry in entries)
+            for (var i = 0; i < entries.Count; i++)
             {
-                using var buffer = await entry.ToMemoryAsync();
+                using var buffer = await entries[i].ToMemoryAsync(token: token);
                 result += buffer.Length;
             }
 

src/DotNext.IO/Buffers/BufferWriter.cs

@@ -196,7 +196,7 @@ public static int Write(this ref BufferWriterSlim<byte> writer, scoped ReadOnlyS
     }
 
     private static bool TryFormat<T>(IBufferWriter<byte> writer, T value, Span<char> buffer, in EncodingContext context, LengthFormat? lengthFormat, ReadOnlySpan<char> format, IFormatProvider? provider, out long bytesWritten)
-        where T : notnull, ISpanFormattable
+        where T : ISpanFormattable
     {
         if (!value.TryFormat(buffer, out var charsWritten, format, provider))
         {
@@ -228,7 +228,7 @@ private static bool TryFormat<T>(IBufferWriter<byte> writer, T value, Span<char>
     /// <returns>The number of written bytes.</returns>
     [SkipLocalsInit]
     public static long Format<T>(this IBufferWriter<byte> writer, T value, in EncodingContext context, LengthFormat? lengthFormat, ReadOnlySpan<char> format = default, IFormatProvider? provider = null, MemoryAllocator<char>? allocator = null)
-        where T : notnull, ISpanFormattable
+        where T : ISpanFormattable
     {
         // attempt to allocate char buffer on the stack
         Span<char> charBuffer = stackalloc char[SpanOwner<char>.StackallocThreshold];
@@ -259,7 +259,7 @@ public static long Format<T>(this IBufferWriter<byte> writer, T value, in Encodi
     /// <returns>The number of written bytes.</returns>
     /// <exception cref="InsufficientMemoryException"><paramref name="writer"/> has not enough free space to place UTF-8 bytes.</exception>
     public static int Format<T>(this IBufferWriter<byte> writer, T value, LengthFormat? lengthFormat, ReadOnlySpan<char> format = default, IFormatProvider? provider = null)
-        where T : notnull, IUtf8SpanFormattable
+        where T : IUtf8SpanFormattable
     {
         var expectedLengthSize = lengthFormat switch
         {

src/DotNext.IO/Buffers/IBufferReader.cs

@@ -60,7 +60,7 @@ void IReadOnlySpanConsumer<byte>.Invoke(ReadOnlySpan<byte> source)
 
 [StructLayout(LayoutKind.Auto)]
 internal unsafe struct WellKnownIntegerReader<T>(delegate*<ReadOnlySpan<byte>, bool, T> parser) : IBufferReader, ISupplier<T>
-    where T : notnull, IBinaryInteger<T>
+    where T : IBinaryInteger<T>
 {
     private T? buffer;
     private int writtenBytes;
@@ -84,7 +84,7 @@ void IReadOnlySpanConsumer<byte>.Invoke(ReadOnlySpan<byte> source)
 
 [StructLayout(LayoutKind.Auto)]
 internal unsafe struct IntegerReader<T>(delegate*<ReadOnlySpan<byte>, bool, T> parser) : IBufferReader, ISupplier<T>
-    where T : notnull, IBinaryInteger<T>
+    where T : IBinaryInteger<T>
 {
     private MemoryOwner<byte> buffer = Memory.AllocateExactly<byte>(Number.GetMaxByteCount<T>());
     private int writtenBytes;
@@ -116,7 +116,7 @@ T ISupplier<T>.Invoke()
 
 [StructLayout(LayoutKind.Auto)]
 internal struct BinaryFormattable256Reader<T> : IBufferReader, ISupplier<T>
-    where T : notnull, IBinaryFormattable<T>
+    where T : IBinaryFormattable<T>
 {
     private Buffer256 buffer;
     private int writtenBytes;
@@ -141,7 +141,7 @@ readonly T ISupplier<T>.Invoke()
 
 [StructLayout(LayoutKind.Auto)]
 internal struct BinaryFormattableReader<T>() : IBufferReader, ISupplier<T>
-    where T : notnull, IBinaryFormattable<T>
+    where T : IBinaryFormattable<T>
 {
     private MemoryOwner<byte> buffer = Memory.AllocateExactly<byte>(T.Size);
     private int writtenBytes;

src/DotNext.IO/IO/DataTransferObject.cs

@@ -47,7 +47,7 @@ ValueTask<T> IDataTransferObject.ITransformation<T>.TransformAsync<TReader>(TRea
     /// <returns>The task representing state of asynchronous execution.</returns>
     /// <exception cref="OperationCanceledException">The operation has been canceled.</exception>
     public static ValueTask WriteToAsync<TObject>(this TObject dto, Stream output, Memory<byte> buffer, CancellationToken token = default)
-        where TObject : notnull, IDataTransferObject
+        where TObject : IDataTransferObject
         => dto.WriteToAsync(new AsyncStreamBinaryAccessor(output, buffer), token);
 
     /// <summary>
@@ -61,7 +61,7 @@ public static ValueTask WriteToAsync<TObject>(this TObject dto, Stream output, M
     /// <returns>The task representing state of asynchronous execution.</returns>
     /// <exception cref="OperationCanceledException">The operation has been canceled.</exception>
     public static ValueTask WriteToAsync<TObject>(this TObject dto, Stream output, int bufferSize = DefaultBufferSize, CancellationToken token = default)
-        where TObject : notnull, IDataTransferObject
+        where TObject : IDataTransferObject
     {
         return dto.TryGetMemory(out var memory) ?
             output.WriteAsync(memory, token) :
@@ -85,7 +85,7 @@ static async ValueTask WriteToStreamAsync(TObject dto, Stream output, int buffer
     /// <returns>The task representing state of asynchronous execution.</returns>
     /// <exception cref="OperationCanceledException">The operation has been canceled.</exception>
     public static ValueTask WriteToAsync<TObject>(this TObject dto, PipeWriter output, long bufferSize = 0L, CancellationToken token = default)
-        where TObject : notnull, IDataTransferObject
+        where TObject : IDataTransferObject
     {
         return bufferSize >= 0L
             ? dto.WriteToAsync(new PipeBinaryWriter(output, bufferSize), token)
@@ -102,7 +102,7 @@ public static ValueTask WriteToAsync<TObject>(this TObject dto, PipeWriter outpu
     /// <returns>The task representing state of asynchronous execution.</returns>
     /// <exception cref="OperationCanceledException">The operation has been canceled.</exception>
     public static ValueTask WriteToAsync<TObject>(this TObject dto, IBufferWriter<byte> writer, CancellationToken token = default)
-        where TObject : notnull, IDataTransferObject
+        where TObject : IDataTransferObject
     {
         ValueTask result;
         if (dto.TryGetMemory(out var memory))
@@ -136,7 +136,7 @@ public static ValueTask WriteToAsync<TObject>(this TObject dto, IBufferWriter<by
     /// <returns>The content of the object.</returns>
     /// <exception cref="OperationCanceledException">The operation has been canceled.</exception>
     public static ValueTask<string> ToStringAsync<TObject>(this TObject dto, Encoding encoding, MemoryAllocator<byte>? allocator = null, CancellationToken token = default)
-        where TObject : notnull, IDataTransferObject
+        where TObject : IDataTransferObject
     {
         ValueTask<string> result;
 
@@ -186,7 +186,7 @@ static async ValueTask<string> DecodeAsync(TObject dto, Encoding encoding, Memor
     /// <returns>The content of the object.</returns>
     /// <exception cref="OperationCanceledException">The operation has been canceled.</exception>
     public static ValueTask<byte[]> ToByteArrayAsync<TObject>(this TObject dto, MemoryAllocator<byte>? allocator = null, CancellationToken token = default)
-        where TObject : notnull, IDataTransferObject
+        where TObject : IDataTransferObject
     {
         ValueTask<byte[]> result;
 
@@ -236,7 +236,7 @@ static async ValueTask<byte[]> BufferizeAsync(TObject dto, MemoryAllocator<byte>
     /// <returns>The content of the object.</returns>
     /// <exception cref="OperationCanceledException">The operation has been canceled.</exception>
     public static ValueTask<MemoryOwner<byte>> ToMemoryAsync<TObject>(this TObject dto, MemoryAllocator<byte>? allocator = null, CancellationToken token = default)
-        where TObject : notnull, IDataTransferObject
+        where TObject : IDataTransferObject
     {
         ValueTask<MemoryOwner<byte>> result;
 
@@ -287,6 +287,6 @@ static async ValueTask<MemoryOwner<byte>> BufferizeAsync(TObject dto, MemoryAllo
     /// <returns>The converted DTO content.</returns>
     /// <exception cref="OperationCanceledException">The operation has been canceled.</exception>
     public static ValueTask<TResult> TransformAsync<TResult, TObject>(this TObject dto, Func<IAsyncBinaryReader, CancellationToken, ValueTask<TResult>> transformation, CancellationToken token = default)
-        where TObject : notnull, IDataTransferObject
+        where TObject : IDataTransferObject
         => dto.TransformAsync<TResult, DelegatingDecoder<TResult>>(new DelegatingDecoder<TResult>(transformation), token);
 }

src/DotNext.IO/IO/EncodingTextWriter.cs

@@ -22,7 +22,7 @@ public override void Write(ReadOnlySpan<char> chars)
         => Encoding.GetBytes(chars, writer);
 
     private void WriteFormattable<T>(T value)
-        where T : notnull, ISpanFormattable
+        where T : ISpanFormattable
     {
         var writer = new BufferWriterSlim<char>(stackalloc char[ConversionBufferSize]);
         try

src/DotNext.IO/IO/FileBufferingWriter.cs

@@ -71,7 +71,7 @@ public override Span<byte> GetSpan()
 
         public override Memory<byte> Memory => CreateMemory(length);
 
-        public override MemoryHandle Pin(int elementIndex)
+        public override MemoryHandle Pin(int elementIndex = 0)
         {
             ObjectDisposedException.ThrowIf(ptr is null, this);
             return new(Unsafe.Add<byte>(ptr, elementIndex));
@@ -117,7 +117,7 @@ public override Span<byte> GetSpan()
 
         public override Memory<byte> Memory => memory;
 
-        public override MemoryHandle Pin(int elementIndex)
+        public override MemoryHandle Pin(int elementIndex = 0)
             => memory.Slice(elementIndex).Pin();
 
         public override void Unpin()
@@ -392,79 +392,79 @@ private void PersistBuffer(bool flushToDisk)
     }
 
     /// <inheritdoc/>
-    public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken token = default)
+    public override ValueTask WriteAsync(ReadOnlyMemory<byte> input, CancellationToken token = default)
     {
         if (IsReading)
             return ValueTask.FromException(new InvalidOperationException(ExceptionMessages.WriterInReadMode));
 
-        switch (PrepareMemory(buffer.Length, out var output))
+        switch (PrepareMemory(input.Length, out var output))
         {
             default:
                 return ValueTask.CompletedTask;
             case MemoryEvaluationResult.Success:
-                buffer.CopyTo(output);
-                position += buffer.Length;
+                input.CopyTo(output);
+                position += input.Length;
                 goto default;
             case MemoryEvaluationResult.PersistExistingBuffer:
-                return PersistExistingBufferAsync(buffer, token);
+                return PersistExistingBufferAsync(input, token);
             case MemoryEvaluationResult.PersistAll:
-                return PersistAllAsync(buffer, token);
+                return PersistAllAsync(input, token);
         }
     }
 
-    private ValueTask PersistExistingBufferAsync(ReadOnlyMemory<byte> buffer, CancellationToken token)
+    private ValueTask PersistExistingBufferAsync(ReadOnlyMemory<byte> input, CancellationToken token)
     {
         Debug.Assert(HasBufferedData);
 
         EnsureBackingStore();
-        secondBuffer = buffer;
+        secondBuffer = input;
         return Submit(RandomAccess.WriteAsync(fileBackend, WrittenMemory, filePosition, token), writeAndCopyCallback);
     }
 
-    private ValueTask PersistAllAsync(ReadOnlyMemory<byte> buffer, CancellationToken token)
+    private ValueTask PersistAllAsync(ReadOnlyMemory<byte> input, CancellationToken token)
     {
         EnsureBackingStore();
 
         ValueTask task;
         if (HasBufferedData)
         {
-            secondBuffer = buffer;
+            secondBuffer = input;
             task = RandomAccess.WriteAsync(fileBackend, (IReadOnlyList<ReadOnlyMemory<byte>>)this.As<IDynamicInterfaceCastable>(), filePosition, token);
         }
         else
         {
-            position = buffer.Length;
-            task = RandomAccess.WriteAsync(fileBackend, buffer, filePosition, token);
+            position = input.Length;
+            task = RandomAccess.WriteAsync(fileBackend, input, filePosition, token);
         }
 
         return Submit(task, writeCallback);
     }
 
-    /// <inheritdoc/>
-    public override void Write(ReadOnlySpan<byte> buffer)
+    /// <inheritdoc cref="Stream.Write(ReadOnlySpan{byte})"/>
+    public override void Write(ReadOnlySpan<byte> input)
     {
         if (IsReading)
             throw new InvalidOperationException(ExceptionMessages.WriterInReadMode);
 
-        switch (PrepareMemory(buffer.Length, out var output))
+        switch (PrepareMemory(input.Length, out var output))
         {
             case MemoryEvaluationResult.Success:
-                buffer.CopyTo(output.Span);
-                position += buffer.Length;
+                input.CopyTo(output.Span);
+                position += input.Length;
                 break;
             case MemoryEvaluationResult.PersistExistingBuffer:
                 PersistBuffer(flushToDisk: false);
-                buffer.CopyTo(this.buffer.Span);
-                position = buffer.Length;
+                input.CopyTo(this.buffer.Span);
+                position = input.Length;
                 break;
             case MemoryEvaluationResult.PersistAll:
                 if (HasBufferedData)
                     PersistBuffer(flushToDisk: false);
                 else
                     EnsureBackingStore();
 
-                RandomAccess.Write(fileBackend, buffer, filePosition);
-                filePosition += buffer.Length;
+                RandomAccess.Write(fileBackend, input, filePosition);
+                filePosition += input.Length;
                 break;
         }
     }
@@ -473,28 +473,28 @@ public override void Write(ReadOnlySpan<byte> buffer)
     private void EnsureBackingStore() => fileBackend ??= fileProvider.CreateBackingFileHandle(position, out fileName);
 
     /// <inheritdoc/>
-    public override void Write(byte[] buffer, int offset, int count)
+    public override void Write(byte[] data, int offset, int count)
     {
-        ValidateBufferArguments(buffer, offset, count);
-        Write(new ReadOnlySpan<byte>(buffer, offset, count));
+        ValidateBufferArguments(data, offset, count);
+        Write(new ReadOnlySpan<byte>(data, offset, count));
     }
 
     /// <inheritdoc/>
-    public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken token)
-        => WriteAsync(new ReadOnlyMemory<byte>(buffer, offset, count), token).AsTask();
+    public override Task WriteAsync(byte[] data, int offset, int count, CancellationToken token)
+        => WriteAsync(new ReadOnlyMemory<byte>(data, offset, count), token).AsTask();
 
     /// <inheritdoc/>
     public override void WriteByte(byte value)
         => Write(new(ref value));
 
     /// <inheritdoc/>
-    public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback? callback, object? state)
-        => TaskToAsyncResult.Begin(WriteAsync(buffer, offset, count), callback, state);
+    public override IAsyncResult BeginWrite(byte[] data, int offset, int count, AsyncCallback? callback, object? state)
+        => TaskToAsyncResult.Begin(WriteAsync(data, offset, count), callback, state);
 
     /// <inheritdoc/>
     public override void EndWrite(IAsyncResult ar) => TaskToAsyncResult.End(ar);
 
-    /// <inheritdoc/>
+    /// <inheritdoc cref="Stream.Flush()"/>
     public override void Flush() => Flush(flushToDisk: false);
 
     /// <summary>
@@ -553,7 +553,7 @@ public ValueTask FlushAsync(bool flushToDisk, CancellationToken token = default)
         return result;
     }
 
-    /// <inheritdoc/>
+    /// <inheritdoc cref="Stream.FlushAsync(CancellationToken)"/>
     public override Task FlushAsync(CancellationToken token)
         => FlushAsync(flushToDisk: false, token).AsTask();
 
@@ -562,23 +562,23 @@ public override int ReadByte()
         => throw new NotSupportedException();
 
     /// <inheritdoc/>
-    public override int Read(byte[] buffer, int offset, int count)
+    public override int Read(byte[] data, int offset, int count)
         => throw new NotSupportedException();
 
     /// <inheritdoc/>
-    public override int Read(Span<byte> buffer)
+    public override int Read(Span<byte> data)
         => throw new NotSupportedException();
 
     /// <inheritdoc/>
-    public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken token)
+    public override Task<int> ReadAsync(byte[] data, int offset, int count, CancellationToken token)
         => Task.FromException<int>(new NotSupportedException());
 
     /// <inheritdoc/>
-    public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken token)
+    public override ValueTask<int> ReadAsync(Memory<byte> data, CancellationToken token = default)
         => ValueTask.FromException<int>(new NotSupportedException());
 
     /// <inheritdoc/>
-    public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback? callback, object? state)
+    public override IAsyncResult BeginRead(byte[] data, int offset, int count, AsyncCallback? callback, object? state)
         => throw new NotSupportedException();
 
     /// <inheritdoc/>
@@ -599,15 +599,15 @@ public override void SetLength(long value)
     /// <returns>The task representing asynchronous execution of this method.</returns>
     /// <exception cref="OperationCanceledException">The operation has been canceled.</exception>
     public async Task CopyToAsync<TConsumer>(TConsumer consumer, int bufferSize, CancellationToken token)
-        where TConsumer : notnull, ISupplier<ReadOnlyMemory<byte>, CancellationToken, ValueTask>
+        where TConsumer : ISupplier<ReadOnlyMemory<byte>, CancellationToken, ValueTask>
     {
         ArgumentOutOfRangeException.ThrowIfNegativeOrZero(bufferSize);
 
         if (fileBackend is not null)
         {
             using var buffer = allocator.AllocateAtLeast(bufferSize);
             int count;
-            for (long offset = 0L; (count = await RandomAccess.ReadAsync(fileBackend, buffer.Memory, offset, token).ConfigureAwait(false)) > 0; offset += count)
+            for (var offset = 0L; (count = await RandomAccess.ReadAsync(fileBackend, buffer.Memory, offset, token).ConfigureAwait(false)) > 0; offset += count)
                 await consumer.Invoke(buffer.Memory.Slice(0, count), token).ConfigureAwait(false);
         }
 
@@ -628,13 +628,13 @@ ValueTask IGrowableBuffer<byte>.CopyToAsync<TConsumer>(TConsumer consumer, Cance
     /// <param name="token">The token that can be used to cancel the operation.</param>
     /// <exception cref="OperationCanceledException">The operation has been canceled.</exception>
     public void CopyTo<TConsumer>(TConsumer consumer, int bufferSize, CancellationToken token)
-        where TConsumer : notnull, IReadOnlySpanConsumer<byte>
+        where TConsumer : IReadOnlySpanConsumer<byte>
     {
         if (fileBackend is not null)
         {
             using var buffer = allocator.AllocateAtLeast(bufferSize);
             int count;
-            for (long offset = 0L; (count = RandomAccess.Read(fileBackend, buffer.Span, offset)) > 0; offset += count, token.ThrowIfCancellationRequested())
+            for (var offset = 0L; (count = RandomAccess.Read(fileBackend, buffer.Span, offset)) > 0; offset += count, token.ThrowIfCancellationRequested())
                 consumer.Invoke(buffer.Span.Slice(0, count));
         }