Merge pull request #2810 from MDoerner/TestsFor2737

retailcoder · web-flow · commit 280f29f24079 · 2017-03-07T21:02:11.000-05:00
Tests for 2737
diff --git a/Rubberduck.Parsing/Symbols/DeclarationFinder.cs b/Rubberduck.Parsing/Symbols/DeclarationFinder.cs
@@ -52,8 +52,11 @@ public class DeclarationFinder
         private readonly Lazy<ConcurrentDictionary<Declaration, Declaration[]>> _handlersByWithEventsField;
         private readonly Lazy<ConcurrentDictionary<VBAParser.ImplementsStmtContext, Declaration[]>> _membersByImplementsContext;
         private readonly Lazy<ConcurrentDictionary<Declaration, Declaration[]>> _interfaceMembers;
+        private Lazy<List<Declaration>> _nonBaseAsType;
+        private readonly Lazy<ConcurrentBag<Declaration>> _eventHandlers;
+        private readonly Lazy<ConcurrentBag<Declaration>> _classes;
         
-        private static readonly object ThreadLock = new object();
+        private readonly object threadLock = new object();
 
         public DeclarationFinder(IReadOnlyList<Declaration> declarations, IEnumerable<IAnnotation> annotations, IReadOnlyList<UnboundMemberDeclaration> unresolvedMemberDeclarations, IHostApplication hostApp = null)
         {
@@ -133,8 +136,16 @@ public DeclarationFinder(IReadOnlyList<Declaration> declarations, IEnumerable<IA
                 });
 
             _membersByImplementsContext = new Lazy<ConcurrentDictionary<VBAParser.ImplementsStmtContext, Declaration[]>>(() =>
-            new ConcurrentDictionary<VBAParser.ImplementsStmtContext, Declaration[]>(
-                implementableMembers.ToDictionary(item => item.Context, item => item.Members)), true);
+                new ConcurrentDictionary<VBAParser.ImplementsStmtContext, Declaration[]>(
+                    implementableMembers.ToDictionary(item => item.Context, item => item.Members)), true);
+
+            _nonBaseAsType = new Lazy<List<Declaration>>(() =>
+                            _declarations.AllValues().Where(d =>
+                            !string.IsNullOrWhiteSpace(d.AsTypeName)
+                            && !d.AsTypeIsBaseType
+                            && d.DeclarationType != DeclarationType.Project
+                            && d.DeclarationType != DeclarationType.ProceduralModule).ToList()
+                            ,true);
         }
 
         public IEnumerable<Declaration> FreshUndeclared
@@ -152,38 +163,22 @@ public IEnumerable<Declaration> Members(QualifiedModuleName module)
             return _declarations[module];
         }
 
-        private IEnumerable<Declaration> _nonBaseAsType;
         public IEnumerable<Declaration> FindDeclarationsWithNonBaseAsType()
         {
-            lock (ThreadLock)
-            {
-                return _nonBaseAsType ?? (_nonBaseAsType = _declarations.AllValues().Where(d =>
-                            !string.IsNullOrWhiteSpace(d.AsTypeName)
-                            && !d.AsTypeIsBaseType
-                            && d.DeclarationType != DeclarationType.Project
-                            && d.DeclarationType != DeclarationType.ProceduralModule).ToList());
-            }
-        }
+            return _nonBaseAsType.Value;
 
-        private readonly Lazy<ConcurrentBag<Declaration>> _eventHandlers; 
+        }
+ 
         public IEnumerable<Declaration> FindEventHandlers()
         {
-            lock (ThreadLock)
-            {
-                return _eventHandlers.Value;
-            }
+            return _eventHandlers.Value;
         }
 
-        private readonly Lazy<ConcurrentBag<Declaration>> _classes;
-
         public IEnumerable<Declaration> Classes
         {
             get
             {
-                lock (ThreadLock)
-                {
-                    return _classes.Value;
-                }
+                return _classes.Value;
             }
         }
 
@@ -193,10 +188,7 @@ public IEnumerable<Declaration> Projects
         {
             get
             {
-                lock (ThreadLock)
-                {
-                    return _projects.Value;
-                }
+                return _projects.Value;
             }
         }
 
@@ -214,10 +206,7 @@ public IEnumerable<Declaration> UserDeclarations(DeclarationType type)
 
         public IEnumerable<UnboundMemberDeclaration> FreshUnresolvedMemberDeclarations()
         {
-            lock (ThreadLock)
-            {
-                return _newUnresolved.ToArray();
-            }            
+            return _newUnresolved.ToArray(); //This does not need a lock because enumerators over a ConcurrentBag uses a snapshot.           
         }
 
         public IEnumerable<UnboundMemberDeclaration> UnresolvedMemberDeclarations()
@@ -259,19 +248,18 @@ public Declaration FindParameter(Declaration procedure, string parameterName)
         public IEnumerable<Declaration> FindMemberMatches(Declaration parent, string memberName)
         {
             ConcurrentBag<Declaration> children;
-            if (_declarations.TryGetValue(parent.QualifiedName.QualifiedModuleName, out children))
-            {
-                return children.Where(item => item.DeclarationType.HasFlag(DeclarationType.Member)
-                                             && item.IdentifierName == memberName).ToList();
-            }
-
-            return Enumerable.Empty<Declaration>();
+            return _declarations.TryGetValue(parent.QualifiedName.QualifiedModuleName, out children)
+                ? children.Where(item => item.DeclarationType.HasFlag(DeclarationType.Member)
+                                             && item.IdentifierName == memberName).ToList()
+                : Enumerable.Empty<Declaration>();
         }
 
         public IEnumerable<IAnnotation> FindAnnotations(QualifiedModuleName module)
         {
             ConcurrentBag<IAnnotation> result;
-            return _annotations.TryGetValue(module, out result) ? result : Enumerable.Empty<IAnnotation>();
+            return _annotations.TryGetValue(module, out result) 
+                ? result 
+                : Enumerable.Empty<IAnnotation>();
         }
 
         public bool IsMatch(string declarationName, string potentialMatchName)
@@ -326,7 +314,8 @@ public Declaration FindProject(string name, Declaration currentScope = null)
             Declaration result = null;
             try
             {
-                result = MatchName(name).SingleOrDefault(project => project.DeclarationType.HasFlag(DeclarationType.Project)
+                result = MatchName(name).SingleOrDefault(project => 
+                    project.DeclarationType.HasFlag(DeclarationType.Project)
                     && (currentScope == null || project.ProjectId == currentScope.ProjectId));
             }
             catch (InvalidOperationException exception)
@@ -337,7 +326,7 @@ public Declaration FindProject(string name, Declaration currentScope = null)
             return result;
         }
 
-        public Declaration FindStdModule(string name, Declaration parent = null, bool includeBuiltIn = false)
+        public Declaration FindStdModule(string name, Declaration parent, bool includeBuiltIn = false)
         {
             Debug.Assert(parent != null);
             Declaration result = null;
@@ -356,7 +345,7 @@ public Declaration FindStdModule(string name, Declaration parent = null, bool in
             return result;
         }
 
-        public Declaration FindClassModule(string name, Declaration parent = null, bool includeBuiltIn = false)
+        public Declaration FindClassModule(string name, Declaration parent, bool includeBuiltIn = false)
         {
             Debug.Assert(parent != null);
             Declaration result = null;
diff --git a/Rubberduck.Parsing/VBA/RubberduckParserState.cs b/Rubberduck.Parsing/VBA/RubberduckParserState.cs
@@ -1183,12 +1183,12 @@ public HashSet<QualifiedModuleName> ModulesReferencedBy(QualifiedModuleName refe
 
         public HashSet<QualifiedModuleName> ModulesReferencedBy(IEnumerable<QualifiedModuleName> referencingModules)
         {
-            var referencedModules = new HashSet<QualifiedModuleName>();
-            foreach (var referencingModule in referencedModules)
+            var toModules = new HashSet<QualifiedModuleName>();
+            foreach (var referencingModule in referencingModules)
             {
-                referencedModules.UnionWith(ModulesReferencedBy(referencingModule));
+                toModules.UnionWith(ModulesReferencedBy(referencingModule));
             }
-            return referencedModules;
+            return toModules;
         }
 
         public HashSet<QualifiedModuleName> ModulesReferencing(QualifiedModuleName referencedModule)
diff --git a/RubberduckTests/RubberduckTests.csproj b/RubberduckTests/RubberduckTests.csproj
@@ -203,6 +203,7 @@
     <Compile Include="SourceControl\UnsyncedCommitsViewModelTests.cs" />
     <Compile Include="StringExtensionsTests.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Symbols\DeclarationFinderTests.cs" />
     <Compile Include="TodoExplorer\TodoExplorerTests.cs" />
     <Compile Include="UnitTesting\AssertTests.cs" />
     <Compile Include="UnitTesting\EngineTests.cs" />
diff --git a/RubberduckTests/Symbols/DeclarationFinderTests.cs b/RubberduckTests/Symbols/DeclarationFinderTests.cs
@@ -0,0 +1,71 @@
+﻿using System;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Rubberduck.Parsing.Symbols;
+using Rubberduck.Parsing.VBA;
+using Rubberduck.Parsing.Grammar;
+using Rubberduck.VBEditor;
+using System.Collections.Generic;
+using System.Linq;
+using Antlr4.Runtime;
+
+namespace RubberduckTests.Symbols
+{
+    [TestClass]
+    public class DeclarationFinderTests
+    {
+        [TestCategory("Resolver")]
+        [TestMethod]
+        public void DeclarationFinderCanCopeWithMultipleModulesImplementingTheSameInterface()
+        {
+            var project = GetTestProject("testProject");
+            var interf = GetTestClassModule(project, "interface");
+            var member = GetTestFunction(interf, "testMember", Accessibility.Public);
+            var implementingClass1 = GetTestClassModule(project, "implementingClass1");
+            var implementingClass2 = GetTestClassModule(project, "implementingClass2");
+            var implementsContext1 = new VBAParser.ImplementsStmtContext(null, 0);
+            var implementsContext2 = new VBAParser.ImplementsStmtContext(null, 0);
+            AddReference(interf, implementingClass1, implementsContext1);
+            AddReference(interf, implementingClass1, implementsContext2);
+            var declarations = new List<Declaration> {interf, member, implementingClass1, implementingClass2};
+
+            DeclarationFinder finder = new DeclarationFinder(declarations, new List<Rubberduck.Parsing.Annotations.IAnnotation>(), new List<UnboundMemberDeclaration>());
+            var interfaceDeclarations = finder.FindAllInterfaceMembers().ToList();
+
+            Assert.AreEqual(1, interfaceDeclarations.Count());
+        }
+
+        private static ClassModuleDeclaration GetTestClassModule(Declaration projectDeclatation, string name, bool isExposed = false)
+        {
+            var qualifiedClassModuleMemberName = new QualifiedMemberName(StubQualifiedModuleName(name), name);
+            var classModuleAttributes = new Rubberduck.Parsing.VBA.Attributes();
+            if (isExposed)
+            {
+                classModuleAttributes.AddExposedClassAttribute();
+            }
+            return new ClassModuleDeclaration(qualifiedClassModuleMemberName, projectDeclatation, name, false, null, classModuleAttributes);
+        }
+
+        private static ProjectDeclaration GetTestProject(string name)
+        {
+            var qualifiedProjectName = new QualifiedMemberName(StubQualifiedModuleName("proj"), name);
+            return new ProjectDeclaration(qualifiedProjectName, name, false, null);
+        }
+
+        private static QualifiedModuleName StubQualifiedModuleName(string name)
+        {
+            return new QualifiedModuleName("dummy", "dummy", name);
+        }
+
+        private static FunctionDeclaration GetTestFunction(Declaration moduleDeclatation, string name, Accessibility functionAccessibility)
+        {
+            var qualifiedFunctionMemberName = new QualifiedMemberName(moduleDeclatation.QualifiedName.QualifiedModuleName, name);
+            return new FunctionDeclaration(qualifiedFunctionMemberName, moduleDeclatation, moduleDeclatation, "test", null, "test", functionAccessibility, null, Selection.Home, false, false, null, null);
+        }
+
+        private static void AddReference(Declaration toDeclaration, Declaration fromModuleDeclaration, ParserRuleContext context = null)
+        {
+            toDeclaration.AddReference(toDeclaration.QualifiedName.QualifiedModuleName, fromModuleDeclaration, fromModuleDeclaration, context, toDeclaration.IdentifierName, toDeclaration, Selection.Home, new List<Rubberduck.Parsing.Annotations.IAnnotation>());
+        }
+
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -52,8 +52,11 @@ public class DeclarationFinder`
`52`	`52`	`private readonly Lazy<ConcurrentDictionary<Declaration, Declaration[]>> _handlersByWithEventsField;`
`53`	`53`	`private readonly Lazy<ConcurrentDictionary<VBAParser.ImplementsStmtContext, Declaration[]>> _membersByImplementsContext;`
`54`	`54`	`private readonly Lazy<ConcurrentDictionary<Declaration, Declaration[]>> _interfaceMembers;`
	`55`	`+ private Lazy<List<Declaration>> _nonBaseAsType;`
	`56`	`+ private readonly Lazy<ConcurrentBag<Declaration>> _eventHandlers;`
	`57`	`+ private readonly Lazy<ConcurrentBag<Declaration>> _classes;`
`55`	`58`
`56`		`- private static readonly object ThreadLock = new object();`
	`59`	`+ private readonly object threadLock = new object();`
`57`	`60`
`58`	`61`	`public DeclarationFinder(IReadOnlyList<Declaration> declarations, IEnumerable<IAnnotation> annotations, IReadOnlyList<UnboundMemberDeclaration> unresolvedMemberDeclarations, IHostApplication hostApp = null)`
`59`	`62`	`{`
`@@ -133,8 +136,16 @@ public DeclarationFinder(IReadOnlyList<Declaration> declarations, IEnumerable<IA`
`133`	`136`	`});`
`134`	`137`
`135`	`138`	`_membersByImplementsContext = new Lazy<ConcurrentDictionary<VBAParser.ImplementsStmtContext, Declaration[]>>(() =>`
`136`		`- new ConcurrentDictionary<VBAParser.ImplementsStmtContext, Declaration[]>(`
`137`		`- implementableMembers.ToDictionary(item => item.Context, item => item.Members)), true);`
	`139`	`+ new ConcurrentDictionary<VBAParser.ImplementsStmtContext, Declaration[]>(`
	`140`	`+ implementableMembers.ToDictionary(item => item.Context, item => item.Members)), true);`
	`141`	`+`
	`142`	`+ _nonBaseAsType = new Lazy<List<Declaration>>(() =>`
	`143`	`+ _declarations.AllValues().Where(d =>`
	`144`	`+ !string.IsNullOrWhiteSpace(d.AsTypeName)`
	`145`	`+ && !d.AsTypeIsBaseType`
	`146`	`+ && d.DeclarationType != DeclarationType.Project`
	`147`	`+ && d.DeclarationType != DeclarationType.ProceduralModule).ToList()`
	`148`	`+ ,true);`
`138`	`149`	`}`
`139`	`150`
`140`	`151`	`public IEnumerable<Declaration> FreshUndeclared`
`@@ -152,38 +163,22 @@ public IEnumerable<Declaration> Members(QualifiedModuleName module)`
`152`	`163`	`return _declarations[module];`
`153`	`164`	`}`
`154`	`165`
`155`		`- private IEnumerable<Declaration> _nonBaseAsType;`
`156`	`166`	`public IEnumerable<Declaration> FindDeclarationsWithNonBaseAsType()`
`157`	`167`	`{`
`158`		`- lock (ThreadLock)`
`159`		`- {`
`160`		`- return _nonBaseAsType ?? (_nonBaseAsType = _declarations.AllValues().Where(d =>`
`161`		`- !string.IsNullOrWhiteSpace(d.AsTypeName)`
`162`		`- && !d.AsTypeIsBaseType`
`163`		`- && d.DeclarationType != DeclarationType.Project`
`164`		`- && d.DeclarationType != DeclarationType.ProceduralModule).ToList());`
`165`		`- }`
`166`		`- }`
	`168`	`+ return _nonBaseAsType.Value;`
`167`	`169`
`168`		`- private readonly Lazy<ConcurrentBag<Declaration>> _eventHandlers;`
	`170`	`+ }`
	`171`	`+`
`169`	`172`	`public IEnumerable<Declaration> FindEventHandlers()`
`170`	`173`	`{`
`171`		`- lock (ThreadLock)`
`172`		`- {`
`173`		`- return _eventHandlers.Value;`
`174`		`- }`
	`174`	`+ return _eventHandlers.Value;`
`175`	`175`	`}`
`176`	`176`
`177`		`- private readonly Lazy<ConcurrentBag<Declaration>> _classes;`
`178`		`-`
`179`	`177`	`public IEnumerable<Declaration> Classes`
`180`	`178`	`{`
`181`	`179`	`get`
`182`	`180`	`{`
`183`		`- lock (ThreadLock)`
`184`		`- {`
`185`		`- return _classes.Value;`
`186`		`- }`
	`181`	`+ return _classes.Value;`
`187`	`182`	`}`
`188`	`183`	`}`
`189`	`184`
`@@ -193,10 +188,7 @@ public IEnumerable<Declaration> Projects`
`193`	`188`	`{`
`194`	`189`	`get`
`195`	`190`	`{`
`196`		`- lock (ThreadLock)`
`197`		`- {`
`198`		`- return _projects.Value;`
`199`		`- }`
	`191`	`+ return _projects.Value;`
`200`	`192`	`}`
`201`	`193`	`}`
`202`	`194`
`@@ -214,10 +206,7 @@ public IEnumerable<Declaration> UserDeclarations(DeclarationType type)`
`214`	`206`
`215`	`207`	`public IEnumerable<UnboundMemberDeclaration> FreshUnresolvedMemberDeclarations()`
`216`	`208`	`{`
`217`		`- lock (ThreadLock)`
`218`		`- {`
`219`		`- return _newUnresolved.ToArray();`
`220`		`- }`
	`209`	`+ return _newUnresolved.ToArray(); //This does not need a lock because enumerators over a ConcurrentBag uses a snapshot.`
`221`	`210`	`}`
`222`	`211`
`223`	`212`	`public IEnumerable<UnboundMemberDeclaration> UnresolvedMemberDeclarations()`
`@@ -259,19 +248,18 @@ public Declaration FindParameter(Declaration procedure, string parameterName)`
`259`	`248`	`public IEnumerable<Declaration> FindMemberMatches(Declaration parent, string memberName)`
`260`	`249`	`{`
`261`	`250`	`ConcurrentBag<Declaration> children;`
`262`		`- if (_declarations.TryGetValue(parent.QualifiedName.QualifiedModuleName, out children))`
`263`		`- {`
`264`		`- return children.Where(item => item.DeclarationType.HasFlag(DeclarationType.Member)`
`265`		`- && item.IdentifierName == memberName).ToList();`
`266`		`- }`
`267`		`-`
`268`		`- return Enumerable.Empty<Declaration>();`
	`251`	`+ return _declarations.TryGetValue(parent.QualifiedName.QualifiedModuleName, out children)`
	`252`	`+ ? children.Where(item => item.DeclarationType.HasFlag(DeclarationType.Member)`
	`253`	`+ && item.IdentifierName == memberName).ToList()`
	`254`	`+ : Enumerable.Empty<Declaration>();`
`269`	`255`	`}`
`270`	`256`
`271`	`257`	`public IEnumerable<IAnnotation> FindAnnotations(QualifiedModuleName module)`
`272`	`258`	`{`
`273`	`259`	`ConcurrentBag<IAnnotation> result;`
`274`		`- return _annotations.TryGetValue(module, out result) ? result : Enumerable.Empty<IAnnotation>();`
	`260`	`+ return _annotations.TryGetValue(module, out result)`
	`261`	`+ ? result`
	`262`	`+ : Enumerable.Empty<IAnnotation>();`
`275`	`263`	`}`
`276`	`264`
`277`	`265`	`public bool IsMatch(string declarationName, string potentialMatchName)`
`@@ -326,7 +314,8 @@ public Declaration FindProject(string name, Declaration currentScope = null)`
`326`	`314`	`Declaration result = null;`
`327`	`315`	`try`
`328`	`316`	`{`
`329`		`- result = MatchName(name).SingleOrDefault(project => project.DeclarationType.HasFlag(DeclarationType.Project)`
	`317`	`+ result = MatchName(name).SingleOrDefault(project =>`
	`318`	`+ project.DeclarationType.HasFlag(DeclarationType.Project)`
`330`	`319`	`&& (currentScope == null \|\| project.ProjectId == currentScope.ProjectId));`
`331`	`320`	`}`
`332`	`321`	`catch (InvalidOperationException exception)`
`@@ -337,7 +326,7 @@ public Declaration FindProject(string name, Declaration currentScope = null)`
`337`	`326`	`return result;`
`338`	`327`	`}`
`339`	`328`
`340`		`- public Declaration FindStdModule(string name, Declaration parent = null, bool includeBuiltIn = false)`
	`329`	`+ public Declaration FindStdModule(string name, Declaration parent, bool includeBuiltIn = false)`
`341`	`330`	`{`
`342`	`331`	`Debug.Assert(parent != null);`
`343`	`332`	`Declaration result = null;`
`@@ -356,7 +345,7 @@ public Declaration FindStdModule(string name, Declaration parent = null, bool in`
`356`	`345`	`return result;`
`357`	`346`	`}`
`358`	`347`
`359`		`- public Declaration FindClassModule(string name, Declaration parent = null, bool includeBuiltIn = false)`
	`348`	`+ public Declaration FindClassModule(string name, Declaration parent, bool includeBuiltIn = false)`
`360`	`349`	`{`
`361`	`350`	`Debug.Assert(parent != null);`
`362`	`351`	`Declaration result = null;`
Original file line number	Diff line number	Diff line change
`@@ -1183,12 +1183,12 @@ public HashSet<QualifiedModuleName> ModulesReferencedBy(QualifiedModuleName refe`
`1183`	`1183`
`1184`	`1184`	`public HashSet<QualifiedModuleName> ModulesReferencedBy(IEnumerable<QualifiedModuleName> referencingModules)`
`1185`	`1185`	`{`
`1186`		`- var referencedModules = new HashSet<QualifiedModuleName>();`
`1187`		`- foreach (var referencingModule in referencedModules)`
	`1186`	`+ var toModules = new HashSet<QualifiedModuleName>();`
	`1187`	`+ foreach (var referencingModule in referencingModules)`
`1188`	`1188`	`{`
`1189`		`- referencedModules.UnionWith(ModulesReferencedBy(referencingModule));`
	`1189`	`+ toModules.UnionWith(ModulesReferencedBy(referencingModule));`
`1190`	`1190`	`}`
`1191`		`- return referencedModules;`
	`1191`	`+ return toModules;`
`1192`	`1192`	`}`
`1193`	`1193`
`1194`	`1194`	`public HashSet<QualifiedModuleName> ModulesReferencing(QualifiedModuleName referencedModule)`