This code

---
void main()
{
    const s = S(42);
    T* ptr = cast() s.t;
}

struct S
{
    T* t;

    this(int i)
    {
        t = new T(42);
    }
}

struct T
{
    int i;
}
---

fails to compile:

---
q.d(4): Error: cannot implicitly convert expression `s.t` of type `const(T)*` to `T*`
---

It's exactly what would happen if the cast() were not there. If I change the offending line to

---
    T* ptr = (cast() s).t;
---

to force the cast to be on s, then the code compiles. So, it would appear that without parens, the cast() applies to t (which is what I would expect), and putting the parens around the entire expression has the same result as having none:

---
    T* ptr = (cast() s.t);
---

which is also what I would expect. However, in this case, I wouldn't expect it to matter one whit whether the cast applied to s or to t. If s becomes mutable, then its t member will be mutable, and if s is left const and the cast applies to its t member, then t should still be mutable, and then the resulting pointer value should be mutable. In either case, the result should be a mutable T* which should be able to be used to initialize the variable.

Maybe there's some language detail here that I'm missing, and this isn't actually a bug, but I don't see any reason why using cast() wouldn't work on s.t, so something about using the . operator seems to be mucking things up.

Note that

---
    T* t = cast(T*) s.t;
---

does work, so the issue is specifically with cast().