Rename new Stream.Read/Write{Async} Span/Memory source/Destination arguments to buffer (#17141)

Anipik · stephentoub · commit f819fdcabea2 · 2018-03-23T08:43:47.000-04:00
* changed to buffer

* More Common changes

* fixed

* another fix
diff --git a/src/mscorlib/shared/System/IO/FileStream.cs b/src/mscorlib/shared/System/IO/FileStream.cs
@@ -304,15 +304,15 @@ public override int Read(byte[] array, int offset, int count)
                 ReadSpan(new Span<byte>(array, offset, count));
         }
 
-        public override int Read(Span<byte> destination)
+        public override int Read(Span<byte> buffer)
         {
             if (GetType() == typeof(FileStream) && !_useAsyncIO)
             {
                 if (_fileHandle.IsClosed)
                 {
                     throw Error.GetFileNotOpen();
                 }
-                return ReadSpan(destination);
+                return ReadSpan(buffer);
             }
             else
             {
@@ -322,7 +322,7 @@ public override int Read(Span<byte> destination)
                 // of Read(byte[],int,int) overload.  Or if the stream is in async mode, we can't call the
                 // synchronous ReadSpan, so we similarly call the base Read, which will turn delegate to
                 // Read(byte[],int,int), which will do the right thing if we're in async mode.
-                return base.Read(destination);
+                return base.Read(buffer);
             }
         }
 
@@ -355,14 +355,14 @@ public override Task<int> ReadAsync(byte[] buffer, int offset, int count, Cancel
             return ReadAsyncTask(buffer, offset, count, cancellationToken);
         }
 
-        public override ValueTask<int> ReadAsync(Memory<byte> destination, CancellationToken cancellationToken = default(CancellationToken))
+        public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))
         {
             if (!_useAsyncIO || GetType() != typeof(FileStream))
             {
                 // If we're not using async I/O, delegate to the base, which will queue a call to Read.
                 // Or if this isn't a concrete FileStream, a derived type may have overridden ReadAsync(byte[],...),
                 // which was introduced first, so delegate to the base which will delegate to that.
-                return base.ReadAsync(destination, cancellationToken);
+                return base.ReadAsync(buffer, cancellationToken);
             }
 
             if (cancellationToken.IsCancellationRequested)
@@ -375,7 +375,7 @@ public override Task<int> ReadAsync(byte[] buffer, int offset, int count, Cancel
                 throw Error.GetFileNotOpen();
             }
 
-            Task<int> t = ReadAsyncInternal(destination, cancellationToken, out int synchronousResult);
+            Task<int> t = ReadAsyncInternal(buffer, cancellationToken, out int synchronousResult);
             return t != null ?
                 new ValueTask<int>(t) :
                 new ValueTask<int>(synchronousResult);
@@ -412,15 +412,15 @@ public override void Write(byte[] array, int offset, int count)
             }
         }
 
-        public override void Write(ReadOnlySpan<byte> destination)
+        public override void Write(ReadOnlySpan<byte> buffer)
         {
             if (GetType() == typeof(FileStream) && !_useAsyncIO)
             {
                 if (_fileHandle.IsClosed)
                 {
                     throw Error.GetFileNotOpen();
                 }
-                WriteSpan(destination);
+                WriteSpan(buffer);
             }
             else
             {
@@ -430,7 +430,7 @@ public override void Write(ReadOnlySpan<byte> destination)
                 // of Write(byte[],int,int) overload.  Or if the stream is in async mode, we can't call the
                 // synchronous WriteSpan, so we similarly call the base Write, which will turn delegate to
                 // Write(byte[],int,int), which will do the right thing if we're in async mode.
-                base.Write(destination);
+                base.Write(buffer);
             }
         }
 
@@ -461,14 +461,14 @@ public override Task WriteAsync(byte[] buffer, int offset, int count, Cancellati
             return WriteAsyncInternal(new ReadOnlyMemory<byte>(buffer, offset, count), cancellationToken).AsTask();
         }
 
-        public override ValueTask WriteAsync(ReadOnlyMemory<byte> source, CancellationToken cancellationToken = default(CancellationToken))
+        public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))
         {
             if (!_useAsyncIO || GetType() != typeof(FileStream))
             {
                 // If we're not using async I/O, delegate to the base, which will queue a call to Write.
                 // Or if this isn't a concrete FileStream, a derived type may have overridden WriteAsync(byte[],...),
                 // which was introduced first, so delegate to the base which will delegate to that.
-                return base.WriteAsync(source, cancellationToken);
+                return base.WriteAsync(buffer, cancellationToken);
             }
 
             if (cancellationToken.IsCancellationRequested)
@@ -481,7 +481,7 @@ public override Task WriteAsync(byte[] buffer, int offset, int count, Cancellati
                 throw Error.GetFileNotOpen();
             }
 
-            return WriteAsyncInternal(source, cancellationToken);
+            return WriteAsyncInternal(buffer, cancellationToken);
         }
 
         /// <summary>
diff --git a/src/mscorlib/shared/System/IO/MemoryStream.cs b/src/mscorlib/shared/System/IO/MemoryStream.cs
@@ -367,27 +367,27 @@ public override int Read(byte[] buffer, int offset, int count)
             return n;
         }
 
-        public override int Read(Span<byte> destination)
+        public override int Read(Span<byte> buffer)
         {
             if (GetType() != typeof(MemoryStream))
             {
                 // MemoryStream is not sealed, and a derived type may have overridden Read(byte[], int, int) prior
                 // to this Read(Span<byte>) overload being introduced.  In that case, this Read(Span<byte>) overload
                 // should use the behavior of Read(byte[],int,int) overload.
-                return base.Read(destination);
+                return base.Read(buffer);
             }
 
             EnsureNotClosed();
 
-            int n = Math.Min(_length - _position, destination.Length);
+            int n = Math.Min(_length - _position, buffer.Length);
             if (n <= 0)
                 return 0;
 
             // TODO https://github.com/dotnet/coreclr/issues/15076:
             // Read(byte[], int, int) has an n <= 8 optimization, presumably based
             // on benchmarking.  Determine if/where such a cut-off is here and add
             // an equivalent optimization if necessary.
-            new Span<byte>(_buffer, _position, n).CopyTo(destination);
+            new Span<byte>(_buffer, _position, n).CopyTo(buffer);
 
             _position += n;
             return n;
@@ -426,7 +426,7 @@ public override Task<int> ReadAsync(Byte[] buffer, int offset, int count, Cancel
             }
         }
 
-        public override ValueTask<int> ReadAsync(Memory<byte> destination, CancellationToken cancellationToken = default(CancellationToken))
+        public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))
         {
             if (cancellationToken.IsCancellationRequested)
             {
@@ -448,9 +448,9 @@ public override Task<int> ReadAsync(Byte[] buffer, int offset, int count, Cancel
                 // something other than an array and this is a MemoryStream-derived type that doesn't override Read(Span<byte>) will
                 // it then fall back to doing the ArrayPool/copy behavior.
                 return new ValueTask<int>(
-                    MemoryMarshal.TryGetArray(destination, out ArraySegment<byte> destinationArray) ?
+                    MemoryMarshal.TryGetArray(buffer, out ArraySegment<byte> destinationArray) ?
                         Read(destinationArray.Array, destinationArray.Offset, destinationArray.Count) :
-                        Read(destination.Span));
+                        Read(buffer.Span));
             }
             catch (OperationCanceledException oce)
             {
@@ -681,22 +681,22 @@ public override void Write(byte[] buffer, int offset, int count)
             _position = i;
         }
 
-        public override void Write(ReadOnlySpan<byte> source)
+        public override void Write(ReadOnlySpan<byte> buffer)
         {
             if (GetType() != typeof(MemoryStream))
             {
                 // MemoryStream is not sealed, and a derived type may have overridden Write(byte[], int, int) prior
                 // to this Write(Span<byte>) overload being introduced.  In that case, this Write(Span<byte>) overload
                 // should use the behavior of Write(byte[],int,int) overload.
-                base.Write(source);
+                base.Write(buffer);
                 return;
             }
 
             EnsureNotClosed();
             EnsureWriteable();
 
             // Check for overflow
-            int i = _position + source.Length;
+            int i = _position + buffer.Length;
             if (i < 0)
                 throw new IOException(SR.IO_StreamTooLong);
 
@@ -718,7 +718,7 @@ public override void Write(ReadOnlySpan<byte> source)
                 _length = i;
             }
 
-            source.CopyTo(new Span<byte>(_buffer, _position, source.Length));
+            buffer.CopyTo(new Span<byte>(_buffer, _position, buffer.Length));
             _position = i;
         }
 
@@ -752,7 +752,7 @@ public override Task WriteAsync(Byte[] buffer, int offset, int count, Cancellati
             }
         }
 
-        public override ValueTask WriteAsync(ReadOnlyMemory<byte> source, CancellationToken cancellationToken = default(CancellationToken))
+        public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))
         {
             if (cancellationToken.IsCancellationRequested)
             {
@@ -763,13 +763,13 @@ public override Task WriteAsync(Byte[] buffer, int offset, int count, Cancellati
             {
                 // See corresponding comment in ReadAsync for why we don't just always use Write(ReadOnlySpan<byte>).
                 // Unlike ReadAsync, we could delegate to WriteAsync(byte[], ...) here, but we don't for consistency.
-                if (MemoryMarshal.TryGetArray(source, out ArraySegment<byte> sourceArray))
+                if (MemoryMarshal.TryGetArray(buffer, out ArraySegment<byte> sourceArray))
                 {
                     Write(sourceArray.Array, sourceArray.Offset, sourceArray.Count);
                 }
                 else
                 {
-                    Write(source.Span);
+                    Write(buffer.Span);
                 }
                 return default;
             }
diff --git a/src/mscorlib/shared/System/IO/PinnedBufferMemoryStream.cs b/src/mscorlib/shared/System/IO/PinnedBufferMemoryStream.cs
@@ -38,9 +38,9 @@ internal PinnedBufferMemoryStream(byte[] array)
                 Initialize(ptr, len, len, FileAccess.Read);
         }
 
-        public override int Read(Span<byte> destination) => ReadCore(destination);
+        public override int Read(Span<byte> buffer) => ReadCore(buffer);
 
-        public override void Write(ReadOnlySpan<byte> source) => WriteCore(source);
+        public override void Write(ReadOnlySpan<byte> buffer) => WriteCore(buffer);
 
         ~PinnedBufferMemoryStream()
         {
diff --git a/src/mscorlib/shared/System/IO/UnmanagedMemoryStream.cs b/src/mscorlib/shared/System/IO/UnmanagedMemoryStream.cs
@@ -379,22 +379,22 @@ public override int Read(byte[] buffer, int offset, int count)
             return ReadCore(new Span<byte>(buffer, offset, count));
         }
 
-        public override int Read(Span<byte> destination)
+        public override int Read(Span<byte> buffer)
         {
             if (GetType() == typeof(UnmanagedMemoryStream))
             {
-                return ReadCore(destination);
+                return ReadCore(buffer);
             }
             else
             {
                 // UnmanagedMemoryStream is not sealed, and a derived type may have overridden Read(byte[], int, int) prior
                 // to this Read(Span<byte>) overload being introduced.  In that case, this Read(Span<byte>) overload
                 // should use the behavior of Read(byte[],int,int) overload.
-                return base.Read(destination);
+                return base.Read(buffer);
             }
         }
 
-        internal int ReadCore(Span<byte> destination)
+        internal int ReadCore(Span<byte> buffer)
         {
             EnsureNotClosed();
             EnsureReadable();
@@ -403,7 +403,7 @@ internal int ReadCore(Span<byte> destination)
             // changes our position after we decide we can read some bytes.
             long pos = Interlocked.Read(ref _position);
             long len = Interlocked.Read(ref _length);
-            long n = Math.Min(len - pos, destination.Length);
+            long n = Math.Min(len - pos, buffer.Length);
             if (n <= 0)
             {
                 return 0;
@@ -418,7 +418,7 @@ internal int ReadCore(Span<byte> destination)
 
             unsafe
             {
-                fixed (byte* pBuffer = &MemoryMarshal.GetReference(destination))
+                fixed (byte* pBuffer = &MemoryMarshal.GetReference(buffer))
                 {
                     if (_buffer != null)
                     {
@@ -486,9 +486,9 @@ public override Task<Int32> ReadAsync(Byte[] buffer, Int32 offset, Int32 count,
         /// <summary>
         /// Reads bytes from stream and puts them into the buffer
         /// </summary>
-        /// <param name="destination">Buffer to read the bytes to.</param>
+        /// <param name="buffer">Buffer to read the bytes to.</param>
         /// <param name="cancellationToken">Token that can be used to cancel this operation.</param>
-        public override ValueTask<int> ReadAsync(Memory<byte> destination, CancellationToken cancellationToken = default(CancellationToken))
+        public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))
         {
             if (cancellationToken.IsCancellationRequested)
             {
@@ -510,9 +510,9 @@ public override Task<Int32> ReadAsync(Byte[] buffer, Int32 offset, Int32 count,
                 // something other than an array and this is an UnmanagedMemoryStream-derived type that doesn't override Read(Span<byte>) will
                 // it then fall back to doing the ArrayPool/copy behavior.
                 return new ValueTask<int>(
-                    MemoryMarshal.TryGetArray(destination, out ArraySegment<byte> destinationArray) ?
+                    MemoryMarshal.TryGetArray(buffer, out ArraySegment<byte> destinationArray) ?
                         Read(destinationArray.Array, destinationArray.Offset, destinationArray.Count) :
-                        Read(destination.Span));
+                        Read(buffer.Span));
             }
             catch (Exception ex)
             {
@@ -659,29 +659,29 @@ public override void Write(byte[] buffer, int offset, int count)
             WriteCore(new Span<byte>(buffer, offset, count));
         }
 
-        public override void Write(ReadOnlySpan<byte> source)
+        public override void Write(ReadOnlySpan<byte> buffer)
         {
             if (GetType() == typeof(UnmanagedMemoryStream))
             {
-                WriteCore(source);
+                WriteCore(buffer);
             }
             else
             {
                 // UnmanagedMemoryStream is not sealed, and a derived type may have overridden Write(byte[], int, int) prior
                 // to this Write(Span<byte>) overload being introduced.  In that case, this Write(Span<byte>) overload
                 // should use the behavior of Write(byte[],int,int) overload.
-                base.Write(source);
+                base.Write(buffer);
             }
         }
 
-        internal unsafe void WriteCore(ReadOnlySpan<byte> source)
+        internal unsafe void WriteCore(ReadOnlySpan<byte> buffer)
         {
             EnsureNotClosed();
             EnsureWriteable();
 
             long pos = Interlocked.Read(ref _position);  // Use a local to avoid a race condition
             long len = Interlocked.Read(ref _length);
-            long n = pos + source.Length;
+            long n = pos + buffer.Length;
             // Check for overflow
             if (n < 0)
             {
@@ -709,12 +709,12 @@ internal unsafe void WriteCore(ReadOnlySpan<byte> source)
                 }
             }
 
-            fixed (byte* pBuffer = &MemoryMarshal.GetReference(source))
+            fixed (byte* pBuffer = &MemoryMarshal.GetReference(buffer))
             {
                 if (_buffer != null)
                 {
                     long bytesLeft = _capacity - pos;
-                    if (bytesLeft < source.Length)
+                    if (bytesLeft < buffer.Length)
                     {
                         throw new ArgumentException(SR.Arg_BufferTooSmall);
                     }
@@ -724,7 +724,7 @@ internal unsafe void WriteCore(ReadOnlySpan<byte> source)
                     try
                     {
                         _buffer.AcquirePointer(ref pointer);
-                        Buffer.Memcpy(pointer + pos + _offset, pBuffer, source.Length);
+                        Buffer.Memcpy(pointer + pos + _offset, pBuffer, buffer.Length);
                     }
                     finally
                     {
@@ -736,7 +736,7 @@ internal unsafe void WriteCore(ReadOnlySpan<byte> source)
                 }
                 else
                 {
-                    Buffer.Memcpy(_mem + pos, pBuffer, source.Length);
+                    Buffer.Memcpy(_mem + pos, pBuffer, buffer.Length);
                 }
             }
 
@@ -783,7 +783,7 @@ public override Task WriteAsync(Byte[] buffer, Int32 offset, Int32 count, Cancel
         /// </summary>
         /// <param name="buffer">Buffer that will be written.</param>
         /// <param name="cancellationToken">Token that can be used to cancel the operation.</param>
-        public override ValueTask WriteAsync(ReadOnlyMemory<byte> source, CancellationToken cancellationToken = default(CancellationToken))
+        public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))
         {
             if (cancellationToken.IsCancellationRequested)
             {
@@ -794,13 +794,13 @@ public override Task WriteAsync(Byte[] buffer, Int32 offset, Int32 count, Cancel
             {
                 // See corresponding comment in ReadAsync for why we don't just always use Write(ReadOnlySpan<byte>).
                 // Unlike ReadAsync, we could delegate to WriteAsync(byte[], ...) here, but we don't for consistency.
-                if (MemoryMarshal.TryGetArray(source, out ArraySegment<byte> sourceArray))
+                if (MemoryMarshal.TryGetArray(buffer, out ArraySegment<byte> sourceArray))
                 {
                     Write(sourceArray.Array, sourceArray.Offset, sourceArray.Count);
                 }
                 else
                 {
-                    Write(source.Span);
+                    Write(buffer.Span);
                 }
                 return default;
             }
diff --git a/src/mscorlib/shared/System/IO/UnmanagedMemoryStreamWrapper.cs b/src/mscorlib/shared/System/IO/UnmanagedMemoryStreamWrapper.cs
diff --git a/src/mscorlib/src/System/IO/Stream.cs b/src/mscorlib/src/System/IO/Stream.cs

Original file line number	Diff line number	Diff line change
`@@ -304,15 +304,15 @@ public override int Read(byte[] array, int offset, int count)`
`304`	`304`	`ReadSpan(new Span<byte>(array, offset, count));`
`305`	`305`	`}`
`306`	`306`
`307`		`- public override int Read(Span<byte> destination)`
	`307`	`+ public override int Read(Span<byte> buffer)`
`308`	`308`	`{`
`309`	`309`	`if (GetType() == typeof(FileStream) && !_useAsyncIO)`
`310`	`310`	`{`
`311`	`311`	`if (_fileHandle.IsClosed)`
`312`	`312`	`{`
`313`	`313`	`throw Error.GetFileNotOpen();`
`314`	`314`	`}`
`315`		`- return ReadSpan(destination);`
	`315`	`+ return ReadSpan(buffer);`
`316`	`316`	`}`
`317`	`317`	`else`
`318`	`318`	`{`
`@@ -322,7 +322,7 @@ public override int Read(Span<byte> destination)`
`322`	`322`	`// of Read(byte[],int,int) overload. Or if the stream is in async mode, we can't call the`
`323`	`323`	`// synchronous ReadSpan, so we similarly call the base Read, which will turn delegate to`
`324`	`324`	`// Read(byte[],int,int), which will do the right thing if we're in async mode.`
`325`		`- return base.Read(destination);`
	`325`	`+ return base.Read(buffer);`
`326`	`326`	`}`
`327`	`327`	`}`
`328`	`328`
`@@ -355,14 +355,14 @@ public override Task<int> ReadAsync(byte[] buffer, int offset, int count, Cancel`
`355`	`355`	`return ReadAsyncTask(buffer, offset, count, cancellationToken);`
`356`	`356`	`}`
`357`	`357`
`358`		`- public override ValueTask<int> ReadAsync(Memory<byte> destination, CancellationToken cancellationToken = default(CancellationToken))`
	`358`	`+ public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))`
`359`	`359`	`{`
`360`	`360`	`if (!_useAsyncIO \|\| GetType() != typeof(FileStream))`
`361`	`361`	`{`
`362`	`362`	`// If we're not using async I/O, delegate to the base, which will queue a call to Read.`
`363`	`363`	`// Or if this isn't a concrete FileStream, a derived type may have overridden ReadAsync(byte[],...),`
`364`	`364`	`// which was introduced first, so delegate to the base which will delegate to that.`
`365`		`- return base.ReadAsync(destination, cancellationToken);`
	`365`	`+ return base.ReadAsync(buffer, cancellationToken);`
`366`	`366`	`}`
`367`	`367`
`368`	`368`	`if (cancellationToken.IsCancellationRequested)`
`@@ -375,7 +375,7 @@ public override Task<int> ReadAsync(byte[] buffer, int offset, int count, Cancel`
`375`	`375`	`throw Error.GetFileNotOpen();`
`376`	`376`	`}`
`377`	`377`
`378`		`- Task<int> t = ReadAsyncInternal(destination, cancellationToken, out int synchronousResult);`
	`378`	`+ Task<int> t = ReadAsyncInternal(buffer, cancellationToken, out int synchronousResult);`
`379`	`379`	`return t != null ?`
`380`	`380`	`new ValueTask<int>(t) :`
`381`	`381`	`new ValueTask<int>(synchronousResult);`
`@@ -412,15 +412,15 @@ public override void Write(byte[] array, int offset, int count)`
`412`	`412`	`}`
`413`	`413`	`}`
`414`	`414`
`415`		`- public override void Write(ReadOnlySpan<byte> destination)`
	`415`	`+ public override void Write(ReadOnlySpan<byte> buffer)`
`416`	`416`	`{`
`417`	`417`	`if (GetType() == typeof(FileStream) && !_useAsyncIO)`
`418`	`418`	`{`
`419`	`419`	`if (_fileHandle.IsClosed)`
`420`	`420`	`{`
`421`	`421`	`throw Error.GetFileNotOpen();`
`422`	`422`	`}`
`423`		`- WriteSpan(destination);`
	`423`	`+ WriteSpan(buffer);`
`424`	`424`	`}`
`425`	`425`	`else`
`426`	`426`	`{`
`@@ -430,7 +430,7 @@ public override void Write(ReadOnlySpan<byte> destination)`
`430`	`430`	`// of Write(byte[],int,int) overload. Or if the stream is in async mode, we can't call the`
`431`	`431`	`// synchronous WriteSpan, so we similarly call the base Write, which will turn delegate to`
`432`	`432`	`// Write(byte[],int,int), which will do the right thing if we're in async mode.`
`433`		`- base.Write(destination);`
	`433`	`+ base.Write(buffer);`
`434`	`434`	`}`
`435`	`435`	`}`
`436`	`436`
`@@ -461,14 +461,14 @@ public override Task WriteAsync(byte[] buffer, int offset, int count, Cancellati`
`461`	`461`	`return WriteAsyncInternal(new ReadOnlyMemory<byte>(buffer, offset, count), cancellationToken).AsTask();`
`462`	`462`	`}`
`463`	`463`
`464`		`- public override ValueTask WriteAsync(ReadOnlyMemory<byte> source, CancellationToken cancellationToken = default(CancellationToken))`
	`464`	`+ public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))`
`465`	`465`	`{`
`466`	`466`	`if (!_useAsyncIO \|\| GetType() != typeof(FileStream))`
`467`	`467`	`{`
`468`	`468`	`// If we're not using async I/O, delegate to the base, which will queue a call to Write.`
`469`	`469`	`// Or if this isn't a concrete FileStream, a derived type may have overridden WriteAsync(byte[],...),`
`470`	`470`	`// which was introduced first, so delegate to the base which will delegate to that.`
`471`		`- return base.WriteAsync(source, cancellationToken);`
	`471`	`+ return base.WriteAsync(buffer, cancellationToken);`
`472`	`472`	`}`
`473`	`473`
`474`	`474`	`if (cancellationToken.IsCancellationRequested)`
`@@ -481,7 +481,7 @@ public override Task WriteAsync(byte[] buffer, int offset, int count, Cancellati`
`481`	`481`	`throw Error.GetFileNotOpen();`
`482`	`482`	`}`
`483`	`483`
`484`		`- return WriteAsyncInternal(source, cancellationToken);`
	`484`	`+ return WriteAsyncInternal(buffer, cancellationToken);`
`485`	`485`	`}`
`486`	`486`
`487`	`487`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -367,27 +367,27 @@ public override int Read(byte[] buffer, int offset, int count)`
`367`	`367`	`return n;`
`368`	`368`	`}`
`369`	`369`
`370`		`- public override int Read(Span<byte> destination)`
	`370`	`+ public override int Read(Span<byte> buffer)`
`371`	`371`	`{`
`372`	`372`	`if (GetType() != typeof(MemoryStream))`
`373`	`373`	`{`
`374`	`374`	`// MemoryStream is not sealed, and a derived type may have overridden Read(byte[], int, int) prior`
`375`	`375`	`// to this Read(Span<byte>) overload being introduced. In that case, this Read(Span<byte>) overload`
`376`	`376`	`// should use the behavior of Read(byte[],int,int) overload.`
`377`		`- return base.Read(destination);`
	`377`	`+ return base.Read(buffer);`
`378`	`378`	`}`
`379`	`379`
`380`	`380`	`EnsureNotClosed();`
`381`	`381`
`382`		`- int n = Math.Min(_length - _position, destination.Length);`
	`382`	`+ int n = Math.Min(_length - _position, buffer.Length);`
`383`	`383`	`if (n <= 0)`
`384`	`384`	`return 0;`
`385`	`385`
`386`	`386`	`// TODO https://github.com/dotnet/coreclr/issues/15076:`
`387`	`387`	`// Read(byte[], int, int) has an n <= 8 optimization, presumably based`
`388`	`388`	`// on benchmarking. Determine if/where such a cut-off is here and add`
`389`	`389`	`// an equivalent optimization if necessary.`
`390`		`- new Span<byte>(_buffer, _position, n).CopyTo(destination);`
	`390`	`+ new Span<byte>(_buffer, _position, n).CopyTo(buffer);`
`391`	`391`
`392`	`392`	`_position += n;`
`393`	`393`	`return n;`
`@@ -426,7 +426,7 @@ public override Task<int> ReadAsync(Byte[] buffer, int offset, int count, Cancel`
`426`	`426`	`}`
`427`	`427`	`}`
`428`	`428`
`429`		`- public override ValueTask<int> ReadAsync(Memory<byte> destination, CancellationToken cancellationToken = default(CancellationToken))`
	`429`	`+ public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))`
`430`	`430`	`{`
`431`	`431`	`if (cancellationToken.IsCancellationRequested)`
`432`	`432`	`{`
`@@ -448,9 +448,9 @@ public override Task<int> ReadAsync(Byte[] buffer, int offset, int count, Cancel`
`448`	`448`	`// something other than an array and this is a MemoryStream-derived type that doesn't override Read(Span<byte>) will`
`449`	`449`	`// it then fall back to doing the ArrayPool/copy behavior.`
`450`	`450`	`return new ValueTask<int>(`
`451`		`- MemoryMarshal.TryGetArray(destination, out ArraySegment<byte> destinationArray) ?`
	`451`	`+ MemoryMarshal.TryGetArray(buffer, out ArraySegment<byte> destinationArray) ?`
`452`	`452`	`Read(destinationArray.Array, destinationArray.Offset, destinationArray.Count) :`
`453`		`- Read(destination.Span));`
	`453`	`+ Read(buffer.Span));`
`454`	`454`	`}`
`455`	`455`	`catch (OperationCanceledException oce)`
`456`	`456`	`{`
`@@ -681,22 +681,22 @@ public override void Write(byte[] buffer, int offset, int count)`
`681`	`681`	`_position = i;`
`682`	`682`	`}`
`683`	`683`
`684`		`- public override void Write(ReadOnlySpan<byte> source)`
	`684`	`+ public override void Write(ReadOnlySpan<byte> buffer)`
`685`	`685`	`{`
`686`	`686`	`if (GetType() != typeof(MemoryStream))`
`687`	`687`	`{`
`688`	`688`	`// MemoryStream is not sealed, and a derived type may have overridden Write(byte[], int, int) prior`
`689`	`689`	`// to this Write(Span<byte>) overload being introduced. In that case, this Write(Span<byte>) overload`
`690`	`690`	`// should use the behavior of Write(byte[],int,int) overload.`
`691`		`- base.Write(source);`
	`691`	`+ base.Write(buffer);`
`692`	`692`	`return;`
`693`	`693`	`}`
`694`	`694`
`695`	`695`	`EnsureNotClosed();`
`696`	`696`	`EnsureWriteable();`
`697`	`697`
`698`	`698`	`// Check for overflow`
`699`		`- int i = _position + source.Length;`
	`699`	`+ int i = _position + buffer.Length;`
`700`	`700`	`if (i < 0)`
`701`	`701`	`throw new IOException(SR.IO_StreamTooLong);`
`702`	`702`
`@@ -718,7 +718,7 @@ public override void Write(ReadOnlySpan<byte> source)`
`718`	`718`	`_length = i;`
`719`	`719`	`}`
`720`	`720`
`721`		`- source.CopyTo(new Span<byte>(_buffer, _position, source.Length));`
	`721`	`+ buffer.CopyTo(new Span<byte>(_buffer, _position, buffer.Length));`
`722`	`722`	`_position = i;`
`723`	`723`	`}`
`724`	`724`
`@@ -752,7 +752,7 @@ public override Task WriteAsync(Byte[] buffer, int offset, int count, Cancellati`
`752`	`752`	`}`
`753`	`753`	`}`
`754`	`754`
`755`		`- public override ValueTask WriteAsync(ReadOnlyMemory<byte> source, CancellationToken cancellationToken = default(CancellationToken))`
	`755`	`+ public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))`
`756`	`756`	`{`
`757`	`757`	`if (cancellationToken.IsCancellationRequested)`
`758`	`758`	`{`
`@@ -763,13 +763,13 @@ public override Task WriteAsync(Byte[] buffer, int offset, int count, Cancellati`
`763`	`763`	`{`
`764`	`764`	`// See corresponding comment in ReadAsync for why we don't just always use Write(ReadOnlySpan<byte>).`
`765`	`765`	`// Unlike ReadAsync, we could delegate to WriteAsync(byte[], ...) here, but we don't for consistency.`
`766`		`- if (MemoryMarshal.TryGetArray(source, out ArraySegment<byte> sourceArray))`
	`766`	`+ if (MemoryMarshal.TryGetArray(buffer, out ArraySegment<byte> sourceArray))`
`767`	`767`	`{`
`768`	`768`	`Write(sourceArray.Array, sourceArray.Offset, sourceArray.Count);`
`769`	`769`	`}`
`770`	`770`	`else`
`771`	`771`	`{`
`772`		`- Write(source.Span);`
	`772`	`+ Write(buffer.Span);`
`773`	`773`	`}`
`774`	`774`	`return default;`
`775`	`775`	`}`
Original file line number	Diff line number	Diff line change
`@@ -38,9 +38,9 @@ internal PinnedBufferMemoryStream(byte[] array)`
`38`	`38`	`Initialize(ptr, len, len, FileAccess.Read);`
`39`	`39`	`}`
`40`	`40`
`41`		`- public override int Read(Span<byte> destination) => ReadCore(destination);`
	`41`	`+ public override int Read(Span<byte> buffer) => ReadCore(buffer);`
`42`	`42`
`43`		`- public override void Write(ReadOnlySpan<byte> source) => WriteCore(source);`
	`43`	`+ public override void Write(ReadOnlySpan<byte> buffer) => WriteCore(buffer);`
`44`	`44`
`45`	`45`	`~PinnedBufferMemoryStream()`
`46`	`46`	`{`
Original file line number	Diff line number	Diff line change
`@@ -379,22 +379,22 @@ public override int Read(byte[] buffer, int offset, int count)`
`379`	`379`	`return ReadCore(new Span<byte>(buffer, offset, count));`
`380`	`380`	`}`
`381`	`381`
`382`		`- public override int Read(Span<byte> destination)`
	`382`	`+ public override int Read(Span<byte> buffer)`
`383`	`383`	`{`
`384`	`384`	`if (GetType() == typeof(UnmanagedMemoryStream))`
`385`	`385`	`{`
`386`		`- return ReadCore(destination);`
	`386`	`+ return ReadCore(buffer);`
`387`	`387`	`}`
`388`	`388`	`else`
`389`	`389`	`{`
`390`	`390`	`// UnmanagedMemoryStream is not sealed, and a derived type may have overridden Read(byte[], int, int) prior`
`391`	`391`	`// to this Read(Span<byte>) overload being introduced. In that case, this Read(Span<byte>) overload`
`392`	`392`	`// should use the behavior of Read(byte[],int,int) overload.`
`393`		`- return base.Read(destination);`
	`393`	`+ return base.Read(buffer);`
`394`	`394`	`}`
`395`	`395`	`}`
`396`	`396`
`397`		`- internal int ReadCore(Span<byte> destination)`
	`397`	`+ internal int ReadCore(Span<byte> buffer)`
`398`	`398`	`{`
`399`	`399`	`EnsureNotClosed();`
`400`	`400`	`EnsureReadable();`
`@@ -403,7 +403,7 @@ internal int ReadCore(Span<byte> destination)`
`403`	`403`	`// changes our position after we decide we can read some bytes.`
`404`	`404`	`long pos = Interlocked.Read(ref _position);`
`405`	`405`	`long len = Interlocked.Read(ref _length);`
`406`		`- long n = Math.Min(len - pos, destination.Length);`
	`406`	`+ long n = Math.Min(len - pos, buffer.Length);`
`407`	`407`	`if (n <= 0)`
`408`	`408`	`{`
`409`	`409`	`return 0;`
`@@ -418,7 +418,7 @@ internal int ReadCore(Span<byte> destination)`
`418`	`418`
`419`	`419`	`unsafe`
`420`	`420`	`{`
`421`		`- fixed (byte* pBuffer = &MemoryMarshal.GetReference(destination))`
	`421`	`+ fixed (byte* pBuffer = &MemoryMarshal.GetReference(buffer))`
`422`	`422`	`{`
`423`	`423`	`if (_buffer != null)`
`424`	`424`	`{`
`@@ -486,9 +486,9 @@ public override Task<Int32> ReadAsync(Byte[] buffer, Int32 offset, Int32 count,`
`486`	`486`	`/// <summary>`
`487`	`487`	`/// Reads bytes from stream and puts them into the buffer`
`488`	`488`	`/// </summary>`
`489`		`- /// <param name="destination">Buffer to read the bytes to.</param>`
	`489`	`+ /// <param name="buffer">Buffer to read the bytes to.</param>`
`490`	`490`	`/// <param name="cancellationToken">Token that can be used to cancel this operation.</param>`
`491`		`- public override ValueTask<int> ReadAsync(Memory<byte> destination, CancellationToken cancellationToken = default(CancellationToken))`
	`491`	`+ public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))`
`492`	`492`	`{`
`493`	`493`	`if (cancellationToken.IsCancellationRequested)`
`494`	`494`	`{`
`@@ -510,9 +510,9 @@ public override Task<Int32> ReadAsync(Byte[] buffer, Int32 offset, Int32 count,`
`510`	`510`	`// something other than an array and this is an UnmanagedMemoryStream-derived type that doesn't override Read(Span<byte>) will`
`511`	`511`	`// it then fall back to doing the ArrayPool/copy behavior.`
`512`	`512`	`return new ValueTask<int>(`
`513`		`- MemoryMarshal.TryGetArray(destination, out ArraySegment<byte> destinationArray) ?`
	`513`	`+ MemoryMarshal.TryGetArray(buffer, out ArraySegment<byte> destinationArray) ?`
`514`	`514`	`Read(destinationArray.Array, destinationArray.Offset, destinationArray.Count) :`
`515`		`- Read(destination.Span));`
	`515`	`+ Read(buffer.Span));`
`516`	`516`	`}`
`517`	`517`	`catch (Exception ex)`
`518`	`518`	`{`
`@@ -659,29 +659,29 @@ public override void Write(byte[] buffer, int offset, int count)`
`659`	`659`	`WriteCore(new Span<byte>(buffer, offset, count));`
`660`	`660`	`}`
`661`	`661`
`662`		`- public override void Write(ReadOnlySpan<byte> source)`
	`662`	`+ public override void Write(ReadOnlySpan<byte> buffer)`
`663`	`663`	`{`
`664`	`664`	`if (GetType() == typeof(UnmanagedMemoryStream))`
`665`	`665`	`{`
`666`		`- WriteCore(source);`
	`666`	`+ WriteCore(buffer);`
`667`	`667`	`}`
`668`	`668`	`else`
`669`	`669`	`{`
`670`	`670`	`// UnmanagedMemoryStream is not sealed, and a derived type may have overridden Write(byte[], int, int) prior`
`671`	`671`	`// to this Write(Span<byte>) overload being introduced. In that case, this Write(Span<byte>) overload`
`672`	`672`	`// should use the behavior of Write(byte[],int,int) overload.`
`673`		`- base.Write(source);`
	`673`	`+ base.Write(buffer);`
`674`	`674`	`}`
`675`	`675`	`}`
`676`	`676`
`677`		`- internal unsafe void WriteCore(ReadOnlySpan<byte> source)`
	`677`	`+ internal unsafe void WriteCore(ReadOnlySpan<byte> buffer)`
`678`	`678`	`{`
`679`	`679`	`EnsureNotClosed();`
`680`	`680`	`EnsureWriteable();`
`681`	`681`
`682`	`682`	`long pos = Interlocked.Read(ref _position); // Use a local to avoid a race condition`
`683`	`683`	`long len = Interlocked.Read(ref _length);`
`684`		`- long n = pos + source.Length;`
	`684`	`+ long n = pos + buffer.Length;`
`685`	`685`	`// Check for overflow`
`686`	`686`	`if (n < 0)`
`687`	`687`	`{`
`@@ -709,12 +709,12 @@ internal unsafe void WriteCore(ReadOnlySpan<byte> source)`
`709`	`709`	`}`
`710`	`710`	`}`
`711`	`711`
`712`		`- fixed (byte* pBuffer = &MemoryMarshal.GetReference(source))`
	`712`	`+ fixed (byte* pBuffer = &MemoryMarshal.GetReference(buffer))`
`713`	`713`	`{`
`714`	`714`	`if (_buffer != null)`
`715`	`715`	`{`
`716`	`716`	`long bytesLeft = _capacity - pos;`
`717`		`- if (bytesLeft < source.Length)`
	`717`	`+ if (bytesLeft < buffer.Length)`
`718`	`718`	`{`
`719`	`719`	`throw new ArgumentException(SR.Arg_BufferTooSmall);`
`720`	`720`	`}`
`@@ -724,7 +724,7 @@ internal unsafe void WriteCore(ReadOnlySpan<byte> source)`
`724`	`724`	`try`
`725`	`725`	`{`
`726`	`726`	`_buffer.AcquirePointer(ref pointer);`
`727`		`- Buffer.Memcpy(pointer + pos + _offset, pBuffer, source.Length);`
	`727`	`+ Buffer.Memcpy(pointer + pos + _offset, pBuffer, buffer.Length);`
`728`	`728`	`}`
`729`	`729`	`finally`
`730`	`730`	`{`
`@@ -736,7 +736,7 @@ internal unsafe void WriteCore(ReadOnlySpan<byte> source)`
`736`	`736`	`}`
`737`	`737`	`else`
`738`	`738`	`{`
`739`		`- Buffer.Memcpy(_mem + pos, pBuffer, source.Length);`
	`739`	`+ Buffer.Memcpy(_mem + pos, pBuffer, buffer.Length);`
`740`	`740`	`}`
`741`	`741`	`}`
`742`	`742`
`@@ -783,7 +783,7 @@ public override Task WriteAsync(Byte[] buffer, Int32 offset, Int32 count, Cancel`
`783`	`783`	`/// </summary>`
`784`	`784`	`/// <param name="buffer">Buffer that will be written.</param>`
`785`	`785`	`/// <param name="cancellationToken">Token that can be used to cancel the operation.</param>`
`786`		`- public override ValueTask WriteAsync(ReadOnlyMemory<byte> source, CancellationToken cancellationToken = default(CancellationToken))`
	`786`	`+ public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))`
`787`	`787`	`{`
`788`	`788`	`if (cancellationToken.IsCancellationRequested)`
`789`	`789`	`{`
`@@ -794,13 +794,13 @@ public override Task WriteAsync(Byte[] buffer, Int32 offset, Int32 count, Cancel`
`794`	`794`	`{`
`795`	`795`	`// See corresponding comment in ReadAsync for why we don't just always use Write(ReadOnlySpan<byte>).`
`796`	`796`	`// Unlike ReadAsync, we could delegate to WriteAsync(byte[], ...) here, but we don't for consistency.`
`797`		`- if (MemoryMarshal.TryGetArray(source, out ArraySegment<byte> sourceArray))`
	`797`	`+ if (MemoryMarshal.TryGetArray(buffer, out ArraySegment<byte> sourceArray))`
`798`	`798`	`{`
`799`	`799`	`Write(sourceArray.Array, sourceArray.Offset, sourceArray.Count);`
`800`	`800`	`}`
`801`	`801`	`else`
`802`	`802`	`{`
`803`		`- Write(source.Span);`
	`803`	`+ Write(buffer.Span);`
`804`	`804`	`}`
`805`	`805`	`return default;`
`806`	`806`	`}`