Use ExceptionDispatchInfo to throw better exception (When BubbleExceptionContainer and TargetInvocationException (#138 and #124)

codingseb · codingseb · commit 0f2a444ff0c6 · 2022-06-08T09:34:10.000+02:00
diff --git a/CodingSeb.ExpressionEvaluator/CodingSeb.ExpressionEvaluator.csproj b/CodingSeb.ExpressionEvaluator/CodingSeb.ExpressionEvaluator.csproj
@@ -5,9 +5,9 @@
     <Product>CodingSeb.ExpressionEvaluator</Product>
     <Description>A Simple Math and Pseudo C# Expression Evaluator in One C# File. Can also execute small C# like scripts</Description>
     <Copyright>Copyright © Coding Seb 2017</Copyright>
-    <Version>1.4.37.0</Version>
-    <AssemblyVersion>1.4.37.0</AssemblyVersion>
-    <FileVersion>1.4.37.0</FileVersion>
+    <Version>1.4.38.0</Version>
+    <AssemblyVersion>1.4.38.0</AssemblyVersion>
+    <FileVersion>1.4.38.0</FileVersion>
     <OutputPath>bin\$(Configuration)\</OutputPath>
     <Authors>Coding Seb</Authors>
     <PackageId>CodingSeb.ExpressionEvaluator</PackageId>
@@ -19,7 +19,12 @@
     <PackageIconUrl>https://github.com/codingseb/ExpressionEvaluator/blob/master/Icon.png?raw=true</PackageIconUrl>
     <PackageIcon>Icon.png</PackageIcon>
     <PackageRequireLicenseAcceptance>false</PackageRequireLicenseAcceptance>
-    <PackageReleaseNotes>* Correction of the explicit cast between primitive types and rounding numbers before (int)3.6 -&gt; 4 now (int)3.6 -&gt; 3</PackageReleaseNotes>
+    <PackageReleaseNotes>* OptionInlineNamespacesEvaluationActive become OptionInlineNamespacesEvaluationRule and allow more possibilities with the addition of InlineNamespacesList
+   This option can now be one of those :
+   - InlineNamespacesEvaluationRule.AllowAll
+   - InlineNamespacesEvaluationRule.AllowOnlyInlineNamespacesList
+   - InlineNamespacesEvaluationRule.BlockOnlyInlineNamespacesList
+   - InlineNamespacesEvaluationRule.BlockAll</PackageReleaseNotes>
     <PackageLicenseFile>LICENSE.md</PackageLicenseFile>
     <RepositoryUrl>https://github.com/codingseb/ExpressionEvaluator</RepositoryUrl>
 	<GenerateDocumentationFile>true</GenerateDocumentationFile>
diff --git a/CodingSeb.ExpressionEvaluator/ExpressionEvaluator.cs b/CodingSeb.ExpressionEvaluator/ExpressionEvaluator.cs
@@ -1,6 +1,6 @@
 /******************************************************************************************************
     Title : ExpressionEvaluator (https://github.com/codingseb/ExpressionEvaluator)
-    Version : 1.4.37.0 
+    Version : 1.4.38.0 
     (if last digit (the forth) is not a zero, the version is an intermediate version and can be unstable)
 
     Author : Coding Seb
@@ -16,6 +16,7 @@
 using System.Linq;
 using System.Reflection;
 using System.Runtime.CompilerServices;
+using System.Runtime.ExceptionServices;
 using System.Runtime.InteropServices;
 using System.Text;
 using System.Text.RegularExpressions;
@@ -286,6 +287,8 @@ protected enum TryBlockEvaluatedState
                 {ExpressionOperator.ConditionalAnd, (dynamic left, dynamic right) => {
                     if ( left is BubbleExceptionContainer leftExceptionContainer)
                     {
+                        ExceptionDispatchInfo.Capture(leftExceptionContainer.Exception).Throw();
+                        // Will not go here but Resharper detect some errors because he does not know ExceptionDispatchInfo stuff.
                         throw leftExceptionContainer.Exception;
                     }
                     else if (!left)
@@ -294,6 +297,8 @@ protected enum TryBlockEvaluatedState
                     }
                     else if (right is BubbleExceptionContainer rightExceptionContainer)
                     {
+                        ExceptionDispatchInfo.Capture(rightExceptionContainer.Exception).Throw();
+                        // Will not go here but Resharper detect some errors because he does not know ExceptionDispatchInfo stuff.
                         throw rightExceptionContainer.Exception;
                     }
                     else
@@ -307,6 +312,8 @@ protected enum TryBlockEvaluatedState
                 {ExpressionOperator.ConditionalOr, (dynamic left, dynamic right) => {
                     if ( left is BubbleExceptionContainer leftExceptionContainer)
                     {
+                        ExceptionDispatchInfo.Capture(leftExceptionContainer.Exception).Throw();
+                        // Will not go here but Resharper detect some errors because he does not know ExceptionDispatchInfo stuff.
                         throw leftExceptionContainer.Exception;
                     }
                     else if (left)
@@ -315,6 +322,8 @@ protected enum TryBlockEvaluatedState
                     }
                     else if (right is BubbleExceptionContainer rightExceptionContainer)
                     {
+                        ExceptionDispatchInfo.Capture(rightExceptionContainer.Exception).Throw();
+                        // Will not go here but Resharper detect some errors because he does not know ExceptionDispatchInfo stuff.
                         throw rightExceptionContainer.Exception;
                     }
                     else
@@ -1129,7 +1138,14 @@ object ManageJumpStatementsOrExpressionEval(string expression)
 
                 if (expression.StartsWith("throw ", StringComparisonForCasing))
                 {
-                    throw Evaluate(expression.Remove(0, 6)) as Exception;
+                    if (Evaluate(expression.Remove(0, 6)) is Exception exception)
+                    {
+                        ExceptionDispatchInfo.Capture(exception).Throw();
+                    }
+                    else
+                    {
+                        throw new ExpressionEvaluatorSyntaxErrorException("throw keyword must be follow by an Exception instance");
+                    }
                 }
 
                 expression = returnKeywordRegex.Replace(expression, match =>
@@ -1595,7 +1611,8 @@ public object Evaluate(string expression)
 
             try
             {
-                ExpressionEvaluationEventArg expressionEvaluationEventArg = new ExpressionEvaluationEventArg(expression, this);
+                ExpressionEvaluationEventArg expressionEvaluationEventArg =
+                    new ExpressionEvaluationEventArg(expression, this);
 
                 ExpressionEvaluating?.Invoke(this, expressionEvaluationEventArg);
 
@@ -1618,7 +1635,8 @@ public object Evaluate(string expression)
 
                             if (!s.Trim().Equals(string.Empty))
                             {
-                                throw new ExpressionEvaluatorSyntaxErrorException($"Invalid character [{(int)s[0]}:{s}]");
+                                throw new ExpressionEvaluatorSyntaxErrorException(
+                                    $"Invalid character [{(int)s[0]}:{s}]");
                             }
                         }
                     }
@@ -1637,6 +1655,10 @@ public object Evaluate(string expression)
 
                 return result;
             }
+            catch (TargetInvocationException exception) when (exception.InnerException != null)
+            {
+                ExceptionDispatchInfo.Capture(exception.InnerException).Throw();
+            }
             finally
             {
                 evaluationStackCount--;
@@ -3088,7 +3110,9 @@ protected virtual bool EvaluateString(string expression, Stack<object> stack, re
                             object obj = Evaluate(innerExp.ToString());
 
                             if (obj is BubbleExceptionContainer bubbleExceptionContainer)
-                                throw bubbleExceptionContainer.Exception;
+                            {
+                                ExceptionDispatchInfo.Capture(bubbleExceptionContainer.Exception).Throw();
+                            }
 
                             resultString.Append(obj);
                         }
@@ -3283,15 +3307,16 @@ void EvaluateFirstPreviousUnaryOp(int j)
                 {
                     if (item is BubbleExceptionContainer bubbleExceptionContainer)
                     {
-                        throw bubbleExceptionContainer.Exception; //Throw the first occuring error
+                        //Throw the first occuring error
+                        ExceptionDispatchInfo.Capture(bubbleExceptionContainer.Exception).Throw();
                     }
                 }
                 throw new ExpressionEvaluatorSyntaxErrorException("Syntax error. Check that no operator is missing");
             }
             else if (evaluationStackCount == 1 && stack.Peek() is BubbleExceptionContainer bubbleExceptionContainer)
             {
                 //We reached the top level of the evaluation. So we want to throw the resulting exception.
-                throw bubbleExceptionContainer.Exception;
+                ExceptionDispatchInfo.Capture(bubbleExceptionContainer.Exception).Throw();
             }
 
             return stack.Pop();
@@ -3364,7 +3389,9 @@ protected virtual object ManageKindOfAssignation(string expression, ref int inde
             }
 
             if (result is BubbleExceptionContainer exceptionContainer)
-                throw exceptionContainer.Exception;
+            {
+                ExceptionDispatchInfo.Capture(exceptionContainer.Exception).Throw();
+            }
 
             if (stack != null)
             {
@@ -3395,9 +3422,9 @@ protected virtual void AssignVariable(string varName, object value)
                     {
                         Variables[varName] = Convert.ChangeType(value, stronglyTypedVariable.Type);
                     }
-                    catch
+                    catch(Exception exception)
                     {
-                        throw new InvalidCastException($"A object of type {typeToAssign} can not be cast implicitely in {stronglyTypedVariable.Type}");
+                        throw new InvalidCastException($"A object of type {typeToAssign} can not be cast implicitely in {stronglyTypedVariable.Type}", exception);
                     }
                 }
             }
@@ -4117,8 +4144,10 @@ protected virtual Type GetTypeByFriendlyName(string typeName, string genericType
                     }
                 }
             }
-            catch (ExpressionEvaluatorSyntaxErrorException)
+            catch (ExpressionEvaluatorSyntaxErrorException exception)
             {
+                ExceptionDispatchInfo.Capture(exception).Throw();
+                // Will not go here but Resharper detect some errors because he does not know ExceptionDispatchInfo stuff.
                 throw;
             }
             catch { }
diff --git a/TryWindow/MainWindow.xaml.cs b/TryWindow/MainWindow.xaml.cs
@@ -5,6 +5,7 @@
 using System.IO;
 using System.Linq;
 using System.Reflection;
+using System.Runtime.ExceptionServices;
 using System.Threading;
 using System.Threading.Tasks;
 using System.Windows;
@@ -94,11 +95,11 @@ private async void CalculateButton_Click(object sender, RoutedEventArgs e)
                 if (exception == null)
                     ResultTextBlock.Text = result;
                 else
-                    throw exception;
+                    ExceptionDispatchInfo.Capture(exception).Throw();
             }
             catch (Exception exception)
             {
-                ResultTextBlock.Text = exception.Message;
+                ResultTextBlock.Text = exception.Message + "\r\n" + exception.StackTrace;
             }
 
             ExecutionTimeTextBlock.Text = $"Execution time : {stopWatch.Elapsed}";

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`/******************************************************************************************************`
`2`	`2`	`Title : ExpressionEvaluator (https://github.com/codingseb/ExpressionEvaluator)`
`3`		`- Version : 1.4.37.0`
	`3`	`+ Version : 1.4.38.0`
`4`	`4`	`(if last digit (the forth) is not a zero, the version is an intermediate version and can be unstable)`
`5`	`5`
`6`	`6`	`Author : Coding Seb`
`@@ -16,6 +16,7 @@`
`16`	`16`	`using System.Linq;`
`17`	`17`	`using System.Reflection;`
`18`	`18`	`using System.Runtime.CompilerServices;`
	`19`	`+using System.Runtime.ExceptionServices;`
`19`	`20`	`using System.Runtime.InteropServices;`
`20`	`21`	`using System.Text;`
`21`	`22`	`using System.Text.RegularExpressions;`
`@@ -286,6 +287,8 @@ protected enum TryBlockEvaluatedState`
`286`	`287`	`{ExpressionOperator.ConditionalAnd, (dynamic left, dynamic right) => {`
`287`	`288`	`if ( left is BubbleExceptionContainer leftExceptionContainer)`
`288`	`289`	`{`
	`290`	`+ ExceptionDispatchInfo.Capture(leftExceptionContainer.Exception).Throw();`
	`291`	`+ // Will not go here but Resharper detect some errors because he does not know ExceptionDispatchInfo stuff.`
`289`	`292`	`throw leftExceptionContainer.Exception;`
`290`	`293`	`}`
`291`	`294`	`else if (!left)`
`@@ -294,6 +297,8 @@ protected enum TryBlockEvaluatedState`
`294`	`297`	`}`
`295`	`298`	`else if (right is BubbleExceptionContainer rightExceptionContainer)`
`296`	`299`	`{`
	`300`	`+ ExceptionDispatchInfo.Capture(rightExceptionContainer.Exception).Throw();`
	`301`	`+ // Will not go here but Resharper detect some errors because he does not know ExceptionDispatchInfo stuff.`
`297`	`302`	`throw rightExceptionContainer.Exception;`
`298`	`303`	`}`
`299`	`304`	`else`
`@@ -307,6 +312,8 @@ protected enum TryBlockEvaluatedState`
`307`	`312`	`{ExpressionOperator.ConditionalOr, (dynamic left, dynamic right) => {`
`308`	`313`	`if ( left is BubbleExceptionContainer leftExceptionContainer)`
`309`	`314`	`{`
	`315`	`+ ExceptionDispatchInfo.Capture(leftExceptionContainer.Exception).Throw();`
	`316`	`+ // Will not go here but Resharper detect some errors because he does not know ExceptionDispatchInfo stuff.`
`310`	`317`	`throw leftExceptionContainer.Exception;`
`311`	`318`	`}`
`312`	`319`	`else if (left)`
`@@ -315,6 +322,8 @@ protected enum TryBlockEvaluatedState`
`315`	`322`	`}`
`316`	`323`	`else if (right is BubbleExceptionContainer rightExceptionContainer)`
`317`	`324`	`{`
	`325`	`+ ExceptionDispatchInfo.Capture(rightExceptionContainer.Exception).Throw();`
	`326`	`+ // Will not go here but Resharper detect some errors because he does not know ExceptionDispatchInfo stuff.`
`318`	`327`	`throw rightExceptionContainer.Exception;`
`319`	`328`	`}`
`320`	`329`	`else`
`@@ -1129,7 +1138,14 @@ object ManageJumpStatementsOrExpressionEval(string expression)`
`1129`	`1138`
`1130`	`1139`	`if (expression.StartsWith("throw ", StringComparisonForCasing))`
`1131`	`1140`	`{`
`1132`		`- throw Evaluate(expression.Remove(0, 6)) as Exception;`
	`1141`	`+ if (Evaluate(expression.Remove(0, 6)) is Exception exception)`
	`1142`	`+ {`
	`1143`	`+ ExceptionDispatchInfo.Capture(exception).Throw();`
	`1144`	`+ }`
	`1145`	`+ else`
	`1146`	`+ {`
	`1147`	`+ throw new ExpressionEvaluatorSyntaxErrorException("throw keyword must be follow by an Exception instance");`
	`1148`	`+ }`
`1133`	`1149`	`}`
`1134`	`1150`
`1135`	`1151`	`expression = returnKeywordRegex.Replace(expression, match =>`
`@@ -1595,7 +1611,8 @@ public object Evaluate(string expression)`
`1595`	`1611`
`1596`	`1612`	`try`
`1597`	`1613`	`{`
`1598`		`- ExpressionEvaluationEventArg expressionEvaluationEventArg = new ExpressionEvaluationEventArg(expression, this);`
	`1614`	`+ ExpressionEvaluationEventArg expressionEvaluationEventArg =`
	`1615`	`+ new ExpressionEvaluationEventArg(expression, this);`
`1599`	`1616`
`1600`	`1617`	`ExpressionEvaluating?.Invoke(this, expressionEvaluationEventArg);`
`1601`	`1618`
`@@ -1618,7 +1635,8 @@ public object Evaluate(string expression)`
`1618`	`1635`
`1619`	`1636`	`if (!s.Trim().Equals(string.Empty))`
`1620`	`1637`	`{`
`1621`		`- throw new ExpressionEvaluatorSyntaxErrorException($"Invalid character [{(int)s[0]}:{s}]");`
	`1638`	`+ throw new ExpressionEvaluatorSyntaxErrorException(`
	`1639`	`+ $"Invalid character [{(int)s[0]}:{s}]");`
`1622`	`1640`	`}`
`1623`	`1641`	`}`
`1624`	`1642`	`}`
`@@ -1637,6 +1655,10 @@ public object Evaluate(string expression)`
`1637`	`1655`
`1638`	`1656`	`return result;`
`1639`	`1657`	`}`
	`1658`	`+ catch (TargetInvocationException exception) when (exception.InnerException != null)`
	`1659`	`+ {`
	`1660`	`+ ExceptionDispatchInfo.Capture(exception.InnerException).Throw();`
	`1661`	`+ }`
`1640`	`1662`	`finally`
`1641`	`1663`	`{`
`1642`	`1664`	`evaluationStackCount--;`
`@@ -3088,7 +3110,9 @@ protected virtual bool EvaluateString(string expression, Stack<object> stack, re`
`3088`	`3110`	`object obj = Evaluate(innerExp.ToString());`
`3089`	`3111`
`3090`	`3112`	`if (obj is BubbleExceptionContainer bubbleExceptionContainer)`
`3091`		`- throw bubbleExceptionContainer.Exception;`
	`3113`	`+ {`
	`3114`	`+ ExceptionDispatchInfo.Capture(bubbleExceptionContainer.Exception).Throw();`
	`3115`	`+ }`
`3092`	`3116`
`3093`	`3117`	`resultString.Append(obj);`
`3094`	`3118`	`}`
`@@ -3283,15 +3307,16 @@ void EvaluateFirstPreviousUnaryOp(int j)`
`3283`	`3307`	`{`
`3284`	`3308`	`if (item is BubbleExceptionContainer bubbleExceptionContainer)`
`3285`	`3309`	`{`
`3286`		`- throw bubbleExceptionContainer.Exception; //Throw the first occuring error`
	`3310`	`+ //Throw the first occuring error`
	`3311`	`+ ExceptionDispatchInfo.Capture(bubbleExceptionContainer.Exception).Throw();`
`3287`	`3312`	`}`
`3288`	`3313`	`}`
`3289`	`3314`	`throw new ExpressionEvaluatorSyntaxErrorException("Syntax error. Check that no operator is missing");`
`3290`	`3315`	`}`
`3291`	`3316`	`else if (evaluationStackCount == 1 && stack.Peek() is BubbleExceptionContainer bubbleExceptionContainer)`
`3292`	`3317`	`{`
`3293`	`3318`	`//We reached the top level of the evaluation. So we want to throw the resulting exception.`
`3294`		`- throw bubbleExceptionContainer.Exception;`
	`3319`	`+ ExceptionDispatchInfo.Capture(bubbleExceptionContainer.Exception).Throw();`
`3295`	`3320`	`}`
`3296`	`3321`
`3297`	`3322`	`return stack.Pop();`
`@@ -3364,7 +3389,9 @@ protected virtual object ManageKindOfAssignation(string expression, ref int inde`
`3364`	`3389`	`}`
`3365`	`3390`
`3366`	`3391`	`if (result is BubbleExceptionContainer exceptionContainer)`
`3367`		`- throw exceptionContainer.Exception;`
	`3392`	`+ {`
	`3393`	`+ ExceptionDispatchInfo.Capture(exceptionContainer.Exception).Throw();`
	`3394`	`+ }`
`3368`	`3395`
`3369`	`3396`	`if (stack != null)`
`3370`	`3397`	`{`
`@@ -3395,9 +3422,9 @@ protected virtual void AssignVariable(string varName, object value)`
`3395`	`3422`	`{`
`3396`	`3423`	`Variables[varName] = Convert.ChangeType(value, stronglyTypedVariable.Type);`
`3397`	`3424`	`}`
`3398`		`- catch`
	`3425`	`+ catch(Exception exception)`
`3399`	`3426`	`{`
`3400`		`- throw new InvalidCastException($"A object of type {typeToAssign} can not be cast implicitely in {stronglyTypedVariable.Type}");`
	`3427`	`+ throw new InvalidCastException($"A object of type {typeToAssign} can not be cast implicitely in {stronglyTypedVariable.Type}", exception);`
`3401`	`3428`	`}`
`3402`	`3429`	`}`
`3403`	`3430`	`}`
`@@ -4117,8 +4144,10 @@ protected virtual Type GetTypeByFriendlyName(string typeName, string genericType`
`4117`	`4144`	`}`
`4118`	`4145`	`}`
`4119`	`4146`	`}`
`4120`		`- catch (ExpressionEvaluatorSyntaxErrorException)`
	`4147`	`+ catch (ExpressionEvaluatorSyntaxErrorException exception)`
`4121`	`4148`	`{`
	`4149`	`+ ExceptionDispatchInfo.Capture(exception).Throw();`
	`4150`	`+ // Will not go here but Resharper detect some errors because he does not know ExceptionDispatchInfo stuff.`
`4122`	`4151`	`throw;`
`4123`	`4152`	`}`
`4124`	`4153`	`catch { }`