Bug 8269 – The 'with statement' does not observe temporary object lifetime

The spec at http://dlang.org/statement.html#WithStatement says: <quote> The WithStatement with (expression) { ... ident; } is semantically equivalent to: { Object tmp; tmp = expression; ... tmp.ident; } </quote> Unfortunately, the anonymous object in the following code is destroyed even before entering the 'with' scope: import std.stdio; struct S { this(int i = 0) { writeln("constructed"); } ~this() { writeln("destructed"); } } void main() { with(S(1)) { writeln("inside 'with' statement"); } } Observed output: constructed destructed inside 'with' statement Expected output: constructed inside 'with' statement destructed Ali

*** Issue 9145 has been marked as a duplicate of this issue. ***

Slightly renamed title to make it more searchable.

(In reply to comment #0) > The spec at > > http://dlang.org/statement.html#WithStatement > > says: > > <quote> > The WithStatement > with (expression) > { > ... > ident; > } > is semantically equivalent to: > { > Object tmp; > tmp = expression; > ... > tmp.ident; > } > </quote> What it does end up doing is inject an initializer and a comma expression, and then takes the address of that. It's totally bizarre..

*** Issue 11351 has been marked as a duplicate of this issue. ***

Smaller testcase: --- struct S { bool alive = true; ~this() { alive = false; } } void main() { with(S()) // <-- `S` is created and destructed here assert(alive); // fails } --- This is a major issue as it breaks RAII.

@yebblies: why did you remove the "preapproved" tag?

(In reply to Andrei Alexandrescu from comment #6) > @yebblies: why did you remove the "preapproved" tag? I don't see the point of it on a wrong code bug. Either the bug is valid and it will be fixed, or it isn't and it won't.

I see - fine. I was hoping to boost its visibility :o).

(In reply to Andrei Alexandrescu from comment #8) > I see - fine. I was hoping to boost its visibility :o). I can't speak for the other dmd contributors, but I never look at the preapproved list. I will look at the ice and wrong-code lists when I'm in that kind of mood. If you really want to boost its profile, tou could try putting a big bounty on it :D This is actually a perfect example of a good bug for a bounty - it is non-controversial, and has a small, well-defined scope. It's almost entirely debugging and implementation. Anyway, it's next on my list, assuming I don't get distracted. As Andrej noted the implementation of 'with' is a big weird and needs some work.

@yebblies: good idea! https://www.bountysource.com/issues/3635875-the-with-statement-does-not-observe-temporary-object-lifetime

I would suspect that this is likely because of how the with statement currently expands itself, although it's certainly possible that it's e2ir (though I don't think it actually is present at the e2ir layer, was about to check that)

It is how it expands itself. with(exp) {...} gets re-written to with(auto tmp = exp, tmp) {...} and then with(auto withptr = &(auto tmp = exp, tmp)) {...} which ends up looking like auto withptr = &(auto tmp = exp, tmp) ... in the glue layer. Since tmp is local to the expression, the dtor code is inserted right after it. https://github.com/D-Programming-Language/dmd/pull/3855

Why would the with statement be creating a temporary in the first place? It seems terribly inefficient, surely it can just alias the original object and be done with it?

(In reply to Damian from comment #13) > Why would the with statement be creating a temporary in the first place? It > seems terribly inefficient, surely it can just alias the original object and > be done with it? It does when it can, but it can't when the with argument is an rvalue. eg Struct generateStructForMe() { ... } with(generateStructForMe()) { auto x = member1 + member2; } You want this to expand to (and in lvalue cases it will) auto withptr = &generateStructForMe(); auto x = withptr.member1 + withptr.member2; But this can't work, because the struct has to be stored somewhere before you can take its address. The struct literals in these examples are also rvalues and work the same way. Class references and struct pointers do not have this problem an can be copied freely.

What does it do about postblits in this case?

(In reply to Orvid King from comment #15) > What does it do about postblits in this case? The same thing that happens with auto tmp = someRvalue(); with(tmp) { }

Commits pushed to master at https://github.com/D-Programming-Language/dmd https://github.com/D-Programming-Language/dmd/commit/4321a856bd1e3ed1aa0fe5e613a658ad192c9e86 Fix Issue 8269 - The 'with statement' does not observe temporary object lifetime https://github.com/D-Programming-Language/dmd/commit/839f2e1bc929ba3055c4d64c022a5f98fa7225c5 Merge pull request #3855 from yebblies/issue8269 Issue 8269 - The 'with statement' does not observe temporary object lifetime