patchwork fix for an undocumented bug with IdentifierReferenceListener where references of procedure 'Foo' wouldn't get picked up correctly if more than 1 module defined a Foo' member.

Author: retailcoder

RetailCoder.VBE/Inspections/ProcedureNotUsedInspection.cs

@@ -20,11 +20,13 @@ public ProcedureNotUsedInspection()
         public IEnumerable<CodeInspectionResultBase> GetInspectionResults(VBProjectParseResult parseResult)
         {
             var handlers = parseResult.Declarations.Items.Where(item => item.DeclarationType == DeclarationType.Control)
-                .SelectMany(control => parseResult.Declarations.FindEventHandlers(control));
+                .SelectMany(control => parseResult.Declarations.FindEventHandlers(control))
+                .ToList();
 
             var issues = parseResult.Declarations.Items
-                .Where(item => !IsIgnoredProcedure(parseResult.Declarations, item, handlers))
-                .Select(issue => new IdentifierNotUsedInspectionResult(string.Format(Name, issue.IdentifierName), Severity, issue.Context, issue.QualifiedName.QualifiedModuleName));
+                .Where(item => !IsIgnoredDeclaration(parseResult.Declarations, item, handlers))
+                .Select(issue => new IdentifierNotUsedInspectionResult(string.Format(Name, issue.IdentifierName), Severity, issue.Context, issue.QualifiedName.QualifiedModuleName))
+                .ToList();
 
             return issues;
         }
@@ -35,7 +37,7 @@ public IEnumerable<CodeInspectionResultBase> GetInspectionResults(VBProjectParse
             DeclarationType.Function
         };
 
-        private bool IsIgnoredProcedure(Declarations declarations, Declaration declaration, IEnumerable<Declaration> handlers)
+        private bool IsIgnoredDeclaration(Declarations declarations, Declaration declaration, IEnumerable<Declaration> handlers)
         {
             var result = !ProcedureTypes.Contains(declaration.DeclarationType)
                 || declaration.References.Any()
@@ -106,7 +108,6 @@ private bool IsInterfaceMember(Declarations declarations, Declaration procedure)
                 return true;
             }
 
-            // todo: find a way to avoid running this for every procedure in a class
             var result = GetImplementedInterfaceMembers(declarations, procedure.ComponentName)
                 .Contains(procedure.IdentifierName);
 

Rubberduck.Parsing/Symbols/IdentifierReferenceListener.cs

@@ -330,7 +330,7 @@ private bool EnterIdentifier(ParserRuleContext context, Selection selection, boo
             var name = context.GetText();
             var matches = _declarations[name].Where(IsInScope);
 
-            var declaration = GetClosestScope(matches);
+            var declaration = GetClosestScope(matches, context);
             if (declaration != null)
             {
                 var reference = new IdentifierReference(_qualifiedName, name, selection, context, declaration, isAssignmentTarget, hasExplicitLetStatement);
@@ -357,24 +357,29 @@ public override void EnterVsAssign(VBAParser.VsAssignContext context)
             var callStatementD = context.Parent.Parent.Parent as VBAParser.ICS_B_ProcedureCallContext;
 
             var procedureName = string.Empty;
+            ParserRuleContext identifierContext = null;
             if (callStatementA != null)
             {
                 procedureName = callStatementA.ambiguousIdentifier().GetText();
+                identifierContext = callStatementA.ambiguousIdentifier();
             }
             else if(callStatementB != null)
             {
                 procedureName = callStatementB.ambiguousIdentifier().GetText();
+                identifierContext = callStatementB.ambiguousIdentifier();
             }
             else if (callStatementC != null)
             {
                 procedureName = callStatementC.ambiguousIdentifier().GetText();
+                identifierContext = callStatementC.ambiguousIdentifier();
             }
             else if (callStatementD != null)
             {
                 procedureName = callStatementD.certainIdentifier().GetText();
+                identifierContext = callStatementD.certainIdentifier();
             }
 
-            var procedure = FindProcedureDeclaration(procedureName);
+            var procedure = FindProcedureDeclaration(procedureName, identifierContext);
             if (procedure == null)
             {
                 return;
@@ -393,13 +398,13 @@ public override void EnterVsAssign(VBAParser.VsAssignContext context)
             }
         }
 
-        private Declaration FindProcedureDeclaration(string procedureName)
+        private Declaration FindProcedureDeclaration(string procedureName, ParserRuleContext context)
         {
             var matches = _declarations[procedureName]
                 .Where(declaration => ProcedureDeclarations.Contains(declaration.DeclarationType))
                 .Where(IsInScope);
 
-            var procedure = GetClosestScope(matches);
+            var procedure = GetClosestScope(matches, context);
             return procedure;
         }
 
@@ -428,7 +433,8 @@ private bool IsInScope(Declaration declaration)
 
             if (ProcedureDeclarations.Contains(declaration.DeclarationType))
             {
-                if (declaration.Accessibility == Accessibility.Public)
+                if (declaration.Accessibility == Accessibility.Public 
+                 || declaration.Accessibility == Accessibility.Implicit)
                 {
                     var result = declaration.Project.Equals(_qualifiedName.Project);
                     return result;
@@ -443,7 +449,7 @@ private bool IsInScope(Declaration declaration)
                    || IsGlobalProcedure(declaration);
         }
 
-        private Declaration GetClosestScope(IEnumerable<Declaration> declarations)
+        private Declaration GetClosestScope(IEnumerable<Declaration> declarations, ParserRuleContext context)
         {
             // this method (as does the rest of Rubberduck) assumes the VBA code is compilable.
 
@@ -460,7 +466,25 @@ private Declaration GetClosestScope(IEnumerable<Declaration> declarations)
                 return moduleScope;
             }
 
-            // multiple matches in global scope??
+            if (matches.Count == 1)
+            {
+                return matches[0];
+            }
+
+            var memberProcedureCallContext = context.Parent as VBAParser.ICS_B_MemberProcedureCallContext;
+            if (memberProcedureCallContext != null)
+            {
+                var parentMemberName = memberProcedureCallContext.implicitCallStmt_InStmt().Stop.Text;
+                var matchingParents = _declarations.Items.Where(d => d.IdentifierName == parentMemberName);
+
+                var matchingParent = matchingParents.FirstOrDefault();
+                if (matchingParent != null)
+                {
+                    var parentType = matches.FirstOrDefault(p => p.ComponentName == matchingParent.AsTypeName);
+                    return matches.FirstOrDefault(m => m.ParentScope == parentType.ParentScope);
+                }
+            }            
+
             return matches.FirstOrDefault();
         }