Rethrow exceptions instead of throwing them again

Dan Zwell · ugly-ec2-automated · commit 52dc07cc8dfb · 2018-04-12T08:17:45.000+01:00
When an exception is thrown again ("throw ex"), its stack will be overwritten. Instead, it should be rethrown with its original context. More info here (Figure 2): https://msdn.microsoft.com/en-us/magazine/mt620018.aspx Issue #5
diff --git a/UnityProject/Assets/Plugins/AsyncAwaitUtil/Source/IEnumeratorAwaitExtensions.cs b/UnityProject/Assets/Plugins/AsyncAwaitUtil/Source/IEnumeratorAwaitExtensions.cs
@@ -4,6 +4,7 @@
 using System.Linq;
 using System.Reflection;
 using System.Runtime.CompilerServices;
+using System.Runtime.ExceptionServices;
 using System.Text;
 using System.Threading;
 using UnityEngine;
@@ -154,7 +155,7 @@ public T GetResult()
 
             if (_exception != null)
             {
-                throw _exception;
+                ExceptionDispatchInfo.Capture(_exception).Throw();
             }
 
             return _result;
@@ -202,7 +203,7 @@ public void GetResult()
 
             if (_exception != null)
             {
-                throw _exception;
+                ExceptionDispatchInfo.Capture(_exception).Throw();
             }
         }
 
diff --git a/UnityProject/Assets/Plugins/AsyncAwaitUtil/Source/TaskExtensions.cs b/UnityProject/Assets/Plugins/AsyncAwaitUtil/Source/TaskExtensions.cs
@@ -3,6 +3,7 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Runtime.CompilerServices;
+using System.Runtime.ExceptionServices;
 using System.Threading.Tasks;
 using UnityEngine;
 
@@ -17,7 +18,7 @@ public static IEnumerator AsIEnumerator(this Task task)
 
         if (task.IsFaulted)
         {
-            throw task.Exception;
+            ExceptionDispatchInfo.Capture(task.Exception).Throw();
         }
     }
 
@@ -31,7 +32,7 @@ public static IEnumerator<T> AsIEnumerator<T>(this Task<T> task)
 
         if (task.IsFaulted)
         {
-            throw task.Exception;
+            ExceptionDispatchInfo.Capture(task.Exception).Throw();
         }
 
         yield return task.Result;
diff --git a/UnityProject/Assets/Plugins/UniRx/Scripts/Notification.cs b/UnityProject/Assets/Plugins/UniRx/Scripts/Notification.cs
@@ -8,6 +8,7 @@
 using System.Diagnostics;
 using System.Globalization;
 using System.Collections.Generic;
+using System.Runtime.ExceptionServices;
 using System;
 
 #pragma warning disable 0659
@@ -270,7 +271,8 @@ public OnErrorNotification(Exception exception)
             /// <summary>
             /// Throws the exception.
             /// </summary>
-            public override T Value { get { throw exception; } }
+			// Note: the 2nd "throw" is never reached:
+            public override T Value { get { ExceptionDispatchInfo.Capture(exception).Throw(); throw null; } }
 
             /// <summary>
             /// Returns the exception.
diff --git a/UnityProject/Assets/Plugins/UniRx/Scripts/Observer.cs b/UnityProject/Assets/Plugins/UniRx/Scripts/Observer.cs
@@ -1,4 +1,5 @@
 ﻿using System;
+using System.Runtime.ExceptionServices;
 using System.Threading;
 
 namespace UniRx
@@ -492,7 +493,7 @@ public static IDisposable SubscribeWithState3<T, TState1, TState2, TState3>(this
     internal static class Stubs
     {
         public static readonly Action Nop = () => { };
-        public static readonly Action<Exception> Throw = ex => { throw ex; };
+        public static readonly Action<Exception> Throw = ex => { ExceptionDispatchInfo.Capture(ex).Throw(); };
 
         // marker for CatchIgnore and Catch avoid iOS AOT problem.
         public static IObservable<TSource> CatchIgnore<TSource>(Exception ex)
@@ -505,19 +506,19 @@ internal static class Stubs<T>
     {
         public static readonly Action<T> Ignore = (T t) => { };
         public static readonly Func<T, T> Identity = (T t) => t;
-        public static readonly Action<Exception, T> Throw = (ex, _) => { throw ex; };
+        public static readonly Action<Exception, T> Throw = (ex, _) => { ExceptionDispatchInfo.Capture(ex).Throw(); };
     }
 
     internal static class Stubs<T1, T2>
     {
         public static readonly Action<T1, T2> Ignore = (x, y) => { };
-        public static readonly Action<Exception, T1, T2> Throw = (ex, _, __) => { throw ex; };
+        public static readonly Action<Exception, T1, T2> Throw = (ex, _, __) => { ExceptionDispatchInfo.Capture(ex).Throw(); };
     }
 
 
     internal static class Stubs<T1, T2, T3>
     {
         public static readonly Action<T1, T2, T3> Ignore = (x, y, z) => { };
-        public static readonly Action<Exception, T1, T2, T3> Throw = (ex, _, __, ___) => { throw ex; };
+        public static readonly Action<Exception, T1, T2, T3> Throw = (ex, _, __, ___) => { ExceptionDispatchInfo.Capture(ex).Throw(); };
     }
 }
diff --git a/UnityProject/Assets/Plugins/UniRx/Scripts/Operators/Wait.cs b/UnityProject/Assets/Plugins/UniRx/Scripts/Operators/Wait.cs
@@ -1,4 +1,5 @@
 ﻿using System;
+using System.Runtime.ExceptionServices;
 
 namespace UniRx.Operators
 {
@@ -36,7 +37,7 @@ public T Run()
                 }
             }
 
-            if (ex != null) throw ex;
+            if (ex != null) ExceptionDispatchInfo.Capture(ex).Throw();
             if (!seenValue) throw new InvalidOperationException("No Elements.");
 
             return value;
diff --git a/UnityProject/Assets/Plugins/UniRx/Scripts/Subjects/AsyncSubject.cs b/UnityProject/Assets/Plugins/UniRx/Scripts/Subjects/AsyncSubject.cs
@@ -1,5 +1,6 @@
 ﻿using System;
 using System.Collections.Generic;
+using System.Runtime.ExceptionServices;
 using UniRx.InternalUtil;
 
 #if (ENABLE_MONO_BLEEDING_EDGE_EDITOR || ENABLE_MONO_BLEEDING_EDGE_STANDALONE)
@@ -29,7 +30,7 @@ public T Value
             {
                 ThrowIfDisposed();
                 if (!isStopped) throw new InvalidOperationException("AsyncSubject is not completed yet");
-                if (lastError != null) throw lastError;
+                if (lastError != null) ExceptionDispatchInfo.Capture(lastError).Throw();
                 return lastValue;
             }
         }
@@ -315,7 +316,7 @@ public T GetResult()
 
             if (lastError != null)
             {
-                throw lastError;
+                ExceptionDispatchInfo.Capture(lastError).Throw();
             }
 
             if (!hasValue)
diff --git a/UnityProject/Assets/Plugins/UniRx/Scripts/Subjects/BehaviorSubject.cs b/UnityProject/Assets/Plugins/UniRx/Scripts/Subjects/BehaviorSubject.cs
@@ -1,4 +1,5 @@
 ﻿using System;
+using System.Runtime.ExceptionServices;
 using UniRx.InternalUtil;
 
 namespace UniRx
@@ -23,7 +24,7 @@ public T Value
             get
             {
                 ThrowIfDisposed();
-                if (lastError != null) throw lastError;
+                if (lastError != null) ExceptionDispatchInfo.Capture(lastError).Throw();
                 return lastValue;
             }
         }
diff --git a/UnityProject/Assets/Plugins/UniRx/Scripts/UnityEngineBridge/MainThreadDispatcher.cs b/UnityProject/Assets/Plugins/UniRx/Scripts/UnityEngineBridge/MainThreadDispatcher.cs
@@ -5,6 +5,7 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Runtime.ExceptionServices;
 using System.Reflection;
 using System.Threading;
 using UniRx.InternalUtil;
@@ -444,7 +445,7 @@ public static void Initialize()
                     // Throw exception when calling from a worker thread.
                     var ex = new Exception("UniRx requires a MainThreadDispatcher component created on the main thread. Make sure it is added to the scene before calling UniRx from a worker thread.");
                     UnityEngine.Debug.LogException(ex);
-                    throw ex;
+                    ExceptionDispatchInfo.Capture(ex).Throw();
                 }
 
                 if (isQuitting)
diff --git a/UnityProject/Assets/Plugins/UniRx/Scripts/UnityEngineBridge/Observable.Unity.cs b/UnityProject/Assets/Plugins/UniRx/Scripts/UnityEngineBridge/Observable.Unity.cs
@@ -5,6 +5,7 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Runtime.ExceptionServices;
 using UniRx.Triggers;
 using UnityEngine;
 using System.Threading;
@@ -156,7 +157,7 @@ bool IEnumerator.MoveNext()
             {
                 if (reThrowOnError && HasError)
                 {
-                    throw Error;
+                    ExceptionDispatchInfo.Capture(Error).Throw();
                 }
 
                 return false;
@@ -1147,7 +1148,7 @@ static IEnumerable<IObservable<T>> RepeatInfinite<T>(IObservable<T> source)
         internal static class Stubs
         {
             public static readonly Action Nop = () => { };
-            public static readonly Action<Exception> Throw = ex => { throw ex; };
+            public static readonly Action<Exception> Throw = ex => { ExceptionDispatchInfo.Capture(ex).Throw(); };
 
             // Stubs<T>.Ignore can't avoid iOS AOT problem.
             public static void Ignore<T>(T t)

Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,7 @@`
`4`	`4`	`using System.Linq;`
`5`	`5`	`using System.Reflection;`
`6`	`6`	`using System.Runtime.CompilerServices;`
	`7`	`+using System.Runtime.ExceptionServices;`
`7`	`8`	`using System.Text;`
`8`	`9`	`using System.Threading;`
`9`	`10`	`using UnityEngine;`
`@@ -154,7 +155,7 @@ public T GetResult()`
`154`	`155`
`155`	`156`	`if (_exception != null)`
`156`	`157`	`{`
`157`		`- throw _exception;`
	`158`	`+ ExceptionDispatchInfo.Capture(_exception).Throw();`
`158`	`159`	`}`
`159`	`160`
`160`	`161`	`return _result;`
`@@ -202,7 +203,7 @@ public void GetResult()`
`202`	`203`
`203`	`204`	`if (_exception != null)`
`204`	`205`	`{`
`205`		`- throw _exception;`
	`206`	`+ ExceptionDispatchInfo.Capture(_exception).Throw();`
`206`	`207`	`}`
`207`	`208`	`}`
`208`	`209`
Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,7 @@`
`3`	`3`	`using System.Collections.Generic;`
`4`	`4`	`using System.Diagnostics;`
`5`	`5`	`using System.Runtime.CompilerServices;`
	`6`	`+using System.Runtime.ExceptionServices;`
`6`	`7`	`using System.Threading.Tasks;`
`7`	`8`	`using UnityEngine;`
`8`	`9`
`@@ -17,7 +18,7 @@ public static IEnumerator AsIEnumerator(this Task task)`
`17`	`18`
`18`	`19`	`if (task.IsFaulted)`
`19`	`20`	`{`
`20`		`- throw task.Exception;`
	`21`	`+ ExceptionDispatchInfo.Capture(task.Exception).Throw();`
`21`	`22`	`}`
`22`	`23`	`}`
`23`	`24`
`@@ -31,7 +32,7 @@ public static IEnumerator<T> AsIEnumerator<T>(this Task<T> task)`
`31`	`32`
`32`	`33`	`if (task.IsFaulted)`
`33`	`34`	`{`
`34`		`- throw task.Exception;`
	`35`	`+ ExceptionDispatchInfo.Capture(task.Exception).Throw();`
`35`	`36`	`}`
`36`	`37`
`37`	`38`	`yield return task.Result;`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`using System;`
	`2`	`+using System.Runtime.ExceptionServices;`
`2`	`3`	`using System.Threading;`
`3`	`4`
`4`	`5`	`namespace UniRx`
`@@ -492,7 +493,7 @@ public static IDisposable SubscribeWithState3<T, TState1, TState2, TState3>(this`
`492`	`493`	`internal static class Stubs`
`493`	`494`	`{`
`494`	`495`	`public static readonly Action Nop = () => { };`
`495`		`- public static readonly Action<Exception> Throw = ex => { throw ex; };`
	`496`	`+ public static readonly Action<Exception> Throw = ex => { ExceptionDispatchInfo.Capture(ex).Throw(); };`
`496`	`497`
`497`	`498`	`// marker for CatchIgnore and Catch avoid iOS AOT problem.`
`498`	`499`	`public static IObservable<TSource> CatchIgnore<TSource>(Exception ex)`
`@@ -505,19 +506,19 @@ internal static class Stubs<T>`
`505`	`506`	`{`
`506`	`507`	`public static readonly Action<T> Ignore = (T t) => { };`
`507`	`508`	`public static readonly Func<T, T> Identity = (T t) => t;`
`508`		`- public static readonly Action<Exception, T> Throw = (ex, _) => { throw ex; };`
	`509`	`+ public static readonly Action<Exception, T> Throw = (ex, _) => { ExceptionDispatchInfo.Capture(ex).Throw(); };`
`509`	`510`	`}`
`510`	`511`
`511`	`512`	`internal static class Stubs<T1, T2>`
`512`	`513`	`{`
`513`	`514`	`public static readonly Action<T1, T2> Ignore = (x, y) => { };`
`514`		`- public static readonly Action<Exception, T1, T2> Throw = (ex, _, __) => { throw ex; };`
	`515`	`+ public static readonly Action<Exception, T1, T2> Throw = (ex, _, __) => { ExceptionDispatchInfo.Capture(ex).Throw(); };`
`515`	`516`	`}`
`516`	`517`
`517`	`518`
`518`	`519`	`internal static class Stubs<T1, T2, T3>`
`519`	`520`	`{`
`520`	`521`	`public static readonly Action<T1, T2, T3> Ignore = (x, y, z) => { };`
`521`		`- public static readonly Action<Exception, T1, T2, T3> Throw = (ex, _, __, ___) => { throw ex; };`
	`522`	`+ public static readonly Action<Exception, T1, T2, T3> Throw = (ex, _, __, ___) => { ExceptionDispatchInfo.Capture(ex).Throw(); };`
`522`	`523`	`}`
`523`	`524`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.Collections.Generic;`
	`3`	`+using System.Runtime.ExceptionServices;`
`3`	`4`	`using UniRx.InternalUtil;`
`4`	`5`
`5`	`6`	`#if (ENABLE_MONO_BLEEDING_EDGE_EDITOR \|\| ENABLE_MONO_BLEEDING_EDGE_STANDALONE)`
`@@ -29,7 +30,7 @@ public T Value`
`29`	`30`	`{`
`30`	`31`	`ThrowIfDisposed();`
`31`	`32`	`if (!isStopped) throw new InvalidOperationException("AsyncSubject is not completed yet");`
`32`		`- if (lastError != null) throw lastError;`
	`33`	`+ if (lastError != null) ExceptionDispatchInfo.Capture(lastError).Throw();`
`33`	`34`	`return lastValue;`
`34`	`35`	`}`
`35`	`36`	`}`
`@@ -315,7 +316,7 @@ public T GetResult()`
`315`	`316`
`316`	`317`	`if (lastError != null)`
`317`	`318`	`{`
`318`		`- throw lastError;`
	`319`	`+ ExceptionDispatchInfo.Capture(lastError).Throw();`
`319`	`320`	`}`
`320`	`321`
`321`	`322`	`if (!hasValue)`
Original file line number	Diff line number	Diff line change
`@@ -5,6 +5,7 @@`
`5`	`5`	`using System;`
`6`	`6`	`using System.Collections;`
`7`	`7`	`using System.Collections.Generic;`
	`8`	`+using System.Runtime.ExceptionServices;`
`8`	`9`	`using UniRx.Triggers;`
`9`	`10`	`using UnityEngine;`
`10`	`11`	`using System.Threading;`
`@@ -156,7 +157,7 @@ bool IEnumerator.MoveNext()`
`156`	`157`	`{`
`157`	`158`	`if (reThrowOnError && HasError)`
`158`	`159`	`{`
`159`		`- throw Error;`
	`160`	`+ ExceptionDispatchInfo.Capture(Error).Throw();`
`160`	`161`	`}`
`161`	`162`
`162`	`163`	`return false;`
`@@ -1147,7 +1148,7 @@ static IEnumerable<IObservable<T>> RepeatInfinite<T>(IObservable<T> source)`
`1147`	`1148`	`internal static class Stubs`
`1148`	`1149`	`{`
`1149`	`1150`	`public static readonly Action Nop = () => { };`
`1150`		`- public static readonly Action<Exception> Throw = ex => { throw ex; };`
	`1151`	`+ public static readonly Action<Exception> Throw = ex => { ExceptionDispatchInfo.Capture(ex).Throw(); };`
`1151`	`1152`
`1152`	`1153`	`// Stubs<T>.Ignore can't avoid iOS AOT problem.`
`1153`	`1154`	`public static void Ignore<T>(T t)`