Unexpected memory reuse

[Anonymous via Digitalmars-d-learn]

module test;
import std.stdio;

class buffer(T, size_t sz) {
	auto arr = new T[sz];
	enum end = sz-1;
}

void foo(T, size_t sz)() {
	auto buf = new buffer!(T,sz);
	writeln("before ", buf.arr);
	foreach(ref ele; buf.arr) ++ele;
	writeln("after ", buf.arr);
}

unittest {
	foo!(uint,4);
	foo!(uint,4);

	auto a = new buffer!(uint,4);
	writeln(a.arr);
	auto b = new buffer!(uint,4);
	writeln(b.arr);
}

void main() {
	auto c = new buffer!(uint,4);
	writeln(c.arr);
}

rdmd -unittest test.d
before [0, 0, 0, 0]
after [1, 1, 1, 1]
before [1, 1, 1, 1]
after [2, 2, 2, 2]
a [2, 2, 2, 2]
b [2, 2, 2, 2]
c [2, 2, 2, 2]
[Finished in 1.3s]

I narrowed this down after much frustration. I'm using some fixed 
size buffers and thought it useful to define the size as part of 
the type, from which other aspects could be statically derived. 
Apparently it's not so useful. So I guess I can refactor the 
buffer's array length into the constructor or something, but I 
really didn't see this kind of memoization(?) coming.