Tests of CallStack unwinding after caught exception (and quick patch)

Jint.Tests/Runtime/CallStackTests.cs

@@ -0,0 +1,60 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace Jint.Tests.Runtime
+{
+    public class CallStackTests
+    {
+        [Fact]
+        public void ShouldUnwindAfterCaughtException()
+        {
+            var engine = new Engine();
+            engine.Execute(@"
+                function thrower()
+                {
+                    throw new Error('test');
+                }
+
+                try
+                {
+                    thrower();
+                }
+                catch (error)
+                {
+                }
+                "
+            );
+            Assert.Equal(0, engine.CallStack.Count);
+        }
+
+        [Fact]
+        public void ShouldUnwindAfterCaughtExceptionNested()
+        {
+            var engine = new Engine();
+            engine.Execute(@"
+                function thrower2()
+                {
+                    throw new Error('test');
+                }
+
+                function thrower1()
+                {
+                    thrower2();
+                }
+
+                try
+                {
+                    thrower1();
+                }
+                catch (error)
+                {
+                }
+            ");
+            Assert.Equal(0, engine.CallStack.Count);
+        }
+    }
+}

Jint/Runtime/Interpreter/Statements/JintTryStatement.cs

@@ -30,12 +30,23 @@ public JintTryStatement(Engine engine, TryStatement statement) : base(engine, st
 
         protected override Completion ExecuteInternal()
         {
+            int callStackSizeBeforeExecution = _engine.CallStack.Count;
+
             var b = _block.Execute();
             if (b.Type == CompletionType.Throw)
             {
                 // execute catch
                 if (_catch != null)
                 {
+                    // Quick-patch for call stack not being unwinded when an exception is caught.
+                    // Ideally, this should instead be solved by always popping the stack when returning
+                    // from a call, regardless of whether it throws (i.e. CallStack.Pop() in finally clause
+                    // in Engine.Call/Engine.Construct - however, that method currently breaks stack traces
+                    // in error messages.
+                    while (callStackSizeBeforeExecution < _engine.CallStack.Count)
+                    {
+                        _engine.CallStack.Pop();
+                    }
                     var c = b.Value;
                     var oldEnv = _engine.ExecutionContext.LexicalEnvironment;
                     var catchEnv = LexicalEnvironment.NewDeclarativeEnvironment(_engine, oldEnv);