From e5b93d9e72f4b4bbdd32d187751e8228d777c0fb Mon Sep 17 00:00:00 2001 From: tannevaled Date: Fri, 28 Aug 2026 15:06:38 +0200 Subject: [PATCH] IO::Buffer: add #slice and #resize Follow-up to the initial IO::Buffer, adding the two deferred memory operations: - slice(offset = 0, length = size - offset) returns a buffer sharing this buffer's memory over the range, so a write through the slice shows in the original. It inherits the read-only flag, reports as neither internal nor external (it owns no allocation), and can itself be resized; an out-of-range range raises ArgumentError. - resize(size) reallocates, preserving the leading bytes (a larger buffer is zero-filled) and marking the buffer internal; an external buffer (.for / .string) cannot be resized and raises AccessError. Verified against ruby 4.0.6. Whole-package coverage stays at 100%; the ruby/spec floor rises 15890 -> 15905 (core/io/buffer resize +7 plus slice/internal/external). Co-Authored-By: Claude Opus 4.8 --- internal/vm/io_buffer.go | 40 +++++++++++++++++++++++++- internal/vm/io_buffer_internal_test.go | 12 ++++++++ scripts/conformance/rubyspec/FLOOR | 2 +- 3 files changed, 52 insertions(+), 2 deletions(-) diff --git a/internal/vm/io_buffer.go b/internal/vm/io_buffer.go index 5f239228..7aebb3d1 100644 --- a/internal/vm/io_buffer.go +++ b/internal/vm/io_buffer.go @@ -22,6 +22,7 @@ type ioBuffer struct { data []byte readonly bool external bool // memory owned elsewhere (.for copies a String, .string yields) + borrowed bool // a slice sharing another buffer's memory — neither external nor internal freed bool } @@ -207,13 +208,50 @@ func (vm *VM) registerIOBuffer() { pred("empty?", func(b *ioBuffer) bool { return !b.freed && len(b.data) == 0 }) pred("valid?", func(b *ioBuffer) bool { return true }) pred("external?", func(b *ioBuffer) bool { return !b.freed && b.external }) - pred("internal?", func(b *ioBuffer) bool { return !b.freed && !b.external }) + pred("internal?", func(b *ioBuffer) bool { return !b.freed && !b.external && !b.borrowed }) pred("mapped?", func(b *ioBuffer) bool { return false }) pred("shared?", func(b *ioBuffer) bool { return false }) pred("private?", func(b *ioBuffer) bool { return false }) pred("locked?", func(b *ioBuffer) bool { return false }) pred("readonly?", func(b *ioBuffer) bool { return b.readonly }) + // slice(offset = 0, length = size - offset) returns a buffer that shares this + // buffer's memory over the given range, so writes through the slice are visible + // in the original. Like MRI's slice it reports as internal, inherits the + // read-only flag, and can itself be resized; an out-of-range range raises + // ArgumentError. + dm("slice", func(_ *VM, self object.Value, args []object.Value, _ *Proc) object.Value { + b := self.(*ioBuffer) + data := b.live() + off := 0 + if len(args) > 0 { + off = int(intArg(args[0])) + } + length := len(data) - off + if len(args) > 1 { + length = int(intArg(args[1])) + } + if off < 0 || length < 0 || off+length > len(data) { + raise("ArgumentError", "Specified offset+length is bigger than the buffer size!") + } + return &ioBuffer{data: data[off : off+length : off+length], readonly: b.readonly, borrowed: true} + }) + // resize(size) reallocates the buffer to the new size, preserving the leading + // bytes (a larger buffer is zero-filled). An external buffer (from .for / + // .string, or a slice) cannot be resized. + dm("resize", func(_ *VM, self object.Value, args []object.Value, _ *Proc) object.Value { + b := self.(*ioBuffer) + b.live() + if b.external { + raise("IO::Buffer::AccessError", "Cannot resize external buffer!") + } + nd := make([]byte, int(intArg(args[0]))) + copy(nd, b.data) + b.data = nd + b.borrowed = false + return b + }) + dm("free", func(_ *VM, self object.Value, _ []object.Value, _ *Proc) object.Value { b := self.(*ioBuffer) b.freed = true diff --git a/internal/vm/io_buffer_internal_test.go b/internal/vm/io_buffer_internal_test.go index 81acbc83..dbbea4c4 100644 --- a/internal/vm/io_buffer_internal_test.go +++ b/internal/vm/io_buffer_internal_test.go @@ -72,9 +72,21 @@ func TestIOBuffer(t *testing.T) { {`b = IO::Buffer.new(6); b.set_string("abcdef", 0, 3); p b.get_string(0, 3)`, `"abc"`}, {`b = IO::Buffer.new(6); b.set_string("abcdef", 0, 2, 2); p b.get_string(0, 2)`, `"cd"`}, {`begin; IO::Buffer.new(2).set_value(:U32, 0, 1); rescue ArgumentError => e; p e.class; end`, `ArgumentError`}, + // slice shares memory (a write through the slice shows in the original), + // inherits read-only, and reports as neither internal nor external. + {`b = IO::Buffer.new(5); s = b.slice(1, 2); s.set_string("XY"); p b.get_string.bytes`, `[0, 88, 89, 0, 0]`}, + {`b = IO::Buffer.for("hello"); s = b.slice(1, 3); p [s.get_string, s.readonly?, s.internal?, s.external?]`, `["ell", true, false, false]`}, + {`b = IO::Buffer.for("hello"); p [b.slice.get_string, b.slice(2).get_string]`, `["hello", "llo"]`}, + // resize preserves the leading bytes; growing a slice detaches it (now internal). + {`b = IO::Buffer.new(4); b.set_string("abcd"); b.resize(6); p [b.size, b.get_string(0, 4)]`, `[6, "abcd"]`}, + {`b = IO::Buffer.new(4); b.set_string("abcd"); b.resize(2); p b.get_string`, `"ab"`}, + {`b = IO::Buffer.new(4); s = b.slice(0, 2); s.resize(5); p [s.size, s.internal?]`, `[5, true]`}, // free nullifies the buffer. {`b = IO::Buffer.new(4); b.free; p [b.null?, b.size, b.internal?, b.to_s]`, `[true, 0, false, "#"]`}, // Error paths. + {`begin; IO::Buffer.for("hello").slice(3, 10); rescue ArgumentError => e; p e.message; end`, `"Specified offset+length is bigger than the buffer size!"`}, + {`begin; IO::Buffer.for("x").resize(5); rescue IO::Buffer::AccessError => e; p e.message; end`, `"Cannot resize external buffer!"`}, + {`begin; b = IO::Buffer.new(2); b.free; b.slice(0, 1); rescue IO::Buffer::AccessError => e; p e.class; end`, `IO::Buffer::AccessError`}, {`begin; IO::Buffer.for("x").set_string("y"); rescue IO::Buffer::AccessError => e; p e.message; end`, `"Buffer is not writable!"`}, {`begin; IO::Buffer.for("x").set_value(:U8, 0, 1); rescue IO::Buffer::AccessError => e; p e.class; end`, `IO::Buffer::AccessError`}, {`begin; b = IO::Buffer.new(2); b.free; b.get_string; rescue IO::Buffer::AccessError => e; p e.message; end`, `"The buffer is not allocated!"`}, diff --git a/scripts/conformance/rubyspec/FLOOR b/scripts/conformance/rubyspec/FLOOR index 8dde623d..cf516350 100644 --- a/scripts/conformance/rubyspec/FLOOR +++ b/scripts/conformance/rubyspec/FLOOR @@ -1 +1 @@ -15890 +15905