Merge pull request #2966 from Hosch250/refactorInspections

Refactor a few inspections

Author: retailcoder

RetailCoder.VBE/UI/Inspections/AggregateInspectionResult.cs

@@ -20,6 +20,7 @@ public AggregateInspectionResult(IInspectionResult firstResult, int count)
         public string Description => string.Format(InspectionsUI.AggregateInspectionResultFormat, _result.Inspection.Description, _count);
 
         public QualifiedSelection QualifiedSelection => _result.QualifiedSelection;
+        public QualifiedMemberName? QualifiedMemberName => _result.QualifiedMemberName;
         public IInspection Inspection => _result.Inspection;
 
         public Declaration Target => _result.Target;

RetailCoder.VBE/UI/Inspections/InspectionResultsControl.xaml

@@ -593,20 +593,28 @@
 
                 <TextBlock Margin="4" Text="{Binding SelectedItem.Inspection.Meta}" FontSize="10" TextWrapping="WrapWithOverflow"/>
                 <TextBlock Margin="8" Text="{Binding SelectedItem.QualifiedSelection}" FontSize="10" TextWrapping="WrapWithOverflow" />
-                
+
                 <WrapPanel>
                     <controls:LinkButton Margin="4"
-                            Visibility="{Binding CanExecuteQuickFixInModule, Converter={StaticResource BoolToVisibility}}"
-                            Command="{Binding QuickFixInModuleCommand}"
-                            Content="{Resx ResxName=Rubberduck.Inspections.Resources.InspectionsUI, Key=QuickFix_ThisModule}" />
+                                         Visibility="{Binding CanExecuteQuickFixInProcedure, Converter={StaticResource BoolToVisibility}}"
+                                         Command="{Binding QuickFixInProcedureCommand}"
+                                         Content="{Resx ResxName=Rubberduck.Parsing.Inspections.Resources.InspectionsUI, Key=QuickFix_ThisProcedure}" />
+                    <controls:LinkButton Margin="4"
+                                         Visibility="{Binding CanExecuteQuickFixInModule, Converter={StaticResource BoolToVisibility}}"
+                                         Command="{Binding QuickFixInModuleCommand}"
+                                         Content="{Resx ResxName=Rubberduck.Parsing.Inspections.Resources.InspectionsUI, Key=QuickFix_ThisModule}" />
+                    <controls:LinkButton Margin="4"
+                                         Visibility="{Binding CanExecuteQuickFixInProject, Converter={StaticResource BoolToVisibility}}"
+                                         Command="{Binding QuickFixInProjectCommand}"
+                                         Content="{Resx ResxName=Rubberduck.Parsing.Inspections.Resources.InspectionsUI, Key=QuickFix_ThisProject}" />
                     <controls:LinkButton Margin="4"
-                            Visibility="{Binding CanExecuteQuickFixInProject, Converter={StaticResource BoolToVisibility}}"
-                            Command="{Binding QuickFixInProjectCommand}"
-                            Content="{Resx ResxName=Rubberduck.Inspections.Resources.InspectionsUI, Key=QuickFix_ThisProject}" />
+                                         Visibility="{Binding CanExecuteQuickFixInProject, Converter={StaticResource BoolToVisibility}}"
+                                         Command="{Binding QuickFixInAllProjectsCommand}"
+                                         Content="{Resx ResxName=Rubberduck.Parsing.Inspections.Resources.InspectionsUI, Key=QuickFix_All}" />
                     <controls:LinkButton Margin="4"
                             Visibility="{Binding CanDisableInspection, Converter={StaticResource BoolToVisibility}}"
                             Command="{Binding DisableInspectionCommand}"
-                            Content="{Resx ResxName=Rubberduck.Inspections.Resources.InspectionsUI, Key=DisableThisInspection}" />
+                            Content="{Resx ResxName=Rubberduck.Parsing.Inspections.Resources.InspectionsUI, Key=DisableThisInspection}" />
                 </WrapPanel>
             </StackPanel>
         </Border>

RetailCoder.VBE/UI/Inspections/InspectionResultsViewModel.cs

@@ -61,6 +61,7 @@ public InspectionResultsViewModel(RubberduckParserState state, IInspector inspec
 
             DisableInspectionCommand = new DelegateCommand(LogManager.GetCurrentClassLogger(), ExecuteDisableInspectionCommand);
             QuickFixCommand = new DelegateCommand(LogManager.GetCurrentClassLogger(), ExecuteQuickFixCommand, CanExecuteQuickFixCommand);
+            QuickFixInProcedureCommand = new DelegateCommand(LogManager.GetCurrentClassLogger(), ExecuteQuickFixInProcedureCommand, _ => SelectedItem != null && _state.Status == ParserState.Ready);
             QuickFixInModuleCommand = new DelegateCommand(LogManager.GetCurrentClassLogger(), ExecuteQuickFixInModuleCommand, _ => SelectedItem != null && _state.Status == ParserState.Ready);
             QuickFixInProjectCommand = new DelegateCommand(LogManager.GetCurrentClassLogger(), ExecuteQuickFixInProjectCommand, _ => SelectedItem != null && _state.Status == ParserState.Ready);
             QuickFixInAllProjectsCommand = new DelegateCommand(LogManager.GetCurrentClassLogger(), ExecuteQuickFixInAllProjectsCommand, _ => SelectedItem != null && _state.Status == ParserState.Ready);
@@ -121,6 +122,7 @@ public INavigateSource SelectedItem
 
                 SelectedInspection = null;
                 CanQuickFix = false;
+                CanExecuteQuickFixInProcedure = false;
                 CanExecuteQuickFixInModule = false;
                 CanExecuteQuickFixInProject = false;
 
@@ -130,11 +132,13 @@ public INavigateSource SelectedItem
                     SelectedInspection = inspectionResult.Inspection;
                     CanQuickFix = _quickFixProvider.HasQuickFixes(inspectionResult);
                     _defaultFix = _quickFixProvider.QuickFixes(inspectionResult).FirstOrDefault();
+                    CanExecuteQuickFixInProcedure = _defaultFix != null && _defaultFix.CanFixInProcedure;
                     CanExecuteQuickFixInModule = _defaultFix != null && _defaultFix.CanFixInModule;
+                    CanExecuteQuickFixInModule = _defaultFix != null && _defaultFix.CanFixInProcedure;
+                    CanExecuteQuickFixInProject = _defaultFix != null && _defaultFix.CanFixInProject;
                 }
 
                 CanDisableInspection = SelectedInspection != null;
-                CanExecuteQuickFixInProject = _defaultFix != null && _defaultFix.CanFixInProject;
             }
         }
 
@@ -215,6 +219,7 @@ public bool GroupByLocation
         public CommandBase SetLocationGroupingCommand { get; }
         public CommandBase RefreshCommand { get; }
         public CommandBase QuickFixCommand { get; }
+        public CommandBase QuickFixInProcedureCommand { get; }
         public CommandBase QuickFixInModuleCommand { get; }
         public CommandBase QuickFixInProjectCommand { get; }
         public CommandBase QuickFixInAllProjectsCommand { get; }
@@ -314,6 +319,30 @@ private bool CanExecuteQuickFixCommand(object parameter)
             return !IsBusy && quickFix != null && _state.Status == ParserState.Ready;
         }
 
+        private bool _canExecuteQuickFixInProcedure;
+        public bool CanExecuteQuickFixInProcedure
+        {
+            get { return _canExecuteQuickFixInProcedure; }
+            set { _canExecuteQuickFixInProcedure = value; OnPropertyChanged(); }
+        }
+
+        private void ExecuteQuickFixInProcedureCommand(object parameter)
+        {
+            if (_defaultFix == null)
+            {
+                return;
+            }
+
+            var selectedResult = SelectedItem as IInspectionResult;
+            if (selectedResult == null)
+            {
+                return;
+            }
+
+            _quickFixProvider.FixInProcedure(_defaultFix, selectedResult.QualifiedMemberName,
+                selectedResult.Inspection.GetType(), Results);
+        }
+
         private bool _canExecuteQuickFixInModule;
         public bool CanExecuteQuickFixInModule
         {

Rubberduck.Inspections/Abstract/InspectionBase.cs

@@ -2,11 +2,13 @@
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
+using Rubberduck.Parsing;
 using Rubberduck.Parsing.Annotations;
 using Rubberduck.Parsing.Inspections.Abstract;
 using Rubberduck.Parsing.Inspections.Resources;
 using Rubberduck.Parsing.Symbols;
 using Rubberduck.Parsing.VBA;
+using Rubberduck.VBEditor;
 using Rubberduck.VBEditor.SafeComWrappers.Abstract;
 
 namespace Rubberduck.Inspections.Abstract
@@ -93,6 +95,18 @@ protected virtual IEnumerable<Declaration> BuiltInDeclarations
             get { return State.AllDeclarations.Where(declaration => !declaration.IsUserDefined); }
         }
 
+        protected QualifiedMemberName? GetQualifiedMemberName(QualifiedContext context)
+        {
+            var members = State.DeclarationFinder.Members(context.ModuleName);
+            return members.SingleOrDefault(m => m.Selection.Contains(context.Context.GetSelection()))?.QualifiedName;
+        }
+
+        protected QualifiedMemberName? GetQualifiedMemberName(IdentifierReference reference)
+        {
+            var members = State.DeclarationFinder.Members(reference.QualifiedModuleName);
+            return members.SingleOrDefault(m => m.Selection.Contains(reference.Selection))?.QualifiedName;
+        }
+
         protected bool IsIgnoringInspectionResultFor(IVBComponent component, int line)
         {
             var annotations = State.GetModuleAnnotations(component).ToList();
@@ -105,8 +119,18 @@ protected bool IsIgnoringInspectionResultFor(IVBComponent component, int line)
             // VBE 1-based indexing
             for (var i = line; i >= 1; i--)
             {
-                var annotation = annotations.SingleOrDefault(a => a.QualifiedSelection.Selection.StartLine == i) as IgnoreAnnotation;
-                if (annotation != null && annotation.InspectionNames.Contains(AnnotationName))
+                var annotation = annotations.SingleOrDefault(a => a.QualifiedSelection.Selection.StartLine == i);
+                var ignoreAnnotation = annotation as IgnoreAnnotation;
+                var ignoreModuleAnnotation = annotation as IgnoreModuleAnnotation;
+
+                if (ignoreAnnotation?.InspectionNames.Contains(AnnotationName) == true)
+                {
+                    return true;
+                }
+
+                if (ignoreModuleAnnotation != null &&
+                    (ignoreModuleAnnotation.InspectionNames.Contains(AnnotationName) ||
+                     !ignoreModuleAnnotation.InspectionNames.Any()))
                 {
                     return true;
                 }

Rubberduck.Inspections/Abstract/InspectionResultBase.cs

@@ -14,45 +14,50 @@ namespace Rubberduck.Inspections.Abstract
     public abstract class InspectionResultBase : IInspectionResult, INavigateSource, IExportable
     {
         protected InspectionResultBase(IInspection inspection, Declaration target)
-            : this(inspection, target.QualifiedName.QualifiedModuleName, target.Context)
-        {
-            Target = target;
-        }
-
-        /// <summary>
-        /// Creates a comment inspection result.
-        /// </summary>
-        protected InspectionResultBase(IInspection inspection, QualifiedModuleName qualifiedName)
-            : this(inspection, qualifiedName, null)
+            : this(inspection, target.QualifiedName.QualifiedModuleName, target.Context, target)
         { }
-
-        /// <summary>
-        /// Creates an inspection result.
-        /// </summary>
-        protected InspectionResultBase(IInspection inspection, QualifiedModuleName qualifiedName, ParserRuleContext context)
+        
+        protected InspectionResultBase(IInspection inspection, QualifiedModuleName qualifiedName, QualifiedMemberName? qualifiedMemberName, ParserRuleContext context)
         {
             Inspection = inspection;
             QualifiedName = qualifiedName;
+            QualifiedMemberName = qualifiedMemberName;
             Context = context;
         }
-
-        /// <summary>
-        /// Creates an inspection result.
-        /// </summary>
-        protected InspectionResultBase(IInspection inspection, QualifiedModuleName qualifiedName, ParserRuleContext context, Declaration declaration)
+        
+        protected InspectionResultBase(IInspection inspection, QualifiedModuleName qualifiedName, ParserRuleContext context, Declaration target)
         {
             Inspection = inspection;
             QualifiedName = qualifiedName;
             Context = context;
-            Target = declaration;
+            Target = target;
+
+            QualifiedMemberName = GetQualifiedMemberName(target);
         }
 
+        private QualifiedMemberName? GetQualifiedMemberName(Declaration target)
+        {
+            if (string.IsNullOrEmpty(target?.QualifiedName.QualifiedModuleName.ComponentName))
+            {
+                return null;
+            }
+
+            if (target.DeclarationType.HasFlag(DeclarationType.Member))
+            {
+                return target.QualifiedName;
+            }
+
+            return GetQualifiedMemberName(target.ParentDeclaration);
+        }
+        
         public IInspection Inspection { get; }
 
         public abstract string Description { get; }
 
         protected QualifiedModuleName QualifiedName { get; }
 
+        public QualifiedMemberName? QualifiedMemberName { get; }
+
         public ParserRuleContext Context { get; }
 
         public Declaration Target { get; }

Rubberduck.Inspections/Concrete/ConstantNotUsedInspection.cs

@@ -18,8 +18,7 @@ public ConstantNotUsedInspection(RubberduckParserState state)
 
         public override IEnumerable<IInspectionResult> GetInspectionResults()
         {
-            var results = State.DeclarationFinder
-                .UserDeclarations(DeclarationType.Constant)
+            var results = State.DeclarationFinder.UserDeclarations(DeclarationType.Constant)
                 .Where(declaration => declaration.Context != null
                     && !declaration.References.Any()
                     && !IsIgnoringInspectionResultFor(declaration, AnnotationName))

Rubberduck.Inspections/Concrete/EmptyStringLiteralInspection.cs

@@ -26,7 +26,7 @@ public override IEnumerable<IInspectionResult> GetInspectionResults()
         {
             return Listener.Contexts
                 .Where(result => !IsIgnoringInspectionResultFor(result.ModuleName.Component, result.Context.Start.Line))
-                .Select(result => new EmptyStringLiteralInspectionResult(this, result));
+                .Select(result => new EmptyStringLiteralInspectionResult(this, result, GetQualifiedMemberName(result)));
         }
 
         public class EmptyStringLiteralListener : VBAParserBaseListener, IInspectionListener

Rubberduck.Inspections/Concrete/ImplicitActiveSheetReferenceInspection.cs

@@ -39,7 +39,7 @@ public override IEnumerable<IInspectionResult> GetInspectionResults()
             return members
                 .SelectMany(declaration => declaration.References)
                 .Where(issue => !issue.IsIgnoringInspectionResultFor(AnnotationName))
-                .Select(issue => new ImplicitActiveSheetReferenceInspectionResult(this, issue))
+                .Select(issue => new ImplicitActiveSheetReferenceInspectionResult(this, issue, GetQualifiedMemberName(issue)))
                 .ToList();
         }
     }

Rubberduck.Inspections/Concrete/ImplicitActiveWorkbookReferenceInspection.cs

@@ -41,7 +41,7 @@ public override IEnumerable<IInspectionResult> GetInspectionResults()
                 .SelectMany(item => item.References.Where(reference => !IsIgnoringInspectionResultFor(reference, AnnotationName)))
                 .ToList();
 
-            return members.Select(issue => new ImplicitActiveWorkbookReferenceInspectionResult(this, issue));
+            return members.Select(issue => new ImplicitActiveWorkbookReferenceInspectionResult(this, issue, GetQualifiedMemberName(issue)));
         }
     }
 }

Rubberduck.Inspections/Concrete/ImplicitDefaultMemberAssignmentInspection.cs

@@ -30,7 +30,7 @@ public override IEnumerable<IInspectionResult> GetInspectionResults()
                     return reference.IsAssignment && letStmtContext != null && letStmtContext.LET() == null;
                 });
 
-            return interestingReferences.Select(reference => new ImplicitDefaultMemberAssignmentInspectionResult(this, reference));
+            return interestingReferences.Select(reference => new ImplicitDefaultMemberAssignmentInspectionResult(this, reference, GetQualifiedMemberName(reference)));
         }
 
         public override CodeInspectionType InspectionType => CodeInspectionType.MaintainabilityAndReadabilityIssues;