Merge branch 'next' into CommandHierarchyCanExecuteConditions

Author: MDoerner

README.md

@@ -59,6 +59,6 @@ along with this program.  If not, see http://www.gnu.org/licenses/.
 
 [![JetBrains ReSharper logo](https://cloud.githubusercontent.com/assets/5751684/20271309/616bb740-aa58-11e6-91c9-65287b740985.png)](https://www.jetbrains.com/resharper/)
 
-Since the project's early days, JetBrains' Open-Source team has been supporting Rubberduck - and we deeply thank them for that. ReSharper has been not only a tool we couldn't do without; it's been an inspiration, the ultimate level of polished perfection to strive for in our own IDE add-in project. So just like you're missing out if you write VBA and you're not using Rubberduck, you're missing out if you write C# and aren't using ReSharper.
+Since the project's early days, JetBrains' Open-Source team has been supporting Rubberduck with free OSS licenses for all core contributors - and we deeply thank them for that. ReSharper has been not only a tool we couldn't do without; it's been an inspiration, the ultimate level of polished perfection to strive for in our own IDE add-in project. So just like you're missing out if you write VBA and you're not using Rubberduck, you're missing out if you write C# and aren't using ReSharper.
 
 <sub>Note: Rubberduck is not a JetBrains product. JetBrains does not contribute and is not affiliated to the Rubberduck project in any way.</sub>

Rubberduck.CodeAnalysis/Inspections/Abstract/InspectionBase.cs

@@ -11,6 +11,7 @@
 using System.Threading;
 using NLog;
 using Rubberduck.Parsing.Inspections;
+using Rubberduck.Inspections.Inspections.Extensions;
 
 namespace Rubberduck.Inspections.Abstract
 {
@@ -68,78 +69,22 @@ protected InspectionBase(RubberduckParserState state)
         /// </summary>
         protected virtual IEnumerable<Declaration> Declarations
         {
-            get { return State.AllDeclarations.Where(declaration => !IsIgnoringInspectionResultFor(declaration, AnnotationName)); }
+            get { return State.AllDeclarations.Where(declaration => !declaration.IsIgnoringInspectionResultFor(AnnotationName)); }
         }
 
         /// <summary>
         /// Gets all user declarations in the parser state without an @Ignore annotation for this inspection.
         /// </summary>
         protected virtual IEnumerable<Declaration> UserDeclarations
         {
-            get { return State.AllUserDeclarations.Where(declaration => !IsIgnoringInspectionResultFor(declaration, AnnotationName)); }
+            get { return State.AllUserDeclarations.Where(declaration => !declaration.IsIgnoringInspectionResultFor(AnnotationName)); }
         }
 
         protected virtual IEnumerable<Declaration> BuiltInDeclarations
         {
             get { return State.AllDeclarations.Where(declaration => !declaration.IsUserDefined); }
         }
 
-        protected bool IsIgnoringInspectionResultFor(QualifiedModuleName module, int line)
-        {
-            var lineScopedAnnotations = State.DeclarationFinder.FindAnnotations(module, line);
-            foreach (var ignoreAnnotation in lineScopedAnnotations.OfType<IgnoreAnnotation>())
-            {
-                if (ignoreAnnotation.InspectionNames.Contains(AnnotationName))
-                {
-                    return true;
-                }
-            }
-
-            var moduleDeclaration = State.DeclarationFinder.Members(module)
-                .First(decl => decl.DeclarationType.HasFlag(DeclarationType.Module));
-
-            foreach (var ignoreModuleAnnotation in moduleDeclaration.Annotations.OfType<IgnoreModuleAnnotation>())
-            {
-                if (ignoreModuleAnnotation.InspectionNames.Contains(AnnotationName)
-                    || !ignoreModuleAnnotation.InspectionNames.Any())
-                {
-                    return true;
-                }
-            }
-
-            return false;
-        }
-
-        protected bool IsIgnoringInspectionResultFor(Declaration declaration, string inspectionName)
-        {
-            var module = Declaration.GetModuleParent(declaration);
-            if (module == null)
-            {
-                return false;
-            }
-
-            var isIgnoredAtModuleLevel = module.Annotations
-                    .Any(annotation => annotation.AnnotationType == AnnotationType.IgnoreModule
-                                       && ((IgnoreModuleAnnotation) annotation).IsIgnored(inspectionName));
-
-
-            if (declaration.DeclarationType == DeclarationType.Parameter)
-            {
-                return isIgnoredAtModuleLevel || declaration.ParentDeclaration.Annotations.Any(annotation =>
-                    annotation.AnnotationType == AnnotationType.Ignore
-                    && ((IgnoreAnnotation)annotation).IsIgnored(inspectionName));
-            }
-
-            return isIgnoredAtModuleLevel || declaration.Annotations.Any(annotation =>
-                annotation.AnnotationType == AnnotationType.Ignore
-                && ((IgnoreAnnotation)annotation).IsIgnored(inspectionName));
-        }
-
-        protected bool IsIgnoringInspectionResultFor(IdentifierReference reference, string inspectionName)
-        {
-            return reference != null && reference.IsIgnoringInspectionResultFor(inspectionName);
-        }
-
         public int CompareTo(IInspection other)
         {
             return string.Compare(InspectionType + Name, other.InspectionType + other.Name, StringComparison.Ordinal);

Rubberduck.CodeAnalysis/Inspections/Abstract/MemberAccessMayReturnNothingInspectionBase.cs

@@ -3,6 +3,7 @@
 using Antlr4.Runtime.Tree;
 using Rubberduck.Inspections.CodePathAnalysis;
 using Rubberduck.Inspections.CodePathAnalysis.Nodes;
+using Rubberduck.Inspections.Inspections.Extensions;
 using Rubberduck.Inspections.Results;
 using Rubberduck.Parsing;
 using Rubberduck.Parsing.Grammar;
@@ -28,7 +29,7 @@ protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
             }
 
             var output = new List<IInspectionResult>();
-            foreach (var reference in interesting.Where(use => !IsIgnoringInspectionResultFor(use, AnnotationName)))
+            foreach (var reference in interesting.Where(use => !use.IsIgnoringInspectionResultFor(AnnotationName)))
             {
                 var access = reference.Context.GetAncestor<VBAParser.MemberAccessExprContext>();
                 var usageContext = access.Parent is VBAParser.IndexExprContext

Rubberduck.CodeAnalysis/Inspections/Concrete/ApplicationWorksheetFunctionInspection.cs

@@ -8,6 +8,7 @@
 using Rubberduck.Parsing.Symbols;
 using Rubberduck.Parsing.VBA;
 using Rubberduck.VBEditor;
+using Rubberduck.Inspections.Inspections.Extensions;
 
 namespace Rubberduck.Inspections.Concrete
 {
@@ -33,7 +34,7 @@ protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
                                                            members.Contains(decl.IdentifierName));
 
             return from usage in usages
-                   from reference in usage.References.Where(use => !IsIgnoringInspectionResultFor(use, AnnotationName))
+                   from reference in usage.References.Where(use => !use.IsIgnoringInspectionResultFor(AnnotationName))
                    let qualifiedSelection = new QualifiedSelection(reference.QualifiedModuleName, reference.Selection)
                    select new IdentifierReferenceInspectionResult(this,
                                                string.Format(InspectionResults.ApplicationWorksheetFunctionInspection, usage.IdentifierName),

Rubberduck.CodeAnalysis/Inspections/Concrete/AssignedByValParameterInspection.cs

@@ -6,6 +6,7 @@
 using Rubberduck.Resources.Inspections;
 using Rubberduck.Parsing.Symbols;
 using Rubberduck.Parsing.VBA;
+using Rubberduck.Inspections.Inspections.Extensions;
 
 namespace Rubberduck.Inspections.Concrete
 {
@@ -20,7 +21,7 @@ protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
             var parameters = State.DeclarationFinder.UserDeclarations(DeclarationType.Parameter)
                 .Cast<ParameterDeclaration>()
                 .Where(item => !item.IsByRef 
-                    && !IsIgnoringInspectionResultFor(item, AnnotationName)
+                    && !item.IsIgnoringInspectionResultFor(AnnotationName)
                     && item.References.Any(reference => reference.IsAssignment));
 
             return parameters

Rubberduck.CodeAnalysis/Inspections/Concrete/AssignmentNotUsedInspection.cs

@@ -8,6 +8,7 @@
 using System.Linq;
 using Rubberduck.Inspections.Results;
 using Rubberduck.Parsing.Grammar;
+using Rubberduck.Inspections.Inspections.Extensions;
 
 namespace Rubberduck.Inspections.Concrete
 {
@@ -46,6 +47,9 @@ protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
             }
 
             return nodes
+                .Where(issue => !issue.IsIgnoringInspectionResultFor(AnnotationName)
+                            // Ignoring the Declaration disqualifies all assignments
+                            && !issue.Declaration.IsIgnoringInspectionResultFor(AnnotationName))
                 .Select(issue => new IdentifierReferenceInspectionResult(this, Description, State, issue))
                 .ToList();
         }

Rubberduck.CodeAnalysis/Inspections/Concrete/BooleanAssignedInIfElseInspection.cs

@@ -9,6 +9,7 @@
 using Rubberduck.Resources.Inspections;
 using Rubberduck.Parsing.VBA;
 using Rubberduck.VBEditor;
+using Rubberduck.Inspections.Inspections.Extensions;
 
 namespace Rubberduck.Inspections.Concrete
 {
@@ -23,7 +24,7 @@ public BooleanAssignedInIfElseInspection(RubberduckParserState state)
         protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
         {
             return Listener.Contexts
-                .Where(result => !IsIgnoringInspectionResultFor(result.ModuleName, result.Context.Start.Line))
+                .Where(result => !result.IsIgnoringInspectionResultFor(State.DeclarationFinder, AnnotationName))
                 .Select(result => new QualifiedContextInspectionResult(this,
                                                        string.Format(InspectionResults.BooleanAssignedInIfElseInspection,
                                                             (((VBAParser.IfStmtContext)result.Context).block().GetDescendent<VBAParser.LetStmtContext>()).lExpression().GetText().Trim()),

Rubberduck.CodeAnalysis/Inspections/Concrete/ConstantNotUsedInspection.cs

@@ -9,6 +9,7 @@
 using Rubberduck.Resources.Inspections;
 using Rubberduck.Parsing.Symbols;
 using Rubberduck.Parsing.VBA;
+using Rubberduck.Inspections.Inspections.Extensions;
 
 namespace Rubberduck.Inspections.Concrete
 {
@@ -22,7 +23,7 @@ protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
             var results = State.DeclarationFinder.UserDeclarations(DeclarationType.Constant)
                 .Where(declaration => declaration.Context != null
                     && !declaration.References.Any()
-                    && !IsIgnoringInspectionResultFor(declaration, AnnotationName))
+                    && !declaration.IsIgnoringInspectionResultFor(AnnotationName))
                 .ToList();
 
             return results.Select(issue => 

Rubberduck.CodeAnalysis/Inspections/Concrete/DefTypeStatementInspection.cs

@@ -10,6 +10,7 @@
 using Rubberduck.VBEditor;
 using Antlr4.Runtime.Misc;
 using Rubberduck.Inspections.Results;
+using Rubberduck.Inspections.Inspections.Extensions;
 
 namespace Rubberduck.Inspections.Concrete
 {
@@ -25,7 +26,7 @@ public DefTypeStatementInspection(RubberduckParserState state)
 
         protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
         {
-            var results = Listener.Contexts.Where(context => !IsIgnoringInspectionResultFor(context.ModuleName, context.Context.Start.Line))
+            var results = Listener.Contexts.Where(context => !context.IsIgnoringInspectionResultFor(State.DeclarationFinder, AnnotationName))
                 .Select(context => new QualifiedContextInspectionResult(this,
                                                                         string.Format(InspectionResults.DefTypeStatementInspection,
                                                                                       GetTypeOfDefType(context.Context.start.Text),

Rubberduck.CodeAnalysis/Inspections/Concrete/EmptyCaseBlockInspection.cs

@@ -9,6 +9,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using Rubberduck.Resources.Experimentals;
+using Rubberduck.Inspections.Inspections.Extensions;
 
 namespace Rubberduck.Inspections.Concrete
 {
@@ -24,7 +25,7 @@ public EmptyCaseBlockInspection(RubberduckParserState state)
         protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
         {
             return Listener.Contexts
-                .Where(result => !IsIgnoringInspectionResultFor(result.ModuleName, result.Context.Start.Line))
+                .Where(result => !result.IsIgnoringInspectionResultFor(State.DeclarationFinder, AnnotationName))
                 .Select(result => new QualifiedContextInspectionResult(this,
                                                         InspectionResults.EmptyCaseBlockInspection,
                                                         result));