Fix up NRT annotations based on netcoreapp3.1 ref assemblies

AArnott · AArnott · commit edf78580fb6b · 2020-06-25T11:07:21.000-06:00
diff --git a/src/Nerdbank.Streams/BufferTextWriter.cs b/src/Nerdbank.Streams/BufferTextWriter.cs
@@ -93,7 +93,7 @@ public BufferTextWriter(IBufferWriter<byte> bufferWriter, Encoding encoding)
         }
 
         /// <inheritdoc />
-        public override Encoding? Encoding => this.encoding;
+        public override Encoding? Encoding => this.encoding!;
 
         /// <summary>
         /// Gets the number of uninitialized characters remaining in <see cref="charBuffer"/>.
@@ -279,7 +279,7 @@ private void EncodeCharacters(bool flushEncoder)
 
                 if (MemoryMarshal.TryGetArray(this.memory, out ArraySegment<byte> segment))
                 {
-                    this.memoryPosition += this.encoder!.GetBytes(this.charBuffer, 0, this.charBufferPosition, segment.Array, segment.Offset + this.memoryPosition, flush: flushEncoder);
+                    this.memoryPosition += this.encoder!.GetBytes(this.charBuffer, 0, this.charBufferPosition, segment.Array!, segment.Offset + this.memoryPosition, flush: flushEncoder);
                 }
                 else
                 {
diff --git a/src/Nerdbank.Streams/MultiplexingStream.Channel.cs b/src/Nerdbank.Streams/MultiplexingStream.Channel.cs
@@ -344,7 +344,7 @@ public void Dispose()
                     }
                     else
                     {
-                        this.mxStreamIOReaderCompleted!.ContinueWith(finalDisposalAction, this, CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default).Forget();
+                        this.mxStreamIOReaderCompleted!.ContinueWith(finalDisposalAction!, this, CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default).Forget();
                     }
                 }
             }
@@ -801,6 +801,7 @@ private void LocalContentExamined(long bytesExamined)
 
             private async Task AutoCloseOnPipesClosureAsync()
             {
+                Assumes.NotNull(this.mxStreamIOReaderCompleted);
                 await Task.WhenAll(this.mxStreamIOWriterCompleted.WaitAsync(), this.mxStreamIOReaderCompleted).ConfigureAwait(false);
 
                 if (this.TraceSource!.Switch.ShouldTrace(TraceEventType.Information))
@@ -830,13 +831,13 @@ private void DisposeSelfOnFailure(Task task)
                 {
                     if (task.IsFaulted)
                     {
-                        this.Fault(task.Exception.InnerException ?? task.Exception);
+                        this.Fault(task.Exception!.InnerException ?? task.Exception);
                     }
                 }
                 else
                 {
                     task.ContinueWith(
-                        (t, s) => ((Channel)s).Fault(t.Exception.InnerException ?? t.Exception),
+                        (t, s) => ((Channel)s!).Fault(t.Exception!.InnerException ?? t.Exception),
                         this,
                         CancellationToken.None,
                         TaskContinuationOptions.OnlyOnFaulted,
diff --git a/src/Nerdbank.Streams/MultiplexingStream.cs b/src/Nerdbank.Streams/MultiplexingStream.cs
@@ -323,7 +323,7 @@ public Channel CreateChannel(ChannelOptions? options = default)
         public Channel AcceptChannel(int id, ChannelOptions? options = default)
         {
             options = options ?? DefaultChannelOptions;
-            Channel channel;
+            Channel? channel;
             lock (this.syncObject)
             {
                 Verify.Operation(this.openChannels.TryGetValue(id, out channel), "No channel with that ID found.");
@@ -344,7 +344,7 @@ public Channel AcceptChannel(int id, ChannelOptions? options = default)
         /// <exception cref="InvalidOperationException">Thrown if the channel was already accepted.</exception>
         public void RejectChannel(int id)
         {
-            Channel channel;
+            Channel? channel;
             lock (this.syncObject)
             {
                 Verify.Operation(this.openChannels.TryGetValue(id, out channel), "No channel with that ID found.");
@@ -409,7 +409,7 @@ public async Task<Channel> OfferChannelAsync(string name, ChannelOptions? option
                 ChannelId = channel.Id,
             };
 
-            using (cancellationToken.Register(this.OfferChannelCanceled, channel))
+            using (cancellationToken.Register(this.OfferChannelCanceled!, channel))
             {
                 await this.SendFrameAsync(header, payload, cancellationToken).ConfigureAwait(false);
                 await channel.Acceptance.ConfigureAwait(false);
@@ -500,7 +500,7 @@ public async Task<Channel> AcceptChannelAsync(string name, ChannelOptions? optio
                 }
                 else
                 {
-                    using (cancellationToken.Register(this.AcceptChannelCanceled, Tuple.Create(pendingAcceptChannel, name), false))
+                    using (cancellationToken.Register(this.AcceptChannelCanceled!, Tuple.Create(pendingAcceptChannel, name), false))
                     {
                         channel = await pendingAcceptChannel!.Task.ConfigureAwait(false);
 
@@ -783,7 +783,7 @@ private void OnOfferAccepted(FrameHeader header, ReadOnlySequence<byte> payloadB
         {
             Channel.AcceptanceParameters acceptanceParameters = this.formatter.DeserializeAcceptanceParameters(payloadBuffer);
             int channelId = header.RequiredChannelId;
-            Channel channel;
+            Channel? channel;
             lock (this.syncObject)
             {
                 if (!this.openChannels.TryGetValue(channelId, out channel))
@@ -833,7 +833,7 @@ private void OnOffer(int channelId, ReadOnlySequence<byte> payloadBuffer)
 
             var channel = new Channel(this, offeredLocally: false, channelId, offerParameters);
             bool acceptingChannelAlreadyPresent = false;
-            ChannelOptions options = DefaultChannelOptions;
+            ChannelOptions? options = DefaultChannelOptions;
             lock (this.syncObject)
             {
                 if (this.acceptingChannels.TryGetValue(offerParameters.Name, out var acceptingChannels))
@@ -849,7 +849,7 @@ private void OnOffer(int channelId, ReadOnlySequence<byte> payloadBuffer)
                             }
 
                             acceptingChannelAlreadyPresent = true;
-                            options = (ChannelOptions)candidate.Task.AsyncState;
+                            options = (ChannelOptions?)candidate.Task.AsyncState;
                             Assumes.NotNull(options);
                             break;
                         }
@@ -1078,13 +1078,13 @@ private void DisposeSelfOnFailure(Task task)
             {
                 if (task.IsFaulted)
                 {
-                    this.Fault(task.Exception.InnerException ?? task.Exception);
+                    this.Fault(task.Exception!.InnerException ?? task.Exception);
                 }
             }
             else
             {
                 task.ContinueWith(
-                    (t, s) => ((MultiplexingStream)s).Fault(t.Exception.InnerException ?? t.Exception),
+                    (t, s) => ((MultiplexingStream)s!).Fault(t.Exception!.InnerException ?? t.Exception),
                     this,
                     CancellationToken.None,
                     TaskContinuationOptions.OnlyOnFaulted,
diff --git a/src/Nerdbank.Streams/PipeExtensions.cs b/src/Nerdbank.Streams/PipeExtensions.cs
@@ -219,7 +219,7 @@ public static IDuplexPipe UsePipe(this Stream stream, bool allowUnwrap, int size
             }
 #pragma warning restore CS0618 // Type or member is obsolete
 
-            closeStreamAntecedent?.ContinueWith((_, state) => ((Stream)state).Dispose(), stream, cancellationToken, TaskContinuationOptions.None, TaskScheduler.Default).Forget();
+            closeStreamAntecedent?.ContinueWith((_, state) => ((Stream)state!).Dispose(), stream, cancellationToken, TaskContinuationOptions.None, TaskScheduler.Default).Forget();
             return new DuplexPipe(input, output);
         }
 
@@ -480,7 +480,7 @@ private static PipeReader UsePipeReader(this Stream stream, int sizeHint = 0, Pi
                 disposeWhenReaderCompleted.ContinueWith(
                     (_, s1) =>
                     {
-                        var tuple = (Tuple<Pipe, Stream>)s1;
+                        var tuple = (Tuple<Pipe, Stream>)s1!;
                         tuple.Item1.Writer.OnReaderCompleted((ex, s2) => ((Stream)s2).Dispose(), tuple.Item2);
                     },
                     Tuple.Create(pipe, stream),
diff --git a/src/Nerdbank.Streams/SequenceTextReader.cs b/src/Nerdbank.Streams/SequenceTextReader.cs
@@ -220,16 +220,16 @@ public override Task<string> ReadToEndAsync()
         }
 
         /// <inheritdoc />
-        public override Task<string> ReadLineAsync()
+        public override Task<string?> ReadLineAsync()
         {
             try
             {
-                string result = this.ReadLine();
-                return Task.FromResult(result);
+                string? result = this.ReadLine();
+                return Task.FromResult<string?>(result);
             }
             catch (Exception ex)
             {
-                return Task.FromException<string>(ex);
+                return Task.FromException<string?>(ex);
             }
         }
 
@@ -304,7 +304,7 @@ private void DecodeChars()
 
                 if (MemoryMarshal.TryGetArray(memory, out ArraySegment<byte> segment))
                 {
-                    this.decoder!.Convert(segment.Array, segment.Offset, segment.Count, this.charBuffer, this.charBufferLength, this.charBuffer.Length - this.charBufferLength, flush: false, out int bytesUsed, out int charsUsed, out bool completed);
+                    this.decoder!.Convert(segment.Array!, segment.Offset, segment.Count, this.charBuffer, this.charBufferLength, this.charBuffer.Length - this.charBufferLength, flush: false, out int bytesUsed, out int charsUsed, out bool completed);
                     this.charBufferLength += charsUsed;
                     this.sequencePosition = this.sequence.GetPosition(bytesUsed, this.sequencePosition);
                 }
diff --git a/src/Nerdbank.Streams/Sequence`1.cs b/src/Nerdbank.Streams/Sequence`1.cs
@@ -124,8 +124,8 @@ public Sequence(ArrayPool<T> arrayPool)
         /// <param name="sequence">The sequence to convert.</param>
         public static implicit operator ReadOnlySequence<T>(Sequence<T> sequence)
         {
-            return sequence.first != null
-                ? new ReadOnlySequence<T>(sequence.first, sequence.first.Start, sequence.last, sequence.last!.End)
+            return sequence.first is { } first && sequence.last is { } last
+                ? new ReadOnlySequence<T>(first, first.Start, last, last!.End)
                 : Empty;
         }
 
@@ -139,7 +139,7 @@ public static implicit operator ReadOnlySequence<T>(Sequence<T> sequence)
         /// </param>
         public void AdvanceTo(SequencePosition position)
         {
-            var firstSegment = (SequenceSegment)position.GetObject();
+            var firstSegment = (SequenceSegment?)position.GetObject();
             if (firstSegment == null)
             {
                 // Emulate PipeReader behavior which is to just return for default(SequencePosition)
diff --git a/src/Nerdbank.Streams/Substream.cs b/src/Nerdbank.Streams/Substream.cs
@@ -22,9 +22,7 @@ public class Substream : Stream, IDisposableObservable, Microsoft.VisualStudio.T
 
         private readonly Stream underlyingStream;
 
-#pragma warning disable SA1011 // Closing square brackets should be spaced correctly
-        private byte[]? buffer;
-#pragma warning restore SA1011 // Closing square brackets should be spaced correctly
+        private readonly byte[] buffer;
 
         private int count;
 
@@ -38,7 +36,7 @@ internal Substream(Stream underlyingStream, int minimumBufferSize = DefaultBuffe
         }
 
         /// <inheritdoc/>
-        public bool IsDisposed => this.buffer == null;
+        public bool IsDisposed { get; private set; }
 
         /// <inheritdoc/>
         public override bool CanRead => false;
@@ -85,7 +83,7 @@ public async ValueTask DisposeAsync(CancellationToken cancellationToken = defaul
             await this.underlyingStream.FlushAsync(cancellationToken).ConfigureAwait(false);
 
             ArrayPool<byte>.Shared.Return(this.buffer);
-            this.buffer = null;
+            this.IsDisposed = true;
 
             this.Dispose();
         }
@@ -177,7 +175,7 @@ protected override void Dispose(bool disposing)
                     this.underlyingStream.Flush();
 
                     ArrayPool<byte>.Shared.Return(this.buffer);
-                    this.buffer = null;
+                    this.IsDisposed = true;
                 }
             }
 
diff --git a/src/Nerdbank.Streams/netcoreapp2.1/PublicAPI.Shipped.txt b/src/Nerdbank.Streams/netcoreapp2.1/PublicAPI.Shipped.txt
@@ -194,7 +194,7 @@ override Nerdbank.Streams.SequenceTextReader.ReadAsync(System.Memory<char> buffe
 override Nerdbank.Streams.SequenceTextReader.ReadAsync(char[]! buffer, int index, int count) -> System.Threading.Tasks.Task<int>!
 override Nerdbank.Streams.SequenceTextReader.ReadBlockAsync(System.Memory<char> buffer, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<int>
 override Nerdbank.Streams.SequenceTextReader.ReadBlockAsync(char[]! buffer, int index, int count) -> System.Threading.Tasks.Task<int>!
-override Nerdbank.Streams.SequenceTextReader.ReadLineAsync() -> System.Threading.Tasks.Task<string!>!
+override Nerdbank.Streams.SequenceTextReader.ReadLineAsync() -> System.Threading.Tasks.Task<string?>!
 override Nerdbank.Streams.SequenceTextReader.ReadToEndAsync() -> System.Threading.Tasks.Task<string!>!
 override Nerdbank.Streams.SimplexStream.CanRead.get -> bool
 override Nerdbank.Streams.SimplexStream.CanSeek.get -> bool
diff --git a/src/Nerdbank.Streams/netstandard2.0/PublicAPI.Shipped.txt b/src/Nerdbank.Streams/netstandard2.0/PublicAPI.Shipped.txt
@@ -185,7 +185,7 @@ override Nerdbank.Streams.SequenceTextReader.Read() -> int
 override Nerdbank.Streams.SequenceTextReader.Read(char[]! buffer, int index, int count) -> int
 override Nerdbank.Streams.SequenceTextReader.ReadAsync(char[]! buffer, int index, int count) -> System.Threading.Tasks.Task<int>!
 override Nerdbank.Streams.SequenceTextReader.ReadBlockAsync(char[]! buffer, int index, int count) -> System.Threading.Tasks.Task<int>!
-override Nerdbank.Streams.SequenceTextReader.ReadLineAsync() -> System.Threading.Tasks.Task<string!>!
+override Nerdbank.Streams.SequenceTextReader.ReadLineAsync() -> System.Threading.Tasks.Task<string?>!
 override Nerdbank.Streams.SequenceTextReader.ReadToEndAsync() -> System.Threading.Tasks.Task<string!>!
 override Nerdbank.Streams.SimplexStream.CanRead.get -> bool
 override Nerdbank.Streams.SimplexStream.CanSeek.get -> bool

Original file line number	Diff line number	Diff line change
`@@ -93,7 +93,7 @@ public BufferTextWriter(IBufferWriter<byte> bufferWriter, Encoding encoding)`
`93`	`93`	`}`
`94`	`94`
`95`	`95`	`/// <inheritdoc />`
`96`		`- public override Encoding? Encoding => this.encoding;`
	`96`	`+ public override Encoding? Encoding => this.encoding!;`
`97`	`97`
`98`	`98`	`/// <summary>`
`99`	`99`	`/// Gets the number of uninitialized characters remaining in <see cref="charBuffer"/>.`
`@@ -279,7 +279,7 @@ private void EncodeCharacters(bool flushEncoder)`
`279`	`279`
`280`	`280`	`if (MemoryMarshal.TryGetArray(this.memory, out ArraySegment<byte> segment))`
`281`	`281`	`{`
`282`		`- this.memoryPosition += this.encoder!.GetBytes(this.charBuffer, 0, this.charBufferPosition, segment.Array, segment.Offset + this.memoryPosition, flush: flushEncoder);`
	`282`	`+ this.memoryPosition += this.encoder!.GetBytes(this.charBuffer, 0, this.charBufferPosition, segment.Array!, segment.Offset + this.memoryPosition, flush: flushEncoder);`
`283`	`283`	`}`
`284`	`284`	`else`
`285`	`285`	`{`
Original file line number	Diff line number	Diff line change
`@@ -344,7 +344,7 @@ public void Dispose()`
`344`	`344`	`}`
`345`	`345`	`else`
`346`	`346`	`{`
`347`		`- this.mxStreamIOReaderCompleted!.ContinueWith(finalDisposalAction, this, CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default).Forget();`
	`347`	`+ this.mxStreamIOReaderCompleted!.ContinueWith(finalDisposalAction!, this, CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default).Forget();`
`348`	`348`	`}`
`349`	`349`	`}`
`350`	`350`	`}`
`@@ -801,6 +801,7 @@ private void LocalContentExamined(long bytesExamined)`
`801`	`801`
`802`	`802`	`private async Task AutoCloseOnPipesClosureAsync()`
`803`	`803`	`{`
	`804`	`+ Assumes.NotNull(this.mxStreamIOReaderCompleted);`
`804`	`805`	`await Task.WhenAll(this.mxStreamIOWriterCompleted.WaitAsync(), this.mxStreamIOReaderCompleted).ConfigureAwait(false);`
`805`	`806`
`806`	`807`	`if (this.TraceSource!.Switch.ShouldTrace(TraceEventType.Information))`
`@@ -830,13 +831,13 @@ private void DisposeSelfOnFailure(Task task)`
`830`	`831`	`{`
`831`	`832`	`if (task.IsFaulted)`
`832`	`833`	`{`
`833`		`- this.Fault(task.Exception.InnerException ?? task.Exception);`
	`834`	`+ this.Fault(task.Exception!.InnerException ?? task.Exception);`
`834`	`835`	`}`
`835`	`836`	`}`
`836`	`837`	`else`
`837`	`838`	`{`
`838`	`839`	`task.ContinueWith(`
`839`		`- (t, s) => ((Channel)s).Fault(t.Exception.InnerException ?? t.Exception),`
	`840`	`+ (t, s) => ((Channel)s!).Fault(t.Exception!.InnerException ?? t.Exception),`
`840`	`841`	`this,`
`841`	`842`	`CancellationToken.None,`
`842`	`843`	`TaskContinuationOptions.OnlyOnFaulted,`
Original file line number	Diff line number	Diff line change
`@@ -323,7 +323,7 @@ public Channel CreateChannel(ChannelOptions? options = default)`
`323`	`323`	`public Channel AcceptChannel(int id, ChannelOptions? options = default)`
`324`	`324`	`{`
`325`	`325`	`options = options ?? DefaultChannelOptions;`
`326`		`- Channel channel;`
	`326`	`+ Channel? channel;`
`327`	`327`	`lock (this.syncObject)`
`328`	`328`	`{`
`329`	`329`	`Verify.Operation(this.openChannels.TryGetValue(id, out channel), "No channel with that ID found.");`
`@@ -344,7 +344,7 @@ public Channel AcceptChannel(int id, ChannelOptions? options = default)`
`344`	`344`	`/// <exception cref="InvalidOperationException">Thrown if the channel was already accepted.</exception>`
`345`	`345`	`public void RejectChannel(int id)`
`346`	`346`	`{`
`347`		`- Channel channel;`
	`347`	`+ Channel? channel;`
`348`	`348`	`lock (this.syncObject)`
`349`	`349`	`{`
`350`	`350`	`Verify.Operation(this.openChannels.TryGetValue(id, out channel), "No channel with that ID found.");`
`@@ -409,7 +409,7 @@ public async Task<Channel> OfferChannelAsync(string name, ChannelOptions? option`
`409`	`409`	`ChannelId = channel.Id,`
`410`	`410`	`};`
`411`	`411`
`412`		`- using (cancellationToken.Register(this.OfferChannelCanceled, channel))`
	`412`	`+ using (cancellationToken.Register(this.OfferChannelCanceled!, channel))`
`413`	`413`	`{`
`414`	`414`	`await this.SendFrameAsync(header, payload, cancellationToken).ConfigureAwait(false);`
`415`	`415`	`await channel.Acceptance.ConfigureAwait(false);`
`@@ -500,7 +500,7 @@ public async Task<Channel> AcceptChannelAsync(string name, ChannelOptions? optio`
`500`	`500`	`}`
`501`	`501`	`else`
`502`	`502`	`{`
`503`		`- using (cancellationToken.Register(this.AcceptChannelCanceled, Tuple.Create(pendingAcceptChannel, name), false))`
	`503`	`+ using (cancellationToken.Register(this.AcceptChannelCanceled!, Tuple.Create(pendingAcceptChannel, name), false))`
`504`	`504`	`{`
`505`	`505`	`channel = await pendingAcceptChannel!.Task.ConfigureAwait(false);`
`506`	`506`
`@@ -783,7 +783,7 @@ private void OnOfferAccepted(FrameHeader header, ReadOnlySequence<byte> payloadB`
`783`	`783`	`{`
`784`	`784`	`Channel.AcceptanceParameters acceptanceParameters = this.formatter.DeserializeAcceptanceParameters(payloadBuffer);`
`785`	`785`	`int channelId = header.RequiredChannelId;`
`786`		`- Channel channel;`
	`786`	`+ Channel? channel;`
`787`	`787`	`lock (this.syncObject)`
`788`	`788`	`{`
`789`	`789`	`if (!this.openChannels.TryGetValue(channelId, out channel))`
`@@ -833,7 +833,7 @@ private void OnOffer(int channelId, ReadOnlySequence<byte> payloadBuffer)`
`833`	`833`
`834`	`834`	`var channel = new Channel(this, offeredLocally: false, channelId, offerParameters);`
`835`	`835`	`bool acceptingChannelAlreadyPresent = false;`
`836`		`- ChannelOptions options = DefaultChannelOptions;`
	`836`	`+ ChannelOptions? options = DefaultChannelOptions;`
`837`	`837`	`lock (this.syncObject)`
`838`	`838`	`{`
`839`	`839`	`if (this.acceptingChannels.TryGetValue(offerParameters.Name, out var acceptingChannels))`
`@@ -849,7 +849,7 @@ private void OnOffer(int channelId, ReadOnlySequence<byte> payloadBuffer)`
`849`	`849`	`}`
`850`	`850`
`851`	`851`	`acceptingChannelAlreadyPresent = true;`
`852`		`- options = (ChannelOptions)candidate.Task.AsyncState;`
	`852`	`+ options = (ChannelOptions?)candidate.Task.AsyncState;`
`853`	`853`	`Assumes.NotNull(options);`
`854`	`854`	`break;`
`855`	`855`	`}`
`@@ -1078,13 +1078,13 @@ private void DisposeSelfOnFailure(Task task)`
`1078`	`1078`	`{`
`1079`	`1079`	`if (task.IsFaulted)`
`1080`	`1080`	`{`
`1081`		`- this.Fault(task.Exception.InnerException ?? task.Exception);`
	`1081`	`+ this.Fault(task.Exception!.InnerException ?? task.Exception);`
`1082`	`1082`	`}`
`1083`	`1083`	`}`
`1084`	`1084`	`else`
`1085`	`1085`	`{`
`1086`	`1086`	`task.ContinueWith(`
`1087`		`- (t, s) => ((MultiplexingStream)s).Fault(t.Exception.InnerException ?? t.Exception),`
	`1087`	`+ (t, s) => ((MultiplexingStream)s!).Fault(t.Exception!.InnerException ?? t.Exception),`
`1088`	`1088`	`this,`
`1089`	`1089`	`CancellationToken.None,`
`1090`	`1090`	`TaskContinuationOptions.OnlyOnFaulted,`
Original file line number	Diff line number	Diff line change
`@@ -219,7 +219,7 @@ public static IDuplexPipe UsePipe(this Stream stream, bool allowUnwrap, int size`
`219`	`219`	`}`
`220`	`220`	`#pragma warning restore CS0618 // Type or member is obsolete`
`221`	`221`
`222`		`- closeStreamAntecedent?.ContinueWith((_, state) => ((Stream)state).Dispose(), stream, cancellationToken, TaskContinuationOptions.None, TaskScheduler.Default).Forget();`
	`222`	`+ closeStreamAntecedent?.ContinueWith((_, state) => ((Stream)state!).Dispose(), stream, cancellationToken, TaskContinuationOptions.None, TaskScheduler.Default).Forget();`
`223`	`223`	`return new DuplexPipe(input, output);`
`224`	`224`	`}`
`225`	`225`
`@@ -480,7 +480,7 @@ private static PipeReader UsePipeReader(this Stream stream, int sizeHint = 0, Pi`
`480`	`480`	`disposeWhenReaderCompleted.ContinueWith(`
`481`	`481`	`(_, s1) =>`
`482`	`482`	`{`
`483`		`- var tuple = (Tuple<Pipe, Stream>)s1;`
	`483`	`+ var tuple = (Tuple<Pipe, Stream>)s1!;`
`484`	`484`	`tuple.Item1.Writer.OnReaderCompleted((ex, s2) => ((Stream)s2).Dispose(), tuple.Item2);`
`485`	`485`	`},`
`486`	`486`	`Tuple.Create(pipe, stream),`
Original file line number	Diff line number	Diff line change
`@@ -220,16 +220,16 @@ public override Task<string> ReadToEndAsync()`
`220`	`220`	`}`
`221`	`221`
`222`	`222`	`/// <inheritdoc />`
`223`		`- public override Task<string> ReadLineAsync()`
	`223`	`+ public override Task<string?> ReadLineAsync()`
`224`	`224`	`{`
`225`	`225`	`try`
`226`	`226`	`{`
`227`		`- string result = this.ReadLine();`
`228`		`- return Task.FromResult(result);`
	`227`	`+ string? result = this.ReadLine();`
	`228`	`+ return Task.FromResult<string?>(result);`
`229`	`229`	`}`
`230`	`230`	`catch (Exception ex)`
`231`	`231`	`{`
`232`		`- return Task.FromException<string>(ex);`
	`232`	`+ return Task.FromException<string?>(ex);`
`233`	`233`	`}`
`234`	`234`	`}`
`235`	`235`
`@@ -304,7 +304,7 @@ private void DecodeChars()`
`304`	`304`
`305`	`305`	`if (MemoryMarshal.TryGetArray(memory, out ArraySegment<byte> segment))`
`306`	`306`	`{`
`307`		`- this.decoder!.Convert(segment.Array, segment.Offset, segment.Count, this.charBuffer, this.charBufferLength, this.charBuffer.Length - this.charBufferLength, flush: false, out int bytesUsed, out int charsUsed, out bool completed);`
	`307`	`+ this.decoder!.Convert(segment.Array!, segment.Offset, segment.Count, this.charBuffer, this.charBufferLength, this.charBuffer.Length - this.charBufferLength, flush: false, out int bytesUsed, out int charsUsed, out bool completed);`
`308`	`308`	`this.charBufferLength += charsUsed;`
`309`	`309`	`this.sequencePosition = this.sequence.GetPosition(bytesUsed, this.sequencePosition);`
`310`	`310`	`}`
Original file line number	Diff line number	Diff line change
`@@ -124,8 +124,8 @@ public Sequence(ArrayPool<T> arrayPool)`
`124`	`124`	`/// <param name="sequence">The sequence to convert.</param>`
`125`	`125`	`public static implicit operator ReadOnlySequence<T>(Sequence<T> sequence)`
`126`	`126`	`{`
`127`		`- return sequence.first != null`
`128`		`- ? new ReadOnlySequence<T>(sequence.first, sequence.first.Start, sequence.last, sequence.last!.End)`
	`127`	`+ return sequence.first is { } first && sequence.last is { } last`
	`128`	`+ ? new ReadOnlySequence<T>(first, first.Start, last, last!.End)`
`129`	`129`	`: Empty;`
`130`	`130`	`}`
`131`	`131`
`@@ -139,7 +139,7 @@ public static implicit operator ReadOnlySequence<T>(Sequence<T> sequence)`
`139`	`139`	`/// </param>`
`140`	`140`	`public void AdvanceTo(SequencePosition position)`
`141`	`141`	`{`
`142`		`- var firstSegment = (SequenceSegment)position.GetObject();`
	`142`	`+ var firstSegment = (SequenceSegment?)position.GetObject();`
`143`	`143`	`if (firstSegment == null)`
`144`	`144`	`{`
`145`	`145`	`// Emulate PipeReader behavior which is to just return for default(SequencePosition)`