Cannot get the instance pointer of a class if opCast matches

[rikkimax]

Once a matching opCast is declared in a class, it is no longer possible to obtain the instance pointer needed for memory deallocation.

class Foo {
    auto opCast(T)() {
        return this;
    }
}

void main() {
    Foo foo = new Foo;
    void* ptr = cast(void*)foo; // Error: cannot implicitly convert expression `foo.opCast()` of type `example.Foo` to `void*`
}

[ntrel]

s/cannot/get/ in title.

Doesn't this work?

void* ptr = *cast(void**)&foo;

[rikkimax]

That works, so does a union.

[Adityazzzzz]

Previously, the compiler would prioritize the user-defined opCast over the built-in pointer cast. If opCast returned the object itself (or any non-pointer type), the compiler would error, making it impossible to obtain the raw memory address needed for operations like core.memory.GC.free.

The Fix:

• Modified visit(CastExp) in expressionsem.d.
• Added a check to explicitly skip opCast lookup when the target type is void*.
• This restores the expected behavior: cast(void*) now always yields the raw pointer address, ignoring any user-defined opCast.

Test Case (verified locally):

class Foo {
    auto opCast(T)() {
        return this;
    }
}

void main() {
    Foo foo = new Foo;
    // Before fix: Error: cannot implicitly convert expression `foo.opCast()` to `void*`
    // After fix: Compiles successfully
    void* ptr = cast(void*)foo; 
}

[ntrel]

@Adityazzzzz Won't that break code when opCast returns a pointer?

[Adityazzzzz]

@Adityazzzzz Won't that break code when opCast returns a pointer?

Thanks for catching that! You are absolutely right. If opCast returns a valid pointer (or something convertible to void*), we should definitely respect it.
​I will update the PR to only bypass opCast if its return type is not implicitly convertible to void*. This will fix the infinite recursion bug while preserving valid opCast implementations. Pushing the fix shortly

[Adityazzzzz]

@ntrel
I have updated the logic to strictly target the regression. The compiler now only ignores opCast if it returns a class (which causes the recursion bug). Valid opCast implementations that return pointers are now respected.
I've also added a regression test (compiler/test/runnable/issue22260.d) covering both scenarios.