Test covering #2737 (fix is already in) - Closes #2737

Author: MDoerner

Rubberduck.Parsing/Symbols/DeclarationFinder.cs

@@ -136,8 +136,8 @@ 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 =>

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" />

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>());
+        }
+
+    }
+}