Should this always work?

[frame]

I always thought as long as an object implements an interface, it 
should be able to cast it from a void* if it really points to a 
supporting object.

I have the similar structure:


```d
interface AI {
     string doSomething();
}

template S() {
     void foo() {

     }
}

abstract class A : AI {
     string doSomething() {
         return "Hello, World";
     }
}

class B : A {
     mixin S;

     void other() {

     }
}

auto b = new B;
auto p = cast(void*) b;
auto c = cast(AI) p;

c.doSomething();
```

But in my code with the real object, this generates a RangeError, 
AcccesError, memory garbage:
```d
auto b = new B;
auto p = cast(void*) b;
auto c = cast(AI) p; // AI with corrupt data

c.doSomething(); // error
```

But this works:
```d
auto b = new B;
auto p = cast(void*) b;
auto c = cast(A) p; // A with correct data

c.doSomething(); // no error
```

If the runtime could not successfully cast it to AI, it should 
return null. Am I wrong here?