Make DeclarationFinder store members by declarationType

rubberduck-vba · Jan 4, 2020 · 9a51872 · 9a51872
1 parent 7f414d1
commit 9a51872
Show file tree

Hide file tree

Showing 4 changed files with 39 additions and 11 deletions.
diff --git a/Rubberduck.CodeAnalysis/QuickFixes/ConvertToProcedureQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/ConvertToProcedureQuickFix.cs
@@ -50,7 +50,7 @@ namespace Rubberduck.Inspections.QuickFixes
     public sealed class ConvertToProcedureQuickFix : QuickFixBase
     {
         public ConvertToProcedureQuickFix()
-            : base(typeof(NonReturningFunctionInspection), typeof(FunctionReturnValueNeverUsedInspection))
+            : base(typeof(NonReturningFunctionInspection))
         {}
 
         public override void Fix(IInspectionResult result, IRewriteSession rewriteSession)

diff --git a/Rubberduck.Parsing/VBA/DeclarationCaching/DeclarationFinder.cs b/Rubberduck.Parsing/VBA/DeclarationCaching/DeclarationFinder.cs
@@ -26,7 +26,7 @@ public class DeclarationFinder
 
         private readonly IHostApplication _hostApp;
         private IDictionary<string, List<Declaration>> _declarationsByName;
-        private IDictionary<QualifiedModuleName, List<Declaration>> _declarations;
+        private IDictionary<QualifiedModuleName, IDictionary<DeclarationType, List<Declaration>>> _declarations;
 
         private readonly IReadOnlyDictionary<QualifiedModuleName, IFailedResolutionStore> _failedResolutionStores;
         private readonly ConcurrentDictionary<QualifiedModuleName, IMutableFailedResolutionStore> _newFailedResolutionStores;
@@ -104,6 +104,8 @@ private List<Action> CollectionConstructionActions(IReadOnlyList<Declaration> de
                 () =>
                     _declarations = declarations
                         .GroupBy(item => item.QualifiedName.QualifiedModuleName)
+                        .SelectMany(grp1 => grp1.GroupBy(declaration => declaration.DeclarationType), (grp1, grp2) => (grp1, grp2))
+                        .GroupBy(tpl => tpl.grp1.Key, tpl => tpl.grp2)
                         .ToDictionary(),
                 () =>
                     _declarationsByName = declarations
@@ -282,16 +284,33 @@ public IEnumerable<Declaration> Members(Declaration module)
             return Members(module.QualifiedName.QualifiedModuleName);
         }
 
+        public IEnumerable<Declaration> Members(Declaration module, DeclarationType declarationType)
+        {
+            return Members(module.QualifiedName.QualifiedModuleName, declarationType);
+        }
+
         public IEnumerable<Declaration> Members(QualifiedModuleName module)
         {
             return _declarations.TryGetValue(module, out var members)
-                    ? members
+                    ? members.AllValues()
                     : Enumerable.Empty<Declaration>();
         }
 
+        public IEnumerable<Declaration> Members(QualifiedModuleName module, DeclarationType declarationType)
+        {
+            if (!_declarations.TryGetValue(module, out var membersByType))
+            {
+                return Enumerable.Empty<Declaration>();
+            }
+
+            return membersByType
+                    .Where(item => item.Key.HasFlag(declarationType))
+                    .SelectMany(item => item.Value);
+        }
+
         public Declaration ModuleDeclaration(QualifiedModuleName module)
         {
-            return Members(module).SingleOrDefault(member => member.DeclarationType.HasFlag(DeclarationType.Module));
+            return Members(module, DeclarationType.Module).SingleOrDefault();
         }
 
         public IReadOnlyCollection<QualifiedModuleName> AllModules => _declarations.Keys.AsReadOnly();
@@ -494,10 +513,8 @@ public IEnumerable<ParameterDeclaration> Parameters(Declaration parameterizedMem
 
         public IEnumerable<Declaration> FindMemberMatches(Declaration parent, string memberName)
         {
-            return _declarations.TryGetValue(parent.QualifiedName.QualifiedModuleName, out var children)
-                ? children.Where(item => item.DeclarationType.HasFlag(DeclarationType.Member)
-                                             && item.IdentifierName == memberName)
-                : Enumerable.Empty<Declaration>();
+            return Members(parent.QualifiedName.QualifiedModuleName, DeclarationType.Member)
+                .Where(member => member.IdentifierName.Equals(memberName));
         }
 
         public IEnumerable<IParseTreeAnnotation> FindAnnotations(QualifiedModuleName module, int annotatedLine)

diff --git a/Rubberduck.VBEEditor/Extensions/DictionaryExtensions.cs b/Rubberduck.VBEEditor/Extensions/DictionaryExtensions.cs
@@ -24,16 +24,27 @@ public static IEnumerable<TValue> AllValues<TKey, TValue>(
             return source.SelectMany(item => item.Value);
         }
 
+        public static IEnumerable<TValue> AllValues<TKey1, TKey2, TValue>(
+            this IDictionary<TKey1, IDictionary<TKey2, List<TValue>>> source)
+        {
+            return source.SelectMany(item => item.Value.AllValues());
+        }
+
         public static ConcurrentDictionary<TKey, ConcurrentBag<TValue>> ToConcurrentDictionary<TKey, TValue>(this IEnumerable<IGrouping<TKey, TValue>> source)
         {
             return new ConcurrentDictionary<TKey, ConcurrentBag<TValue>>(source.Select(x => new KeyValuePair<TKey, ConcurrentBag<TValue>>(x.Key, new ConcurrentBag<TValue>(x))));
         }
 
-        public static Dictionary<TKey, List<TValue>> ToDictionary<TKey, TValue>(this IEnumerable<IGrouping<TKey, TValue>> source)
+        public static IDictionary<TKey, List<TValue>> ToDictionary<TKey, TValue>(this IEnumerable<IGrouping<TKey, TValue>> source)
         {
             return source.ToDictionary(group => group.Key, group => group.ToList());
         }
 
+        public static IDictionary<TKey1, IDictionary<TKey2, List<TValue>>> ToDictionary<TKey1, TKey2, TValue>(this IEnumerable<IGrouping<TKey1, IGrouping<TKey2, TValue>>> source)
+        {
+            return source.ToDictionary(group => group.Key, group => group.ToDictionary());
+        }
+
         public static IReadOnlyDictionary<TKey, IReadOnlyList<TValue>> ToReadonlyDictionary<TKey, TValue>(this IEnumerable<IGrouping<TKey, TValue>> source)
         {
             return source.ToDictionary(group => group.Key, group => (IReadOnlyList<TValue>)group.ToList());

diff --git a/RubberduckTests/QuickFixes/IgnoreOnceQuickFixTests.cs b/RubberduckTests/QuickFixes/IgnoreOnceQuickFixTests.cs
@@ -125,11 +125,11 @@ Public Sub Goo()
 End Sub";
 
             const string expectedCode =
-                @"'@Ignore FunctionReturnValueNotUsed
-Public Function Foo(ByVal bar As String) As Boolean
+                @"Public Function Foo(ByVal bar As String) As Boolean
 End Function
 
 Public Sub Goo()
+    '@Ignore FunctionReturnValueNotUsed
     Foo ""test""
 End Sub";