Saved the unresolved member declarations on the module states and refilled the unresolved and undeclared collections on the DeclarationFinder upon refresh.

MDoerner · MDoerner · commit a302e55b8f65 · 2017-02-28T21:16:57.000+01:00
diff --git a/Rubberduck.Parsing/Symbols/DeclarationFinder.cs b/Rubberduck.Parsing/Symbols/DeclarationFinder.cs
@@ -30,7 +30,7 @@ public static IEnumerable<TValue> AllValues<TKey, TValue>(
         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 class DeclarationFinder
@@ -42,8 +42,10 @@ public class DeclarationFinder
         private readonly AnnotationService _annotationService;
         private readonly ConcurrentDictionary<string, ConcurrentBag<Declaration>> _declarationsByName;
         private readonly ConcurrentDictionary<QualifiedModuleName, ConcurrentBag<Declaration>> _declarations;
-        private readonly ConcurrentDictionary<QualifiedMemberName, ConcurrentBag<Declaration>> _undeclared;
-        private readonly ConcurrentBag<UnboundMemberDeclaration> _unresolved;
+        private readonly ConcurrentDictionary<QualifiedMemberName, ConcurrentBag<Declaration>> _newUndeclared;
+        private readonly ConcurrentBag<UnboundMemberDeclaration> _newUnresolved;
+        private readonly Dictionary<QualifiedMemberName, List<Declaration>> _undeclared;
+        private readonly List<UnboundMemberDeclaration> _unresolved;
         private readonly ConcurrentDictionary<QualifiedModuleName, ConcurrentBag<IAnnotation>> _annotations;
         private readonly ConcurrentDictionary<Declaration, ConcurrentBag<Declaration>> _parametersByParent;
         private readonly ConcurrentDictionary<DeclarationType, ConcurrentBag<Declaration>> _userDeclarationsByType;
@@ -54,7 +56,7 @@ public class DeclarationFinder
         
         private static readonly object ThreadLock = new object();
 
-        public DeclarationFinder(IReadOnlyList<Declaration> declarations, IEnumerable<IAnnotation> annotations, IHostApplication hostApp = null)
+        public DeclarationFinder(IReadOnlyList<Declaration> declarations, IEnumerable<IAnnotation> annotations, IReadOnlyList<UnboundMemberDeclaration> unresolvedMemberDeclarations, IHostApplication hostApp = null)
         {
             _hostApp = hostApp;
             _annotations = annotations.GroupBy(node => node.QualifiedSelection.QualifiedName).ToConcurrentDictionary();
@@ -90,8 +92,11 @@ public DeclarationFinder(IReadOnlyList<Declaration> declarations, IEnumerable<IA
                         .ToDictionary(item => item.WithEventsField, item => item.Handlers.ToArray())
                     ), true);
 
-            _undeclared = new ConcurrentDictionary<QualifiedMemberName, ConcurrentBag<Declaration>>(new Dictionary<QualifiedMemberName, ConcurrentBag<Declaration>>());
-            _unresolved = new ConcurrentBag<UnboundMemberDeclaration>(new List<UnboundMemberDeclaration>());
+            _newUndeclared = new ConcurrentDictionary<QualifiedMemberName, ConcurrentBag<Declaration>>(new Dictionary<QualifiedMemberName, ConcurrentBag<Declaration>>());
+            _undeclared = declarations.Where(declaration => declaration.IsUndeclared).GroupBy(item => item.QualifiedName).ToDictionary(group => group.Key, group => group.ToList());
+            _newUnresolved = new ConcurrentBag<UnboundMemberDeclaration>(new List<UnboundMemberDeclaration>());
+            _unresolved = unresolvedMemberDeclarations.ToList();
+            
             _annotationService = new AnnotationService(this);
 
             var implementsInstructions = UserDeclarations(DeclarationType.ClassModule).SelectMany(cls => 
@@ -134,9 +139,14 @@ public DeclarationFinder(IReadOnlyList<Declaration> declarations, IEnumerable<IA
                 implementableMembers.ToDictionary(item => item.Context, item => item.Members)), true);
         }
 
+        public IEnumerable<Declaration> FreshUndeclared
+        {
+            get { return _newUndeclared.AllValues(); }
+        }
+
         public IEnumerable<Declaration> Undeclared
         {
-            get { return _undeclared.AllValues(); }
+            get { return _undeclared.SelectMany(item => item.Value).ToList(); }
         }
 
         public IEnumerable<Declaration> Members(Declaration module)
@@ -209,14 +219,19 @@ public IEnumerable<Declaration> UserDeclarations(DeclarationType type)
             return result;
         }
 
-        public IEnumerable<UnboundMemberDeclaration> UnresolvedMemberDeclarations()
+        public IEnumerable<UnboundMemberDeclaration> FreshUnresolvedMemberDeclarations()
         {
             lock (ThreadLock)
             {
-                return _unresolved.ToArray();
+                return _newUnresolved.ToArray();
             }            
         }
 
+        public IEnumerable<UnboundMemberDeclaration> UnresolvedMemberDeclarations()
+        {
+            return _unresolved.ToList();
+        }
+
         public IEnumerable<Declaration> FindHandlersForWithEventsField(Declaration field)
         {
             Declaration[] result;
@@ -510,13 +525,13 @@ public Declaration OnUndeclaredVariable(Declaration enclosingProcedure, string i
                     Accessibility.Implicit, DeclarationType.Variable, context, context.GetSelection(), false, null,
                     false, annotations, null, true);
 
-            var hasUndeclared = _undeclared.ContainsKey(enclosingProcedure.QualifiedName);
+            var hasUndeclared = _newUndeclared.ContainsKey(enclosingProcedure.QualifiedName);
             if (hasUndeclared)
             {
                 ConcurrentBag<Declaration> undeclared;
-                while (!_undeclared.TryGetValue(enclosingProcedure.QualifiedName, out undeclared))
+                while (!_newUndeclared.TryGetValue(enclosingProcedure.QualifiedName, out undeclared))
                 {
-                    _undeclared.TryGetValue(enclosingProcedure.QualifiedName, out undeclared);
+                    _newUndeclared.TryGetValue(enclosingProcedure.QualifiedName, out undeclared);
                 }
                 var inScopeUndeclared = undeclared.FirstOrDefault(d => d.IdentifierName == identifierName);
                 if (inScopeUndeclared != null)
@@ -527,7 +542,7 @@ public Declaration OnUndeclaredVariable(Declaration enclosingProcedure, string i
             }
             else
             {
-                _undeclared.TryAdd(enclosingProcedure.QualifiedName, new ConcurrentBag<Declaration> { undeclaredLocal });
+                _newUndeclared.TryAdd(enclosingProcedure.QualifiedName, new ConcurrentBag<Declaration> { undeclaredLocal });
             }
             return undeclaredLocal;
         }
@@ -550,7 +565,7 @@ public void AddUnboundContext(Declaration parentDeclaration, VBAParser.LExprCont
                 (access is VBAParser.MemberAccessExprContext) ? (ParserRuleContext)access.children[0] : withExpression.Context, 
                 annotations);
 
-            _unresolved.Add(declaration);
+            _newUnresolved.Add(declaration);
         }
 
         public Declaration OnBracketedExpression(string expression, ParserRuleContext context)
@@ -561,13 +576,13 @@ public Declaration OnBracketedExpression(string expression, ParserRuleContext co
             var qualifiedName = hostApp.QualifiedName.QualifiedModuleName.QualifyMemberName(expression);
 
             ConcurrentBag<Declaration> undeclared;
-            if (_undeclared.TryGetValue(qualifiedName, out undeclared))
+            if (_newUndeclared.TryGetValue(qualifiedName, out undeclared))
             {
                 return undeclared.SingleOrDefault();
             }
 
             var item = new Declaration(qualifiedName, hostApp, hostApp, Tokens.Variant, string.Empty, false, false, Accessibility.Global, DeclarationType.BracketedExpression, context, context.GetSelection(), false, null);
-            _undeclared.TryAdd(qualifiedName, new ConcurrentBag<Declaration> { item });
+            _newUndeclared.TryAdd(qualifiedName, new ConcurrentBag<Declaration> { item });
             return item;
         }
 
diff --git a/Rubberduck.Parsing/VBA/ModuleState.cs b/Rubberduck.Parsing/VBA/ModuleState.cs
@@ -13,6 +13,7 @@ namespace Rubberduck.Parsing.VBA
     public class ModuleState
     {
         public ConcurrentDictionary<Declaration, byte> Declarations { get; private set; }
+        public ConcurrentDictionary<UnboundMemberDeclaration, byte> UnresolvedMemberDeclarations { get; private set; }
         public ITokenStream TokenStream { get; private set; }
         public IParseTree ParseTree { get; private set; }
         public ParserState State { get; private set; }
@@ -29,7 +30,8 @@ public class ModuleState
         public ModuleState(ConcurrentDictionary<Declaration, byte> declarations)
         {
             Declarations = declarations;
-            TokenStream = null;
+            UnresolvedMemberDeclarations = new ConcurrentDictionary<UnboundMemberDeclaration, byte>();
+            TokenStream = null;UnboundMemberDeclaration
             ParseTree = null;
 
             if (declarations.Any() && declarations.ElementAt(0).Key.QualifiedName.QualifiedModuleName.Component != null)
@@ -55,6 +57,7 @@ public ModuleState(ConcurrentDictionary<Declaration, byte> declarations)
         public ModuleState(ParserState state)
         {
             Declarations = new ConcurrentDictionary<Declaration, byte>();
+            UnresolvedMemberDeclarations = new ConcurrentDictionary<UnboundMemberDeclaration, byte>();
             TokenStream = null;
             ParseTree = null;
             State = state;
@@ -72,6 +75,7 @@ public ModuleState(ParserState state)
         public ModuleState(SyntaxErrorException moduleException)
         {
             Declarations = new ConcurrentDictionary<Declaration, byte>();
+            UnresolvedMemberDeclarations = new ConcurrentDictionary<UnboundMemberDeclaration, byte>();
             TokenStream = null;
             ParseTree = null;
             State = ParserState.Error;
@@ -89,6 +93,7 @@ public ModuleState(SyntaxErrorException moduleException)
         public ModuleState(IDictionary<Tuple<string, DeclarationType>, Attributes> moduleAttributes)
         {
             Declarations = new ConcurrentDictionary<Declaration, byte>();
+            UnresolvedMemberDeclarations = new ConcurrentDictionary<UnboundMemberDeclaration, byte>();
             TokenStream = null;
             ParseTree = null;
             State = ParserState.None;
diff --git a/Rubberduck.Parsing/VBA/ParseCoordinator.cs b/Rubberduck.Parsing/VBA/ParseCoordinator.cs
@@ -241,7 +241,8 @@ private void ExecuteCommonParseActivities(List<IVBComponent> toParse, Cancellati
                     throw new OperationCanceledException(token);
                 }
 
-            ResolveAllReferences(token);
+            var toResolveReferences = State.ParseTrees.Select(kvp => kvp.Key).ToHashSet();
+            ResolveAllReferences(toResolveReferences, token);
 
                 if (token.IsCancellationRequested || State.Status >= ParserState.Error)
                 {
@@ -469,11 +470,11 @@ private Declaration CreateProjectDeclaration(QualifiedModuleName projectQualifie
         }
 
 
-        private void ResolveAllReferences(CancellationToken token)
+        private void ResolveAllReferences(ICollection<QualifiedModuleName> toResolve, CancellationToken token)
         {
                 token.ThrowIfCancellationRequested();
     
-            var components = State.ParseTrees.Select(kvp => kvp.Key.Component).ToList();
+            var components = toResolve.Select(qmn => qmn.Component).ToList();
             
                 token.ThrowIfCancellationRequested();
             
@@ -485,13 +486,15 @@ private void ResolveAllReferences(CancellationToken token)
 
                 token.ThrowIfCancellationRequested();
 
+            var parseTreesToResolve = State.ParseTrees.Where(kvp => toResolve.Contains(kvp.Key)).ToList();
+
             var options = new ParallelOptions();
             options.CancellationToken = token;
             options.MaxDegreeOfParallelism = _maxDegreeOfReferenceResolverParallelism;
             try
             {
-                Parallel.For(0, State.ParseTrees.Count, options,
-                    (index) => ResolveReferences(State.DeclarationFinder, State.ParseTrees[index].Key, State.ParseTrees[index].Value, token)
+                Parallel.For(0, parseTreesToResolve.Count, options,
+                    (index) => ResolveReferences(State.DeclarationFinder, parseTreesToResolve[index].Key, parseTreesToResolve[index].Value, token)
                 );
             }
             catch (AggregateException exception)
@@ -510,10 +513,11 @@ private void ResolveAllReferences(CancellationToken token)
 
                 token.ThrowIfCancellationRequested();
             
-            AddUndeclaredVariablesToDeclarations();
+            AddNewUndeclaredVariablesToDeclarations();
+            AddNewUnresolvedMemberDeclarations();
 
             //This is here and not in the calling method because it has to happen before the ready state is reached.
-            //RefreshDeclarationFinder(); //Commented out because it breaks the unresolved and undeclared collections.
+            RefreshDeclarationFinder();
 
                 token.ThrowIfCancellationRequested();
 
@@ -604,15 +608,24 @@ private void AddModuleToModuleReferences(DeclarationFinder finder, QualifiedModu
             }
         }
 
-        private void AddUndeclaredVariablesToDeclarations()
+        private void AddNewUndeclaredVariablesToDeclarations()
         {
-            var undeclared = State.DeclarationFinder.Undeclared.ToList();
+            var undeclared = State.DeclarationFinder.FreshUndeclared.ToList();
             foreach (var declaration in undeclared)
             {
                 State.AddDeclaration(declaration);
             }
         }
 
+        private void AddNewUnresolvedMemberDeclarations()
+        {
+            var unresolved = State.DeclarationFinder.FreshUnresolvedMemberDeclarations().ToList();
+            foreach (var declaration in unresolved)
+            {
+                State.AddUnresolvedMemberDeclaration(declaration);
+            }
+        }
+
 
         /// <summary>
         /// Starts parsing all components of all unprotected VBProjects associated with the VBE-Instance passed to the constructor of this parser instance.
diff --git a/Rubberduck.Parsing/VBA/RubberduckParserState.cs b/Rubberduck.Parsing/VBA/RubberduckParserState.cs
@@ -69,7 +69,7 @@ public sealed class RubberduckParserState : IDisposable
 
         internal void RefreshFinder(IHostApplication host)
         {
-            DeclarationFinder = new DeclarationFinder(AllDeclarations, AllAnnotations, host);
+            DeclarationFinder = new DeclarationFinder(AllDeclarations, AllAnnotations, AllUnresolvedMemberDeclarations, host);
         }
 
         private readonly IVBE _vbe;
@@ -629,6 +629,28 @@ public IReadOnlyList<Declaration> AllDeclarations
             }
         }
 
+        /// <summary>
+        /// Gets a copy of the unresolved member declarations.
+        /// </summary>
+        public IReadOnlyList<UnboundMemberDeclaration> AllUnresolvedMemberDeclarations
+        {
+            get
+            {
+                var declarations = new List<UnboundMemberDeclaration>();
+                foreach (var state in _moduleStates.Values)
+                {
+                    if (state.UnresolvedMemberDeclarations == null)
+                    {
+                        continue;
+                    }
+
+                    declarations.AddRange(state.UnresolvedMemberDeclarations.Keys);
+                }
+
+                return declarations;
+            }
+        }
+
         private readonly ConcurrentBag<SerializableProject> _builtInDeclarationTrees = new ConcurrentBag<SerializableProject>();
         public IProducerConsumerCollection<SerializableProject> BuiltInDeclarationTrees { get { return _builtInDeclarationTrees; } }
 
@@ -694,6 +716,28 @@ public void AddDeclaration(Declaration declaration)
             }
         }
 
+        /// <summary>
+        /// Adds the specified <see cref="UnboundMemberDeclaration"/> to the collection (replaces existing).
+        /// </summary>
+        public void AddUnresolvedMemberDeclaration(UnboundMemberDeclaration declaration)
+        {
+            var key = declaration.QualifiedName.QualifiedModuleName;
+            var declarations = _moduleStates.GetOrAdd(key, new ModuleState(new ConcurrentDictionary<Declaration, byte>())).UnresolvedMemberDeclarations;
+
+            if (declarations.ContainsKey(declaration))
+            {
+                byte _;
+                while (!declarations.TryRemove(declaration, out _))
+                {
+                    Logger.Warn("Could not remove existing unresolved member declaration for '{0}' ({1}). Retrying.", declaration.IdentifierName, declaration.DeclarationType);
+                }
+            }
+            while (!declarations.TryAdd(declaration, 0) && !declarations.ContainsKey(declaration))
+            {
+                Logger.Warn("Could not add unresolved member declaration '{0}' ({1}). Retrying.", declaration.IdentifierName, declaration.DeclarationType);
+            }
+        }
+
         private void ClearStateCache(string projectId, bool notifyStateChanged = false)
         {
             try

Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ public static IEnumerable<TValue> AllValues<TKey, TValue>(`
`30`	`30`	`public static ConcurrentDictionary<TKey, ConcurrentBag<TValue>> ToConcurrentDictionary<TKey, TValue>(this IEnumerable<IGrouping<TKey, TValue>> source)`
`31`	`31`	`{`
`32`	`32`	`return new ConcurrentDictionary<TKey, ConcurrentBag<TValue>>(source.Select(x => new KeyValuePair<TKey, ConcurrentBag<TValue>>(x.Key, new ConcurrentBag<TValue>(x))));`
`33`		`- }`
	`33`	`+ }`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`public class DeclarationFinder`
`@@ -42,8 +42,10 @@ public class DeclarationFinder`
`42`	`42`	`private readonly AnnotationService _annotationService;`
`43`	`43`	`private readonly ConcurrentDictionary<string, ConcurrentBag<Declaration>> _declarationsByName;`
`44`	`44`	`private readonly ConcurrentDictionary<QualifiedModuleName, ConcurrentBag<Declaration>> _declarations;`
`45`		`- private readonly ConcurrentDictionary<QualifiedMemberName, ConcurrentBag<Declaration>> _undeclared;`
`46`		`- private readonly ConcurrentBag<UnboundMemberDeclaration> _unresolved;`
	`45`	`+ private readonly ConcurrentDictionary<QualifiedMemberName, ConcurrentBag<Declaration>> _newUndeclared;`
	`46`	`+ private readonly ConcurrentBag<UnboundMemberDeclaration> _newUnresolved;`
	`47`	`+ private readonly Dictionary<QualifiedMemberName, List<Declaration>> _undeclared;`
	`48`	`+ private readonly List<UnboundMemberDeclaration> _unresolved;`
`47`	`49`	`private readonly ConcurrentDictionary<QualifiedModuleName, ConcurrentBag<IAnnotation>> _annotations;`
`48`	`50`	`private readonly ConcurrentDictionary<Declaration, ConcurrentBag<Declaration>> _parametersByParent;`
`49`	`51`	`private readonly ConcurrentDictionary<DeclarationType, ConcurrentBag<Declaration>> _userDeclarationsByType;`
`@@ -54,7 +56,7 @@ public class DeclarationFinder`
`54`	`56`
`55`	`57`	`private static readonly object ThreadLock = new object();`
`56`	`58`
`57`		`- public DeclarationFinder(IReadOnlyList<Declaration> declarations, IEnumerable<IAnnotation> annotations, IHostApplication hostApp = null)`
	`59`	`+ public DeclarationFinder(IReadOnlyList<Declaration> declarations, IEnumerable<IAnnotation> annotations, IReadOnlyList<UnboundMemberDeclaration> unresolvedMemberDeclarations, IHostApplication hostApp = null)`
`58`	`60`	`{`
`59`	`61`	`_hostApp = hostApp;`
`60`	`62`	`_annotations = annotations.GroupBy(node => node.QualifiedSelection.QualifiedName).ToConcurrentDictionary();`
`@@ -90,8 +92,11 @@ public DeclarationFinder(IReadOnlyList<Declaration> declarations, IEnumerable<IA`
`90`	`92`	`.ToDictionary(item => item.WithEventsField, item => item.Handlers.ToArray())`
`91`	`93`	`), true);`
`92`	`94`
`93`		`- _undeclared = new ConcurrentDictionary<QualifiedMemberName, ConcurrentBag<Declaration>>(new Dictionary<QualifiedMemberName, ConcurrentBag<Declaration>>());`
`94`		`- _unresolved = new ConcurrentBag<UnboundMemberDeclaration>(new List<UnboundMemberDeclaration>());`
	`95`	`+ _newUndeclared = new ConcurrentDictionary<QualifiedMemberName, ConcurrentBag<Declaration>>(new Dictionary<QualifiedMemberName, ConcurrentBag<Declaration>>());`
	`96`	`+ _undeclared = declarations.Where(declaration => declaration.IsUndeclared).GroupBy(item => item.QualifiedName).ToDictionary(group => group.Key, group => group.ToList());`
	`97`	`+ _newUnresolved = new ConcurrentBag<UnboundMemberDeclaration>(new List<UnboundMemberDeclaration>());`
	`98`	`+ _unresolved = unresolvedMemberDeclarations.ToList();`
	`99`	`+`
`95`	`100`	`_annotationService = new AnnotationService(this);`
`96`	`101`
`97`	`102`	`var implementsInstructions = UserDeclarations(DeclarationType.ClassModule).SelectMany(cls =>`
`@@ -134,9 +139,14 @@ public DeclarationFinder(IReadOnlyList<Declaration> declarations, IEnumerable<IA`
`134`	`139`	`implementableMembers.ToDictionary(item => item.Context, item => item.Members)), true);`
`135`	`140`	`}`
`136`	`141`
	`142`	`+ public IEnumerable<Declaration> FreshUndeclared`
	`143`	`+ {`
	`144`	`+ get { return _newUndeclared.AllValues(); }`
	`145`	`+ }`
	`146`	`+`
`137`	`147`	`public IEnumerable<Declaration> Undeclared`
`138`	`148`	`{`
`139`		`- get { return _undeclared.AllValues(); }`
	`149`	`+ get { return _undeclared.SelectMany(item => item.Value).ToList(); }`
`140`	`150`	`}`
`141`	`151`
`142`	`152`	`public IEnumerable<Declaration> Members(Declaration module)`
`@@ -209,14 +219,19 @@ public IEnumerable<Declaration> UserDeclarations(DeclarationType type)`
`209`	`219`	`return result;`
`210`	`220`	`}`
`211`	`221`
`212`		`- public IEnumerable<UnboundMemberDeclaration> UnresolvedMemberDeclarations()`
	`222`	`+ public IEnumerable<UnboundMemberDeclaration> FreshUnresolvedMemberDeclarations()`
`213`	`223`	`{`
`214`	`224`	`lock (ThreadLock)`
`215`	`225`	`{`
`216`		`- return _unresolved.ToArray();`
	`226`	`+ return _newUnresolved.ToArray();`
`217`	`227`	`}`
`218`	`228`	`}`
`219`	`229`
	`230`	`+ public IEnumerable<UnboundMemberDeclaration> UnresolvedMemberDeclarations()`
	`231`	`+ {`
	`232`	`+ return _unresolved.ToList();`
	`233`	`+ }`
	`234`	`+`
`220`	`235`	`public IEnumerable<Declaration> FindHandlersForWithEventsField(Declaration field)`
`221`	`236`	`{`
`222`	`237`	`Declaration[] result;`
`@@ -510,13 +525,13 @@ public Declaration OnUndeclaredVariable(Declaration enclosingProcedure, string i`
`510`	`525`	`Accessibility.Implicit, DeclarationType.Variable, context, context.GetSelection(), false, null,`
`511`	`526`	`false, annotations, null, true);`
`512`	`527`
`513`		`- var hasUndeclared = _undeclared.ContainsKey(enclosingProcedure.QualifiedName);`
	`528`	`+ var hasUndeclared = _newUndeclared.ContainsKey(enclosingProcedure.QualifiedName);`
`514`	`529`	`if (hasUndeclared)`
`515`	`530`	`{`
`516`	`531`	`ConcurrentBag<Declaration> undeclared;`
`517`		`- while (!_undeclared.TryGetValue(enclosingProcedure.QualifiedName, out undeclared))`
	`532`	`+ while (!_newUndeclared.TryGetValue(enclosingProcedure.QualifiedName, out undeclared))`
`518`	`533`	`{`
`519`		`- _undeclared.TryGetValue(enclosingProcedure.QualifiedName, out undeclared);`
	`534`	`+ _newUndeclared.TryGetValue(enclosingProcedure.QualifiedName, out undeclared);`
`520`	`535`	`}`
`521`	`536`	`var inScopeUndeclared = undeclared.FirstOrDefault(d => d.IdentifierName == identifierName);`
`522`	`537`	`if (inScopeUndeclared != null)`
`@@ -527,7 +542,7 @@ public Declaration OnUndeclaredVariable(Declaration enclosingProcedure, string i`
`527`	`542`	`}`
`528`	`543`	`else`
`529`	`544`	`{`
`530`		`- _undeclared.TryAdd(enclosingProcedure.QualifiedName, new ConcurrentBag<Declaration> { undeclaredLocal });`
	`545`	`+ _newUndeclared.TryAdd(enclosingProcedure.QualifiedName, new ConcurrentBag<Declaration> { undeclaredLocal });`
`531`	`546`	`}`
`532`	`547`	`return undeclaredLocal;`
`533`	`548`	`}`
`@@ -550,7 +565,7 @@ public void AddUnboundContext(Declaration parentDeclaration, VBAParser.LExprCont`
`550`	`565`	`(access is VBAParser.MemberAccessExprContext) ? (ParserRuleContext)access.children[0] : withExpression.Context,`
`551`	`566`	`annotations);`
`552`	`567`
`553`		`- _unresolved.Add(declaration);`
	`568`	`+ _newUnresolved.Add(declaration);`
`554`	`569`	`}`
`555`	`570`
`556`	`571`	`public Declaration OnBracketedExpression(string expression, ParserRuleContext context)`
`@@ -561,13 +576,13 @@ public Declaration OnBracketedExpression(string expression, ParserRuleContext co`
`561`	`576`	`var qualifiedName = hostApp.QualifiedName.QualifiedModuleName.QualifyMemberName(expression);`
`562`	`577`
`563`	`578`	`ConcurrentBag<Declaration> undeclared;`
`564`		`- if (_undeclared.TryGetValue(qualifiedName, out undeclared))`
	`579`	`+ if (_newUndeclared.TryGetValue(qualifiedName, out undeclared))`
`565`	`580`	`{`
`566`	`581`	`return undeclared.SingleOrDefault();`
`567`	`582`	`}`
`568`	`583`
`569`	`584`	`var item = new Declaration(qualifiedName, hostApp, hostApp, Tokens.Variant, string.Empty, false, false, Accessibility.Global, DeclarationType.BracketedExpression, context, context.GetSelection(), false, null);`
`570`		`- _undeclared.TryAdd(qualifiedName, new ConcurrentBag<Declaration> { item });`
	`585`	`+ _newUndeclared.TryAdd(qualifiedName, new ConcurrentBag<Declaration> { item });`
`571`	`586`	`return item;`
`572`	`587`	`}`
`573`	`588`
Original file line number	Diff line number	Diff line change
`@@ -241,7 +241,8 @@ private void ExecuteCommonParseActivities(List<IVBComponent> toParse, Cancellati`
`241`	`241`	`throw new OperationCanceledException(token);`
`242`	`242`	`}`
`243`	`243`
`244`		`- ResolveAllReferences(token);`
	`244`	`+ var toResolveReferences = State.ParseTrees.Select(kvp => kvp.Key).ToHashSet();`
	`245`	`+ ResolveAllReferences(toResolveReferences, token);`
`245`	`246`
`246`	`247`	`if (token.IsCancellationRequested \|\| State.Status >= ParserState.Error)`
`247`	`248`	`{`
`@@ -469,11 +470,11 @@ private Declaration CreateProjectDeclaration(QualifiedModuleName projectQualifie`
`469`	`470`	`}`
`470`	`471`
`471`	`472`
`472`		`- private void ResolveAllReferences(CancellationToken token)`
	`473`	`+ private void ResolveAllReferences(ICollection<QualifiedModuleName> toResolve, CancellationToken token)`
`473`	`474`	`{`
`474`	`475`	`token.ThrowIfCancellationRequested();`
`475`	`476`
`476`		`- var components = State.ParseTrees.Select(kvp => kvp.Key.Component).ToList();`
	`477`	`+ var components = toResolve.Select(qmn => qmn.Component).ToList();`
`477`	`478`
`478`	`479`	`token.ThrowIfCancellationRequested();`
`479`	`480`
`@@ -485,13 +486,15 @@ private void ResolveAllReferences(CancellationToken token)`
`485`	`486`
`486`	`487`	`token.ThrowIfCancellationRequested();`
`487`	`488`
	`489`	`+ var parseTreesToResolve = State.ParseTrees.Where(kvp => toResolve.Contains(kvp.Key)).ToList();`
	`490`	`+`
`488`	`491`	`var options = new ParallelOptions();`
`489`	`492`	`options.CancellationToken = token;`
`490`	`493`	`options.MaxDegreeOfParallelism = _maxDegreeOfReferenceResolverParallelism;`
`491`	`494`	`try`
`492`	`495`	`{`
`493`		`- Parallel.For(0, State.ParseTrees.Count, options,`
`494`		`- (index) => ResolveReferences(State.DeclarationFinder, State.ParseTrees[index].Key, State.ParseTrees[index].Value, token)`
	`496`	`+ Parallel.For(0, parseTreesToResolve.Count, options,`
	`497`	`+ (index) => ResolveReferences(State.DeclarationFinder, parseTreesToResolve[index].Key, parseTreesToResolve[index].Value, token)`
`495`	`498`	`);`
`496`	`499`	`}`
`497`	`500`	`catch (AggregateException exception)`
`@@ -510,10 +513,11 @@ private void ResolveAllReferences(CancellationToken token)`
`510`	`513`
`511`	`514`	`token.ThrowIfCancellationRequested();`
`512`	`515`
`513`		`- AddUndeclaredVariablesToDeclarations();`
	`516`	`+ AddNewUndeclaredVariablesToDeclarations();`
	`517`	`+ AddNewUnresolvedMemberDeclarations();`
`514`	`518`
`515`	`519`	`//This is here and not in the calling method because it has to happen before the ready state is reached.`
`516`		`- //RefreshDeclarationFinder(); //Commented out because it breaks the unresolved and undeclared collections.`
	`520`	`+ RefreshDeclarationFinder();`
`517`	`521`
`518`	`522`	`token.ThrowIfCancellationRequested();`
`519`	`523`
`@@ -604,15 +608,24 @@ private void AddModuleToModuleReferences(DeclarationFinder finder, QualifiedModu`
`604`	`608`	`}`
`605`	`609`	`}`
`606`	`610`
`607`		`- private void AddUndeclaredVariablesToDeclarations()`
	`611`	`+ private void AddNewUndeclaredVariablesToDeclarations()`
`608`	`612`	`{`
`609`		`- var undeclared = State.DeclarationFinder.Undeclared.ToList();`
	`613`	`+ var undeclared = State.DeclarationFinder.FreshUndeclared.ToList();`
`610`	`614`	`foreach (var declaration in undeclared)`
`611`	`615`	`{`
`612`	`616`	`State.AddDeclaration(declaration);`
`613`	`617`	`}`
`614`	`618`	`}`
`615`	`619`
	`620`	`+ private void AddNewUnresolvedMemberDeclarations()`
	`621`	`+ {`
	`622`	`+ var unresolved = State.DeclarationFinder.FreshUnresolvedMemberDeclarations().ToList();`
	`623`	`+ foreach (var declaration in unresolved)`
	`624`	`+ {`
	`625`	`+ State.AddUnresolvedMemberDeclaration(declaration);`
	`626`	`+ }`
	`627`	`+ }`
	`628`	`+`
`616`	`629`
`617`	`630`	`/// <summary>`
`618`	`631`	`/// Starts parsing all components of all unprotected VBProjects associated with the VBE-Instance passed to the constructor of this parser instance.`