Merge remote-tracking branch 'upstream/next' into Issue5109_Consolida…

…te_copy_command_logic
rubberduck-vba · Nov 8, 2019 · 5574017 · 5574017
2 parents be14f14 + 2ccff5a
commit 5574017
Show file tree

Hide file tree

Showing 126 changed files with 4,629 additions and 2,260 deletions.
diff --git a/Rubberduck.CodeAnalysis/Inspections/Concrete/ObsoleteGlobalInspection.cs b/Rubberduck.CodeAnalysis/Inspections/Concrete/ObsoleteGlobalInspection.cs
@@ -2,6 +2,7 @@
 using System.Linq;
 using Rubberduck.Common;
 using Rubberduck.Inspections.Abstract;
+using Rubberduck.Inspections.Inspections.Extensions;
 using Rubberduck.Inspections.Results;
 using Rubberduck.Parsing.Inspections.Abstract;
 using Rubberduck.Resources.Inspections;

diff --git a/Rubberduck.CodeAnalysis/Inspections/Concrete/ParameterCanBeByValInspection.cs b/Rubberduck.CodeAnalysis/Inspections/Concrete/ParameterCanBeByValInspection.cs
@@ -2,7 +2,6 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
-using Rubberduck.Common;
 using Rubberduck.Inspections.Abstract;
 using Rubberduck.Inspections.Results;
 using Rubberduck.Parsing;
@@ -12,7 +11,6 @@
 using Rubberduck.Parsing.Symbols;
 using Rubberduck.Parsing.VBA;
 using Rubberduck.Parsing.VBA.Extensions;
-using Rubberduck.Inspections.Inspections.Extensions;
 
 namespace Rubberduck.Inspections.Concrete
 {
@@ -61,8 +59,8 @@ protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
             parametersThatCanBeChangedToBePassedByVal.AddRange(InterFaceMembersThatCanBeChangedToBePassedByVal(interfaceDeclarationMembers));
 
             var eventMembers = State.DeclarationFinder.UserDeclarations(DeclarationType.Event).ToList();
-            var formEventHandlerScopeDeclarations = State.FindFormEventHandlers();
-            var eventHandlerScopeDeclarations = State.DeclarationFinder.FindEventHandlers().Concat(parameters.FindUserEventHandlers());
+            var formEventHandlerScopeDeclarations = State.DeclarationFinder.FindFormEventHandlers();
+            var eventHandlerScopeDeclarations = State.DeclarationFinder.FindEventHandlers();
             var eventScopeDeclarations = eventMembers
                 .Concat(formEventHandlerScopeDeclarations)
                 .Concat(eventHandlerScopeDeclarations)
@@ -157,11 +155,8 @@ private IEnumerable<ParameterDeclaration> EventMembersThatCanBeChangedToBePassed
 
                 var parameterCanBeChangedToBeByVal = eventParameters.Select(parameter => parameter.IsByRef).ToList();
 
-                //todo: Find a better way to find the handlers.
                 var eventHandlers = State.DeclarationFinder
-                    .AllUserDeclarations
-                    .FindHandlersForEvent(memberDeclaration)
-                    .Select(s => s.Item2)
+                    .FindEventHandlers(memberDeclaration)
                     .ToList();
 
                 foreach (var eventHandler in eventHandlers.OfType<IParameterizedDeclaration>())

diff --git a/Rubberduck.CodeAnalysis/Inspections/Concrete/ProcedureCanBeWrittenAsFunctionInspection.cs b/Rubberduck.CodeAnalysis/Inspections/Concrete/ProcedureCanBeWrittenAsFunctionInspection.cs
@@ -1,7 +1,6 @@
 using System.Collections.Generic;
 using System.Linq;
 using Antlr4.Runtime;
-using Rubberduck.Common;
 using Rubberduck.Inspections.Abstract;
 using Rubberduck.Inspections.Results;
 using Rubberduck.Parsing;
@@ -11,7 +10,6 @@
 using Rubberduck.Parsing.Symbols;
 using Rubberduck.Parsing.VBA;
 using Rubberduck.VBEditor;
-using Rubberduck.Inspections.Inspections.Extensions;
 
 namespace Rubberduck.Inspections.Concrete
 {
@@ -71,21 +69,20 @@ protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
             return Listener.Contexts
                 .Where(context => context.Context.Parent is VBAParser.SubStmtContext
                                     && HasArgumentReferencesWithIsAssignmentFlagged(context))
-                .Select(context => GetSubStmtParentDeclaration(context))
+                .Select(GetSubStmtParentDeclaration)
                 .Where(decl => decl != null && 
                                 !ignored.Contains(decl) &&
                                 userDeclarations.Where(item => item.IsWithEvents)
-                                   .All(withEvents => userDeclarations.FindEventProcedures(withEvents) == null) &&
+                                   .All(withEvents => !State.DeclarationFinder.FindHandlersForWithEventsField(withEvents).Any()) &&
                                !builtinHandlers.Contains(decl))
                 .Select(result => new DeclarationInspectionResult(this,
                     string.Format(InspectionResults.ProcedureCanBeWrittenAsFunctionInspection, result.IdentifierName),
                     result));
 
             bool HasArgumentReferencesWithIsAssignmentFlagged(QualifiedContext<ParserRuleContext> context)
             {
-                return contextLookup.TryGetValue(context.Context.GetChild<VBAParser.ArgContext>(), out Declaration decl)
-                    ? decl.References.Any(rf => rf.IsAssignment)
-                        : false;
+                return contextLookup.TryGetValue(context.Context.GetChild<VBAParser.ArgContext>(), out Declaration decl) 
+                       && decl.References.Any(rf => rf.IsAssignment);
             }
 
             Declaration GetSubStmtParentDeclaration(QualifiedContext<ParserRuleContext> context)

diff --git a/Rubberduck.CodeAnalysis/Inspections/Concrete/ProcedureNotUsedInspection.cs b/Rubberduck.CodeAnalysis/Inspections/Concrete/ProcedureNotUsedInspection.cs
@@ -2,11 +2,13 @@
 using System.Linq;
 using Rubberduck.Common;
 using Rubberduck.Inspections.Abstract;
+using Rubberduck.Inspections.Inspections.Extensions;
 using Rubberduck.Inspections.Results;
 using Rubberduck.Parsing.Inspections.Abstract;
 using Rubberduck.Resources.Inspections;
 using Rubberduck.Parsing.Symbols;
 using Rubberduck.Parsing.VBA;
+using Rubberduck.Parsing.VBA.Extensions;
 using Rubberduck.VBEditor.SafeComWrappers;
 
 namespace Rubberduck.Inspections.Concrete
@@ -58,40 +60,19 @@ public sealed class ProcedureNotUsedInspection : InspectionBase
 
         protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
         {
-            var declarations = UserDeclarations.ToList();
-
             var classes = State.DeclarationFinder.UserDeclarations(DeclarationType.ClassModule)
                 .Concat(State.DeclarationFinder.UserDeclarations(DeclarationType.Document))
                 .ToList(); 
             var modules = State.DeclarationFinder.UserDeclarations(DeclarationType.ProceduralModule).ToList();
 
-            var handlers = State.DeclarationFinder.UserDeclarations(DeclarationType.Control)
-                .SelectMany(control => declarations.FindEventHandlers(control)).ToList();
+            var handlers = State.DeclarationFinder.FindEventHandlers().ToHashSet();
 
-            var builtInHandlers = State.DeclarationFinder.FindEventHandlers();
-            handlers.AddRange(builtInHandlers);
+            var interfaceMembers = State.DeclarationFinder.FindAllInterfaceMembers().ToHashSet();
+            var implementingMembers = State.DeclarationFinder.FindAllInterfaceImplementingMembers().ToHashSet();
 
-            var withEventFields = State.DeclarationFinder.UserDeclarations(DeclarationType.Variable).Where(item => item.IsWithEvents).ToList();
-            var withHanders = withEventFields
-                .SelectMany(field => State.DeclarationFinder.FindHandlersForWithEventsField(field))
+            var items = State.AllUserDeclarations
+                .Where(item => !IsIgnoredDeclaration(item, interfaceMembers, implementingMembers, handlers, classes, modules))
                 .ToList();
-
-            handlers.AddRange(withHanders);
-
-            var forms = State.DeclarationFinder.UserDeclarations(DeclarationType.ClassModule)
-                .Where(item => item.QualifiedName.QualifiedModuleName.ComponentType == ComponentType.UserForm)
-                .ToList();
-
-            if (forms.Any())
-            {
-                handlers.AddRange(forms.SelectMany(form => State.FindFormEventHandlers(form)));
-            }
-
-            var interfaceMembers = State.DeclarationFinder.FindAllInterfaceMembers().ToList();
-            var implementingMembers = State.DeclarationFinder.FindAllInterfaceImplementingMembers().ToList();
-
-            var items = declarations
-                .Where(item => !IsIgnoredDeclaration(item, interfaceMembers, implementingMembers, handlers, classes, modules)).ToList();
             var issues = items.Select(issue => new DeclarationInspectionResult(this,
                                                                     string.Format(InspectionResults.IdentifierNotUsedInspection, issue.DeclarationType.ToLocalizedString(), issue.IdentifierName),
                                                                     issue));

diff --git a/Rubberduck.CodeAnalysis/Inspections/Extensions/DeclarationTypeExtensions.cs b/Rubberduck.CodeAnalysis/Inspections/Extensions/DeclarationTypeExtensions.cs
@@ -0,0 +1,14 @@
+using System.Globalization;
+using Rubberduck.Parsing.Symbols;
+using Rubberduck.Resources;
+
+namespace Rubberduck.Inspections.Inspections.Extensions
+{
+    public static class DeclarationTypeExtensions
+    {
+        public static string ToLocalizedString(this DeclarationType type)
+        {
+            return RubberduckUI.ResourceManager.GetString("DeclarationType_" + type, CultureInfo.CurrentUICulture);
+        }
+    }
+}
diff --git a/Rubberduck.CodeAnalysis/QuickFixes/ExpandBangNotationQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/ExpandBangNotationQuickFix.cs
@@ -1,10 +1,12 @@
-using System.Linq;
+using System.Collections.Generic;
+using System.Linq;
 using Antlr4.Runtime;
 using Rubberduck.Inspections.Abstract;
 using Rubberduck.Inspections.Concrete;
 using Rubberduck.Parsing.Grammar;
 using Rubberduck.Parsing.Inspections.Abstract;
 using Rubberduck.Parsing.Rewriter;
+using Rubberduck.Parsing.Symbols;
 using Rubberduck.Parsing.VBA;
 using Rubberduck.Parsing.VBA.DeclarationCaching;
 using Rubberduck.VBEditor;
@@ -59,10 +61,34 @@ private void InsertDefaultMember(VBAParser.DictionaryAccessContext dictionaryAcc
         private string DefaultMemberAccessCode(QualifiedSelection selection, DeclarationFinder finder)
         {
             var defaultMemberAccesses = finder.IdentifierReferences(selection);
-            var defaultMemberNames = defaultMemberAccesses.Select(reference => reference.Declaration.IdentifierName);
+            var defaultMemberNames = defaultMemberAccesses
+                .Select(DefaultMemberName)
+                .Select(declarationName => IsNotLegalIdentifierName(declarationName) 
+                                            ? $"[{declarationName}]" 
+                                            : declarationName);
             return $".{string.Join("().", defaultMemberNames)}";
         }
 
+        private static string DefaultMemberName(IdentifierReference defaultMemberReference)
+        {
+            var defaultMemberMemberName = defaultMemberReference.Declaration.QualifiedName;
+            var fullDefaultMemberName = $"{defaultMemberMemberName.QualifiedModuleName.ProjectName}.{defaultMemberMemberName.QualifiedModuleName.ComponentName}.{defaultMemberMemberName.MemberName}";
+
+            if (DefaultMemberOverrides.TryGetValue(fullDefaultMemberName, out var defaultMemberOverride))
+            {
+                return defaultMemberOverride;
+            }
+
+            return defaultMemberMemberName.MemberName;
+        }
+
+        private bool IsNotLegalIdentifierName(string declarationName)
+        {
+            return string.IsNullOrEmpty(declarationName)
+                || NonIdentifierCharacters.Any(character => declarationName.Contains(character))
+                || AdditionalNonFirstIdentifierCharacters.Contains(declarationName[0]); ;
+        }
+
         public override string Description(IInspectionResult result)
         {
             return Resources.Inspections.QuickFixes.ExpandBangNotationQuickFix;
@@ -71,5 +97,14 @@ public override string Description(IInspectionResult result)
         public override bool CanFixInProcedure => true;
         public override bool CanFixInModule => true;
         public override bool CanFixInProject => true;
+
+        private string NonIdentifierCharacters = "[](){}\r\n\t.,'\"\\ |!@#$%^&*-+:=; ";
+        private string AdditionalNonFirstIdentifierCharacters = "0123456789_";
+
+        private static readonly Dictionary<string, string> DefaultMemberOverrides = new Dictionary<string, string>
+        {
+            ["Excel.Range._Default"] = "Item"
+        };
+
     }
 }
diff --git a/Rubberduck.CodeAnalysis/QuickFixes/ExpandDefaultMemberQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/ExpandDefaultMemberQuickFix.cs
@@ -1,7 +1,9 @@
-using System.Linq;
+using System.Collections.Generic;
+using System.Linq;
 using Antlr4.Runtime;
 using Rubberduck.Inspections.Abstract;
 using Rubberduck.Inspections.Concrete;
+using Rubberduck.Parsing.Grammar;
 using Rubberduck.Parsing.Inspections.Abstract;
 using Rubberduck.Parsing.Rewriter;
 using Rubberduck.Parsing.Symbols;
@@ -54,10 +56,74 @@ private void InsertDefaultMember(ParserRuleContext lExpressionContext, Qualified
         private string DefaultMemberAccessCode(QualifiedSelection selection, DeclarationFinder finder)
         {
             var defaultMemberAccesses = finder.IdentifierReferences(selection).Where(reference => reference.DefaultMemberRecursionDepth > 0);
-            var defaultMemberNames = defaultMemberAccesses.Select(reference => reference.Declaration.IdentifierName);
+            var defaultMemberNames = defaultMemberAccesses.Select(DefaultMemberName)
+                .Select(declarationName => IsNotLegalIdentifierName(declarationName)
+                                            ? $"[{declarationName}]"
+                                            : declarationName);
             return $".{string.Join("().", defaultMemberNames)}";
         }
 
+        private bool IsNotLegalIdentifierName(string declarationName)
+        {
+            return string.IsNullOrEmpty(declarationName)
+                || NonIdentifierCharacters.Any(character => declarationName.Contains(character))
+                || AdditionalNonFirstIdentifierCharacters.Contains(declarationName[0]);                ;
+        }
+
+        private static string DefaultMemberName(IdentifierReference defaultMemberReference)
+        {
+            var defaultMemberMemberName = defaultMemberReference.Declaration.QualifiedName;
+            var fullDefaultMemberName = $"{defaultMemberMemberName.QualifiedModuleName.ProjectName}.{defaultMemberMemberName.QualifiedModuleName.ComponentName}.{defaultMemberMemberName.MemberName}";
+
+            if (DefaultMemberBaseOverrides.TryGetValue(fullDefaultMemberName, out var baseOverride))
+            {
+                if (DefaultMemberArgumentNumberOverrides.TryGetValue(fullDefaultMemberName, out var argumentNumberOverrides))
+                {
+                    var numberOfArguments = NumberOfArguments(defaultMemberReference);
+                    if (argumentNumberOverrides.TryGetValue(numberOfArguments, out var numberOfArgumentsOverride))
+                    {
+                        return numberOfArgumentsOverride;
+                    }
+                }
+
+                return baseOverride;
+            }
+
+            return defaultMemberMemberName.MemberName;
+        }
+
+        private static int NumberOfArguments(IdentifierReference defaultMemberReference)
+        {
+            if (defaultMemberReference.IsNonIndexedDefaultMemberAccess)
+            {
+                return 0;
+            }
+
+            var argumentList = ArgumentList(defaultMemberReference);
+            if (argumentList == null)
+            {
+                return -1;
+            }
+
+            var arguments = argumentList.argument();
+
+            return arguments?.Length ?? 0;
+        }
+
+        private static VBAParser.ArgumentListContext ArgumentList(IdentifierReference indexedDefaultMemberReference)
+        {
+            var defaultMemberReferenceContextWithArguments = indexedDefaultMemberReference.Context.Parent;
+            switch (defaultMemberReferenceContextWithArguments)
+            {
+                case VBAParser.IndexExprContext indexExpression:
+                    return indexExpression.argumentList();
+                case VBAParser.WhitespaceIndexExprContext whiteSpaceIndexExpression:
+                    return whiteSpaceIndexExpression.argumentList();
+                default:
+                    return null;
+            }
+        }
+
         public override string Description(IInspectionResult result)
         {
             return Resources.Inspections.QuickFixes.ExpandDefaultMemberQuickFix;
@@ -66,5 +132,18 @@ public override string Description(IInspectionResult result)
         public override bool CanFixInProcedure => true;
         public override bool CanFixInModule => true;
         public override bool CanFixInProject => true;
+
+        private string NonIdentifierCharacters = "[](){}\r\n\t.,'\"\\ |!@#$%^&*-+:=; ";
+        private string AdditionalNonFirstIdentifierCharacters = "0123456789_";
+
+        private static readonly Dictionary<string, string> DefaultMemberBaseOverrides = new Dictionary<string, string>
+        {
+            ["Excel.Range._Default"] = "Item"
+        };
+
+        private static readonly Dictionary<string, Dictionary<int, string>> DefaultMemberArgumentNumberOverrides = new Dictionary<string, Dictionary<int, string>>
+        {
+            ["Excel.Range._Default"] = new Dictionary<int, string>{[0] = "Value"}
+        };
     }
 }
diff --git a/Rubberduck.CodeAnalysis/QuickFixes/PassParameterByValueQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/PassParameterByValueQuickFix.cs
@@ -1,5 +1,4 @@
 using System.Linq;
-using Rubberduck.Common;
 using Rubberduck.Inspections.Abstract;
 using Rubberduck.Inspections.Concrete;
 using Rubberduck.Parsing.Grammar;
@@ -52,12 +51,14 @@ private void FixMethods(Declaration target, IRewriteSession rewriteSession)
                 return; // should only happen if the parse results are stale; prevents a crash in that case
             }
 
-            //FIXME: Make this use the DeclarationFinder.
             var members = target.ParentDeclaration.DeclarationType == DeclarationType.Event
-                ? _state.AllUserDeclarations.FindHandlersForEvent(target.ParentDeclaration)
-                    .Select(s => s.Item2)
+                ? _state.DeclarationFinder
+                    .FindEventHandlers(target.ParentDeclaration)
                     .ToList()
-                : _state.DeclarationFinder.FindInterfaceImplementationMembers(target.ParentDeclaration).Cast<Declaration>().ToList();
+                : _state.DeclarationFinder
+                    .FindInterfaceImplementationMembers(target.ParentDeclaration)
+                    .Cast<Declaration>()
+                    .ToList();
 
             foreach (var member in members)
             {