Fix aligned buffer write (#11861)

* Fix aligned buffer write

This is a particularly subtle bug that requires a chunk (or remaining bit of a chunk) and the destination buffer being _exactly_ the same size. When this happens, the following sequence occurs:

1. `source.Length` and `destination.Length` are exactly aligned. This means that we do not enter the `if` on line 450, and `endOfChunkWritten` will be true.
2. We slice `destination` by `source.Length`. This leaves us with a `destination` that has 0 elements, and `IsEmpty` is true.
3. Because `endOfChunkWritten` is true, we enter the `if` on line 466. This increments us to the next chunk.
4. On line 472 (in the before diff), `destination.IsEmpty` is true, so we enter the `if`, and break out of the loop, never reseting `charIndex` to 0.
5. 4 happens again, this time on line 480 (in the before diff). Again, we do not reset `charIndex` to 0.

To fix this, we want to unconditionally reset `charIndex` when we increment a chunk, not wait until after the destination has been checked for empty.

* Ensure that no more than `count` characters are read into the destination buffer.

* Add tests.

* Simplify code around chunk tracking

* .NET Framework build fixes

* .NET FRAMEWORK!!!!!!!!!!!!!!!!!!!!!!!!1

* Feedback

Author: 333fred

src/Compiler/Microsoft.AspNetCore.Razor.Language/test/CodeGeneration/CSharpCodeWriterTest.cs

@@ -6,6 +6,7 @@
 using System;
 using System.Collections.Generic;
 using Microsoft.AspNetCore.Razor.Language.Intermediate;
+using Roslyn.Test.Utilities;
 using Xunit;
 
 namespace Microsoft.AspNetCore.Razor.Language.CodeGeneration;
@@ -439,4 +440,46 @@ class C
 
             """, output);
     }
+
+    [Fact, WorkItem("https://github.com/dotnet/core/issues/9885")]
+    public void AlignedPages_WritesCorrectlyWhenPageAndBufferAreAligned()
+    {
+        var pages = new LinkedList<ReadOnlyMemory<char>[]>();
+
+        const string FirstLine = "First Line";
+        pages.AddLast([(FirstLine + FirstLine).AsMemory(), "Second".AsMemory()]);
+
+        var testReader = CodeWriter.GetTestTextReader(pages);
+        var output = new char[FirstLine.Length];
+
+        testReader.Read(output, 0, output.Length);
+        Assert.Equal(FirstLine, string.Join("", output));
+        Array.Clear(output, 0, output.Length);
+
+        testReader.Read(output, 0, output.Length);
+        Assert.Equal(FirstLine, string.Join("", output));
+        Array.Clear(output, 0, output.Length);
+
+        testReader.Read(output, 0, output.Length);
+        Assert.Equal("Second\0\0\0\0", string.Join("", output));
+    }
+
+    [Fact]
+    public void ReaderOnlyReadsAsMuchAsRequested()
+    {
+        var pages = new LinkedList<ReadOnlyMemory<char>[]>();
+
+        const string FirstLine = "First Line";
+        pages.AddLast([FirstLine.AsMemory()]);
+
+        var testReader = CodeWriter.GetTestTextReader(pages);
+        var output = new char[FirstLine.Length];
+
+        testReader.Read(output, 0, 2);
+        Assert.Equal("Fi\0\0\0\0\0\0\0\0", string.Join("", output));
+        Array.Clear(output, 0, output.Length);
+
+        testReader.Read(output, 0, output.Length);
+        Assert.Equal("rst Line\0\0", string.Join("", output));
+    }
 }

src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/CodeGeneration/CodeWriter.cs

@@ -323,14 +323,20 @@ public CodeWriter WriteLine([InterpolatedStringHandlerArgument("")] ref WriteInt
 
     public SourceText GetText()
     {
-        using var reader = new Reader(this);
+        using var reader = new Reader(_pages, Length);
         return SourceText.From(reader, Length, Encoding.UTF8);
     }
 
-    private sealed class Reader(CodeWriter codeWriter) : TextReader
+    // Internal for testing
+    internal static TextReader GetTestTextReader(LinkedList<ReadOnlyMemory<char>[]> pages)
     {
-        private LinkedListNode<ReadOnlyMemory<char>[]>? _page = codeWriter._pages.First;
-        private int _remainingLength = codeWriter.Length;
+        return new Reader(pages, pages.Count);
+    }
+
+    private sealed class Reader(LinkedList<ReadOnlyMemory<char>[]> pages, int length) : TextReader
+    {
+        private LinkedListNode<ReadOnlyMemory<char>[]>? _page = pages.First;
+        private int _remainingLength = length;
         private int _chunkIndex;
         private int _charIndex;
 
@@ -413,7 +419,7 @@ public override int Read(char[] buffer, int index, int count)
                 return -1;
             }
 
-            var destination = buffer.AsSpan(index);
+            var destination = buffer.AsSpan(index, count);
             var charsWritten = 0;
 
             var page = _page;
@@ -443,38 +449,29 @@ public override int Read(char[] buffer, int index, int count)
                         }
                     }
 
-                    var endOfChunkWritten = true;
-
                     // Are we about to write past the end of the buffer? If so, adjust source.
                     // This will be the last chunk we write, so be sure to update charIndex.
                     if (source.Length > destination.Length)
                     {
                         source = source[..destination.Length];
                         charIndex += source.Length;
-
-                        // There's more to this chunk to write! Note this so that we don't update
-                        // chunkIndex later.
-                        endOfChunkWritten = false;
+                    }
+                    else
+                    {
+                        chunkIndex++;
+                        charIndex = 0;
                     }
 
                     source.CopyTo(destination);
                     destination = destination[source.Length..];
 
                     charsWritten += source.Length;
 
-                    // Be careful not to increment chunkIndex unless we actually wrote to the end of the chunk.
-                    if (endOfChunkWritten)
-                    {
-                        chunkIndex++;
-                    }
-
                     // Break if we are done writing. chunkIndex and charIndex should have their correct values at this point.
                     if (destination.IsEmpty)
                     {
                         break;
                     }
-
-                    charIndex = 0;
                 }
 
                 if (destination.IsEmpty)