Merge pull request #2052 from Hosch250/inspectionBugs

Inspection bugs

Author: retailcoder

RetailCoder.VBE/Inspections/AssignedByValParameterInspectionResult.cs

@@ -13,9 +13,10 @@ public class AssignedByValParameterInspectionResult : InspectionResultBase
         public AssignedByValParameterInspectionResult(IInspection inspection, Declaration target)
             : base(inspection, target)
         {
-            _quickFixes = new[]
+            _quickFixes = new CodeInspectionQuickFix[]
             {
                 new PassParameterByReferenceQuickFix(target.Context, QualifiedSelection),
+                new IgnoreOnceQuickFix(Context, QualifiedSelection, inspection.AnnotationName)
             };
         }
 

RetailCoder.VBE/Inspections/EmptyStringLiteralInspection.cs

@@ -26,8 +26,9 @@ public override IEnumerable<InspectionResultBase> GetInspectionResults()
             {
                 return new InspectionResultBase[] { };
             }
-            return ParseTreeResults.EmptyStringLiterals.Select(
-                    context => new EmptyStringLiteralInspectionResult(this,
+            return ParseTreeResults.EmptyStringLiterals
+                .Where(s => !IsInspectionDisabled(s.ModuleName.Component, s.Context.Start.Line))
+                .Select(context => new EmptyStringLiteralInspectionResult(this,
                             new QualifiedContext<ParserRuleContext>(context.ModuleName, context.Context)));
         }
 

RetailCoder.VBE/Inspections/EmptyStringLiteralInspectionResult.cs

@@ -13,9 +13,10 @@ public class EmptyStringLiteralInspectionResult : InspectionResultBase
         public EmptyStringLiteralInspectionResult(IInspection inspection, QualifiedContext<ParserRuleContext> qualifiedContext)
             : base(inspection, qualifiedContext.ModuleName, qualifiedContext.Context)
         {
-            _quickFixes = new[]
+            _quickFixes = new CodeInspectionQuickFix[]
             {
-                new RepaceEmptyStringLiteralStatementQuickFix(Context, QualifiedSelection), 
+                new RepaceEmptyStringLiteralStatementQuickFix(Context, QualifiedSelection),
+                new IgnoreOnceQuickFix(Context, QualifiedSelection, Inspection.AnnotationName)
             };
         }
 

RetailCoder.VBE/Inspections/EncapsulatePublicFieldInspectionResult.cs

@@ -16,9 +16,10 @@ public class EncapsulatePublicFieldInspectionResult : InspectionResultBase
         public EncapsulatePublicFieldInspectionResult(IInspection inspection, Declaration target, RubberduckParserState state)
             : base(inspection, target)
         {
-            _quickFixes = new[]
+            _quickFixes = new CodeInspectionQuickFix[]
             {
                 new EncapsulateFieldQuickFix(target.Context, target.QualifiedSelection, target, state),
+                new IgnoreOnceQuickFix(Context, QualifiedSelection, Inspection.AnnotationName)
             };
         }
 

RetailCoder.VBE/Inspections/FunctionReturnValueNotUsedInspectionResult.cs

@@ -34,9 +34,10 @@ public FunctionReturnValueNotUsedInspectionResult(
             var root = new ConvertToProcedureQuickFix(context, QualifiedSelection, returnStatements);
             var compositeFix = new CompositeCodeInspectionFix(root);
             children.ToList().ForEach(child => compositeFix.AddChild(new ConvertToProcedureQuickFix(child.Item1, child.Item2, child.Item3)));
-            _quickFixes = new[]
+            _quickFixes = new CodeInspectionQuickFix[]
             {
-                compositeFix
+                compositeFix,
+                new IgnoreOnceQuickFix(Context, QualifiedSelection, Inspection.AnnotationName)
             };
         }
 

RetailCoder.VBE/Inspections/ImplicitByRefParameterInspection.cs

@@ -26,7 +26,7 @@ public override IEnumerable<InspectionResultBase> GetInspectionResults()
 
             var issues = (from item in UserDeclarations
                 where
-                    !item.IsInspectionDisabled(AnnotationName)
+                    !IsInspectionDisabled(item, AnnotationName)
                     && item.DeclarationType == DeclarationType.Parameter
                     // ParamArray parameters do not allow an explicit "ByRef" parameter mechanism.               
                     && !((ParameterDeclaration)item).IsParamArray

RetailCoder.VBE/Inspections/ImplicitPublicMemberInspection.cs

@@ -30,7 +30,7 @@ public ImplicitPublicMemberInspection(RubberduckParserState state)
         public override IEnumerable<InspectionResultBase> GetInspectionResults()
         {
             var issues = from item in UserDeclarations
-                         where !item.IsInspectionDisabled(AnnotationName) 
+                         where !IsInspectionDisabled(item, AnnotationName) 
                                && ProcedureTypes.Contains(item.DeclarationType)
                                && item.Accessibility == Accessibility.Implicit
                          let context = new QualifiedContext<ParserRuleContext>(item.QualifiedName, item.Context)

RetailCoder.VBE/Inspections/ImplicitVariantReturnTypeInspection.cs

@@ -28,7 +28,7 @@ public ImplicitVariantReturnTypeInspection(RubberduckParserState state)
         public override IEnumerable<InspectionResultBase> GetInspectionResults()
         {
             var issues = from item in UserDeclarations
-                               where !item.IsInspectionDisabled(AnnotationName)
+                               where !IsInspectionDisabled(item, AnnotationName)
                                 && ProcedureTypes.Contains(item.DeclarationType)
                                 && !item.IsTypeSpecified
                                let issue = new {Declaration = item, QualifiedContext = new QualifiedContext<ParserRuleContext>(item.QualifiedName, item.Context)}

RetailCoder.VBE/Inspections/InspectionBase.cs

@@ -1,6 +1,8 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using Microsoft.Vbe.Interop;
+using Rubberduck.Parsing.Annotations;
 using Rubberduck.Parsing.Symbols;
 using Rubberduck.Parsing.VBA;
 
@@ -73,20 +75,56 @@ protected InspectionBase(RubberduckParserState state, CodeInspectionSeverity def
         /// </summary>
         protected virtual IEnumerable<Declaration> Declarations
         {
-            get { return State.AllDeclarations.Where(declaration => !declaration.IsInspectionDisabled(AnnotationName)); }
+            get { return State.AllDeclarations.Where(declaration => !IsInspectionDisabled(declaration, 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 => !IsInspectionDisabled(declaration, AnnotationName)); }
         }
 
         protected virtual IEnumerable<Declaration> BuiltInDeclarations
         {
             get { return State.AllDeclarations.Where(declaration => declaration.IsBuiltIn); }
         }
 
-        /// <summary>
-        /// Gets all user declarations in the parser state without an @Ignore annotation for this inspection.
-        /// </summary>
-        protected virtual IEnumerable<Declaration> UserDeclarations
+        protected bool IsInspectionDisabled(VBComponent component, int line)
         {
-            get { return State.AllUserDeclarations.Where(declaration => !declaration.IsInspectionDisabled(AnnotationName)); }
+            var annotations = State.GetModuleAnnotations(component).ToList();
+
+            if (State.GetModuleAnnotations(component) == null)
+            {
+                return false;
+            }
+
+            // VBE 1-based indexing
+            for (var i = line - 1; i >= 1; i--)
+            {
+                var annotation = annotations.SingleOrDefault(a => a.QualifiedSelection.Selection.StartLine == i) as IgnoreAnnotation;
+                if (annotation != null && annotation.InspectionNames.Contains(AnnotationName))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        protected bool IsInspectionDisabled(Declaration declaration, string inspectionName)
+        {
+            if (declaration.DeclarationType == DeclarationType.Parameter)
+            {
+                return declaration.ParentDeclaration.Annotations.Any(annotation =>
+                    annotation.AnnotationType == AnnotationType.Ignore
+                    && ((IgnoreAnnotation)annotation).IsIgnored(inspectionName));
+            }
+
+            return declaration.Annotations.Any(annotation =>
+                annotation.AnnotationType == AnnotationType.Ignore
+                && ((IgnoreAnnotation)annotation).IsIgnored(inspectionName));
         }
 
         public int CompareTo(IInspection other)

RetailCoder.VBE/Inspections/MoveFieldCloserToUsageInspectionResult.cs

@@ -15,9 +15,10 @@ public class MoveFieldCloserToUsageInspectionResult : InspectionResultBase
         public MoveFieldCloserToUsageInspectionResult(IInspection inspection, Declaration target, RubberduckParserState state, IMessageBox messageBox)
             : base(inspection, target)
         {
-            _quickFixes = new[]
+            _quickFixes = new CodeInspectionQuickFix[]
             {
                 new MoveFieldCloserToUsageQuickFix(target.Context, target.QualifiedSelection, target, state, messageBox),
+                new IgnoreOnceQuickFix(Context, QualifiedSelection, Inspection.AnnotationName)
             };
         }