Wire up member attribute recovery in the RewritingManager

Author: MDoerner

Rubberduck.Parsing/Rewriter/RewritingManager.cs

@@ -8,14 +8,16 @@ public class RewritingManager : IRewritingManager
     {
         private readonly HashSet<IRewriteSession> _activeCodePaneSessions = new HashSet<IRewriteSession>();
         private readonly HashSet<IRewriteSession> _activeAttributesSessions = new HashSet<IRewriteSession>();
+        private readonly IMemberAttributeRecoverer _memberAttributeRecoverer;
 
         private readonly IRewriteSessionFactory _sessionFactory;
 
         private readonly object _invalidationLockObject = new object();
 
-        public RewritingManager(IRewriteSessionFactory sessionFactory)
+        public RewritingManager(IRewriteSessionFactory sessionFactory, IMemberAttributeRecoverer memberAttributeRecoverer)
         {
             _sessionFactory = sessionFactory;
+            _memberAttributeRecoverer = memberAttributeRecoverer;
         }
 
 
@@ -51,10 +53,19 @@ private bool TryAllowExclusiveRewrite(IRewriteSession rewriteSession)
                 }
 
                 InvalidateAllSessionsInternal();
+                if (rewriteSession.TargetCodeKind == CodeKind.CodePaneCode)
+                {
+                    RequestMemberAttributeRecovery(rewriteSession);
+                }
                 return true;
             }
         }
 
+        private void RequestMemberAttributeRecovery(IRewriteSession rewriteSession)
+        {
+            _memberAttributeRecoverer.RecoverCurrentMemberAttributesAfterNextParse(rewriteSession.CheckedOutModules);
+        }
+
         private bool IsCurrentlyActive(IRewriteSession rewriteSession)
         {
             switch (rewriteSession.TargetCodeKind)

RubberduckTests/Mocks/MockParser.cs

@@ -134,7 +134,8 @@ public static (SynchronousParseCoordinator parser, IRewritingManager rewritingMa
                 attributesSourceCodeHandler);
             var rewriterProvider = new RewriterProvider(tokenStreamCache, moduleRewriterFactory);
             var rewriteSessionFactory = new RewriteSessionFactory(state, rewriterProvider);
-            var rewritingManager = new RewritingManager(rewriteSessionFactory); 
+            var stubMembersAttributeRecoverer = new Mock<IMemberAttributeRecoverer>().Object;
+            var rewritingManager = new RewritingManager(rewriteSessionFactory, stubMembersAttributeRecoverer); 
 
             var parser = new SynchronousParseCoordinator(
                 state,

RubberduckTests/Rewriter/RewriteManagerTests.cs

@@ -5,6 +5,7 @@
 using NUnit.Framework;
 using Rubberduck.Parsing.Rewriter;
 using Rubberduck.Parsing.VBA.Parsing;
+using Rubberduck.VBEditor;
 
 namespace RubberduckTests.Rewriter
 {
@@ -177,10 +178,47 @@ public void CallingTheRewritingAllowedCallbackFromANoLongerActiveAttributesSessi
             }
         }
 
-        private IRewritingManager RewritingManager(out MockRewriteSessionFactory mockFactory)
+        [Test]
+        [Category("Rewriter")]
+        public void CallingTheRewritingAllowedCallbackFromAnActiveCodePaneSessionRequestMemberAttributeRecoveryForTheCheckedOutModules()
+        {
+            var memberAttributeRecovererMock = new Mock<IMemberAttributeRecoverer>();
+            memberAttributeRecovererMock.Setup(m => m.RecoverCurrentMemberAttributesAfterNextParse(It.IsAny<IEnumerable<QualifiedModuleName>>()));
+
+            var rewritingManager = RewritingManager(out var mockFactory, memberAttributeRecovererMock.Object);
+            var codePaneSession = rewritingManager.CheckOutCodePaneSession();
+
+            var moduleToCheckOutRewriterFor = new QualifiedModuleName("project", "path", "module");
+            codePaneSession.CheckOutModuleRewriter(moduleToCheckOutRewriterFor);
+
+            codePaneSession.TryRewrite();
+
+            memberAttributeRecovererMock.Verify(m => m.RecoverCurrentMemberAttributesAfterNextParse(new HashSet<QualifiedModuleName>{ moduleToCheckOutRewriterFor }), Times.Once);
+        }
+
+        [Test]
+        [Category("Rewriter")]
+        public void CallingTheRewritingAllowedCallbackFromAnActiveAttributesSessionDoesNotRequestMemberAttributeRecovery()
         {
+            var memberAttributeRecovererMock = new Mock<IMemberAttributeRecoverer>();
+            memberAttributeRecovererMock.Setup(m => m.RecoverCurrentMemberAttributesAfterNextParse(It.IsAny<IEnumerable<QualifiedModuleName>>()));
+
+            var rewritingManager = RewritingManager(out var mockFactory, memberAttributeRecovererMock.Object);
+            var codePaneSession = rewritingManager.CheckOutAttributesSession();
+
+            var moduleToCheckOutRewriterFor = new QualifiedModuleName("project", "path", "module");
+            codePaneSession.CheckOutModuleRewriter(moduleToCheckOutRewriterFor);
+
+            codePaneSession.TryRewrite();
+
+            memberAttributeRecovererMock.Verify(m => m.RecoverCurrentMemberAttributesAfterNextParse(It.IsAny<IEnumerable<QualifiedModuleName>>()), Times.Never);
+        }
+
+        private IRewritingManager RewritingManager(out MockRewriteSessionFactory mockFactory, IMemberAttributeRecoverer memberAttributeRecoverer = null)
+        {
+            var recoverer = memberAttributeRecoverer ?? new Mock<IMemberAttributeRecoverer>().Object;
             mockFactory = new MockRewriteSessionFactory();
-            return new RewritingManager(mockFactory);
+            return new RewritingManager(mockFactory, recoverer);
         }
     }
 
@@ -215,6 +253,12 @@ private Mock<IRewriteSession> MockSession(Func<IRewriteSession, bool> rewritingA
             mockSession.Setup(m => m.Invalidate()).Callback(() => isInvalidated = true);
             mockSession.Setup(m => m.TargetCodeKind).Returns(targetCodeKind);
 
+            var checkedOutModules = new HashSet<QualifiedModuleName>();
+            mockSession.Setup(m => m.CheckOutModuleRewriter(It.IsAny<QualifiedModuleName>()))
+                .Returns( (QualifiedModuleName module) => null)
+                .Callback((QualifiedModuleName module) => checkedOutModules.Add(module));
+            mockSession.Setup(m => m.CheckedOutModules).Returns(() => checkedOutModules);
+
             return mockSession;
         }