An Issue I Wish To Raise Awareness On

[Atila Neves via Digitalmars-d]

On Friday, 21 July 2017 at 22:02:41 UTC, Jonathan M Davis wrote:
> On Friday, July 21, 2017 08:37:51 Atila Neves via Digitalmars-d 
> wrote:
>> On Thursday, 20 July 2017 at 21:20:46 UTC, Jonathan M Davis 
>> wrote:
>> > On Thursday, July 20, 2017 07:40:35 Dominikus Dittes Scherkl
>> >
>> > via Digitalmars-d wrote:
>> >> On Wednesday, 19 July 2017 at 22:35:43 UTC, Jonathan M Davis
>> >>
>> >> wrote:
>> >> > The issue isn't the object being destroyed. It's what it 
>> >> > refers to via its member variables. For instance, what if 
>> >> > an object were to remove itself from a shared list when 
>> >> > it's destroyed (e.g. because it's an observer in the 
>> >> > observer pattern). The object has a reference to the 
>> >> > list, but it doesn't own it.
>> >>
>> >> So, even a thread-local object that has references to a 
>> >> shared
>> >> list
>> >> has to handle those as shared, even in its non-shared
>> >> destructor.
>> >> I can't follow your argument.
>> >
>> > You can't just strip off shared. To do so defeats the 
>> > purpose of shared. If you have something like
>> >
>> > struct S
>> > {
>> >
>> >      shared List<Foo> _list;
>> >
>> >      ~this()
>> >      {
>> >
>> >         ...
>> >
>> >      }
>> >
>> > }
>
> Wow. I've been doing too much C++ lately apparently, since I 
> used <>. :|
>

I noticed, but I wasn't going to say anything ;)

>> This is fine. What dmd does now is strip shared off of the 
>> `this` pointer, not the member variables. There's only a 
>> problem if the sharedness of the member variable(s) depends on 
>> sharedness of the enclosing object.
>
> What happens with something like
>
> struct S
> {
>     Foo* _foo;
>
>     ~this() {...}
> }
>
> shared S s;
>
> Inside the destructor, is what _foo points to still treated as 
> shared: shared(Foo)*?

No. This is what I meant by the sharedness depening on the 
enclosing object. However, there's a workaround:

struct Foo { }


struct S {

     Foo* _foo;
     bool _isShared;

     this(this T, U)(U foo) if(is(T == shared) && is(U == 
shared(Foo)*) || !is(T == shared) && is(U == Foo*)) {
         static if(is(T == shared)) _isShared = true;
         _foo = foo;
     }

     ~this() {
         import std.stdio: writeln;
         _isShared ? writeln("shared dtor") : writeln("non-shared 
dtor");
     }
}

void main() {
     auto f = Foo();
     auto sf = shared Foo();
     auto s = S(&f);
     auto ss = shared S(&sf);
}


It's annoying to use that bool up memory-wise, but I assume it's 
not a big deal for most applications.

In any case, that example wouldn't have worked anyway before my 
change to dmd - even creating the S struct would've been a 
compiler error.

Atila