hijacking a class's members

[Rory Mcguire]

Hi,

The code below is my beginning to attempt a class which implements any class
and throws an exception if one tries to access any member of that class.

Problem is that if I use:
auto a1 = noinit!(A)();

it works and accesses the int x() {...} member of the generated class, but 
if I use:
A a1 = noinit!(A)();

it accesses A.x instead of the generated classes x.

So am I wrong in making a sub class have a member function which hides a 
parent class's member variable or is the compiler wrong and it should 
generate a call to generated sub class?


Thanks!!!
-Rory











================================================
import std.algorithm;
import std.contracts;
import std.traits;

class A {
	int x;
}

string thrower(T)(string name) {
	static if (isNumeric!T) {
		return "@property ref "~ T.stringof ~" "~ name ~"() { 
throw new Exception(\"Uninitialized access!\"); }"
				"@property ref "~ T.stringof ~" 
"~ name ~"(int ignored) { throw new Exception(\"Uninitialized access\"); }";
	} else {
		return "error";
	}
}
string build(alias T, alias generator)(string myname) {
	string s = "auto "~ myname ~" = new class "~T.stringof~" { 
invariant() { throw new Exception(\"inv\");}\n";
	foreach (i,t; typeof(T.tupleof)) {
		string name = find(T.tupleof[i].stringof, '.');
		enforce(name.length >= 2);
		name = name[1..$];
		//pragma(msg, t," ", A.tupleof[i]);
		s ~= "\t"~generator!t(name) ~"\n";
	}
	return s~ "};";
}

auto noinit(alias T)() {
	mixin(build!(T,thrower)("tmp"));
	return tmp;
}


void main() {
	A a = noinit!(A)();
	auto a1 = noinit!(A)();
//	pragma(msg, build!(A,thrower)("Athrower"));
	
	int i = a.x = 3; // uses A.x not the generated ??.x
	int j = a1.x = 3; // uses ??.x
	assert(a.x == 3);
}