sync with next

RetailCoder.VBE/App.cs

@@ -1,9 +1,7 @@
 using System.Collections.Generic;
 using System.IO;
-using System.Reflection;
 using Infralution.Localization.Wpf;
 using NLog;
-using NLog.Fluent;
 using Rubberduck.Common;
 using Rubberduck.Parsing;
 using Rubberduck.Parsing.Symbols;
@@ -13,6 +11,7 @@
 using Rubberduck.UI.Command.MenuItems;
 using System;
 using System.Globalization;
+using System.Linq;
 using System.Windows.Forms;
 using Rubberduck.UI.Command.MenuItems.CommandBars;
 using Rubberduck.VBEditor.SafeComWrappers.Abstract;
@@ -87,8 +86,9 @@ private void RefreshSelection()
                 if (!pane.IsWrappingNullReference)
                 {
                     selectedDeclaration = _parser.State.FindSelectedDeclaration(pane);
+                    var refCount = selectedDeclaration == null ? 0 : selectedDeclaration.References.Count();
                     var caption = _stateBar.GetContextSelectionCaption(_vbe.ActiveCodePane, selectedDeclaration);
-                    _stateBar.SetContextSelectionCaption(caption);
+                    _stateBar.SetContextSelectionCaption(caption, refCount);
                 }
 
                 var currentStatus = _parser.State.Status;

RetailCoder.VBE/Common/DeclarationExtensions.cs

@@ -11,6 +11,7 @@
 using Rubberduck.Properties;
 using Rubberduck.UI;
 using Rubberduck.VBEditor;
+using Rubberduck.VBEditor.Extensions;
 using Rubberduck.VBEditor.SafeComWrappers;
 
 // ReSharper disable LocalizableElement
@@ -292,25 +293,28 @@ public static IEnumerable<Declaration> FindBuiltInEventHandlers(this IEnumerable
                                                    : new[] { e.ParentDeclaration.IdentifierName + "_" + e.IdentifierName };
                                            });
 
-            // class module built-in events
-            var classModuleHandlers = declarationList.Where(item =>
+            var user = declarationList.FirstOrDefault(decl => !decl.IsBuiltIn);
+            var host = user != null ? user.Project.VBE.HostApplication() : null ;
+
+            var handlers = declarationList.Where(item =>
+                        // class module built-in events
+                        (item.DeclarationType == DeclarationType.Procedure &&
+                        item.ParentDeclaration.DeclarationType == DeclarationType.ClassModule && (
+                            item.IdentifierName.Equals("Class_Initialize", StringComparison.InvariantCultureIgnoreCase) ||
+                            item.IdentifierName.Equals("Class_Terminate", StringComparison.InvariantCultureIgnoreCase))) ||
+                        // standard module built-in handlers (Excel specific):
+                        (host != null &&
+                        host.ApplicationName.Equals("Excel", StringComparison.InvariantCultureIgnoreCase) &&
                         item.DeclarationType == DeclarationType.Procedure &&
-                        item.ParentDeclaration.DeclarationType == DeclarationType.ClassModule &&
-                        (item.IdentifierName.Equals("Class_Initialize", StringComparison.InvariantCultureIgnoreCase)
-                        || item.IdentifierName.Equals("Class_Terminate", StringComparison.InvariantCultureIgnoreCase)));
+                        item.ParentDeclaration.DeclarationType == DeclarationType.ProceduralModule && (
+                            item.IdentifierName.Equals("auto_open", StringComparison.InvariantCultureIgnoreCase) ||
+                            item.IdentifierName.Equals("auto_close", StringComparison.InvariantCultureIgnoreCase))) ||
+                        // user handlers:
+                        (!item.IsBuiltIn &&
+                         item.DeclarationType == DeclarationType.Procedure &&
+                         handlerNames.Contains(item.IdentifierName))
+                        ).ToList();
 
-            // standard module built-in handlers:
-            var stdModuleHandlers = declarationList.Where(item =>
-                        item.DeclarationType == DeclarationType.Procedure &&
-                        item.ParentDeclaration.DeclarationType == DeclarationType.ProceduralModule &&
-                (item.IdentifierName.Equals("auto_open", StringComparison.InvariantCultureIgnoreCase)
-                || item.IdentifierName.Equals("auto_close", StringComparison.InvariantCultureIgnoreCase)));
-
-            var handlers = declarationList.Where(declaration => !declaration.IsBuiltIn
-                                                     && declaration.DeclarationType == DeclarationType.Procedure
-                                                     && handlerNames.Contains(declaration.IdentifierName)).ToList();
-
-            handlers.AddRange(classModuleHandlers.Concat(stdModuleHandlers));
             return handlers;
         }
 

RetailCoder.VBE/Inspections/HungarianNotationInspection.cs

@@ -0,0 +1,135 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+using Rubberduck.Inspections.Abstract;
+using Rubberduck.Inspections.Resources;
+using Rubberduck.Inspections.Results;
+using Rubberduck.Parsing.Symbols;
+using Rubberduck.Parsing.VBA;
+using Rubberduck.Settings;
+using Rubberduck.SettingsProvider;
+using Rubberduck.UI;
+
+namespace Rubberduck.Inspections
+{
+    public sealed class HungarianNotationInspection : InspectionBase
+    {
+        #region statics
+        private static readonly List<string> HungarianPrefixes = new List<string>
+        {
+            "chk",
+            "cbo",
+            "cmd",
+            "btn",
+            "fra",
+            "img",
+            "lbl",
+            "lst",
+            "mnu",
+            "opt",
+            "pic",
+            "shp",
+            "txt",
+            "tmr",
+            "chk",
+            "dlg",
+            "drv",
+            "frm",
+            "grd",
+            "obj",
+            "rpt",
+            "fld",
+            "idx",
+            "tbl",
+            "tbd",
+            "bas",
+            "cls",
+            "g",
+            "m",
+            "bln",
+            "byt",
+            "col",
+            "dtm",
+            "dbl",
+            "cur",
+            "int",
+            "lng",
+            "sng",
+            "str",
+            "udt",
+            "vnt",
+            "var",
+            "pgr",
+            "dao",
+            "b",
+            "by",
+            "c",
+            "chr",
+            "i",
+            "l",
+            "s",
+            "o",
+            "n",
+            "dt",
+            "dat",
+            "a",
+            "arr"
+        };
+
+        private static readonly Regex HungarianIdentifierRegex = new Regex(string.Format("^({0})[A-Z0-9].*$", string.Join("|", HungarianPrefixes)));
+
+        private static readonly List<DeclarationType> TargetDeclarationTypes = new List<DeclarationType>
+        {
+            DeclarationType.Parameter,
+            DeclarationType.Constant,
+            DeclarationType.Control,
+            DeclarationType.ClassModule,
+            DeclarationType.Member,
+            DeclarationType.Module,
+            DeclarationType.ProceduralModule,
+            DeclarationType.UserForm,
+            DeclarationType.UserDefinedType,
+            DeclarationType.UserDefinedTypeMember,
+            DeclarationType.Variable
+        };
+
+        #endregion
+
+        private readonly IMessageBox _messageBox;
+        private readonly IPersistanceService<CodeInspectionSettings> _settings;
+
+        public HungarianNotationInspection(IMessageBox messageBox, RubberduckParserState state, IPersistanceService<CodeInspectionSettings> settings)
+            : base(state, CodeInspectionSeverity.Suggestion)
+        {
+            _messageBox = messageBox;
+            _settings = settings;
+        }
+
+        public override string Description
+        {
+            get { return InspectionsUI.HungarianNotationInspectionName; }
+        }
+
+        public override CodeInspectionType InspectionType
+        {
+            get { return CodeInspectionType.MaintainabilityAndReadabilityIssues; }
+        }
+
+        public override IEnumerable<InspectionResultBase> GetInspectionResults()
+        {
+            var settings = _settings.Load(new CodeInspectionSettings()) ?? new CodeInspectionSettings();
+            var whitelistedNames = settings.WhitelistedIdentifiers.Select(s => s.Identifier).ToList();
+
+            var hungarians = UserDeclarations
+                                .Where(declaration => !whitelistedNames.Contains(declaration.IdentifierName) &&
+                                                      TargetDeclarationTypes.Contains(declaration.DeclarationType) &&
+                                                      HungarianIdentifierRegex.IsMatch(declaration.IdentifierName))
+                                .Select(issue => new IdentifierNameInspectionResult(this, issue, State, _messageBox, _settings))
+                                .ToList();
+            return hungarians;
+        }
+    }
+}

RetailCoder.VBE/Inspections/ImplicitActiveSheetReferenceInspection.cs

@@ -28,7 +28,7 @@ public override IEnumerable<InspectionResultBase> GetInspectionResults()
             var matches = BuiltInDeclarations.Where(item =>
                         item.ProjectName == "Excel" &&
                         Targets.Contains(item.IdentifierName) &&
-                        item.ParentDeclaration.ComponentName == "_Global" &&
+                        (item.ParentDeclaration.ComponentName == "_Global" || item.ParentDeclaration.ComponentName == "Global") &&
                         item.AsTypeName == "Range").ToList();
 
             var issues = matches.Where(item => item.References.Any())

RetailCoder.VBE/Inspections/ImplicitActiveWorkbookReferenceInspection.cs

@@ -26,7 +26,9 @@ public ImplicitActiveWorkbookReferenceInspection(RubberduckParserState state)
         private static readonly string[] ParentScopes =
         {
             "_Global",
+            "Global",
             "_Application",
+            "Application",
             "Sheets",
             //"Worksheets",
         };
@@ -37,11 +39,10 @@ public override IEnumerable<InspectionResultBase> GetInspectionResults()
                 .Where(item => item.ProjectName == "Excel" && ParentScopes.Contains(item.ComponentName) 
                     && item.References.Any(r => Targets.Contains(r.IdentifierName)))
                 .SelectMany(declaration => declaration.References.Distinct())
-                .Where(item => Targets.Contains(item.IdentifierName))
                 .ToList();
-
-            return issues.Select(issue =>
-                new ImplicitActiveWorkbookReferenceInspectionResult(this, issue));
+                
+            var filtered = issues.Where(item => Targets.Contains(item.IdentifierName));
+            return filtered.Select(issue => new ImplicitActiveWorkbookReferenceInspectionResult(this, issue));
         }
     }
 }

RetailCoder.VBE/Inspections/MemberNotOnInterfaceInspection.cs

@@ -0,0 +1,83 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Antlr4.Runtime;
+using Rubberduck.Inspections.Abstract;
+using Rubberduck.Inspections.Resources;
+using Rubberduck.Inspections.Results;
+using Rubberduck.Parsing;
+using Rubberduck.Parsing.Grammar;
+using Rubberduck.Parsing.Symbols;
+using Rubberduck.Parsing.VBA;
+using Rubberduck.VBEditor;
+
+namespace Rubberduck.Inspections
+{
+    public sealed class MemberNotOnInterfaceInspection : InspectionBase
+    {
+        private static readonly List<Type> InterestingTypes = new List<Type>
+        {
+            typeof(VBAParser.MemberAccessExprContext),
+            typeof(VBAParser.WithMemberAccessExprContext),
+            typeof(VBAParser.DictionaryAccessExprContext),
+            typeof(VBAParser.WithDictionaryAccessExprContext)
+        }; 
+
+        public MemberNotOnInterfaceInspection(RubberduckParserState state, CodeInspectionSeverity defaultSeverity = CodeInspectionSeverity.Warning)
+            : base(state, defaultSeverity)
+        {
+        }
+
+        public override string Meta { get { return InspectionsUI.MemberNotOnInterfaceInspectionMeta; } }
+        public override string Description { get { return InspectionsUI.MemberNotOnInterfaceInspectionName; } }
+        public override CodeInspectionType InspectionType { get { return CodeInspectionType.CodeQualityIssues; } }
+
+        public override IEnumerable<InspectionResultBase> GetInspectionResults()
+        {
+            var targets = Declarations.Where(decl => decl.AsTypeDeclaration != null && 
+                                                     decl.AsTypeDeclaration.DeclarationType == DeclarationType.ClassModule &&
+                                                     ((ClassModuleDeclaration)decl.AsTypeDeclaration).IsExtensible &&
+                                                     decl.References.Any(usage => InterestingTypes.Contains(usage.Context.Parent.GetType())))
+                                            .ToList();
+
+            //Unfortunately finding implemented members is fairly expensive, so group by the return type.
+            return (from access in targets.GroupBy(t => t.AsTypeDeclaration)
+                let typeDeclaration = access.Key
+                let typeMembers = new HashSet<string>(BuiltInDeclarations.Where(d => d.ParentDeclaration != null && d.ParentDeclaration.Equals(typeDeclaration))
+                                                                         .Select(d => d.IdentifierName)
+                                                                         .Distinct())
+                from references in access.Select(usage => usage.References.Where(r => InterestingTypes.Contains(r.Context.Parent.GetType())))
+                from reference in references.Where(r => !r.IsInspectionDisabled(AnnotationName))
+                let identifier = reference.Context.Parent.GetChild(reference.Context.Parent.ChildCount - 1)
+                where !typeMembers.Contains(identifier.GetText())
+                let pseudoDeclaration = CreatePseudoDeclaration((ParserRuleContext) identifier, reference)
+                where !pseudoDeclaration.Annotations.Any()
+                select new MemberNotOnInterfaceInspectionResult(this, pseudoDeclaration, (ParserRuleContext) identifier, typeDeclaration))
+                                                               .Cast<InspectionResultBase>().ToList();
+        }
+
+        //Builds a throw-away Declaration for the indentifiers found by the inspection. These aren't (and shouldn't be) created by the parser.
+        //Used to pass to the InspectionResult to make it selectable.
+        private static Declaration CreatePseudoDeclaration(ParserRuleContext context, IdentifierReference reference)
+        {
+            return new Declaration(
+                new QualifiedMemberName(reference.QualifiedModuleName, context.GetText()),
+                null, 
+                null, 
+                string.Empty, 
+                string.Empty, 
+                false, 
+                false,
+                Accessibility.Implicit, 
+                DeclarationType.Variable, 
+                context,
+                context.GetSelection(), 
+                false, 
+                null, 
+                true,
+                null,
+                null, 
+                true);
+        }
+    }
+}

RetailCoder.VBE/Inspections/ProcedureNotUsedInspection.cs

@@ -29,7 +29,7 @@ public ProcedureNotUsedInspection(RubberduckParserState state)
             "Workbook_",
             "Document_",
             "Application_",
-            "Session_",
+            "Session_"
         };
 
         public override IEnumerable<InspectionResultBase> GetInspectionResults()
@@ -43,7 +43,7 @@ public override IEnumerable<InspectionResultBase> GetInspectionResults()
                 .SelectMany(control => declarations.FindEventHandlers(control)).ToList();
 
             var withEventFields = declarations.Where(item => item.DeclarationType == DeclarationType.Variable && item.IsWithEvents);
-            handlers.AddRange(withEventFields.SelectMany(field => declarations.FindEventProcedures(field)));
+            handlers.AddRange(withEventFields.SelectMany(declarations.FindEventProcedures));
 
             var forms = declarations.Where(item => item.DeclarationType == DeclarationType.ClassModule
                         && item.QualifiedName.QualifiedModuleName.Component.Type == ComponentType.UserForm)

RetailCoder.VBE/Inspections/QuickFixes/AddIdentifierToWhiteListQuickFix.cs

@@ -0,0 +1,37 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Antlr4.Runtime;
+using Rubberduck.Inspections.Abstract;
+using Rubberduck.Inspections.Resources;
+using Rubberduck.Parsing.Symbols;
+using Rubberduck.Settings;
+using Rubberduck.SettingsProvider;
+using Rubberduck.VBEditor;
+
+namespace Rubberduck.Inspections.QuickFixes
+{
+    public class AddIdentifierToWhiteListQuickFix : QuickFixBase
+    {
+        private readonly IPersistanceService<CodeInspectionSettings> _settings;
+        private readonly Declaration _target;
+
+        public AddIdentifierToWhiteListQuickFix(ParserRuleContext context, QualifiedSelection selection, Declaration target, IPersistanceService<CodeInspectionSettings> settings)
+            : base(context, selection, InspectionsUI.WhiteListIdentifierQuickFix)
+        {
+            _settings = settings;
+            _target = target;
+        }
+
+        public override void Fix()
+        {
+            var inspectionSettings = _settings.Load(new CodeInspectionSettings()) ?? new CodeInspectionSettings();
+            var whitelist = inspectionSettings.WhitelistedIdentifiers;
+            inspectionSettings.WhitelistedIdentifiers =
+                whitelist.Concat(new[] { new WhitelistedIdentifierSetting(_target.IdentifierName) }).ToArray();
+            _settings.Save(inspectionSettings);
+        }
+    }
+}