fixed parser/state glitch; fine-tuned extract/implement interface refactorings

Author: retailcoder

RetailCoder.VBE/Refactorings/ExtractInterface/ExtractInterfaceRefactoring.cs

@@ -62,7 +62,7 @@ private void AddInterface()
             var interfaceComponent = _model.TargetDeclaration.Project.VBComponents.Add(vbext_ComponentType.vbext_ct_ClassModule);
             interfaceComponent.Name = _model.InterfaceName;
 
-            _editor.InsertLines(1, Tokens.Option + ' ' + Tokens.Explicit + Environment.NewLine + Environment.NewLine);
+            _editor.InsertLines(1, Tokens.Option + ' ' + Tokens.Explicit + Environment.NewLine);
             _editor.InsertLines(3, GetInterfaceModuleBody());
 
             var module = _model.TargetDeclaration.QualifiedSelection.QualifiedName.Component.CodeModule;

RetailCoder.VBE/Refactorings/ImplementInterface/ImplementInterfaceRefactoring.cs

@@ -87,7 +87,7 @@ private void AddItems(List<Declaration> members)
 
             foreach (var member in members)
             {
-                module.InsertLines(module.CountOfDeclarationLines + 1, GetInterfaceMember(member));
+                module.InsertLines(module.CountOfDeclarationLines + 2, GetInterfaceMember(member));
             }
         }
 

Rubberduck.Parsing/VBA/RubberduckParserState.cs

@@ -16,6 +16,18 @@ public enum ResolutionState
         Unresolved
     }
 
+    public class ParserStateEventArgs : EventArgs
+    {
+        private readonly ParserState _state;
+
+        public ParserStateEventArgs(ParserState state)
+        {
+            _state = state;
+        }
+
+        public ParserState State { get {return _state; } }
+    }
+
     public sealed class RubberduckParserState
     {
         public event EventHandler ParseRequest;
@@ -30,14 +42,14 @@ public sealed class RubberduckParserState
         private readonly ConcurrentDictionary<VBComponent, IParseTree> _parseTrees =
             new ConcurrentDictionary<VBComponent, IParseTree>();
 
-        public event EventHandler StateChanged;
+        public event EventHandler<ParserStateEventArgs> StateChanged;
 
-        private void OnStateChanged()
+        private void OnStateChanged(ParserState state)
         {
             var handler = StateChanged;
             if (handler != null)
             {
-                handler.Invoke(this, EventArgs.Empty);
+                handler.Invoke(this, new ParserStateEventArgs(state));
             }
         }
 
@@ -56,16 +68,41 @@ public void SetModuleState(VBComponent component, ParserState state, SyntaxError
             // prevent multiple threads from changing state simultaneously:
             lock(_lock)
             {
-                Status = _moduleStates.Values.Any(value => value == ParserState.Error)
-                    ? ParserState.Error
-                    : _moduleStates.Values.Any(value => value == ParserState.Parsing)
-                        ? ParserState.Parsing
-                        : _moduleStates.Values.Any(value => value == ParserState.Resolving)
-                            ? ParserState.Resolving
-                            : ParserState.Ready;
+                Status = EvaluateParserState();
+
             }
         }
 
+        private ParserState EvaluateParserState()
+        {
+            var moduleStates = _moduleStates.Values.ToList();
+            var state = Enum.GetValues(typeof (ParserState)).Cast<ParserState>()
+                .SingleOrDefault(value => moduleStates.All(ps => ps == value));
+
+            if (state != default(ParserState))
+            {
+                // if all modules are in the same state, we have our result.
+                return state;
+            }
+
+            // intermediate states are toggled when *any* module has them.
+            if (moduleStates.Any(ms => ms == ParserState.Error))
+            {
+                // error state takes precedence over every other state
+                return ParserState.Error;
+            }
+            if (moduleStates.Any(ms => ms == ParserState.Parsing || ms == ParserState.Parsed))
+            {
+                return ParserState.Parsing;
+            }
+            if (moduleStates.Any(ms => ms == ParserState.Resolving))
+            {
+                return ParserState.Resolving;
+            }
+
+            return ParserState.Pending;
+        }
+
         public ParserState GetModuleState(VBComponent component)
         {
             return _moduleStates[component];
@@ -80,7 +117,7 @@ private set
                 if (_status != value)
                 {
                     _status = value; 
-                    OnStateChanged();
+                    OnStateChanged(value);
                 }
             } 
         }
@@ -125,7 +162,7 @@ public IEnumerable<CommentNode> Comments
         {
             get
             {
-                return _comments.Values.SelectMany(comments => comments);
+                return _comments.Values.SelectMany(comments => comments.ToList());
             }
         }