Wire up open code pane state recovery in the attributes rewriter

This should reopen the the code panes we close because we export and reimport on an attributes rewrite.

Author: MDoerner

Rubberduck.Parsing/Rewriter/AttributesRewriteSession.cs

@@ -55,12 +55,15 @@ private void ReparseOnSuspension(object requestor, ParserStateEventArgs e)
 
         private void ExecuteAllRewriters()
         {
+            //Attribute rewrites close the affected code panes, so we have to recover the open state. 
+            SelectionRecoverer.SaveOpenState(CheckedOutModuleRewriters.Keys);
             foreach (var module in CheckedOutModuleRewriters.Keys)
             {
                 //We have to mark the modules explicitly as modified because attributes only changes do not alter the code pane code.
                 _parseManager.MarkAsModified(module);
                 CheckedOutModuleRewriters[module].Rewrite();
             }
+            SelectionRecoverer.RecoverOpenState();
         }
     }
 }

Rubberduck.Parsing/Rewriter/RewriteSessionBase.cs

@@ -14,7 +14,7 @@ public abstract class RewriteSessionBase : IRewriteSession
         protected readonly IDictionary<QualifiedModuleName, IExecutableModuleRewriter> CheckedOutModuleRewriters = new Dictionary<QualifiedModuleName, IExecutableModuleRewriter>();
         protected readonly IRewriterProvider RewriterProvider;
 
-        private readonly ISelectionRecoverer _selectionRecoverer;
+        protected readonly ISelectionRecoverer SelectionRecoverer;
         private readonly Func<IRewriteSession, bool> _rewritingAllowed;
 
         protected readonly Logger Logger = LogManager.GetCurrentClassLogger();
@@ -26,7 +26,7 @@ protected RewriteSessionBase(IRewriterProvider rewriterProvider, ISelectionRecov
         {
             RewriterProvider = rewriterProvider;
             _rewritingAllowed = rewritingAllowed;
-            _selectionRecoverer = selectionRecoverer;
+            SelectionRecoverer = selectionRecoverer;
         }
 
         public IReadOnlyCollection<QualifiedModuleName> CheckedOutModules => CheckedOutModuleRewriters.Keys.ToHashSet();
@@ -104,27 +104,27 @@ public bool TryRewrite()
 
         private void PrimeSelectionRecovery()
         {
-            _selectionRecoverer.SaveSelections(CheckedOutModuleRewriters.Keys);
+            SelectionRecoverer.SaveSelections(CheckedOutModuleRewriters.Keys);
 
             foreach (var (module, rewriter) in CheckedOutModuleRewriters)
             {
                 if (rewriter.SelectionOffset.HasValue)
                 {
-                    _selectionRecoverer.AdjustSavedSelection(module, rewriter.SelectionOffset.Value);
+                    SelectionRecoverer.AdjustSavedSelection(module, rewriter.SelectionOffset.Value);
                 }
                 if (rewriter.Selection.HasValue)
                 {
-                    _selectionRecoverer.ReplaceSavedSelection(module, rewriter.Selection.Value);
+                    SelectionRecoverer.ReplaceSavedSelection(module, rewriter.Selection.Value);
                 }
             }
 
-            _selectionRecoverer.RecoverSavedSelectionsOnNextParse();
+            SelectionRecoverer.RecoverSavedSelectionsOnNextParse();
         }
 
         private void PrimeActiveCodePaneRecovery()
         {
-            _selectionRecoverer.SaveActiveCodePane();
-            _selectionRecoverer.RecoverActiveCodePaneOnNextParse();
+            SelectionRecoverer.SaveActiveCodePane();
+            SelectionRecoverer.RecoverActiveCodePaneOnNextParse();
         }
     }
 }

RubberduckTests/Rewriter/AttributesRewriteSessionTests.cs

@@ -89,6 +89,58 @@ public void TargetsAttributesCode()
             Assert.AreEqual(CodeKind.AttributesCode, rewriteSession.TargetCodeKind);
         }
 
+        [Test]
+        [Category("Rewriter")]
+        public void CallsRecoverOpenStateOnRewrite()
+        {
+            var selectionRecovererMock = new Mock<ISelectionRecoverer>();
+            selectionRecovererMock.Setup(m => m.RecoverOpenState());
+
+            var rewriteSession = RewriteSession(session => true, out var mockRewriterProvider, selectionRecoverer: selectionRecovererMock.Object);
+            var module = new QualifiedModuleName("TestProject", string.Empty, "TestModule");
+
+            rewriteSession.CheckOutModuleRewriter(module);
+            rewriteSession.TryRewrite();
+
+            selectionRecovererMock.Verify(m => m.RecoverOpenState(), Times.Once);
+        }
+
+        [Test]
+        [Category("Rewriter")]
+        public void SavesOpenStateForCheckedOutModulesOnRewrite()
+        {
+            var selectionRecovererMock = new Mock<ISelectionRecoverer>();
+            selectionRecovererMock.Setup(m => m.SaveOpenState(It.IsAny<IEnumerable<QualifiedModuleName>>()));
+
+            var rewriteSession = RewriteSession(session => true, out var mockRewriterProvider, selectionRecoverer: selectionRecovererMock.Object);
+            var module = new QualifiedModuleName("TestProject", string.Empty, "TestModule");
+            var module2 = new QualifiedModuleName("TestProject", string.Empty, "TestModule2");
+
+            rewriteSession.CheckOutModuleRewriter(module);
+            rewriteSession.CheckOutModuleRewriter(module2);
+            rewriteSession.TryRewrite();
+
+            selectionRecovererMock.Verify(m => m.SaveOpenState(It.Is<IEnumerable<QualifiedModuleName>>(modules => modules.Count() == 2 && modules.Contains(module) && modules.Contains(module2))));
+        }
+
+        [Test]
+        [Category("Rewriter")]
+        public void SavesOpenStateBeforeRestoringItOnRewrite()
+        {
+            var selectionRecovererMock = new Mock<ISelectionRecoverer>();
+            var lastOperation = string.Empty;
+            selectionRecovererMock.Setup(m => m.SaveOpenState(It.IsAny<IEnumerable<QualifiedModuleName>>())).Callback(() => lastOperation = "SaveOpenState");
+            selectionRecovererMock.Setup(m => m.RecoverOpenState()).Callback(() => lastOperation = "RecoverOpenState");
+
+            var rewriteSession = RewriteSession(session => true, out var mockRewriterProvider, selectionRecoverer: selectionRecovererMock.Object);
+            var module = new QualifiedModuleName("TestProject", string.Empty, "TestModule");
+
+            rewriteSession.CheckOutModuleRewriter(module);
+            rewriteSession.TryRewrite();
+
+            Assert.AreEqual("RecoverOpenState", lastOperation);
+        }
+
         protected override IRewriteSession RewriteSession(IParseManager parseManager, Func<IRewriteSession, bool> rewritingAllowed, out MockRewriterProvider mockProvider, bool rewritersAreDirty = false, ISelectionRecoverer selectionRecoverer = null)
         {
             if (selectionRecoverer == null)