Bug 13501 – [REG2.052] Crash with throwing in scope(failure) after throwing in scope(success)

///////////////////// test.d ///////////////////// int careful() { scope(failure) throw new Exception("Failure"); scope(success) throw new Exception("Success"); return victim(); } int victim() { return 0; } void main() { careful(); } //////////////////////////////////////////////////

This is an old regression. Introduced in https://github.com/D-Programming-Language/druntime/commit/c241f8664934ba74b059e0f61e573f3028d53d02

Any chance that someone can fix this? I wouldn't rate this as regression because it's extremely old.

Is this example valid ? The specs says: A scope(exit) or scope(success) statement may not exit with a throw, goto, break, continue, or return; nor may it be entered with a goto. http://dlang.org/spec/statement.html#ScopeGuardStatement

If that's true, then the code inside them must be enforced as @nothrow, but I bet that would break a ton of D code. It might be that the spec is outdated. Adding spec keyboard.

Throwing inside the scope statement is what's called a "double fault exception". In C++, doing such aborts the program. Andrei proposed extending D to handle this with "exception chaining" and Don Clugston implemented it. Unfortunately, exception chaining turns out to be very confusing in its semantics. Worse, it doesn't fit in well with the exception unwinding schemes we'd like D to fit in with. The spec is correct here, and the compiler should deprecate throwing in the scope statement.

I can understand such limitations being present for scope(exit), but not for scope(success). scope(success) blocks are trivially lowered by inserting code before all returns (or other statements that normally leave the scope), so they should not in principle be special as far as exceptions are concerned. If the problem is generally about throwing while an exception is in flight, I feel like this is too useful to give up at the point, because error recovery in principle may be a non-trivial operation that itself may throw. > The spec is correct here, and the compiler should deprecate throwing in the > scope statement. Such a deprecation would need to be about any and all nothrow code, not just throw statements, which would be a major breaking change. It would, at least, break the pattern: foreach (foo; foos) { scope(failure) stderr.writeln("Error while processing foo" , foo, ":"); processFoo(foo); } because the writeln may throw.

(In reply to Vladimir Panteleev from comment #6) > Such a deprecation would need to be about any and all nothrow code, non-nothrow code*

I cannot reproduce the crash. I'm getting the failure exception being thrown. That's because the scope(failure) simply rewrites to: int careful() { try { scope(success) throw new Exception("Success"); return victim(); } catch(Exception) { throw new Exception("Failure"); } } Is this on par with your expectations Vladimir?