struct Bob { void setThing() shared; } As I understand, `shared` attribution intends to guarantee that I dun synchronisation internally. This method is declared shared, so if I have shared instances, I can call it... because it must handle thread-safety internally. void f(ref shared Bob a, ref Bob b) { a.setThing(); // I have a shared object, can call shared method b.setThing(); // ERROR } The method is shared, which suggests that it must handle thread-safety. My instance `b` is NOT shared, that is, it is thread-local. A method that handles thread-safety doesn't not work when it's only accessed from a single thread. mutable -> shared should work the same as mutable -> const... because surely that's safe?
Conversation: https://github.com/dlang/dmd/pull/8782 Reveals that `scope` is also necessary to guarantee that the promoted reference does not escape. Promotion is safe so long as no promoted-reference outlives the call where the instance was promoted. struct Bob { void setThing() shared scope; } void f(ref shared Bob a, ref Bob b) { a.setThing(); // I have a shared object, can call shared method b.setThing(); // this should work with `scope` }
THIS ISSUE HAS BEEN MOVED TO GITHUB https://github.com/dlang/dmd/issues/17880 DO NOT COMMENT HERE ANYMORE, NOBODY WILL SEE IT, THIS ISSUE HAS BEEN MOVED TO GITHUB