Sync with next

Author: comintern

README.md

@@ -1,4 +1,4 @@
-<img src="https://user-images.githubusercontent.com/5751684/38372412-c3247d70-38bc-11e8-8eaa-2f2d19595a42.png" width=100% />
+<img src="https://user-images.githubusercontent.com/5751684/46327997-aeb98d00-c5d2-11e8-9de5-ba6f9cd1eea3.png" />
 
 <!-- campaign is no longer accepting donations
 ### Donate!
@@ -29,7 +29,6 @@ If you like this project and would like to thank its contributors, you are welco
  * [Installing](https://github.com/rubberduck-vba/Rubberduck/wiki/Installing)
  * [Getting Started](https://github.com/rubberduck-vba/Rubberduck/blob/next/docs/GettingStarted.md) using Rubberduck
  * [Contributing](https://github.com/rubberduck-vba/Rubberduck/blob/next/CONTRIBUTING.md)
- * [User Testimonials](https://github.com/rubberduck-vba/Rubberduck/blob/next/thanks.md)
 
 ---
 

Rubberduck.API/VBA/Parser.cs

@@ -12,11 +12,12 @@
 using Rubberduck.Parsing.Symbols.DeclarationLoaders;
 using Rubberduck.Parsing.VBA;
 using Rubberduck.Parsing.Symbols;
-using Rubberduck.Parsing.Symbols.ParsingExceptions;
 using Rubberduck.Parsing.UIContext;
 using Rubberduck.Parsing.VBA.ComReferenceLoading;
+using Rubberduck.Parsing.VBA.DeclarationCaching;
 using Rubberduck.Parsing.VBA.DeclarationResolving;
 using Rubberduck.Parsing.VBA.Parsing;
+using Rubberduck.Parsing.VBA.Parsing.ParsingExceptions;
 using Rubberduck.Parsing.VBA.ReferenceManagement;
 using Rubberduck.Resources.Registration;
 using Rubberduck.VBEditor.ComManagement;

Rubberduck.CodeAnalysis/CodeMetrics/CodeMetricBase.cs

@@ -1,6 +1,7 @@
 using System.Collections.Generic;
 using Rubberduck.Parsing.Grammar;
 using Rubberduck.Parsing.Symbols;
+using Rubberduck.Parsing.VBA.DeclarationCaching;
 using Rubberduck.VBEditor;
 
 namespace Rubberduck.CodeAnalysis.CodeMetrics

Rubberduck.CodeAnalysis/CodeMetrics/CodeMetricsAnalyst.cs

@@ -4,6 +4,7 @@
 using Rubberduck.VBEditor;
 using System.Collections.Generic;
 using System.Linq;
+using Rubberduck.Parsing.VBA.DeclarationCaching;
 
 namespace Rubberduck.CodeAnalysis.CodeMetrics
 {

Rubberduck.CodeAnalysis/Inspections/Concrete/SheetAccessedUsingStringInspection.cs

@@ -60,7 +60,10 @@ protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
                 var component = GetVBComponentMatchingSheetName(reference);
                 if (component != null)
                 {
-                    reference.Properties.CodeName = (string)component.Properties.Single(property => property.Name == "CodeName").Value;
+                    using (var properties = component.Properties)
+                    {
+                        reference.Properties.CodeName = (string)properties.Single(property => property.Name == "CodeName").Value;
+                    }
                     issues.Add(reference);
                 }
             }
@@ -98,9 +101,35 @@ private IVBComponent GetVBComponentMatchingSheetName(IdentifierReferenceInspecti
             var sheetName = FormatSheetName(sheetArgumentContext.GetText());
             var project = State.Projects.First(p => p.ProjectId == reference.QualifiedName.ProjectId);
 
-            return project.VBComponents.FirstOrDefault(c =>
-                c.Type == ComponentType.Document &&
-                (string) c.Properties.First(property => property.Name == "Name").Value == sheetName);
+
+            //return project.VBComponents.FirstOrDefault(c =>
+            //    c.Type == ComponentType.Document &&
+            //    (string)c.Properties.First(property => property.Name == "Name").Value == sheetName);
+            using (var components = project.VBComponents)
+            {
+                for (var i = 0; i < components.Count; i++)
+                {
+                    using (var component = components[i])
+                    using (var properties = component.Properties)
+                    {
+                        if (component.Type == ComponentType.Document)
+                        {
+                            for (var j = 0; j < properties.Count; j++)
+                            {
+                                using (var property = properties[j])
+                                {
+                                    if (property.Name == "Name" && (string)property.Value == sheetName)
+                                    {
+                                        return component;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+
+                return null;
+            }
         }
 
         private static string FormatSheetName(string sheetName)

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);
         }
     }
 }