Yeah, but its the issue that "a" is just the class *reference*. a points to the class payload, which contains p, and then *p* points to i. But a itself does not point to i. It's the sentence with the bold you commented on:

```D
If $(D target) is a pointer, a dynamic array or a class, then pointsTo will only
check if $(D source) points to $(D target), $(B not) what $(D target) references. 
```

These were the existing semantics, and for what `pointsTo` is made for, I think it is the correct semantic. Having point to analise what is *inside* the payload would prove problematic for generic code.

I will change it to this, for more clarity?

```D
assert(!pointsTo(a, b)); //a and b are aliased, but a does not point to b.
assert( pointsTo(a, a.p)); //a points the class member a.p

a.p = &i;
assert( pointsTo(a.p, i)); //a.p points to i  
assert(!pointsTo(a, i)); //but a itself does not 
```

If you want to know if a class body points to something, then you can call `pointsTo` inside a `tupleof` loop. Not very complicated. Finding out if something points *inside* a class body is more complicated though, but it can be done doing something like this:

(not checked, I need to run ... )
```D
    C a = new C, b = a;
    auto p = cast( ubyte[__traits(classInstanceSizeOf, C)] * )b;
    pointsTo(a, *p);
```