Move check for ignore in declaration annotations

Hosch250 · Hosch250 · commit df50e7c0c1b3 · 2016-07-13T17:58:26.000-05:00
diff --git a/RetailCoder.VBE/Inspections/EmptyStringLiteralInspection.cs b/RetailCoder.VBE/Inspections/EmptyStringLiteralInspection.cs
@@ -27,7 +27,7 @@ public override IEnumerable<InspectionResultBase> GetInspectionResults()
                 return new InspectionResultBase[] { };
             }
             return ParseTreeResults.EmptyStringLiterals
-                .Where(s => !HasIgnoreAnnotation(s.ModuleName.Component, s.Context.Start.Line))
+                .Where(s => !IsInspectionDisabled(s.ModuleName.Component, s.Context.Start.Line))
                 .Select(context => new EmptyStringLiteralInspectionResult(this,
                             new QualifiedContext<ParserRuleContext>(context.ModuleName, context.Context)));
         }
diff --git a/RetailCoder.VBE/Inspections/ImplicitByRefParameterInspection.cs b/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
diff --git a/RetailCoder.VBE/Inspections/ImplicitPublicMemberInspection.cs b/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)
diff --git a/RetailCoder.VBE/Inspections/ImplicitVariantReturnTypeInspection.cs b/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)}
diff --git a/RetailCoder.VBE/Inspections/InspectionBase.cs b/RetailCoder.VBE/Inspections/InspectionBase.cs
@@ -75,15 +75,23 @@ 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); }
         }
 
-        protected bool HasIgnoreAnnotation(VBComponent component, int line)
+        protected bool IsInspectionDisabled(VBComponent component, int line)
         {
             var annotations = State.GetModuleAnnotations(component).ToList();
 
@@ -105,12 +113,18 @@ protected bool HasIgnoreAnnotation(VBComponent component, int line)
             return false;
         }
 
-        /// <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(Declaration declaration, string inspectionName)
         {
-            get { return State.AllUserDeclarations.Where(declaration => !declaration.IsInspectionDisabled(AnnotationName)); }
+            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)
diff --git a/RetailCoder.VBE/Inspections/MultipleDeclarationsInspection.cs b/RetailCoder.VBE/Inspections/MultipleDeclarationsInspection.cs
@@ -21,7 +21,7 @@ public MultipleDeclarationsInspection(RubberduckParserState state)
         public override IEnumerable<InspectionResultBase> GetInspectionResults()
         {
             var issues = UserDeclarations
-                .Where(item => !item.IsInspectionDisabled(AnnotationName))
+                .Where(item => !IsInspectionDisabled(item, AnnotationName))
                 .Where(item => item.DeclarationType == DeclarationType.Variable
                             || item.DeclarationType == DeclarationType.Constant)
                 .GroupBy(variable => variable.Context.Parent as ParserRuleContext)
diff --git a/RetailCoder.VBE/Inspections/ObsoleteCallStatementInspection.cs b/RetailCoder.VBE/Inspections/ObsoleteCallStatementInspection.cs
@@ -27,7 +27,7 @@ public override IEnumerable<InspectionResultBase> GetInspectionResults()
 
             var results = new List<ObsoleteCallStatementUsageInspectionResult>();
 
-            foreach (var context in ParseTreeResults.ObsoleteCallContexts.Where(o => !HasIgnoreAnnotation(o.ModuleName.Component, o.Context.Start.Line)))
+            foreach (var context in ParseTreeResults.ObsoleteCallContexts.Where(o => !IsInspectionDisabled(o.ModuleName.Component, o.Context.Start.Line)))
             {
                 var lines = context.ModuleName.Component.CodeModule.Lines[
                         context.Context.Start.Line, context.Context.Stop.Line - context.Context.Start.Line + 1];
diff --git a/RetailCoder.VBE/Inspections/ObsoleteCommentSyntaxInspection.cs b/RetailCoder.VBE/Inspections/ObsoleteCommentSyntaxInspection.cs
@@ -22,7 +22,7 @@ public ObsoleteCommentSyntaxInspection(RubberduckParserState state)
         public override IEnumerable<InspectionResultBase> GetInspectionResults()
         {
             return State.AllComments.Where(comment => comment.Marker == Tokens.Rem &&
-                                            !HasIgnoreAnnotation(comment.QualifiedSelection.QualifiedName.Component, comment.QualifiedSelection.Selection.StartLine))
+                                            !IsInspectionDisabled(comment.QualifiedSelection.QualifiedName.Component, comment.QualifiedSelection.Selection.StartLine))
                 .Select(comment => new ObsoleteCommentSyntaxInspectionResult(this, comment));
         }
     }
diff --git a/RetailCoder.VBE/Inspections/ObsoleteLetStatementInspection.cs b/RetailCoder.VBE/Inspections/ObsoleteLetStatementInspection.cs
@@ -26,7 +26,7 @@ public override IEnumerable<InspectionResultBase> GetInspectionResults()
                 return new InspectionResultBase[] { };
             }
             return ParseTreeResults.ObsoleteLetContexts
-                .Where(o => !HasIgnoreAnnotation(o.ModuleName.Component, o.Context.Start.Line))
+                .Where(o => !IsInspectionDisabled(o.ModuleName.Component, o.Context.Start.Line))
                 .Select(context => new ObsoleteLetStatementUsageInspectionResult(this, new QualifiedContext<ParserRuleContext>(context.ModuleName, context.Context)));
         }
 
diff --git a/RetailCoder.VBE/Inspections/ProcedureNotUsedInspection.cs b/RetailCoder.VBE/Inspections/ProcedureNotUsedInspection.cs
@@ -46,7 +46,7 @@ public override IEnumerable<InspectionResultBase> GetInspectionResults()
 
             var items = declarations
                 .Where(item => !IsIgnoredDeclaration(declarations, item, handlers, classes, modules)
-                            && !item.IsInspectionDisabled(AnnotationName)).ToList();
+                            && !IsInspectionDisabled(item, AnnotationName)).ToList();
             var issues = items.Select(issue => new IdentifierNotUsedInspectionResult(this, issue, issue.Context, issue.QualifiedName.QualifiedModuleName));
 
             issues = DocumentNames.DocumentEventHandlerPrefixes.Aggregate(issues, (current, item) => current.Where(issue => !issue.Description.Contains("'" + item)));
diff --git a/RetailCoder.VBE/Inspections/UntypedFunctionUsageInspection.cs b/RetailCoder.VBE/Inspections/UntypedFunctionUsageInspection.cs
@@ -49,7 +49,7 @@ public override IEnumerable<InspectionResultBase> GetInspectionResults()
 
             return declarations.SelectMany(declaration => declaration.References
                 .Where(item => _tokens.Contains(item.IdentifierName) &&
-                               !HasIgnoreAnnotation(item.QualifiedModuleName.Component, item.Selection.StartLine))
+                               !IsInspectionDisabled(item.QualifiedModuleName.Component, item.Selection.StartLine))
                 .Select(item => new UntypedFunctionUsageInspectionResult(this, item)));
         }
     }
diff --git a/Rubberduck.Parsing/Symbols/Declaration.cs b/Rubberduck.Parsing/Symbols/Declaration.cs
@@ -306,20 +306,6 @@ public bool IsEnumeratorMember
             }
         }
 
-        public bool IsInspectionDisabled(string inspectionName)
-        {
-            if (DeclarationType == DeclarationType.Parameter)
-            {
-                return ParentDeclaration.Annotations.Any(annotation =>
-                    annotation.AnnotationType == AnnotationType.Ignore
-                    && ((IgnoreAnnotation)annotation).IsIgnored(inspectionName));
-            }
-
-            return Annotations.Any(annotation =>
-                annotation.AnnotationType == AnnotationType.Ignore
-                && ((IgnoreAnnotation)annotation).IsIgnored(inspectionName));
-        }
-
         public void AddReference(
             QualifiedModuleName module,
             Declaration scope,

Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ public override IEnumerable<InspectionResultBase> GetInspectionResults()`
`27`	`27`	`return new InspectionResultBase[] { };`
`28`	`28`	`}`
`29`	`29`	`return ParseTreeResults.EmptyStringLiterals`
`30`		`- .Where(s => !HasIgnoreAnnotation(s.ModuleName.Component, s.Context.Start.Line))`
	`30`	`+ .Where(s => !IsInspectionDisabled(s.ModuleName.Component, s.Context.Start.Line))`
`31`	`31`	`.Select(context => new EmptyStringLiteralInspectionResult(this,`
`32`	`32`	`new QualifiedContext<ParserRuleContext>(context.ModuleName, context.Context)));`
`33`	`33`	`}`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ public ImplicitPublicMemberInspection(RubberduckParserState state)`
`30`	`30`	`public override IEnumerable<InspectionResultBase> GetInspectionResults()`
`31`	`31`	`{`
`32`	`32`	`var issues = from item in UserDeclarations`
`33`		`- where !item.IsInspectionDisabled(AnnotationName)`
	`33`	`+ where !IsInspectionDisabled(item, AnnotationName)`
`34`	`34`	`&& ProcedureTypes.Contains(item.DeclarationType)`
`35`	`35`	`&& item.Accessibility == Accessibility.Implicit`
`36`	`36`	`let context = new QualifiedContext<ParserRuleContext>(item.QualifiedName, item.Context)`
Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ public ImplicitVariantReturnTypeInspection(RubberduckParserState state)`
`28`	`28`	`public override IEnumerable<InspectionResultBase> GetInspectionResults()`
`29`	`29`	`{`
`30`	`30`	`var issues = from item in UserDeclarations`
`31`		`- where !item.IsInspectionDisabled(AnnotationName)`
	`31`	`+ where !IsInspectionDisabled(item, AnnotationName)`
`32`	`32`	`&& ProcedureTypes.Contains(item.DeclarationType)`
`33`	`33`	`&& !item.IsTypeSpecified`
`34`	`34`	`let issue = new {Declaration = item, QualifiedContext = new QualifiedContext<ParserRuleContext>(item.QualifiedName, item.Context)}`
Original file line number	Diff line number	Diff line change
`@@ -75,15 +75,23 @@ protected InspectionBase(RubberduckParserState state, CodeInspectionSeverity def`
`75`	`75`	`/// </summary>`
`76`	`76`	`protected virtual IEnumerable<Declaration> Declarations`
`77`	`77`	`{`
`78`		`- get { return State.AllDeclarations.Where(declaration => !declaration.IsInspectionDisabled(AnnotationName)); }`
	`78`	`+ get { return State.AllDeclarations.Where(declaration => !IsInspectionDisabled(declaration, AnnotationName)); }`
	`79`	`+ }`
	`80`	`+`
	`81`	`+ /// <summary>`
	`82`	`+ /// Gets all user declarations in the parser state without an @Ignore annotation for this inspection.`
	`83`	`+ /// </summary>`
	`84`	`+ protected virtual IEnumerable<Declaration> UserDeclarations`
	`85`	`+ {`
	`86`	`+ get { return State.AllUserDeclarations.Where(declaration => !IsInspectionDisabled(declaration, AnnotationName)); }`
`79`	`87`	`}`
`80`	`88`
`81`	`89`	`protected virtual IEnumerable<Declaration> BuiltInDeclarations`
`82`	`90`	`{`
`83`	`91`	`get { return State.AllDeclarations.Where(declaration => declaration.IsBuiltIn); }`
`84`	`92`	`}`
`85`	`93`
`86`		`- protected bool HasIgnoreAnnotation(VBComponent component, int line)`
	`94`	`+ protected bool IsInspectionDisabled(VBComponent component, int line)`
`87`	`95`	`{`
`88`	`96`	`var annotations = State.GetModuleAnnotations(component).ToList();`
`89`	`97`
`@@ -105,12 +113,18 @@ protected bool HasIgnoreAnnotation(VBComponent component, int line)`
`105`	`113`	`return false;`
`106`	`114`	`}`
`107`	`115`
`108`		`- /// <summary>`
`109`		`- /// Gets all user declarations in the parser state without an @Ignore annotation for this inspection.`
`110`		`- /// </summary>`
`111`		`- protected virtual IEnumerable<Declaration> UserDeclarations`
	`116`	`+ protected bool IsInspectionDisabled(Declaration declaration, string inspectionName)`
`112`	`117`	`{`
`113`		`- get { return State.AllUserDeclarations.Where(declaration => !declaration.IsInspectionDisabled(AnnotationName)); }`
	`118`	`+ if (declaration.DeclarationType == DeclarationType.Parameter)`
	`119`	`+ {`
	`120`	`+ return declaration.ParentDeclaration.Annotations.Any(annotation =>`
	`121`	`+ annotation.AnnotationType == AnnotationType.Ignore`
	`122`	`+ && ((IgnoreAnnotation)annotation).IsIgnored(inspectionName));`
	`123`	`+ }`
	`124`	`+`
	`125`	`+ return declaration.Annotations.Any(annotation =>`
	`126`	`+ annotation.AnnotationType == AnnotationType.Ignore`
	`127`	`+ && ((IgnoreAnnotation)annotation).IsIgnored(inspectionName));`
`114`	`128`	`}`
`115`	`129`
`116`	`130`	`public int CompareTo(IInspection other)`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ public MultipleDeclarationsInspection(RubberduckParserState state)`
`21`	`21`	`public override IEnumerable<InspectionResultBase> GetInspectionResults()`
`22`	`22`	`{`
`23`	`23`	`var issues = UserDeclarations`
`24`		`- .Where(item => !item.IsInspectionDisabled(AnnotationName))`
	`24`	`+ .Where(item => !IsInspectionDisabled(item, AnnotationName))`
`25`	`25`	`.Where(item => item.DeclarationType == DeclarationType.Variable`
`26`	`26`	`\|\| item.DeclarationType == DeclarationType.Constant)`
`27`	`27`	`.GroupBy(variable => variable.Context.Parent as ParserRuleContext)`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ public ObsoleteCommentSyntaxInspection(RubberduckParserState state)`
`22`	`22`	`public override IEnumerable<InspectionResultBase> GetInspectionResults()`
`23`	`23`	`{`
`24`	`24`	`return State.AllComments.Where(comment => comment.Marker == Tokens.Rem &&`
`25`		`- !HasIgnoreAnnotation(comment.QualifiedSelection.QualifiedName.Component, comment.QualifiedSelection.Selection.StartLine))`
	`25`	`+ !IsInspectionDisabled(comment.QualifiedSelection.QualifiedName.Component, comment.QualifiedSelection.Selection.StartLine))`
`26`	`26`	`.Select(comment => new ObsoleteCommentSyntaxInspectionResult(this, comment));`
`27`	`27`	`}`
`28`	`28`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ public override IEnumerable<InspectionResultBase> GetInspectionResults()`
`26`	`26`	`return new InspectionResultBase[] { };`
`27`	`27`	`}`
`28`	`28`	`return ParseTreeResults.ObsoleteLetContexts`
`29`		`- .Where(o => !HasIgnoreAnnotation(o.ModuleName.Component, o.Context.Start.Line))`
	`29`	`+ .Where(o => !IsInspectionDisabled(o.ModuleName.Component, o.Context.Start.Line))`
`30`	`30`	`.Select(context => new ObsoleteLetStatementUsageInspectionResult(this, new QualifiedContext<ParserRuleContext>(context.ModuleName, context.Context)));`
`31`	`31`	`}`
`32`	`32`