`peekByte()` on `std.Io.Reader.failing` triggers an assertion failure

[generalmimon]

Zig Version

0.15.1

Steps to Reproduce and Observed Behavior

Calling peekByte() on std.Io.Reader.failing causes an assertion failure in the standard library.

Reproduction code:

const std = @import("std");
const testing = std.testing;

test "std.Io.Reader.failing.peekByte() should return error.ReadFailed" {
    var r = std.Io.Reader.failing;
    try testing.expectError(error.ReadFailed, r.peekByte());
}

Console output:

$ zig-x86_64-linux-0.15.1/zig test test.zig
thread 187 panic: reached unreachable code
/home/pp/zig-x86_64-linux-0.15.1/lib/std/debug.zig:559:14: 0x102e3e9 in assert (std.zig)
    if (!ok) unreachable; // assertion failure
             ^
/home/pp/zig-x86_64-linux-0.15.1/lib/std/Io/Reader.zig:1250:11: 0x102d3cd in defaultRebase (std.zig)
    assert(r.buffer.len - r.seek >= capacity);
          ^
/home/pp/zig-x86_64-linux-0.15.1/lib/std/Io/Reader.zig:1241:27: 0x1071559 in rebase (std.zig)
    return r.vtable.rebase(r, capacity);
                          ^
/home/pp/zig-x86_64-linux-0.15.1/lib/std/Io/Reader.zig:1026:15: 0x104b5a1 in fillUnbuffered (std.zig)
    try rebase(r, n);
              ^
/home/pp/zig-x86_64-linux-0.15.1/lib/std/Io/Reader.zig:1014:26: 0x10301ff in fill (std.zig)
    return fillUnbuffered(r, n);
                         ^
/home/pp/zig-x86_64-linux-0.15.1/lib/std/Io/Reader.zig:1054:13: 0x102d6f2 in peekByte (std.zig)
    try fill(r, 1);
            ^
/home/pp/test.zig:6:57: 0x102c1a7 in test.std.Io.Reader.failing.peekByte() should return error.ReadFailed (test.zig)
    try testing.expectError(error.ReadFailed, r.peekByte());
                                                        ^
/home/pp/zig-x86_64-linux-0.15.1/lib/compiler/test_runner.zig:218:25: 0x115dd80 in mainTerminal (test_runner.zig)
        if (test_fn.func()) |_| {
                        ^
/home/pp/zig-x86_64-linux-0.15.1/lib/compiler/test_runner.zig:66:28: 0x1156fa1 in main (test_runner.zig)
        return mainTerminal();
                           ^
/home/pp/zig-x86_64-linux-0.15.1/lib/std/start.zig:618:22: 0x1150d3d in posixCallMainAndExit (std.zig)
            root.main();
                     ^
/home/pp/zig-x86_64-linux-0.15.1/lib/std/start.zig:232:5: 0x11505d1 in _start (std.zig)
    asm volatile (switch (native_arch) {
    ^
???:?:?: 0x0 in ??? (???)
error: the following test command crashed:
.cache/zig/o/cfa6149a05a5b2438e887ac7db257da8/test --seed=0x57fc642c

Expected Behavior

I expected that all operations on std.Io.Reader.failing would return error.ReadFailed.

[generalmimon]

I looked into the defaultRebase method where the assertion fails:

zig/lib/std/Io/Reader.zig

Lines 1244 to 1251 in 3db9607

	pub fn defaultRebase(r: *Reader, capacity: usize) RebaseError!void {
	assert(r.buffer.len - r.seek < capacity);
	const data = r.buffer[r.seek..r.end];
	@memmove(r.buffer[0..data.len], data);
	r.seek = 0;
	r.end = data.len;
	assert(r.buffer.len - r.seek >= capacity);
	}

The failing assertion is on line 1250. To me, this doesn't look like the right implementation of rebase for std.Io.Reader.failing, which should always fail. The failing reader is defined as follows:

zig/lib/std/Io/Reader.zig

Lines 134 to 142 in 3db9607

	pub const failing: Reader = .{
	.vtable = &.{
	.stream = failingStream,
	.discard = failingDiscard,
	},
	.buffer = &.{},
	.seek = 0,
	.end = 0,
	};

Note that there are special implementations only for stream and discard, but not rebase, so the default implementation is used:

zig/lib/std/Io/Reader.zig

Line 99 in 3db9607

rebase: *const fn (r: *Reader, capacity: usize) RebaseError!void = defaultRebase,

So I got the idea to make my own failing reader readerFailing, where I override the rebase method to noopRebase, which does nothing. That seems to be enough to fix the panic:

const std = @import("std");
const testing = std.testing;

fn failingStream(r: *std.Io.Reader, w: *std.Io.Writer, limit: std.Io.Limit) std.Io.Reader.StreamError!usize {
    _ = r;
    _ = w;
    _ = limit;
    return error.ReadFailed;
}

fn failingDiscard(r: *std.Io.Reader, limit: std.Io.Limit) std.Io.Reader.Error!usize {
    _ = r;
    _ = limit;
    return error.ReadFailed;
}

fn noopRebase(r: *std.Io.Reader, capacity: usize) std.Io.Reader.RebaseError!void {
    _ = r;
    _ = capacity;
}

const readerFailing: std.Io.Reader = .{
    .vtable = &.{
        .stream = failingStream,
        .discard = failingDiscard,
        .rebase = noopRebase,
    },
    .buffer = &.{},
    .seek = 0,
    .end = 0,
};

test "readerFailing.peekByte() should return error.ReadFailed" {
    var r = readerFailing;
    try testing.expectError(error.ReadFailed, r.peekByte());
}

$ zig-x86_64-linux-0.15.1/zig test test.zig
All 1 tests passed.

But take it with a grain of salt, because I'm new to Zig.

[septemhill]

I think it should be follwing:

fn noopRebase(r: *std.Io.Reader, capacity: usize) std.Io.Reader.RebaseError!void {
    _ = r;
    _ = capacity;
    return error.ReadFailed;
}

If missed the error return, it would return void back, then the error wouldn't be error.ReadFailed.