Merge pull request #4400 from MDoerner/FixURCInspectionForInternationalUsers

retailcoder · web-flow · commit 3ddeba881319 · 2018-10-03T20:33:12.000-04:00
Fix URC inspection for international users
diff --git a/Rubberduck.CodeAnalysis/Inspections/Concrete/UnreachableCaseInspection/ExpressionFilterFactory.cs b/Rubberduck.CodeAnalysis/Inspections/Concrete/UnreachableCaseInspection/ExpressionFilterFactory.cs
@@ -2,55 +2,56 @@
 using Rubberduck.Parsing.Grammar;
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.Linq;
 
 namespace Rubberduck.Inspections.Concrete.UnreachableCaseInspection{
 
     public static class ExpressionFilterFactory
     {
-        private static Dictionary<string, (long typeMin, long typeMax)> IntegralNumberExtents = new Dictionary<string, (long typeMin, long typeMax)>()
+        private static readonly Dictionary<string, (long typeMin, long typeMax)> IntegralNumberExtents = new Dictionary<string, (long typeMin, long typeMax)>()
         {
             [Tokens.LongLong] = (long.MinValue, long.MaxValue),
-            [Tokens.Long] = (Int32.MinValue, Int32.MaxValue),
-            [Tokens.Integer] = (Int16.MinValue, Int16.MaxValue),
-            [Tokens.Int] = (Int16.MinValue, Int16.MaxValue),
+            [Tokens.Long] = (int.MinValue, int.MaxValue),
+            [Tokens.Integer] = (short.MinValue, short.MaxValue),
+            [Tokens.Int] = (short.MinValue, short.MaxValue),
             [Tokens.Byte] = (byte.MinValue, byte.MaxValue)
         };
 
         public static IExpressionFilter Create(string valueType)
         {
             if (IntegralNumberExtents.Keys.Contains(valueType))
             {
-                var integralNumberFilter = new ExpressionFilterIntegral(valueType, long.Parse);
+                var integralNumberFilter = new ExpressionFilterIntegral(valueType, s => long.Parse(s, CultureInfo.InvariantCulture));
                 integralNumberFilter.SetExtents(IntegralNumberExtents[valueType].typeMin, IntegralNumberExtents[valueType].typeMax);
                 return integralNumberFilter;
             }
-            else if (valueType.Equals(Tokens.Double) || valueType.Equals(Tokens.Single))
+            if (valueType.Equals(Tokens.Double) || valueType.Equals(Tokens.Single))
             {
-                var floatingPointNumberFilter = new ExpressionFilter<double>(valueType, double.Parse);
+                var floatingPointNumberFilter = new ExpressionFilter<double>(valueType, s => double.Parse(s, CultureInfo.InvariantCulture));
                 if (valueType.Equals(Tokens.Single))
                 {
                     floatingPointNumberFilter.SetExtents(float.MinValue, float.MaxValue);
                 }
                 return floatingPointNumberFilter;
             }
-            else if (valueType.Equals(Tokens.Currency))
+            if (valueType.Equals(Tokens.Currency))
             {
                 var fixedPointNumberFilter = new ExpressionFilter<decimal>(valueType, VBACurrency.Parse);
                 fixedPointNumberFilter.SetExtents(VBACurrency.MinValue, VBACurrency.MaxValue);
                 return fixedPointNumberFilter;
             }
-            else if (valueType.Equals(Tokens.Boolean))
+            if (valueType.Equals(Tokens.Boolean))
             {
                 return new ExpressionFilterBoolean();
             }
 
-            else if (valueType.Equals(Tokens.Date))
+            if (valueType.Equals(Tokens.Date))
             {
                 return new ExpressionFilterDate();
             }
 
-            return new ExpressionFilter<string>(valueType, (a) => { return a; });
+            return new ExpressionFilter<string>(valueType, a => a);
         }
     }
 }
diff --git a/Rubberduck.CodeAnalysis/Inspections/Concrete/UnreachableCaseInspection/LetCoerce.cs b/Rubberduck.CodeAnalysis/Inspections/Concrete/UnreachableCaseInspection/LetCoerce.cs
diff --git a/Rubberduck.CodeAnalysis/Inspections/Concrete/UnreachableCaseInspection/ParseTreeExpressionEvaluator.cs b/Rubberduck.CodeAnalysis/Inspections/Concrete/UnreachableCaseInspection/ParseTreeExpressionEvaluator.cs
@@ -283,8 +283,8 @@ private IParseTreeValue EvaluateArithmeticOp(string opSymbol, IParseTreeValue LH
                 return _valueFactory.CreateExpression($"{LHS.Token} {opSymbol} {RHS.Token}", opProvider.OperatorDeclaredType);
             }
 
-            if (!LHS.TryLetCoerce(opProvider.OperatorEffectiveType, out IParseTreeValue effLHS)
-                || !RHS.TryLetCoerce(opProvider.OperatorEffectiveType, out IParseTreeValue effRHS))
+            if (!LHS.TryLetCoerce(opProvider.OperatorEffectiveType, out var effLHS)
+                || !RHS.TryLetCoerce(opProvider.OperatorEffectiveType, out var effRHS))
             {
                 return _valueFactory.CreateExpression($"{LHS.Token} {opSymbol} {RHS.Token}", opProvider.OperatorDeclaredType);
             }
@@ -299,45 +299,45 @@ private IParseTreeValue EvaluateArithmeticOp(string opSymbol, IParseTreeValue LH
 
             if (opSymbol.Equals(ArithmeticOperators.MULTIPLY))
             {
-                return _valueFactory.CreateValueType(Calculate(effLHS, effRHS, (decimal a, decimal b) => { return a * b; }, (double a, double b) => { return a * b; }), opProvider.OperatorDeclaredType);
+                return _valueFactory.CreateValueType(Calculate(effLHS, effRHS, (decimal a, decimal b) => a * b, (double a, double b) => a * b), opProvider.OperatorDeclaredType);
             }
-            else if (opSymbol.Equals(ArithmeticOperators.DIVIDE))
+            if (opSymbol.Equals(ArithmeticOperators.DIVIDE))
             {
-                return _valueFactory.CreateValueType(Calculate(effLHS, effRHS, (decimal a, decimal b) => { return a / b; }, (double a, double b) => { return a / b; }), opProvider.OperatorDeclaredType);
+                return _valueFactory.CreateValueType(Calculate(effLHS, effRHS, (decimal a, decimal b) => a / b, (double a, double b) => a / b), opProvider.OperatorDeclaredType);
             }
-            else if (opSymbol.Equals(ArithmeticOperators.INTEGER_DIVIDE))
+            if (opSymbol.Equals(ArithmeticOperators.INTEGER_DIVIDE))
             {
                 return _valueFactory.CreateValueType(Calculate(effLHS, effRHS, IntDivision, IntDivision), opProvider.OperatorDeclaredType);
             }
-            else if (opSymbol.Equals(ArithmeticOperators.PLUS))
+            if (opSymbol.Equals(ArithmeticOperators.PLUS))
             {
                 if (opProvider.OperatorEffectiveType.Equals(Tokens.String))
                 {
                     return _valueFactory.CreateValueType(Concatenate(LHS, RHS), opProvider.OperatorDeclaredType);
                 }
                 if (opProvider.OperatorEffectiveType.Equals(Tokens.Date))
                 {
-                    var result = _valueFactory.CreateDeclaredType(Calculate(effLHS, effRHS, null, (double a, double b) => { return a + b; }), Tokens.Double);
+                    var result = _valueFactory.CreateDeclaredType(Calculate(effLHS, effRHS, null, (double a, double b) => a + b), Tokens.Double);
                     return _valueFactory.CreateDate(result.AsDouble());
                 }
-                return _valueFactory.CreateValueType(Calculate(effLHS, effRHS, (decimal a, decimal b) => { return a + b; }, (double a, double b) => { return a + b; }), opProvider.OperatorDeclaredType);
+                return _valueFactory.CreateValueType(Calculate(effLHS, effRHS, (decimal a, decimal b) => a + b, (double a, double b) => a + b), opProvider.OperatorDeclaredType);
             }
-            else if (opSymbol.Equals(ArithmeticOperators.MINUS))
+            if (opSymbol.Equals(ArithmeticOperators.MINUS))
             {
                 if (LHS.ValueType.Equals(Tokens.Date) && RHS.ValueType.Equals(Tokens.Date))
                 {
                     return _valueFactory.CreateDate(LHS.AsDouble() - RHS.AsDouble());
                 }
-                return _valueFactory.CreateValueType(Calculate(effLHS, effRHS, (decimal a, decimal b) => { return a - b; }, (double a, double b) => { return a - b; }), opProvider.OperatorDeclaredType);
+                return _valueFactory.CreateValueType(Calculate(effLHS, effRHS, (decimal a, decimal b) => a - b, (double a, double b) => a - b), opProvider.OperatorDeclaredType);
             }
-            else if (opSymbol.Equals(ArithmeticOperators.EXPONENT))
+            if (opSymbol.Equals(ArithmeticOperators.EXPONENT))
             {
                 //Math.Pow only takes doubles, so the decimal conversion option is null
-                return _valueFactory.CreateValueType(Calculate(effLHS, effRHS, null, (double a, double b) => { return Math.Pow(a, b); }), opProvider.OperatorDeclaredType);
+                return _valueFactory.CreateValueType(Calculate(effLHS, effRHS, null, Math.Pow), opProvider.OperatorDeclaredType);
             }
-            else if (opSymbol.Equals(ArithmeticOperators.MODULO))
+            if (opSymbol.Equals(ArithmeticOperators.MODULO))
             {
-                return _valueFactory.CreateValueType(Calculate(effLHS, effRHS, (decimal a, decimal b) => { return a % b; }, (double a, double b) => { return a % b; }), opProvider.OperatorDeclaredType);
+                return _valueFactory.CreateValueType(Calculate(effLHS, effRHS, (decimal a, decimal b) => a % b, (double a, double b) => a % b), opProvider.OperatorDeclaredType);
             }
 
             //ArithmeticOperators.AMPERSAND
@@ -377,9 +377,9 @@ private string Calculate(IParseTreeValue LHS, IParseTreeValue RHS, Func<decimal,
 
             if (!(DecimalCalc is null) && LHS.TryLetCoerce(out decimal lhsValue) && RHS.TryLetCoerce(out decimal rhsValue))
             {
-                return DecimalCalc(lhsValue, rhsValue).ToString();
+                return DecimalCalc(lhsValue, rhsValue).ToString(CultureInfo.InvariantCulture);
             }
-            return DoubleCalc(LHS.AsDouble(), RHS.AsDouble()).ToString();
+            return DoubleCalc(LHS.AsDouble(), RHS.AsDouble()).ToString(CultureInfo.InvariantCulture);
         }
 
         private string Compare(IParseTreeValue LHS, IParseTreeValue RHS, Func<decimal, decimal, bool> DecimalCompare, Func<double, double, bool> DoubleCompare)
diff --git a/Rubberduck.CodeAnalysis/Inspections/Concrete/UnreachableCaseInspection/ParseTreeValue.cs b/Rubberduck.CodeAnalysis/Inspections/Concrete/UnreachableCaseInspection/ParseTreeValue.cs
@@ -1,6 +1,7 @@
 ﻿using Rubberduck.Parsing.Grammar;
 using Rubberduck.Parsing.PreProcessing;
 using System;
+using System.Globalization;
 
 namespace Rubberduck.Inspections.Concrete.UnreachableCaseInspection
 {
@@ -153,7 +154,7 @@ public static class ParseTreeValueExtensions
         public static bool TryLetCoerce(this IParseTreeValue parseTreeValue, string destinationType, out IParseTreeValue newValue)
         {
             newValue = null;
-            if (LetCoerce.TryCoerceToken((parseTreeValue.ValueType, parseTreeValue.Token), destinationType, out string valueText))
+            if (LetCoerce.TryCoerceToken((parseTreeValue.ValueType, parseTreeValue.Token), destinationType, out var valueText))
             {
                 newValue = ParseTreeValue.CreateValueType(new TypeTokenPair(destinationType, valueText));
                 return true;
@@ -162,31 +163,31 @@ public static bool TryLetCoerce(this IParseTreeValue parseTreeValue, string dest
         }
 
         public static double AsDouble(this IParseTreeValue parseTreeValue)
-            => double.Parse(LetCoerce.Coerce((parseTreeValue.ValueType, parseTreeValue.Token), Tokens.Double));
+            => double.Parse(LetCoerce.Coerce((parseTreeValue.ValueType, parseTreeValue.Token), Tokens.Double), CultureInfo.InvariantCulture);
 
         public static decimal AsCurrency(this IParseTreeValue parseTreeValue)
-            => decimal.Parse(LetCoerce.Coerce((parseTreeValue.ValueType, parseTreeValue.Token), Tokens.Currency));
+            => decimal.Parse(LetCoerce.Coerce((parseTreeValue.ValueType, parseTreeValue.Token), Tokens.Currency), CultureInfo.InvariantCulture);
 
         public static long AsLong(this IParseTreeValue parseTreeValue)
-            => long.Parse(LetCoerce.Coerce((parseTreeValue.ValueType, parseTreeValue.Token), Tokens.Long));
+            => long.Parse(LetCoerce.Coerce((parseTreeValue.ValueType, parseTreeValue.Token), Tokens.Long), CultureInfo.InvariantCulture);
 
         public static bool AsBoolean(this IParseTreeValue parseTreeValue)
-            =>LetCoerce.Coerce((parseTreeValue.ValueType, parseTreeValue.Token), Tokens.Boolean).Equals(Tokens.True);
+            => LetCoerce.Coerce((parseTreeValue.ValueType, parseTreeValue.Token), Tokens.Boolean).Equals(Tokens.True);
 
         public static bool TryLetCoerce(this IParseTreeValue parseTreeValue, out long newValue)
-            => TryLetCoerce(parseTreeValue, long.Parse, Tokens.Long, out newValue);
+            => TryLetCoerce(parseTreeValue, s => long.Parse(s, CultureInfo.InvariantCulture), Tokens.Long, out newValue);
 
         public static bool TryLetCoerce(this IParseTreeValue parseTreeValue, out double newValue)
-        => TryLetCoerce(parseTreeValue, double.Parse, Tokens.Double, out newValue);
+        => TryLetCoerce(parseTreeValue, s => double.Parse(s, CultureInfo.InvariantCulture), Tokens.Double, out newValue);
 
         public static bool TryLetCoerce(this IParseTreeValue parseTreeValue, out decimal newValue)
-            => TryLetCoerce(parseTreeValue, decimal.Parse, Tokens.Currency, out newValue);
+            => TryLetCoerce(parseTreeValue, s => decimal.Parse(s, CultureInfo.InvariantCulture), Tokens.Currency, out newValue);
 
         public static bool TryLetCoerce(this IParseTreeValue parseTreeValue, out bool value)
             => TryLetCoerce(parseTreeValue, bool.Parse, Tokens.Boolean, out value);
 
         public static bool TryLetCoerce(this IParseTreeValue parseTreeValue, out string value)
-            => TryLetCoerce(parseTreeValue, (a) => { return a; }, Tokens.String, out value);
+            => TryLetCoerce(parseTreeValue, a => a, Tokens.String, out value);
 
         private static bool TryLetCoerce(this IParseTreeValue parseTreeValue, out ComparableDateValue value)
             => TryLetCoerceToDate(parseTreeValue, out value);
diff --git a/Rubberduck.CodeAnalysis/Inspections/Concrete/UnreachableCaseInspection/TypeTokenPair.cs b/Rubberduck.CodeAnalysis/Inspections/Concrete/UnreachableCaseInspection/TypeTokenPair.cs
@@ -8,8 +8,8 @@ namespace Rubberduck.Inspections.Concrete.UnreachableCaseInspection
 {
     public struct TypeTokenPair
     {
-        public string ValueType { private set; get; }
-        public string Token { private set; get; }
+        public string ValueType { get; }
+        public string Token { get; }
 
         public TypeTokenPair(string valueType, string token)
         {
diff --git a/RubberduckTests/Inspections/UnreachableCase/ExpressionFilterUnitTests.cs b/RubberduckTests/Inspections/UnreachableCase/ExpressionFilterUnitTests.cs
@@ -491,7 +491,7 @@ private IParseTreeValue CreateInspValueFrom(string valAndType)
             {
                 var args = RetrieveDelimitedElements(valAndType, VALUE_TYPE_DELIMITER);
                 var value = args[0];
-                string declaredType = args[1].Equals(string.Empty) ? null : args[1];
+                var declaredType = args[1].Equals(string.Empty) ? null : args[1];
                 if (declaredType is null)
                 {
                     return ValueFactory.Create(value);
@@ -533,12 +533,12 @@ private IEnumerable<IRangeClauseExpression> RangeClauseTokensToExpressions(IEnum
                 var operandDelimiters = clause.Where(ch => ch.Equals('_'));
                 if (operandDelimiters.Count() == 2)
                 {
-                    (IParseTreeValue lhs, IParseTreeValue rhs, string symbol) = GetBinaryOpValues(clause);
+                    var (lhs, rhs, symbol) = GetBinaryOpValues(clause);
                     expressionClause = CreateRangeClauseExpression((lhs, rhs, symbol));
                 }
                 else if (operandDelimiters.Count() <= 1)
                 {
-                    (IParseTreeValue operand, string symbol) = GetUnaryOpValues(clause);
+                    var (operand, symbol) = GetUnaryOpValues(clause);
                     if (symbol.Equals(LogicalOperators.NOT))
                     {
                         expressionClause = new UnaryExpression(operand, symbol);
diff --git a/RubberduckTests/Inspections/UnreachableCase/ParseTreeExpressionEvaluatorUnitTests.cs b/RubberduckTests/Inspections/UnreachableCase/ParseTreeExpressionEvaluatorUnitTests.cs
@@ -2,6 +2,7 @@
 using Rubberduck.Inspections.Concrete.UnreachableCaseInspection;
 using Rubberduck.Parsing.Grammar;
 using System;
+using System.Globalization;
 
 namespace RubberduckTests.Inspections.UnreachableCase
 {
@@ -942,8 +943,8 @@ private IParseTreeValue CreateInspValueFrom(string valAndType, string conformTo
             {
                 var compareLength = expected.Length > 5 ? 5 : expected.Length;
                 var accuracy = Math.Pow(10, -1.0 * compareLength);
-                var lhs = double.Parse(result.Token.Substring(0, compareLength));
-                var rhs = double.Parse(expected.Substring(0, compareLength));
+                var lhs = double.Parse(result.Token.Substring(0, compareLength), CultureInfo.InvariantCulture);
+                var rhs = double.Parse(expected.Substring(0, compareLength), CultureInfo.InvariantCulture);
                 Assert.IsTrue(Math.Abs(lhs - rhs) <= accuracy, $"Actual={result.Token} Expected={expected}");
                 return (result,result);
             }
diff --git a/RubberduckTests/Mocks/MockVbeBuilder.cs b/RubberduckTests/Mocks/MockVbeBuilder.cs
@@ -216,7 +216,9 @@ private Mock<IVBE> CreateVbeMock()
 
             var commandBars = DummyCommandBars();
             vbe.SetupGet(m => m.CommandBars).Returns(() => commandBars);
-            
+
+            vbe.Setup(m => m.IsInDesignMode).Returns(true);
+
             return vbe;
         }
 

Original file line number	Diff line number	Diff line change
`@@ -2,55 +2,56 @@`
`2`	`2`	`using Rubberduck.Parsing.Grammar;`
`3`	`3`	`using System;`
`4`	`4`	`using System.Collections.Generic;`
	`5`	`+using System.Globalization;`
`5`	`6`	`using System.Linq;`
`6`	`7`
`7`	`8`	`namespace Rubberduck.Inspections.Concrete.UnreachableCaseInspection{`
`8`	`9`
`9`	`10`	`public static class ExpressionFilterFactory`
`10`	`11`	`{`
`11`		`- private static Dictionary<string, (long typeMin, long typeMax)> IntegralNumberExtents = new Dictionary<string, (long typeMin, long typeMax)>()`
	`12`	`+ private static readonly Dictionary<string, (long typeMin, long typeMax)> IntegralNumberExtents = new Dictionary<string, (long typeMin, long typeMax)>()`
`12`	`13`	`{`
`13`	`14`	`[Tokens.LongLong] = (long.MinValue, long.MaxValue),`
`14`		`- [Tokens.Long] = (Int32.MinValue, Int32.MaxValue),`
`15`		`- [Tokens.Integer] = (Int16.MinValue, Int16.MaxValue),`
`16`		`- [Tokens.Int] = (Int16.MinValue, Int16.MaxValue),`
	`15`	`+ [Tokens.Long] = (int.MinValue, int.MaxValue),`
	`16`	`+ [Tokens.Integer] = (short.MinValue, short.MaxValue),`
	`17`	`+ [Tokens.Int] = (short.MinValue, short.MaxValue),`
`17`	`18`	`[Tokens.Byte] = (byte.MinValue, byte.MaxValue)`
`18`	`19`	`};`
`19`	`20`
`20`	`21`	`public static IExpressionFilter Create(string valueType)`
`21`	`22`	`{`
`22`	`23`	`if (IntegralNumberExtents.Keys.Contains(valueType))`
`23`	`24`	`{`
`24`		`- var integralNumberFilter = new ExpressionFilterIntegral(valueType, long.Parse);`
	`25`	`+ var integralNumberFilter = new ExpressionFilterIntegral(valueType, s => long.Parse(s, CultureInfo.InvariantCulture));`
`25`	`26`	`integralNumberFilter.SetExtents(IntegralNumberExtents[valueType].typeMin, IntegralNumberExtents[valueType].typeMax);`
`26`	`27`	`return integralNumberFilter;`
`27`	`28`	`}`
`28`		`- else if (valueType.Equals(Tokens.Double) \|\| valueType.Equals(Tokens.Single))`
	`29`	`+ if (valueType.Equals(Tokens.Double) \|\| valueType.Equals(Tokens.Single))`
`29`	`30`	`{`
`30`		`- var floatingPointNumberFilter = new ExpressionFilter<double>(valueType, double.Parse);`
	`31`	`+ var floatingPointNumberFilter = new ExpressionFilter<double>(valueType, s => double.Parse(s, CultureInfo.InvariantCulture));`
`31`	`32`	`if (valueType.Equals(Tokens.Single))`
`32`	`33`	`{`
`33`	`34`	`floatingPointNumberFilter.SetExtents(float.MinValue, float.MaxValue);`
`34`	`35`	`}`
`35`	`36`	`return floatingPointNumberFilter;`
`36`	`37`	`}`
`37`		`- else if (valueType.Equals(Tokens.Currency))`
	`38`	`+ if (valueType.Equals(Tokens.Currency))`
`38`	`39`	`{`
`39`	`40`	`var fixedPointNumberFilter = new ExpressionFilter<decimal>(valueType, VBACurrency.Parse);`
`40`	`41`	`fixedPointNumberFilter.SetExtents(VBACurrency.MinValue, VBACurrency.MaxValue);`
`41`	`42`	`return fixedPointNumberFilter;`
`42`	`43`	`}`
`43`		`- else if (valueType.Equals(Tokens.Boolean))`
	`44`	`+ if (valueType.Equals(Tokens.Boolean))`
`44`	`45`	`{`
`45`	`46`	`return new ExpressionFilterBoolean();`
`46`	`47`	`}`
`47`	`48`
`48`		`- else if (valueType.Equals(Tokens.Date))`
	`49`	`+ if (valueType.Equals(Tokens.Date))`
`49`	`50`	`{`
`50`	`51`	`return new ExpressionFilterDate();`
`51`	`52`	`}`
`52`	`53`
`53`		`- return new ExpressionFilter<string>(valueType, (a) => { return a; });`
	`54`	`+ return new ExpressionFilter<string>(valueType, a => a);`
`54`	`55`	`}`
`55`	`56`	`}`
`56`	`57`	`}`
Original file line number	Diff line number	Diff line change
`@@ -283,8 +283,8 @@ private IParseTreeValue EvaluateArithmeticOp(string opSymbol, IParseTreeValue LH`
`283`	`283`	`return _valueFactory.CreateExpression($"{LHS.Token} {opSymbol} {RHS.Token}", opProvider.OperatorDeclaredType);`
`284`	`284`	`}`
`285`	`285`
`286`		`- if (!LHS.TryLetCoerce(opProvider.OperatorEffectiveType, out IParseTreeValue effLHS)`
`287`		`- \|\| !RHS.TryLetCoerce(opProvider.OperatorEffectiveType, out IParseTreeValue effRHS))`
	`286`	`+ if (!LHS.TryLetCoerce(opProvider.OperatorEffectiveType, out var effLHS)`
	`287`	`+ \|\| !RHS.TryLetCoerce(opProvider.OperatorEffectiveType, out var effRHS))`
`288`	`288`	`{`
`289`	`289`	`return _valueFactory.CreateExpression($"{LHS.Token} {opSymbol} {RHS.Token}", opProvider.OperatorDeclaredType);`
`290`	`290`	`}`
`@@ -299,45 +299,45 @@ private IParseTreeValue EvaluateArithmeticOp(string opSymbol, IParseTreeValue LH`
`299`	`299`
`300`	`300`	`if (opSymbol.Equals(ArithmeticOperators.MULTIPLY))`
`301`	`301`	`{`
`302`		`- return _valueFactory.CreateValueType(Calculate(effLHS, effRHS, (decimal a, decimal b) => { return a * b; }, (double a, double b) => { return a * b; }), opProvider.OperatorDeclaredType);`
	`302`	`+ return _valueFactory.CreateValueType(Calculate(effLHS, effRHS, (decimal a, decimal b) => a * b, (double a, double b) => a * b), opProvider.OperatorDeclaredType);`
`303`	`303`	`}`
`304`		`- else if (opSymbol.Equals(ArithmeticOperators.DIVIDE))`
	`304`	`+ if (opSymbol.Equals(ArithmeticOperators.DIVIDE))`
`305`	`305`	`{`
`306`		`- return _valueFactory.CreateValueType(Calculate(effLHS, effRHS, (decimal a, decimal b) => { return a / b; }, (double a, double b) => { return a / b; }), opProvider.OperatorDeclaredType);`
	`306`	`+ return _valueFactory.CreateValueType(Calculate(effLHS, effRHS, (decimal a, decimal b) => a / b, (double a, double b) => a / b), opProvider.OperatorDeclaredType);`
`307`	`307`	`}`
`308`		`- else if (opSymbol.Equals(ArithmeticOperators.INTEGER_DIVIDE))`
	`308`	`+ if (opSymbol.Equals(ArithmeticOperators.INTEGER_DIVIDE))`
`309`	`309`	`{`
`310`	`310`	`return _valueFactory.CreateValueType(Calculate(effLHS, effRHS, IntDivision, IntDivision), opProvider.OperatorDeclaredType);`
`311`	`311`	`}`
`312`		`- else if (opSymbol.Equals(ArithmeticOperators.PLUS))`
	`312`	`+ if (opSymbol.Equals(ArithmeticOperators.PLUS))`
`313`	`313`	`{`
`314`	`314`	`if (opProvider.OperatorEffectiveType.Equals(Tokens.String))`
`315`	`315`	`{`
`316`	`316`	`return _valueFactory.CreateValueType(Concatenate(LHS, RHS), opProvider.OperatorDeclaredType);`
`317`	`317`	`}`
`318`	`318`	`if (opProvider.OperatorEffectiveType.Equals(Tokens.Date))`
`319`	`319`	`{`
`320`		`- var result = _valueFactory.CreateDeclaredType(Calculate(effLHS, effRHS, null, (double a, double b) => { return a + b; }), Tokens.Double);`
	`320`	`+ var result = _valueFactory.CreateDeclaredType(Calculate(effLHS, effRHS, null, (double a, double b) => a + b), Tokens.Double);`
`321`	`321`	`return _valueFactory.CreateDate(result.AsDouble());`
`322`	`322`	`}`
`323`		`- return _valueFactory.CreateValueType(Calculate(effLHS, effRHS, (decimal a, decimal b) => { return a + b; }, (double a, double b) => { return a + b; }), opProvider.OperatorDeclaredType);`
	`323`	`+ return _valueFactory.CreateValueType(Calculate(effLHS, effRHS, (decimal a, decimal b) => a + b, (double a, double b) => a + b), opProvider.OperatorDeclaredType);`
`324`	`324`	`}`
`325`		`- else if (opSymbol.Equals(ArithmeticOperators.MINUS))`
	`325`	`+ if (opSymbol.Equals(ArithmeticOperators.MINUS))`
`326`	`326`	`{`
`327`	`327`	`if (LHS.ValueType.Equals(Tokens.Date) && RHS.ValueType.Equals(Tokens.Date))`
`328`	`328`	`{`
`329`	`329`	`return _valueFactory.CreateDate(LHS.AsDouble() - RHS.AsDouble());`
`330`	`330`	`}`
`331`		`- return _valueFactory.CreateValueType(Calculate(effLHS, effRHS, (decimal a, decimal b) => { return a - b; }, (double a, double b) => { return a - b; }), opProvider.OperatorDeclaredType);`
	`331`	`+ return _valueFactory.CreateValueType(Calculate(effLHS, effRHS, (decimal a, decimal b) => a - b, (double a, double b) => a - b), opProvider.OperatorDeclaredType);`
`332`	`332`	`}`
`333`		`- else if (opSymbol.Equals(ArithmeticOperators.EXPONENT))`
	`333`	`+ if (opSymbol.Equals(ArithmeticOperators.EXPONENT))`
`334`	`334`	`{`
`335`	`335`	`//Math.Pow only takes doubles, so the decimal conversion option is null`
`336`		`- return _valueFactory.CreateValueType(Calculate(effLHS, effRHS, null, (double a, double b) => { return Math.Pow(a, b); }), opProvider.OperatorDeclaredType);`
	`336`	`+ return _valueFactory.CreateValueType(Calculate(effLHS, effRHS, null, Math.Pow), opProvider.OperatorDeclaredType);`
`337`	`337`	`}`
`338`		`- else if (opSymbol.Equals(ArithmeticOperators.MODULO))`
	`338`	`+ if (opSymbol.Equals(ArithmeticOperators.MODULO))`
`339`	`339`	`{`
`340`		`- return _valueFactory.CreateValueType(Calculate(effLHS, effRHS, (decimal a, decimal b) => { return a % b; }, (double a, double b) => { return a % b; }), opProvider.OperatorDeclaredType);`
	`340`	`+ return _valueFactory.CreateValueType(Calculate(effLHS, effRHS, (decimal a, decimal b) => a % b, (double a, double b) => a % b), opProvider.OperatorDeclaredType);`
`341`	`341`	`}`
`342`	`342`
`343`	`343`	`//ArithmeticOperators.AMPERSAND`
`@@ -377,9 +377,9 @@ private string Calculate(IParseTreeValue LHS, IParseTreeValue RHS, Func<decimal,`
`377`	`377`
`378`	`378`	`if (!(DecimalCalc is null) && LHS.TryLetCoerce(out decimal lhsValue) && RHS.TryLetCoerce(out decimal rhsValue))`
`379`	`379`	`{`
`380`		`- return DecimalCalc(lhsValue, rhsValue).ToString();`
	`380`	`+ return DecimalCalc(lhsValue, rhsValue).ToString(CultureInfo.InvariantCulture);`
`381`	`381`	`}`
`382`		`- return DoubleCalc(LHS.AsDouble(), RHS.AsDouble()).ToString();`
	`382`	`+ return DoubleCalc(LHS.AsDouble(), RHS.AsDouble()).ToString(CultureInfo.InvariantCulture);`
`383`	`383`	`}`
`384`	`384`
`385`	`385`	`private string Compare(IParseTreeValue LHS, IParseTreeValue RHS, Func<decimal, decimal, bool> DecimalCompare, Func<double, double, bool> DoubleCompare)`
Original file line number	Diff line number	Diff line change
`@@ -8,8 +8,8 @@ namespace Rubberduck.Inspections.Concrete.UnreachableCaseInspection`
`8`	`8`	`{`
`9`	`9`	`public struct TypeTokenPair`
`10`	`10`	`{`
`11`		`- public string ValueType { private set; get; }`
`12`		`- public string Token { private set; get; }`
	`11`	`+ public string ValueType { get; }`
	`12`	`+ public string Token { get; }`
`13`	`13`
`14`	`14`	`public TypeTokenPair(string valueType, string token)`
`15`	`15`	`{`
Original file line number	Diff line number	Diff line change
`@@ -491,7 +491,7 @@ private IParseTreeValue CreateInspValueFrom(string valAndType)`
`491`	`491`	`{`
`492`	`492`	`var args = RetrieveDelimitedElements(valAndType, VALUE_TYPE_DELIMITER);`
`493`	`493`	`var value = args[0];`
`494`		`- string declaredType = args[1].Equals(string.Empty) ? null : args[1];`
	`494`	`+ var declaredType = args[1].Equals(string.Empty) ? null : args[1];`
`495`	`495`	`if (declaredType is null)`
`496`	`496`	`{`
`497`	`497`	`return ValueFactory.Create(value);`
`@@ -533,12 +533,12 @@ private IEnumerable<IRangeClauseExpression> RangeClauseTokensToExpressions(IEnum`
`533`	`533`	`var operandDelimiters = clause.Where(ch => ch.Equals('_'));`
`534`	`534`	`if (operandDelimiters.Count() == 2)`
`535`	`535`	`{`
`536`		`- (IParseTreeValue lhs, IParseTreeValue rhs, string symbol) = GetBinaryOpValues(clause);`
	`536`	`+ var (lhs, rhs, symbol) = GetBinaryOpValues(clause);`
`537`	`537`	`expressionClause = CreateRangeClauseExpression((lhs, rhs, symbol));`
`538`	`538`	`}`
`539`	`539`	`else if (operandDelimiters.Count() <= 1)`
`540`	`540`	`{`
`541`		`- (IParseTreeValue operand, string symbol) = GetUnaryOpValues(clause);`
	`541`	`+ var (operand, symbol) = GetUnaryOpValues(clause);`
`542`	`542`	`if (symbol.Equals(LogicalOperators.NOT))`
`543`	`543`	`{`
`544`	`544`	`expressionClause = new UnaryExpression(operand, symbol);`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@`
`2`	`2`	`using Rubberduck.Inspections.Concrete.UnreachableCaseInspection;`
`3`	`3`	`using Rubberduck.Parsing.Grammar;`
`4`	`4`	`using System;`
	`5`	`+using System.Globalization;`
`5`	`6`
`6`	`7`	`namespace RubberduckTests.Inspections.UnreachableCase`
`7`	`8`	`{`
`@@ -942,8 +943,8 @@ private IParseTreeValue CreateInspValueFrom(string valAndType, string conformTo`
`942`	`943`	`{`
`943`	`944`	`var compareLength = expected.Length > 5 ? 5 : expected.Length;`
`944`	`945`	`var accuracy = Math.Pow(10, -1.0 * compareLength);`
`945`		`- var lhs = double.Parse(result.Token.Substring(0, compareLength));`
`946`		`- var rhs = double.Parse(expected.Substring(0, compareLength));`
	`946`	`+ var lhs = double.Parse(result.Token.Substring(0, compareLength), CultureInfo.InvariantCulture);`
	`947`	`+ var rhs = double.Parse(expected.Substring(0, compareLength), CultureInfo.InvariantCulture);`
`947`	`948`	`Assert.IsTrue(Math.Abs(lhs - rhs) <= accuracy, $"Actual={result.Token} Expected={expected}");`
`948`	`949`	`return (result,result);`
`949`	`950`	`}`
Original file line number	Diff line number	Diff line change
`@@ -216,7 +216,9 @@ private Mock<IVBE> CreateVbeMock()`
`216`	`216`
`217`	`217`	`var commandBars = DummyCommandBars();`
`218`	`218`	`vbe.SetupGet(m => m.CommandBars).Returns(() => commandBars);`
`219`		`-`
	`219`	`+`
	`220`	`+ vbe.Setup(m => m.IsInDesignMode).Returns(true);`
	`221`	`+`
`220`	`222`	`return vbe;`
`221`	`223`	`}`
`222`	`224`