cas and interfaces

[Johan Engelen]

On Sunday, 23 December 2018 at 14:07:04 UTC, Johannes Loher wrote:
> I recently played around with atomic operations. While doing 
> so, I noticed a problem with the interaction of interfaces and 
> cas. Consider the following program:
>
> ```
> import core.atomic;
> import std.stdio;
>
> interface TestInterface
> {
> }
>
> class TestClass : TestInterface
> {
> }
>
> void main()
> {
>     shared TestInterface testInterface = new shared TestClass;
>     cas(&testInterface, testInterface, new shared 
> TestClass).writeln;
>     writeln(typeid(testInterface));
> }
> ```
> (https://run.dlang.io/is/9P7PAb)

The types of the 2nd and 3rd arguments of `cas` do not have to be 
the same, and aren't in your case. I think what's happening is 
that you are overwriting `testInterface` with a pointer to a 
TestClass which is not a valid TestInterface pointer. And then 
the program does something invalid because, well, you enter UB 
land.
Fixed by:
```
cas(&testInterface, testInterface, cast(shared(TestInterface)) 
new shared TestClass).writeln;
```
Note the cast!

Whether this is a bug in `cas` or not, I don't know. The `cas` 
template checks whether the 3rd can be assigned to the 1st 
argument (`*here = writeThis;`) which indeed compiles _with_ an 
automatic conversion. But then the implementation of `cas` does 
not do any automatic conversions (casts to `void*`). Hence the 
problem you are seeing.

-Johan