Merge pull request #2764 from MDoerner/SelectiveReferenceResolvingPart1

Selective reference resolving part1

Author: retailcoder

Rubberduck.Parsing/Symbols/Declaration.cs

@@ -616,5 +616,12 @@ public void ClearReferences()
         {
             _references = new ConcurrentBag<IdentifierReference>();
         }
+
+        public void RemoveReferencesFrom(ICollection<QualifiedModuleName> modulesByWhichToRemoveReferences)
+        {
+            //This gets replaced with a new ConcurrentBag because one cannot remove specific items from a ConcurrentBag.
+            //Moreover, changing to a ConcurrentDictionary<IdentifierReference,byte> breaks all sorts of tests, for some obscure reason. 
+            var newReferences = new ConcurrentBag<IdentifierReference>(_references.Where(reference => !modulesByWhichToRemoveReferences.Contains(reference.QualifiedModuleName)));
+        }
     }
 }

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,9 @@ 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 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 +55,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 +91,10 @@ 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>>());
+            _newUnresolved = new ConcurrentBag<UnboundMemberDeclaration>(new List<UnboundMemberDeclaration>());
+            _unresolved = unresolvedMemberDeclarations.ToList();
+            
             _annotationService = new AnnotationService(this);
 
             var implementsInstructions = UserDeclarations(DeclarationType.ClassModule).SelectMany(cls => 
@@ -134,9 +137,9 @@ public DeclarationFinder(IReadOnlyList<Declaration> declarations, IEnumerable<IA
                 implementableMembers.ToDictionary(item => item.Context, item => item.Members)), true);
         }
 
-        public IEnumerable<Declaration> Undeclared
+        public IEnumerable<Declaration> FreshUndeclared
         {
-            get { return _undeclared.AllValues(); }
+            get { return _newUndeclared.AllValues(); }
         }
 
         public IEnumerable<Declaration> Members(Declaration module)
@@ -209,14 +212,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 +518,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 +535,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 +558,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 +569,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;
         }
 

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;