sync with next

RetailCoder.VBE/Inspections/Abstract/InspectionBase.cs

@@ -128,6 +128,18 @@ protected bool IsInspectionDisabled(Declaration declaration, string inspectionNa
                 && ((IgnoreAnnotation)annotation).IsIgnored(inspectionName));
         }
 
+        protected bool IsInspectionDisabled(IdentifierReference reference, string inspectionName)
+        {
+            if (reference == null)
+            {
+                return false;
+            }
+
+            return reference.Annotations.Any(annotation =>
+                annotation.AnnotationType == AnnotationType.Ignore
+                && ((IgnoreAnnotation)annotation).IsIgnored(inspectionName));
+        }
+
         public int CompareTo(IInspection other)
         {
             return string.Compare(InspectionType + Name, other.InspectionType + other.Name, StringComparison.Ordinal);

RetailCoder.VBE/Inspections/ImplicitByRefParameterInspection.cs

@@ -25,12 +25,10 @@ public ImplicitByRefParameterInspection(RubberduckParserState state)
         public override IEnumerable<InspectionResultBase> GetInspectionResults()
         {
             var interfaceMembersScope = UserDeclarations.FindInterfaceImplementationMembers().Select(m => m.Scope);
-            var builtinEventHandlers = State.AllDeclarations.FindBuiltInEventHandlers();
+            var builtinEventHandlers = Declarations.FindBuiltInEventHandlers();
 
             var issues = (from item in UserDeclarations
-                where
-                    !IsInspectionDisabled(item, AnnotationName)
-                    && item.DeclarationType == DeclarationType.Parameter
+                where item.DeclarationType == DeclarationType.Parameter
                     // ParamArray parameters do not allow an explicit "ByRef" parameter mechanism.               
                     && !((ParameterDeclaration)item).IsParamArray
                     && !interfaceMembersScope.Contains(item.ParentScope)
@@ -40,7 +38,6 @@ public override IEnumerable<InspectionResultBase> GetInspectionResults()
                 select new QualifiedContext<VBAParser.ArgContext>(item.QualifiedName, arg))
                 .Select(issue => new ImplicitByRefParameterInspectionResult(this, issue.Context.unrestrictedIdentifier().GetText(), issue));
 
-
             return issues;
         }
     }

RetailCoder.VBE/Inspections/ImplicitPublicMemberInspection.cs

@@ -33,11 +33,10 @@ public ImplicitPublicMemberInspection(RubberduckParserState state)
         public override IEnumerable<InspectionResultBase> GetInspectionResults()
         {
             var issues = from item in UserDeclarations
-                         where !IsInspectionDisabled(item, AnnotationName) 
-                               && ProcedureTypes.Contains(item.DeclarationType)
+                         where ProcedureTypes.Contains(item.DeclarationType)
                                && item.Accessibility == Accessibility.Implicit
                          let context = new QualifiedContext<ParserRuleContext>(item.QualifiedName, item.Context)
-                               select new ImplicitPublicMemberInspectionResult(this, context, item);
+                         select new ImplicitPublicMemberInspectionResult(this, context, item);
             return issues;
         }
     }

RetailCoder.VBE/Inspections/ImplicitVariantReturnTypeInspection.cs

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

RetailCoder.VBE/Inspections/MultipleDeclarationsInspection.cs

@@ -24,7 +24,6 @@ public MultipleDeclarationsInspection(RubberduckParserState state)
         public override IEnumerable<InspectionResultBase> GetInspectionResults()
         {
             var issues = UserDeclarations
-                .Where(item => !IsInspectionDisabled(item, AnnotationName))
                 .Where(item => item.DeclarationType == DeclarationType.Variable
                             || item.DeclarationType == DeclarationType.Constant)
                 .GroupBy(variable => variable.Context.Parent as ParserRuleContext)

RetailCoder.VBE/Inspections/ObsoleteCallStatementInspection.cs

@@ -51,8 +51,7 @@ public override IEnumerable<InspectionResultBase> GetInspectionResults()
                     if (!stringStrippedLines.Contains(":"))
                     {
                         results.Add(new ObsoleteCallStatementUsageInspectionResult(this,
-                                new QualifiedContext<VBAParser.CallStmtContext>(context.ModuleName,
-                                    context.Context as VBAParser.CallStmtContext)));
+                                new QualifiedContext<VBAParser.CallStmtContext>(context.ModuleName, context.Context)));
                     }
                 }
             }

RetailCoder.VBE/Inspections/ProcedureNotUsedInspection.cs

@@ -36,13 +36,13 @@ public override IEnumerable<InspectionResultBase> GetInspectionResults()
         {
             var declarations = UserDeclarations.ToList();
 
-            var classes = UserDeclarations.Where(item => item.DeclarationType == DeclarationType.ClassModule).ToList();
-            var modules = UserDeclarations.Where(item => item.DeclarationType == DeclarationType.ProceduralModule).ToList();
+            var classes = declarations.Where(item => item.DeclarationType == DeclarationType.ClassModule).ToList();
+            var modules = declarations.Where(item => item.DeclarationType == DeclarationType.ProceduralModule).ToList();
 
             var handlers = declarations.Where(item => item.DeclarationType == DeclarationType.Control)
                 .SelectMany(control => declarations.FindEventHandlers(control)).ToList();
 
-            var withEventFields = UserDeclarations.Where(item => item.DeclarationType == DeclarationType.Variable && item.IsWithEvents);
+            var withEventFields = declarations.Where(item => item.DeclarationType == DeclarationType.Variable && item.IsWithEvents);
             handlers.AddRange(withEventFields.SelectMany(field => declarations.FindEventProcedures(field)));
 
             var forms = declarations.Where(item => item.DeclarationType == DeclarationType.ClassModule
@@ -54,11 +54,10 @@ public override IEnumerable<InspectionResultBase> GetInspectionResults()
                 handlers.AddRange(forms.SelectMany(form => State.FindFormEventHandlers(form)));
             }
 
-            handlers.AddRange(State.AllDeclarations.FindBuiltInEventHandlers());
+            handlers.AddRange(Declarations.FindBuiltInEventHandlers());
 
             var items = declarations
-                .Where(item => !IsIgnoredDeclaration(declarations, item, handlers, classes, modules)
-                            && !IsInspectionDisabled(item, AnnotationName)).ToList();
+                .Where(item => !IsIgnoredDeclaration(declarations, item, handlers, classes, modules)).ToList();
             var issues = items.Select(issue => new IdentifierNotUsedInspectionResult(this, issue, issue.Context, issue.QualifiedName.QualifiedModuleName));
 
             issues = DocumentEventHandlerPrefixes

RetailCoder.VBE/Inspections/Results/UndeclaredVariableInspectionResult.cs

@@ -17,7 +17,7 @@ public UndeclaredVariableInspectionResult(IInspection inspection, Declaration ta
             _quickFixes = new QuickFixBase[]
             {
                 new IntroduceLocalVariableQuickFix(target), 
-                new IgnoreOnceQuickFix(target.Context, target.QualifiedSelection, inspection.Name), 
+                new IgnoreOnceQuickFix(target.Context, target.QualifiedSelection, inspection.AnnotationName), 
             };
         }
 

RetailCoder.VBE/Inspections/UnassignedVariableUsageInspection.cs

@@ -28,7 +28,7 @@ public override IEnumerable<InspectionResultBase> GetInspectionResults()
                 && !UserDeclarations.Any(d => d.DeclarationType == DeclarationType.UserDefinedType
                     && d.IdentifierName == declaration.AsTypeName)
                 && !declaration.IsSelfAssigned
-                && !declaration.References.Any(reference => reference.IsAssignment));
+                && !declaration.References.Any(reference => reference.IsAssignment && !IsInspectionDisabled(reference, AnnotationName)));
 
             //The parameter scoping was apparently incorrect before - need to filter for the actual function.
             var lenFunction = BuiltInDeclarations.SingleOrDefault(s => s.DeclarationType == DeclarationType.Function && s.Scope.Equals("VBE7.DLL;VBA.Strings.Len"));

RetailCoder.VBE/Inspections/UndeclaredVariableInspection.cs

@@ -3,6 +3,7 @@
 using Rubberduck.Inspections.Abstract;
 using Rubberduck.Inspections.Resources;
 using Rubberduck.Inspections.Results;
+using Rubberduck.Parsing.Symbols;
 using Rubberduck.Parsing.VBA;
 
 namespace Rubberduck.Inspections
@@ -20,7 +21,7 @@ public UndeclaredVariableInspection(RubberduckParserState state)
 
         public override IEnumerable<InspectionResultBase> GetInspectionResults()
         {
-            return UserDeclarations.Where(item => item.IsUndeclared)
+            return UserDeclarations.Where(item => item.IsUndeclared && item.DeclarationType == DeclarationType.Variable)
                 .Select(item => new UndeclaredVariableInspectionResult(this, item));
         }
     }

RetailCoder.VBE/Inspections/UntypedFunctionUsageInspection.cs

@@ -52,7 +52,7 @@ public override IEnumerable<InspectionResultBase> GetInspectionResults()
 
             return declarations.SelectMany(declaration => declaration.References
                 .Where(item => _tokens.Contains(item.IdentifierName) &&
-                               !IsInspectionDisabled(item.QualifiedModuleName.Component, item.Selection.StartLine))
+                               !IsInspectionDisabled(item, AnnotationName))
                 .Select(item => new UntypedFunctionUsageInspectionResult(this, item)));
         }
     }

RetailCoder.VBE/Properties/AssemblyInfo.cs

@@ -31,5 +31,5 @@
 // You can specify all the values or you can default the Build and Revision Numbers 
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("2.0.11.*")]
-[assembly: AssemblyFileVersion("2.0.11.0")]
+[assembly: AssemblyVersion("2.0.12.*")]
+[assembly: AssemblyFileVersion("2.0.12.0")]

Rubberduck.Parsing/Rubberduck.Parsing.csproj

@@ -149,7 +149,7 @@
     <Compile Include="Symbols\DebugDeclarations.cs" />
     <Compile Include="Symbols\AliasDeclarations.cs" />
     <Compile Include="Symbols\FormEventDeclarations.cs" />
-    <Compile Include="Symbols\ICustomDelarationLoader.cs" />
+    <Compile Include="Symbols\ICustomDeclarationLoader.cs" />
     <Compile Include="Symbols\Identifier.cs" />
     <Compile Include="Binding\IBindingContext.cs" />
     <Compile Include="Binding\IBoundExpression.cs" />

Rubberduck.Parsing/VBA/ParseCoordinator.cs

@@ -209,7 +209,7 @@ private void ParseAll(object requestor, CancellationTokenSource token)
                 }
 
                 State.SetStatusAndFireStateChanged(requestor, State.Status);
-                return;
+                //return; // returning here leaves state in 'ResolvedDeclarations' when a module is removed, which disables refresh
             }
 
             foreach (var component in toParse)