Introduce a field on the COM synchronizer for references affected by priority changes

In case the priorities of references change the variable shadowing potentially changes for all references in between. So we need this information to force the corresponding references to be resolved again, even if there is no other reason.

Author: MDoerner

Rubberduck.Parsing/VBA/ComReferenceLoading/COMReferenceSynchronizerBase.cs

@@ -25,7 +25,7 @@ public abstract class COMReferenceSynchronizerBase : ICOMReferenceSynchronizer,
         private readonly IReferencedDeclarationsCollector _referencedDeclarationsCollector;
 
         private readonly List<QualifiedModuleName> _unloadedCOMReferences = new List<QualifiedModuleName>();
-        private readonly List<(string projectId, string referencedProjectId, int newPriority, int oldPriority)> _referencesWithChangedPriority = new List<(string projectId, string referencedProjectId, int newPriority, int oldPriority)>();
+        private readonly List<(string projectId, string referencedProjectId)> _referencesAffectedByPriorityChanges = new List<(string projectId, string referencedProjectId)>();
 
         private readonly Dictionary<(string identifierName, string fullPath), string> _projectIdsByFilePathAndProjectName = new Dictionary<(string identifierName, string fullPath), string>();
 
@@ -59,7 +59,8 @@ protected COMReferenceSynchronizerBase(RubberduckParserState state, IParserState
 
 
         public bool LastSyncOfCOMReferencesLoadedReferences { get; private set; }
-        public IEnumerable<QualifiedModuleName> COMReferencesUnloadedUnloadedInLastSync => _unloadedCOMReferences;
+        public IEnumerable<QualifiedModuleName> COMReferencesUnloadedInLastSync => _unloadedCOMReferences;
+        public IEnumerable<(string projectId, string referencedProjectId)> COMReferencesAffectedByPriorityChangesInLastSync => _referencesAffectedByPriorityChanges;
 
         private readonly IDictionary<string, ReferencePriorityMap> _projectReferences = new Dictionary<string, ReferencePriorityMap>();
         public IReadOnlyCollection<ReferencePriorityMap> ProjectReferences => _projectReferences.Values.AsReadOnly();
@@ -77,7 +78,7 @@ public void SyncComReferences(CancellationToken token)
 
             LastSyncOfCOMReferencesLoadedReferences = false;
             _unloadedCOMReferences.Clear();
-            _referencesWithChangedPriority.Clear();
+            _referencesAffectedByPriorityChanges.Clear();
             RefreshReferencedByProjectId();
 
             var unmapped = new ConcurrentBag<ReferenceInfo>();
@@ -91,31 +92,55 @@ public void SyncComReferences(CancellationToken token)
                 LoadReferences(referencesToLoad, unmapped, token);
             }
 
-            DetermineReferencesWithChangedPriorities(_projectReferences, oldProjectReferences);
+            DetermineReferencesAffectedByPriorityChanges(_projectReferences, oldProjectReferences);
+            UnloadNoLongerExistingReferences(_projectReferences, oldProjectReferences);
 
+            parsingStageTimer.Stop();
+            parsingStageTimer.Log("Loaded and unloaded referenced libraries in {0}ms.");
+        }
+
+        private void UnloadNoLongerExistingReferences(IDictionary<string, ReferencePriorityMap> newProjectReferences, IDictionary<string, ReferencePriorityMap> oldProjectReferences)
+        {
             var noLongerReferencedProjectIds = oldProjectReferences.Keys
-                .Where(projectId => !_projectReferences.ContainsKey(projectId))
+                .Where(projectId => !newProjectReferences.ContainsKey(projectId))
                 .ToList();
 
             foreach (var referencedProjectId in noLongerReferencedProjectIds)
             {
                 UnloadComReference(referencedProjectId);
             }
+        }
 
-            parsingStageTimer.Stop();
-            parsingStageTimer.Log("Loaded and unloaded referenced libraries in {0}ms.");
+        private void DetermineReferencesAffectedByPriorityChanges(IDictionary<string, ReferencePriorityMap> newProjectReferences, IDictionary<string, ReferencePriorityMap> oldProjectReferences)
+        {
+            var referencePriorityChanges = ReferencePriorityChanges(newProjectReferences, oldProjectReferences);
+
+            foreach (var oldMap in oldProjectReferences.Values)
+            {
+                foreach (var projectId in referencePriorityChanges.Keys)
+                {
+                    if (oldMap.TryGetValue(projectId, out var priority)
+                        && referencePriorityChanges[projectId]
+                            .Any(tpl => (tpl.oldPriority <= priority && tpl.newPriority >= priority)
+                                        || (tpl.oldPriority >= priority && tpl.newPriority <= priority)))
+                    {
+                        _referencesAffectedByPriorityChanges.Add((projectId, oldMap.ReferencedProjectId));
+                    }
+                }
+            }
         }
 
-        private void DetermineReferencesWithChangedPriorities(IDictionary<string, ReferencePriorityMap> newProjectReferences, IDictionary<string, ReferencePriorityMap> oldProjectReferences)
+        private static IDictionary<string, List<(int newPriority, int oldPriority)>> ReferencePriorityChanges(IDictionary<string, ReferencePriorityMap> newProjectReferences, IDictionary<string, ReferencePriorityMap> oldProjectReferences)
         {
+            var referencePriorityChanges = new Dictionary<string, List<(int newPriority, int oldPriority)>>();
             foreach (var referencedProjectId in oldProjectReferences.Keys)
             {
                 var oldMap = oldProjectReferences[referencedProjectId];
                 if (!newProjectReferences.TryGetValue(referencedProjectId, out var newMap))
                 {
                     foreach (var projectId in oldMap.Keys)
                     {
-                        _referencesWithChangedPriority.Add((projectId, referencedProjectId, int.MaxValue, oldMap[projectId]));
+                        AddPriorityChangeToDictionary(projectId, int.MaxValue, oldMap[projectId], referencePriorityChanges);
                     }
                 }
                 else
@@ -130,17 +155,15 @@ private void DetermineReferencesWithChangedPriorities(IDictionary<string, Refere
 
                         if (newPriority != oldPriority)
                         {
-                            _referencesWithChangedPriority.Add((projectId, referencedProjectId, newPriority,
-                                oldMap[projectId]));
+                            AddPriorityChangeToDictionary(projectId, newPriority, oldMap[projectId], referencePriorityChanges);
                         }
                     }
 
                     foreach (var projectId in newMap.Keys)
                     {
                         if (!oldMap.ContainsKey(projectId))
                         {
-                            _referencesWithChangedPriority.Add(
-                                (projectId, referencedProjectId, newMap[projectId], int.MaxValue));
+                            AddPriorityChangeToDictionary(projectId, newMap[projectId], int.MaxValue, referencePriorityChanges);
                         }
                     }
                 }
@@ -156,9 +179,27 @@ private void DetermineReferencesWithChangedPriorities(IDictionary<string, Refere
                 var newMap = newProjectReferences[referencedProjectId];
                 foreach (var projectId in newMap.Keys)
                 {
-                    _referencesWithChangedPriority.Add((projectId, referencedProjectId, newMap[projectId], int.MaxValue));
+                    AddPriorityChangeToDictionary(projectId, newMap[projectId], int.MaxValue, referencePriorityChanges);
                 }
             }
+
+            return referencePriorityChanges;
+        }
+
+        private static void AddPriorityChangeToDictionary(
+            string projectId, 
+            int newPriority, 
+            int oldPriority,
+            IDictionary<string, List<(int newPriority, int oldPriority)>> dict)
+        {
+            if (dict.TryGetValue(projectId, out var changeList))
+            {
+                changeList.Add((newPriority, oldPriority));
+            }
+            else
+            {
+                dict.Add(projectId, new List<(int newPriority, int oldPriority)> { (newPriority, oldPriority) });
+            }
         }
 
         private Dictionary<string, List<ReferenceInfo>> ReferencedByProjectId()

Rubberduck.Parsing/VBA/ComReferenceLoading/ICOMReferenceSynchronizer.cs

@@ -7,7 +7,8 @@ namespace Rubberduck.Parsing.VBA.ComReferenceLoading
     public interface ICOMReferenceSynchronizer
     {
         bool LastSyncOfCOMReferencesLoadedReferences { get; }
-        IEnumerable<QualifiedModuleName> COMReferencesUnloadedUnloadedInLastSync { get; }
+        IEnumerable<QualifiedModuleName> COMReferencesUnloadedInLastSync { get; }
+        IEnumerable<(string projectId, string referencedProjectId)> COMReferencesAffectedByPriorityChangesInLastSync { get; }
 
         void SyncComReferences(CancellationToken token);
     }

Rubberduck.Parsing/VBA/ParseCoordinator.cs

@@ -224,9 +224,9 @@ private void ExecuteCommonParseActivities(IReadOnlyCollection<QualifiedModuleNam
             token.ThrowIfCancellationRequested();
 
             _parsingStageService.SyncComReferences(token);
-            if (_parsingStageService.LastSyncOfCOMReferencesLoadedReferences || _parsingStageService.COMReferencesUnloadedUnloadedInLastSync.Any())
+            if (_parsingStageService.LastSyncOfCOMReferencesLoadedReferences || _parsingStageService.COMReferencesUnloadedInLastSync.Any())
             {
-                var unloadedReferences = _parsingStageService.COMReferencesUnloadedUnloadedInLastSync;
+                var unloadedReferences = _parsingStageService.COMReferencesUnloadedInLastSync;
                 var additionalModulesToBeReresolved = OtherModulesReferencingAnyNotToBeParsed(unloadedReferences.ToHashSet().AsReadOnly(), toParse);
                 toReresolveReferences.UnionWith(additionalModulesToBeReresolved);
                 _parserStateManager.SetModuleStates(additionalModulesToBeReresolved, ParserState.ResolvingReferences, token);

Rubberduck.Parsing/VBA/ParsingStageService.cs

@@ -52,30 +52,10 @@ public ParsingStageService(
             _referenceResolver = referenceResolver;
         }
 
-
-        public bool LastLoadOfBuiltInDeclarationsLoadedDeclarations
-        {
-            get
-            {
-                return _builtInDeclarationLoader.LastLoadOfBuiltInDeclarationsLoadedDeclarations;
-            }
-        }
-
-        public bool LastSyncOfCOMReferencesLoadedReferences
-        {
-            get
-            {
-                return _comSynchronizer.LastSyncOfCOMReferencesLoadedReferences;
-            }
-        }
-
-        public IEnumerable<QualifiedModuleName> COMReferencesUnloadedUnloadedInLastSync
-        {
-            get
-            {
-                return _comSynchronizer.COMReferencesUnloadedUnloadedInLastSync;
-            }
-        }
+        public bool LastLoadOfBuiltInDeclarationsLoadedDeclarations => _builtInDeclarationLoader.LastLoadOfBuiltInDeclarationsLoadedDeclarations;
+        public bool LastSyncOfCOMReferencesLoadedReferences => _comSynchronizer.LastSyncOfCOMReferencesLoadedReferences;
+        public IEnumerable<QualifiedModuleName> COMReferencesUnloadedInLastSync => _comSynchronizer.COMReferencesUnloadedInLastSync;
+        public IEnumerable<(string projectId, string referencedProjectId)>COMReferencesAffectedByPriorityChangesInLastSync =>_comSynchronizer.COMReferencesAffectedByPriorityChangesInLastSync;
 
         public void LoadBuitInDeclarations()
         {