Enable CA1844 (#39634)

Contributes to #24055
Fixes #39555

Author: pranavkm

.editorconfig

@@ -166,6 +166,9 @@ dotnet_diagnostic.CA1842.severity = warning
 # CA1843: Do not use 'WaitAll' with a single task
 dotnet_diagnostic.CA1843.severity = warning
 
+# CA1844: Provide memory-based overrides of async methods when subclassing 'Stream'
+dotnet_diagnostic.CA1844.severity = warning
+
 # CA1845: Use span-based 'string.Concat'
 dotnet_diagnostic.CA1845.severity = warning
 

src/Components/Shared/src/ArrayBuilder.cs

@@ -76,10 +76,13 @@ public int Append(in T item)
     }
 
     internal int Append(T[] source, int startIndex, int length)
+        => Append(source.AsSpan(startIndex, length));
+
+    internal int Append(ReadOnlySpan<T> source)
     {
         // Expand storage if needed. Using same doubling approach as would
         // be used if you inserted the items one-by-one.
-        var requiredCapacity = _itemsInUse + length;
+        var requiredCapacity = _itemsInUse + source.Length;
         if (_items.Length < requiredCapacity)
         {
             var candidateCapacity = Math.Max(_items.Length * 2, _minCapacity);
@@ -91,9 +94,9 @@ internal int Append(T[] source, int startIndex, int length)
             GrowBuffer(candidateCapacity);
         }
 
-        Array.Copy(source, startIndex, _items, _itemsInUse, length);
+        source.CopyTo(_items.AsSpan(_itemsInUse));
         var startIndexOfAppendedItems = _itemsInUse;
-        _itemsInUse += length;
+        _itemsInUse += source.Length;
         return startIndexOfAppendedItems;
     }
 

src/Components/Shared/src/ArrayBuilderMemoryStream.cs

@@ -51,6 +51,9 @@ public override int Read(byte[] buffer, int offset, int count)
     public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
         => throw new NotSupportedException();
 
+    public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken)
+        => throw new NotSupportedException();
+
     /// <inheritdoc />
     public override void Write(byte[] buffer, int offset, int count)
     {
@@ -59,6 +62,17 @@ public override void Write(byte[] buffer, int offset, int count)
         ArrayBuilder.Append(buffer, offset, count);
     }
 
+    public override void Write(ReadOnlySpan<byte> buffer)
+    {
+        ArrayBuilder.Append(buffer);
+    }
+
+    public override ValueTask WriteAsync(ReadOnlyMemory<byte> memory, CancellationToken cancellationToken)
+    {
+        ArrayBuilder.Append(memory.Span);
+        return default;
+    }
+
     /// <inheritdoc />
     public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
     {

src/Hosting/TestHost/src/ResponseBodyReaderStream.cs

@@ -57,16 +57,24 @@ public override long Position
 
     public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken) => throw new NotSupportedException();
 
+    public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken) => throw new NotSupportedException();
+
     #endregion NotSupported
 
     public override int Read(byte[] buffer, int offset, int count)
     {
         return ReadAsync(buffer, offset, count, CancellationToken.None).GetAwaiter().GetResult();
     }
 
-    public override async Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+    public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
     {
         VerifyBuffer(buffer, offset, count);
+
+        return ReadAsync(buffer.AsMemory(offset, count), cancellationToken).AsTask();
+    }
+
+    public override async ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default)
+    {
         CheckAborted();
 
         if (_readerComplete)
@@ -90,9 +98,9 @@ public override async Task<int> ReadAsync(byte[] buffer, int offset, int count,
         }
 
         var readableBuffer = result.Buffer;
-        var actual = Math.Min(readableBuffer.Length, count);
+        var actual = Math.Min(readableBuffer.Length, buffer.Length);
         readableBuffer = readableBuffer.Slice(0, actual);
-        readableBuffer.CopyTo(new Span<byte>(buffer, offset, count));
+        readableBuffer.CopyTo(buffer.Span);
         _pipe.Reader.AdvanceTo(readableBuffer.End);
         return (int)actual;
     }

src/Hosting/TestHost/src/ResponseBodyWriterStream.cs

@@ -69,4 +69,9 @@ public override async Task WriteAsync(byte[] buffer, int offset, int count, Canc
     {
         await _responseWriter.WriteAsync(new ReadOnlyMemory<byte>(buffer, offset, count), cancellationToken);
     }
+
+    public override async ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken)
+    {
+        await _responseWriter.WriteAsync(buffer, cancellationToken);
+    }
 }

src/Http/Http/src/Internal/ReferenceReadStream.cs

@@ -123,6 +123,9 @@ public override Task WriteAsync(byte[] buffer, int offset, int count, Cancellati
         throw new NotSupportedException();
     }
 
+    public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken)
+        => throw new NotSupportedException();
+
     public override void SetLength(long value)
     {
         throw new NotSupportedException();

src/Http/WebUtilities/src/BufferedReadStream.cs

@@ -189,6 +189,12 @@ public override void Write(byte[] buffer, int offset, int count)
         _inner.Write(buffer, offset, count);
     }
 
+    /// <inheritdoc/>
+    public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken)
+    {
+        return _inner.WriteAsync(buffer, cancellationToken);
+    }
+
     /// <inheritdoc/>
     public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
     {

src/Http/WebUtilities/src/FileBufferingReadStream.cs

@@ -402,6 +402,12 @@ public override void Write(byte[] buffer, int offset, int count)
         throw new NotSupportedException();
     }
 
+    /// <inheritdoc/>
+    public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken)
+    {
+        throw new NotSupportedException();
+    }
+
     /// <inheritdoc/>
     public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
     {

src/Http/WebUtilities/src/FileBufferingWriteStream.cs

@@ -101,6 +101,10 @@ public override int Read(byte[] buffer, int offset, int count)
     public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
         => throw new NotSupportedException();
 
+    /// <inheritdoc/>
+    public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken)
+        => throw new NotSupportedException();
+
     /// <inheritdoc />
     public override void Write(byte[] buffer, int offset, int count)
     {

src/Http/WebUtilities/src/MultipartReaderStream.cs

@@ -123,6 +123,11 @@ public override void Write(byte[] buffer, int offset, int count)
         throw new NotSupportedException();
     }
 
+    public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default)
+    {
+        throw new NotSupportedException();
+    }
+
     public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
     {
         throw new NotSupportedException();
@@ -207,7 +212,10 @@ public override int Read(byte[] buffer, int offset, int count)
         return UpdatePosition(read);
     }
 
-    public override async Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+    public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        => ReadAsync(buffer.AsMemory(offset, count), cancellationToken).AsTask();
+
+    public override async ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken)
     {
         if (_finished)
         {
@@ -231,7 +239,9 @@ public override async Task<int> ReadAsync(byte[] buffer, int offset, int count,
             if (matchOffset > bufferedData.Offset)
             {
                 // Sync, it's already buffered
-                read = _innerStream.Read(buffer, offset, Math.Min(count, matchOffset - bufferedData.Offset));
+                var slice = buffer[..Math.Min(buffer.Length, matchOffset - bufferedData.Offset)];
+
+                read = _innerStream.Read(slice.Span);
                 return UpdatePosition(read);
             }
 
@@ -259,7 +269,7 @@ public override async Task<int> ReadAsync(byte[] buffer, int offset, int count,
         }
 
         // No possible boundary match within the buffered data, return the data from the buffer.
-        read = _innerStream.Read(buffer, offset, Math.Min(count, bufferedData.Count));
+        read = _innerStream.Read(buffer.Span[..Math.Min(buffer.Length, bufferedData.Count)]);
         return UpdatePosition(read);
     }