Merge branch 'next' of https://github.com/rubberduck-vba/rubberduck into Issue4159

Author: IvenBach

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.CodeAnalysis/Inspections/Concrete/ImplicitDefaultMemberAssignmentInspection.cs

@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using Rubberduck.Inspections.Abstract;
 using Rubberduck.Inspections.Results;
@@ -28,7 +29,10 @@ protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
                 .Where(reference =>
                 {
                     var letStmtContext = reference.Context.GetAncestor<VBAParser.LetStmtContext>();
-                    return reference.IsAssignment && letStmtContext != null && letStmtContext.LET() == null;
+                    return reference.IsAssignment 
+                           && letStmtContext != null 
+                           && letStmtContext.LET() == null
+                           && !reference.IsIgnoringInspectionResultFor(AnnotationName);
                 });
 
             return interestingReferences.Select(reference => new IdentifierReferenceInspectionResult(this,

Rubberduck.CodeAnalysis/Inspections/Concrete/ObsoleteCallStatementInspection.cs

@@ -30,7 +30,8 @@ protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
             foreach (var context in Listener.Contexts.Where(context => !IsIgnoringInspectionResultFor(context.ModuleName, context.Context.Start.Line)))
             {
                 string lines;
-                using (var module = State.ProjectsProvider.Component(context.ModuleName).CodeModule)
+                var component = State.ProjectsProvider.Component(context.ModuleName);
+                using (var module = component.CodeModule)
                 {
                     lines = module.GetLines(context.Context.Start.Line,
                         context.Context.Stop.Line - context.Context.Start.Line + 1);

Rubberduck.CodeAnalysis/Inspections/Concrete/UnassignedVariableUsageInspection.cs

@@ -21,20 +21,22 @@ public UnassignedVariableUsageInspection(RubberduckParserState state)
         protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
         {
             var declarations = State.DeclarationFinder.UserDeclarations(DeclarationType.Variable)
-                .Where(result => !IsIgnoringInspectionResultFor(result, AnnotationName))
-                .Where(declaration => 
-                    State.DeclarationFinder.MatchName(declaration.AsTypeName).All(d => d.DeclarationType != DeclarationType.UserDefinedType)
+                .Where(declaration =>
+                    State.DeclarationFinder.MatchName(declaration.AsTypeName)
+                        .All(d => d.DeclarationType != DeclarationType.UserDefinedType)
                     && !declaration.IsSelfAssigned
-                    && !declaration.References.Any(reference => reference.IsAssignment && !IsIgnoringInspectionResultFor(reference, AnnotationName)));
+                    && !declaration.References.Any(reference => reference.IsAssignment));
 
-            //The parameter scoping was apparently incorrect before - need to filter for the actual function.
+            //See https://github.com/rubberduck-vba/Rubberduck/issues/2010 for why these are being excluded.
+            //TODO: These need to be modified to correctly work in VB6.
             var lenFunction = BuiltInDeclarations.SingleOrDefault(s => s.DeclarationType == DeclarationType.Function && s.Scope.Equals("VBE7.DLL;VBA.Strings.Len"));
-            var lenbFunction = BuiltInDeclarations.SingleOrDefault(s => s.DeclarationType == DeclarationType.Function && s.Scope.Equals("VBE7.DLL;VBA.Strings.Len"));
+            var lenbFunction = BuiltInDeclarations.SingleOrDefault(s => s.DeclarationType == DeclarationType.Function && s.Scope.Equals("VBE7.DLL;VBA.Strings.LenB"));
 
             return declarations.Where(d => d.References.Any() &&
                                            !DeclarationReferencesContainsReference(lenFunction, d) &&
                                            !DeclarationReferencesContainsReference(lenbFunction, d))
                                .SelectMany(d => d.References)
+                               .Where(r => !r.IsIgnoringInspectionResultFor(AnnotationName))
                                .Select(r => new IdentifierReferenceInspectionResult(this,
                                                                  string.Format(InspectionResults.UnassignedVariableUsageInspection, r.IdentifierName),
                                                                  State,

Rubberduck.CodeAnalysis/Inspections/Concrete/UnreachableCaseInspection/ComparableDateValue.cs

@@ -0,0 +1,108 @@
+using Antlr4.Runtime;
+using Rubberduck.Parsing.PreProcessing;
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Globalization;
+
+namespace Rubberduck.Inspections.Concrete.UnreachableCaseInspection
+{
+    public class ComparableDateValue : IValue, IComparable<ComparableDateValue>
+    {
+        private readonly DateValue _dateValue;
+        private readonly int _hashCode;
+
+        public ComparableDateValue(DateValue dateValue)
+        {
+            _dateValue = dateValue;
+            _hashCode = dateValue.AsDecimal.GetHashCode();
+        }
+
+        public Parsing.PreProcessing.ValueType ValueType => _dateValue.ValueType;
+
+        public bool AsBool => _dateValue.AsBool;
+
+        public byte AsByte => _dateValue.AsByte;
+
+        public decimal AsDecimal => _dateValue.AsDecimal;
+
+        public DateTime AsDate => _dateValue.AsDate;
+
+        public string AsString => _dateValue.AsString;
+
+        public IEnumerable<IToken> AsTokens => _dateValue.AsTokens;
+
+        public int CompareTo(ComparableDateValue dateValue)
+            => _dateValue.AsDecimal.CompareTo(dateValue._dateValue.AsDecimal);
+
+        public override int GetHashCode() => _hashCode;
+
+        public override bool Equals(object obj)
+        {
+            if (obj is ComparableDateValue decorator)
+            {
+                return decorator.CompareTo(this) == 0;
+            }
+
+            if (obj is DateValue dateValue)
+            {
+                return dateValue.AsDecimal == _dateValue.AsDecimal;
+            }
+
+            return false;
+        }
+
+        public override string ToString()
+        {
+            return _dateValue.ToString();
+        }
+
+        public string AsDateLiteral()
+        {
+            var asString = AsDate.ToString(CultureInfo.InvariantCulture);
+            var prePostPend = "#";
+            var result = asString.StartsWith(prePostPend) ? asString : $"{prePostPend}{asString}";
+            result = result.EndsWith(prePostPend) ? result : $"{result}{prePostPend}";
+            return result;
+        }
+
+        public static ComparableDateValue Parse(string valueText)
+        {
+                var literal = new DateLiteralExpression(new ConstantExpression(new StringValue(valueText)));
+                return new ComparableDateValue((DateValue)literal.Evaluate());
+        }
+
+        public static bool TryParse(string valueText, out ComparableDateValue value)
+        {
+            value = default;
+            if (!(valueText.StartsWith("#") && valueText.EndsWith("#")))
+            {
+                return false;
+            }
+
+            try
+            {
+                value = Parse(valueText);
+                return true;
+            }
+            catch (SyntaxErrorException)
+            {
+                return false;
+            }
+            catch (ArgumentOutOfRangeException)
+            {
+                return false;
+            }
+            catch (InputMismatchException)
+            {
+                return false;
+            }
+            catch (Exception e)
+            {
+                //even though a SyntaxErrorException/InputMismatchException is thrown, 
+                //this catch-all block seems to be needed(?)
+                return false;
+            }
+        }
+    }
+}