language: guarantee that rethrow preserves stack trace identity

[kasperl]

See issue #15171. I think it makes sense to put this in the language spec as it is a core property of the rethrow semantics.

   var e0, e1, s0, s1;
   try {
     try {
       throw 42;
     } catch (e, s) {
       s0 = s;
       e0 = e;
       rethrow;
     }
   } catch (e, s) {
     e1 = e;
     s1 = s;
   }
   assert(identical(e0, e1));
   assert(identical(s0, s1));

[kasperl]

Marked this as blocking #15171.

[gbracha]

If you feel it's important, we can certainly do that. I find it an odd guarantee to make.

---

Set owner to @gbracha.
Added Accepted label.

[lrhn]

I'm also not convinced that the stack traces need to be identical.
Can you explain why you think it is important?

[sethladd]

cc @nex3.
cc @efortuna.

[nex3]

For a practical use case, this property is critical for implementing stack chain capturing as is currently done in the stack_trace package. It uses an expando on stack traces to track the prior traces in the chain, but this only works if the same stack trace has consistent identity over time. Stack chains are an important tool for debugging asynchronous code, but currently they don't work under dart2js because it doesn't support this property.

[kasperl]

Not sure I understand the argument against guaranteeing this? We have to specify that rethrow preserves the original stack trace somehow (that's 100% essential) and the simplest way of specifying what preserving means is to say that it preserves identity. Also, it's by far the simplest way of implementing it.

[kasperl]

Removed this from the 1.4 milestone.
Added this to the 1.5 milestone.

[kasperl]

Removed this from the 1.5 milestone.
Added this to the 1.6 milestone.

[kasperl]

Removed this from the 1.6 milestone.
Added Oldschool-Milestone-1.6 label.

[kasperl]

Removed Oldschool-Milestone-1.6 label.

[sigmundch]

Whats the current status on this?

The spec 2nd edition says about rethrow (17.10):

Let f be the immediately enclosing function, and let on T catch (p1, p2)
be the immediately enclosing catch clause (17.11).
A rethrow statement always appears inside a catch clause, and any catch
clause is semantically equivalent to some catch clause of the form on T catch
(p1, p2). So we can assume that the rethrow is enclosed in a catch clause of
that form.

The current exception (16.9) is set to p1, the current return value (17.12)
becomes undefined, and the active stack trace (17.11) is set to p2.

This last sentence reads to me as if the stack trace objects must be identical.

[gbracha]

We did introduce this wording into the second edition (it was not there in the first edition). I forget the history, but as worded, it does imply that rethrow preserves the stack object.

[sigmundch]

Great, thanks! I'm closing this issue as fixed and move forward with fixing the dart2js implementation.

---

Added Fixed label.