Reader: fix fill when implementation writes to reader directly

`r.end += stream` is the same as `r.end = r.end + stream`, which causes
`r.end` to be analyzed before stream is called and that value is added
to. However, the implementation is allowed to write directly to `r` (for
example, inflate does this to keep a window) and update `r.end`
independently, causing the outdated value to be added to.

Author: gooncreeper

lib/std/Io/Reader.zig

@@ -1065,10 +1065,10 @@ fn fillUnbuffered(r: *Reader, n: usize) Error!void {
     };
     while (r.end < r.seek + n) {
         writer.end = r.end;
-        r.end += r.vtable.stream(r, &writer, .limited(r.buffer.len - r.end)) catch |err| switch (err) {
+        r.end = (r.vtable.stream(r, &writer, .limited(r.buffer.len - r.end)) catch |err| switch (err) {
             error.WriteFailed => unreachable,
             error.ReadFailed, error.EndOfStream => |e| return e,
-        };
+        }) + r.end; // r.end must be evaluated last since r.vtable.stream may change it
     }
 }
 
@@ -1084,10 +1084,10 @@ pub fn fillMore(r: *Reader) Error!void {
         .end = r.end,
         .vtable = &.{ .drain = Writer.fixedDrain },
     };
-    r.end += r.vtable.stream(r, &writer, .limited(r.buffer.len - r.end)) catch |err| switch (err) {
+    r.end = (r.vtable.stream(r, &writer, .limited(r.buffer.len - r.end)) catch |err| switch (err) {
         error.WriteFailed => unreachable,
         else => |e| return e,
-    };
+    }) + r.end; // r.end must be evaluated last since r.vtable.stream may change it
 }
 
 /// Returns the next byte from the stream or returns `error.EndOfStream`.
@@ -1514,9 +1514,28 @@ test discardDelimiterLimit {
 }
 
 test fill {
-    var r: Reader = .fixed("abc");
-    try r.fill(1);
-    try r.fill(3);
+    var fixed_r: Reader = .fixed("abc");
+    try fixed_r.fill(1);
+    try fixed_r.fill(3);
+
+    // Check writing directly to the reader buffer
+    var buf: [2]u8 = undefined;
+    var indirect_r: Reader = .{
+        .buffer = &buf,
+        .seek = 0,
+        .end = 0,
+        .vtable = &.{
+            .stream = struct {
+                fn stream(r: *Reader, _: *Writer, _: Limit) StreamError!usize {
+                    @memset(r.buffer[r.seek..], 0xff);
+                    r.end = r.buffer.len;
+                    return 0;
+                }
+            }.stream,
+        },
+    };
+    try indirect_r.fill(2);
+    try std.testing.expectEqualSlices(u8, &.{ 0xff, 0xff }, indirect_r.buffered());
 }
 
 test takeByte {