radiance · Radiance self-hosting compiler

lib/std/arch/rv64/tests/trait.writer.rad 2.6 KiB raw

//! Test realistic trait usage: a Writer abstraction with multiple backends.
//!
//! Exercises: a Writer trait used to abstract over different output targets.
//! A BufferWriter writes to an in-memory buffer; a CountingWriter wraps any
//! Writer and tracks how many bytes flow through it. This tests trait objects
//! as struct fields, dispatch chains, and a real-world composition pattern.

trait Writer {
    fn (*mut Writer) write(data: *[u8]) -> i32;
    fn (*Writer) total() -> i32;
}

/// Writes bytes into a fixed-size buffer.
record BufferWriter {
    buf: [u8; 64],
    pos: i32,
}

instance Writer for BufferWriter {
    fn (w: *mut BufferWriter) write(data: *[u8]) -> i32 {
        let mut i: u32 = 0;
        while i < data.len {
            if w.pos >= 64 {
                return w.pos;
            }
            w.buf[w.pos as u32] = data[i];
            w.pos = w.pos + 1;
            i = i + 1;
        }
        return w.pos;
    }

    fn (w: *BufferWriter) total() -> i32 {
        return w.pos;
    }
}

/// Counts bytes written through it, forwarding to an inner writer.
record CountingWriter {
    inner: *mut opaque Writer,
    count: i32,
}

instance Writer for CountingWriter {
    fn (w: *mut CountingWriter) write(data: *[u8]) -> i32 {
        w.count = w.count + data.len as i32;
        return w.inner.write(data);
    }

    fn (w: *CountingWriter) total() -> i32 {
        return w.count;
    }
}

/// Write a slice through any Writer.
fn emit(w: *mut opaque Writer, data: *[u8]) -> i32 {
    return w.write(data);
}

@default fn main() -> i32 {
    // Direct BufferWriter usage through trait.
    let mut buf = BufferWriter { buf: undefined, pos: 0 };
    let w: *mut opaque Writer = &mut buf;
    emit(w, "hello");
    assert w.total() == 5;
    emit(w, " world");
    assert w.total() == 11;

    // Verify buffer contents.
    assert buf.buf[0] == 'h' as u8;
    assert buf.buf[4] == 'o' as u8;
    assert buf.buf[5] == ' ' as u8;
    assert buf.buf[10] == 'd' as u8;

    // Counting writer wrapping a buffer writer.
    let mut buf2 = BufferWriter { buf: undefined, pos: 0 };
    let bw2: *mut opaque Writer = &mut buf2;
    let mut cw = CountingWriter { inner: bw2, count: 0 };
    let w2: *mut opaque Writer = &mut cw;

    emit(w2, "abc");
    assert cw.count == 3;
    // Underlying buffer also received the bytes.
    assert buf2.pos == 3;

    emit(w2, "defgh");
    assert cw.count == 8;
    assert buf2.pos == 8;

    // Check buf2 contents were forwarded correctly.
    assert buf2.buf[0] == 'a' as u8;
    assert buf2.buf[3] == 'd' as u8;
    assert buf2.buf[7] == 'h' as u8;
    return 0;
}

1	//! Test realistic trait usage: a Writer abstraction with multiple backends.
2	//!
3	//! Exercises: a Writer trait used to abstract over different output targets.
4	//! A BufferWriter writes to an in-memory buffer; a CountingWriter wraps any
5	//! Writer and tracks how many bytes flow through it. This tests trait objects
6	//! as struct fields, dispatch chains, and a real-world composition pattern.
7
8	trait Writer {
9	fn (mut Writer) write(data: [u8]) -> i32;
10	fn (*Writer) total() -> i32;
11	}
12
13	/// Writes bytes into a fixed-size buffer.
14	record BufferWriter {
15	buf: [u8; 64],
16	pos: i32,
17	}
18
19	instance Writer for BufferWriter {
20	fn (w: mut BufferWriter) write(data: [u8]) -> i32 {
21	let mut i: u32 = 0;
22	while i < data.len {
23	if w.pos >= 64 {
24	return w.pos;
25	}
26	w.buf[w.pos as u32] = data[i];
27	w.pos = w.pos + 1;
28	i = i + 1;
29	}
30	return w.pos;
31	}
32
33	fn (w: *BufferWriter) total() -> i32 {
34	return w.pos;
35	}
36	}
37
38	/// Counts bytes written through it, forwarding to an inner writer.
39	record CountingWriter {
40	inner: *mut opaque Writer,
41	count: i32,
42	}
43
44	instance Writer for CountingWriter {
45	fn (w: mut CountingWriter) write(data: [u8]) -> i32 {
46	w.count = w.count + data.len as i32;
47	return w.inner.write(data);
48	}
49
50	fn (w: *CountingWriter) total() -> i32 {
51	return w.count;
52	}
53	}
54
55	/// Write a slice through any Writer.
56	fn emit(w: mut opaque Writer, data: [u8]) -> i32 {
57	return w.write(data);
58	}
59
60	@default fn main() -> i32 {
61	// Direct BufferWriter usage through trait.
62	let mut buf = BufferWriter { buf: undefined, pos: 0 };
63	let w: *mut opaque Writer = &mut buf;
64	emit(w, "hello");
65	assert w.total() == 5;
66	emit(w, " world");
67	assert w.total() == 11;
68
69	// Verify buffer contents.
70	assert buf.buf[0] == 'h' as u8;
71	assert buf.buf[4] == 'o' as u8;
72	assert buf.buf[5] == ' ' as u8;
73	assert buf.buf[10] == 'd' as u8;
74
75	// Counting writer wrapping a buffer writer.
76	let mut buf2 = BufferWriter { buf: undefined, pos: 0 };
77	let bw2: *mut opaque Writer = &mut buf2;
78	let mut cw = CountingWriter { inner: bw2, count: 0 };
79	let w2: *mut opaque Writer = &mut cw;
80
81	emit(w2, "abc");
82	assert cw.count == 3;
83	// Underlying buffer also received the bytes.
84	assert buf2.pos == 3;
85
86	emit(w2, "defgh");
87	assert cw.count == 8;
88	assert buf2.pos == 8;
89
90	// Check buf2 contents were forwarded correctly.
91	assert buf2.buf[0] == 'a' as u8;
92	assert buf2.buf[3] == 'd' as u8;
93	assert buf2.buf[7] == 'h' as u8;
94	return 0;
95	}