revert RubberduckParserState.EvaluateParserState to a version that makes tests pass.... thing is, there's still a bug in that method..

retailcoder · retailcoder · commit 4749ed0af95c · 2016-04-11T02:10:55.000-04:00
diff --git a/RetailCoder.VBE/UI/Command/ShowParserErrorsCommand.cs b/RetailCoder.VBE/UI/Command/ShowParserErrorsCommand.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Runtime.InteropServices;
 using System.Windows.Input;
@@ -37,6 +38,11 @@ public override void Execute(object parameter)
             }
 
             var viewModel = CreateViewModel();
+            if (_viewModel == null)
+            {
+                return;
+            }
+
             _viewModel.AddTab(viewModel);
             _viewModel.SelectedTab = viewModel;
 
@@ -55,22 +61,27 @@ private SearchResultsViewModel CreateViewModel()
         {
             var errors = from error in _state.ModuleExceptions
                 let declaration = FindModuleDeclaration(error.Item1)
+                where declaration != null
                 select new SearchResultItem(declaration, error.Item2.GetNavigateCodeEventArgs(declaration), error.Item2.Message);
 
-            var viewModel = new SearchResultsViewModel(_navigateCommand, "Parser Errors", null, errors.ToList());
+            var searchResultItems = errors as IList<SearchResultItem> ?? errors.ToList();
+            var viewModel = new SearchResultsViewModel(_navigateCommand, "Parser Errors", null, searchResultItems);
             return viewModel;
         }
 
         private Declaration FindModuleDeclaration(VBComponent component)
         {
+            var projectName = component.ProjectName();
+
+            var project = _state.AllUserDeclarations.SingleOrDefault(item => 
+                item.DeclarationType == DeclarationType.Project && item.ProjectName == projectName);
 
             var result = _state.AllUserDeclarations.SingleOrDefault(item => item.ProjectName == component.Collection.Parent.ProjectName()
                                                              && item.QualifiedName.QualifiedModuleName.ComponentName == component.Name
                                                              && (item.DeclarationType == DeclarationType.Class || item.DeclarationType == DeclarationType.Module));
-            return result
-                   ?? // module isn't in parser state - give it a dummy declaration, just so the ViewModel has something to chew on:
-                   new Declaration(new QualifiedMemberName(new QualifiedModuleName(component), component.Name), null,
-                       null, component.Name, false, false, Accessibility.Global, DeclarationType.Module, false);
+
+            var declaration = new Declaration(new QualifiedMemberName(new QualifiedModuleName(component), component.Name), project, project.Scope, component.Name, false, false, Accessibility.Global, DeclarationType.Module, false);
+            return result ?? declaration; // module isn't in parser state - give it a dummy declaration, just so the ViewModel has something to chew on
         }
     }
 }
diff --git a/RetailCoder.VBE/UI/Command/SyntaxErrorExtensions.cs b/RetailCoder.VBE/UI/Command/SyntaxErrorExtensions.cs
@@ -7,6 +7,8 @@ public static class SyntaxErrorExtensions
     {
         public static NavigateCodeEventArgs GetNavigateCodeEventArgs(this SyntaxErrorException exception, Declaration declaration)
         {
+            if (declaration == null) return null;
+
             var selection = new Selection(exception.LineNumber, exception.Position, exception.LineNumber, exception.Position);
             return new NavigateCodeEventArgs(declaration.QualifiedName.QualifiedModuleName, selection);
         }
diff --git a/RetailCoder.VBE/UnitTesting/NewUnitTestModuleCommand.cs b/RetailCoder.VBE/UnitTesting/NewUnitTestModuleCommand.cs
@@ -51,7 +51,7 @@ public static void NewUnitTestModule(VBE vbe)
                     hasOptionExplicit = module.CodeModule.Lines[1, module.CodeModule.CountOfDeclarationLines].Contains("Option Explicit");
                 }
 
-                var options = String.Concat(hasOptionExplicit ? String.Empty : "Option Explicit\n", "Option Private Module\n\n");
+                var options = string.Concat(hasOptionExplicit ? string.Empty : "Option Explicit\n", "Option Private Module\n\n");
 
                 module.CodeModule.AddFromString(options + TestModuleEmptyTemplate);
                 module.Activate();
@@ -67,7 +67,7 @@ private static string GetNextTestModuleName(VBProject project)
             var names = project.ComponentNames();
             var index = names.Count(n => n.StartsWith(TestModuleBaseName)) + 1;
 
-            return String.Concat(TestModuleBaseName, index);
+            return string.Concat(TestModuleBaseName, index);
         }
     }
 }
diff --git a/Rubberduck.Parsing/VBA/ParserState.cs b/Rubberduck.Parsing/VBA/ParserState.cs
@@ -1,38 +1,39 @@
 namespace Rubberduck.Parsing.VBA
 {
+    //note: ordering of the members is important
     public enum ParserState
     {
         /// <summary>
         /// Parse was requested but hasn't started yet.
         /// </summary>
-        Pending = 0,
+        Pending,
         /// <summary>
         /// Project references are being loaded into parser state.
         /// </summary>
-        LoadingReference = 1,
+        LoadingReference,
         /// <summary>
         /// Code from modified modules is being parsed.
         /// </summary>
-        Parsing = 2,
+        Parsing,
         /// <summary>
         /// Parse tree is waiting to be walked for identifier resolution.
         /// </summary>
-        Parsed = 3,
+        Parsed,
         /// <summary>
         /// Resolving identifier references.
         /// </summary>
-        Resolving = 4,
+        Resolving,
         /// <summary>
         /// Parser state is in sync with the actual code in the VBE.
         /// </summary>
-        Ready = 5,
+        Ready,
         /// <summary>
         /// Parsing could not be completed for one or more modules.
         /// </summary>
-        Error = 99,
+        Error,
         /// <summary>
         /// Parsing completed, but identifier references could not be resolved for one or more modules.
         /// </summary>
-        ResolverError = 6,
+        ResolverError,
     }
 }
diff --git a/Rubberduck.Parsing/VBA/RubberduckParser.cs b/Rubberduck.Parsing/VBA/RubberduckParser.cs
@@ -274,13 +274,13 @@ private void ResolveInternal(CancellationToken token)
             foreach (var kvp in _state.ParseTrees)
             {
                 if (token.IsCancellationRequested) return;
-                ResolveDeclarations(kvp.Key, kvp.Value);
+                ResolveDeclarations(kvp.Key.Component, kvp.Value);
             }
             var finder = new DeclarationFinder(_state.AllDeclarations, _state.AllComments);
             foreach (var kvp in _state.ParseTrees)
             {
                 if (token.IsCancellationRequested) return;
-                ResolveReferences(finder, kvp.Key, kvp.Value);
+                ResolveReferences(finder, kvp.Key.Component, kvp.Value);
             }
         }
 
diff --git a/Rubberduck.Parsing/VBA/RubberduckParserState.cs b/Rubberduck.Parsing/VBA/RubberduckParserState.cs
@@ -50,23 +50,23 @@ public sealed class RubberduckParserState
         private readonly ConcurrentDictionary<QualifiedModuleName, ConcurrentDictionary<Declaration, byte>> _declarations =
             new ConcurrentDictionary<QualifiedModuleName, ConcurrentDictionary<Declaration, byte>>();
 
-        private readonly ConcurrentDictionary<VBComponent, ITokenStream> _tokenStreams =
-            new ConcurrentDictionary<VBComponent, ITokenStream>();
+        private readonly ConcurrentDictionary<QualifiedModuleName, ITokenStream> _tokenStreams =
+            new ConcurrentDictionary<QualifiedModuleName, ITokenStream>();
 
-        private readonly ConcurrentDictionary<VBComponent, IParseTree> _parseTrees =
-            new ConcurrentDictionary<VBComponent, IParseTree>();
+        private readonly ConcurrentDictionary<QualifiedModuleName, IParseTree> _parseTrees =
+            new ConcurrentDictionary<QualifiedModuleName, IParseTree>();
 
-        private readonly ConcurrentDictionary<VBComponent, ParserState> _moduleStates =
-            new ConcurrentDictionary<VBComponent, ParserState>();
+        private readonly ConcurrentDictionary<QualifiedModuleName, ParserState> _moduleStates =
+            new ConcurrentDictionary<QualifiedModuleName, ParserState>();
 
-        private readonly ConcurrentDictionary<VBComponent, IList<CommentNode>> _comments =
-            new ConcurrentDictionary<VBComponent, IList<CommentNode>>();
+        private readonly ConcurrentDictionary<QualifiedModuleName, IList<CommentNode>> _comments =
+            new ConcurrentDictionary<QualifiedModuleName, IList<CommentNode>>();
 
-        private readonly ConcurrentDictionary<VBComponent, SyntaxErrorException> _moduleExceptions =
-            new ConcurrentDictionary<VBComponent, SyntaxErrorException>();
+        private readonly ConcurrentDictionary<QualifiedModuleName, SyntaxErrorException> _moduleExceptions =
+            new ConcurrentDictionary<QualifiedModuleName, SyntaxErrorException>();
 
-        private readonly ConcurrentDictionary<VBComponent, IDictionary<Tuple<string, DeclarationType>, Attributes>> _moduleAttributes =
-            new ConcurrentDictionary<VBComponent, IDictionary<Tuple<string, DeclarationType>, Attributes>>();
+        private readonly ConcurrentDictionary<QualifiedModuleName, IDictionary<Tuple<string, DeclarationType>, Attributes>> _moduleAttributes =
+            new ConcurrentDictionary<QualifiedModuleName, IDictionary<Tuple<string, DeclarationType>, Attributes>>();
 
         public void AddProject(VBProject project)
         {
@@ -90,7 +90,7 @@ public void RemoveProject(VBProject project)
 
         public IReadOnlyList<Tuple<VBComponent, SyntaxErrorException>> ModuleExceptions
         {
-            get { return _moduleExceptions.Select(kvp => Tuple.Create(kvp.Key, kvp.Value)).Where(item => item.Item2 != null).ToList(); }
+            get { return _moduleExceptions.Select(kvp => Tuple.Create(kvp.Key.Component, kvp.Value)).Where(item => item.Item2 != null).ToList(); }
         }
 
         public event EventHandler<ParserStateEventArgs> StateChanged;
@@ -117,70 +117,45 @@ private void OnModuleStateChanged(VBComponent component, ParserState state)
 
         public void SetModuleState(VBComponent component, ParserState state, SyntaxErrorException parserError = null)
         {
-            _moduleStates.AddOrUpdate(component, state, (c, s) => state);
-            _moduleExceptions.AddOrUpdate(component, parserError, (c, e) => parserError);
+            if (AllUserDeclarations.Any())
+            {
+                var projectName = component.ProjectName();
+                var project = AllUserDeclarations.SingleOrDefault(item =>
+                    item.DeclarationType == DeclarationType.Project && item.ProjectName == projectName);
+
+                if (project == null)
+                {
+                    // ghost component shouldn't even exist
+                    ClearDeclarations(component);
+                    return;
+                }
+            }
+            var key = new QualifiedModuleName(component);
+            _moduleStates.AddOrUpdate(key, state, (c, s) => state);
+            _moduleExceptions.AddOrUpdate(key, parserError, (c, e) => parserError);
 
-            Debug.WriteLine("Module '{0}' state is changing to '{1}' (thread {2})", component.Name, state, Thread.CurrentThread.ManagedThreadId);
+            Debug.WriteLine("Module '{0}' state is changing to '{1}' (thread {2})", key.ComponentName, state, Thread.CurrentThread.ManagedThreadId);
             OnModuleStateChanged(component, state);
 
             Status = EvaluateParserState();
         }
 
-        private static readonly ParserState[] States = Enum.GetValues(typeof(ParserState)).Cast<ParserState>().ToArray();
+        //private static readonly ParserState[] States = Enum.GetValues(typeof(ParserState)).Cast<ParserState>().ToArray();
         private ParserState EvaluateParserState()
         {
             var moduleStates = _moduleStates.Values.ToList();
 
             var prelim = moduleStates.Max();
             if (prelim == ParserState.Parsed && moduleStates.Any(s => s != ParserState.Parsed))
             {
-                prelim = moduleStates.Where(s => s < ParserState.Parsed).Max();
+                prelim = moduleStates.Where(s => s != ParserState.Parsed).Max();
             }
             return prelim;
-            //var moduleStates = _moduleStates.Values.ToList();
-
-            //var state = States.SingleOrDefault(value => moduleStates.All(ps => ps == value));
-            //if (state != default(ParserState))
-            //{
-            //    // if all modules are in the same state, we have our result.
-            //    Debug.WriteLine("ParserState evaluates to '{0}' (thread {1})", state, Thread.CurrentThread.ManagedThreadId);
-            //    return state;
-            //}
-
-            //// error state takes precedence over every other state
-            //if (moduleStates.Any(ms => ms == ParserState.Error))
-            //{
-            //    Debug.WriteLine("ParserState evaluates to '{0}' (thread {1})", ParserState.Error, Thread.CurrentThread.ManagedThreadId);
-            //    return ParserState.Error;
-            //}
-            //if (moduleStates.Any(ms => ms == ParserState.ResolverError))
-            //{
-            //    Debug.WriteLine("ParserState evaluates to '{0}' (thread {1})", ParserState.ResolverError, Thread.CurrentThread.ManagedThreadId);
-            //    return ParserState.ResolverError;
-            //}
-
-            //// "working" states are toggled when *any* module has them.
-            //var result = moduleStates.Min();
-            //if (moduleStates.Any(ms => ms == ParserState.LoadingReference))
-            //{
-            //    result = ParserState.LoadingReference;
-            //}
-            //if (moduleStates.Any(ms => ms == ParserState.Parsing))
-            //{
-            //    result = ParserState.Parsing;
-            //}
-            //if (moduleStates.Any(ms => ms == ParserState.Resolving))
-            //{
-            //    result = ParserState.Resolving;
-            //}
-
-            //// otherwise, return the 
-            //Debug.WriteLine("ParserState evaluates to '{0}' (thread {1})", result, Thread.CurrentThread.ManagedThreadId);
-            //return result;
         }
+
         public ParserState GetModuleState(VBComponent component)
         {
-            return _moduleStates.GetOrAdd(component, ParserState.Pending);
+            return _moduleStates.GetOrAdd(new QualifiedModuleName(component), ParserState.Pending);
         }
 
         private ParserState _status;
@@ -222,7 +197,7 @@ public IEnumerable<QualifiedContext> ObsoleteLetContexts
 
         internal void SetModuleAttributes(VBComponent component, IDictionary<Tuple<string, DeclarationType>, Attributes> attributes)
         {
-            _moduleAttributes.AddOrUpdate(component, attributes, (c, s) => attributes);
+            _moduleAttributes.AddOrUpdate(new QualifiedModuleName(component), attributes, (c, s) => attributes);
         }
 
         private IEnumerable<QualifiedContext> _emptyStringLiterals = new List<QualifiedContext>();
@@ -254,7 +229,7 @@ public IEnumerable<CommentNode> AllComments
         public IEnumerable<CommentNode> GetModuleComments(VBComponent component)
         {
             IList<CommentNode> result;
-            if (_comments.TryGetValue(component, out result))
+            if (_comments.TryGetValue(new QualifiedModuleName(component), out result))
             {
                 return result;
             }
@@ -264,7 +239,7 @@ public IEnumerable<CommentNode> GetModuleComments(VBComponent component)
 
         public void SetModuleComments(VBComponent component, IEnumerable<CommentNode> comments)
         {
-            _comments[component] = comments.ToList();
+            _comments[new QualifiedModuleName(component)] = comments.ToList();
         }
 
         /// <summary>
@@ -294,7 +269,7 @@ public IReadOnlyList<Declaration> AllUserDeclarations
 
         internal IDictionary<Tuple<string, DeclarationType>, Attributes> getModuleAttributes(VBComponent vbComponent)
         {
-            return _moduleAttributes[vbComponent];
+            return _moduleAttributes[new QualifiedModuleName(vbComponent)];
         }
 
         /// <summary>
@@ -359,19 +334,19 @@ public bool ClearDeclarations(VBComponent component)
                 declarationsRemoved = declarations == null ? 0 : declarations.Count;
 
                 IParseTree tree;
-                success = success && (!_parseTrees.ContainsKey(key.Component) || _parseTrees.TryRemove(key.Component, out tree));
+                success = success && (!_parseTrees.ContainsKey(key) || _parseTrees.TryRemove(key, out tree));
 
                 ITokenStream stream;
-                success = success && (!_tokenStreams.ContainsKey(key.Component) || _tokenStreams.TryRemove(key.Component, out stream));
+                success = success && (!_tokenStreams.ContainsKey(key) || _tokenStreams.TryRemove(key, out stream));
 
                 ParserState state;
-                success = success && (!_moduleStates.ContainsKey(key.Component) || _moduleStates.TryRemove(key.Component, out state));
+                success = success && (!_moduleStates.ContainsKey(key) || _moduleStates.TryRemove(key, out state));
 
                 SyntaxErrorException exception;
-                success = success && (!_moduleExceptions.ContainsKey(key.Component) || _moduleExceptions.TryRemove(key.Component, out exception));
+                success = success && (!_moduleExceptions.ContainsKey(key) || _moduleExceptions.TryRemove(key, out exception));
 
                 IList<CommentNode> nodes;
-                success = success && (!_comments.ContainsKey(key.Component) || _comments.TryRemove(key.Component, out nodes));
+                success = success && (!_comments.ContainsKey(key) || _comments.TryRemove(key, out nodes));
             }
 
             Debug.WriteLine("ClearDeclarations({0}): {1} - {2} declarations removed", component.Name, success ? "succeeded" : "failed", declarationsRemoved);
@@ -380,24 +355,24 @@ public bool ClearDeclarations(VBComponent component)
 
         public void AddTokenStream(VBComponent component, ITokenStream stream)
         {
-            _tokenStreams[component] = stream;
+            _tokenStreams[new QualifiedModuleName(component)] = stream;
         }
 
         public void AddParseTree(VBComponent component, IParseTree parseTree)
         {
-            _parseTrees[component] = parseTree;
+            _parseTrees[new QualifiedModuleName(component)] = parseTree;
         }
 
         public IParseTree GetParseTree(VBComponent component)
         {
-            return _parseTrees[component];
+            return _parseTrees[new QualifiedModuleName(component)];
         }
 
-        public IEnumerable<KeyValuePair<VBComponent, IParseTree>> ParseTrees { get { return _parseTrees; } }
+        public IEnumerable<KeyValuePair<QualifiedModuleName, IParseTree>> ParseTrees { get { return _parseTrees; } }
 
         public TokenStreamRewriter GetRewriter(VBComponent component)
         {
-            return new TokenStreamRewriter(_tokenStreams[component]);
+            return new TokenStreamRewriter(_tokenStreams[new QualifiedModuleName(component)]);
         }
 
         /// <summary>
diff --git a/Rubberduck.VBEEditor/Extensions/VbProjectExtensions.cs b/Rubberduck.VBEEditor/Extensions/VbProjectExtensions.cs
diff --git a/Rubberduck.VBEEditor/QualifiedModuleName.cs b/Rubberduck.VBEEditor/QualifiedModuleName.cs
diff --git a/RubberduckTests/Grammar/VBAParserTests.cs b/RubberduckTests/Grammar/VBAParserTests.cs

Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,8 @@ public static class SyntaxErrorExtensions`
`7`	`7`	`{`
`8`	`8`	`public static NavigateCodeEventArgs GetNavigateCodeEventArgs(this SyntaxErrorException exception, Declaration declaration)`
`9`	`9`	`{`
	`10`	`+ if (declaration == null) return null;`
	`11`	`+`
`10`	`12`	`var selection = new Selection(exception.LineNumber, exception.Position, exception.LineNumber, exception.Position);`
`11`	`13`	`return new NavigateCodeEventArgs(declaration.QualifiedName.QualifiedModuleName, selection);`
`12`	`14`	`}`
Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ public static void NewUnitTestModule(VBE vbe)`
`51`	`51`	`hasOptionExplicit = module.CodeModule.Lines[1, module.CodeModule.CountOfDeclarationLines].Contains("Option Explicit");`
`52`	`52`	`}`
`53`	`53`
`54`		`- var options = String.Concat(hasOptionExplicit ? String.Empty : "Option Explicit\n", "Option Private Module\n\n");`
	`54`	`+ var options = string.Concat(hasOptionExplicit ? string.Empty : "Option Explicit\n", "Option Private Module\n\n");`
`55`	`55`
`56`	`56`	`module.CodeModule.AddFromString(options + TestModuleEmptyTemplate);`
`57`	`57`	`module.Activate();`
`@@ -67,7 +67,7 @@ private static string GetNextTestModuleName(VBProject project)`
`67`	`67`	`var names = project.ComponentNames();`
`68`	`68`	`var index = names.Count(n => n.StartsWith(TestModuleBaseName)) + 1;`
`69`	`69`
`70`		`- return String.Concat(TestModuleBaseName, index);`
	`70`	`+ return string.Concat(TestModuleBaseName, index);`
`71`	`71`	`}`
`72`	`72`	`}`
`73`	`73`	`}`
Original file line number	Diff line number	Diff line change
`@@ -274,13 +274,13 @@ private void ResolveInternal(CancellationToken token)`
`274`	`274`	`foreach (var kvp in _state.ParseTrees)`
`275`	`275`	`{`
`276`	`276`	`if (token.IsCancellationRequested) return;`
`277`		`- ResolveDeclarations(kvp.Key, kvp.Value);`
	`277`	`+ ResolveDeclarations(kvp.Key.Component, kvp.Value);`
`278`	`278`	`}`
`279`	`279`	`var finder = new DeclarationFinder(_state.AllDeclarations, _state.AllComments);`
`280`	`280`	`foreach (var kvp in _state.ParseTrees)`
`281`	`281`	`{`
`282`	`282`	`if (token.IsCancellationRequested) return;`
`283`		`- ResolveReferences(finder, kvp.Key, kvp.Value);`
	`283`	`+ ResolveReferences(finder, kvp.Key.Component, kvp.Value);`
`284`	`284`	`}`
`285`	`285`	`}`
`286`	`286`