Change Rewrite to TryRewrite

MDoerner · MDoerner · commit 4494b8d431af · 2018-11-07T23:15:59.000+01:00
This change on the IRewriteSession allows the user to see whether the rewrite actually happened successfully.
diff --git a/Rubberduck.CodeAnalysis/QuickFixes/QuickFixProvider.cs b/Rubberduck.CodeAnalysis/QuickFixes/QuickFixProvider.cs
@@ -78,7 +78,7 @@ public void Fix(IQuickFix fix, IInspectionResult result)
 
             var rewriteSession = RewriteSession(fix.TargetCodeKind);
             fix.Fix(result, rewriteSession);
-            rewriteSession.Rewrite();
+            rewriteSession.TryRewrite();
         }
 
         private IRewriteSession RewriteSession(CodeKind targetCodeKind)
@@ -115,7 +115,7 @@ public void FixInProcedure(IQuickFix fix, QualifiedMemberName? qualifiedMember,
 
                 fix.Fix(result, rewriteSession);
             }
-            rewriteSession.Rewrite();
+            rewriteSession.TryRewrite();
         }
 
         public void FixInModule(IQuickFix fix, QualifiedSelection selection, Type inspectionType, IEnumerable<IInspectionResult> results)
@@ -137,7 +137,7 @@ public void FixInModule(IQuickFix fix, QualifiedSelection selection, Type inspec
 
                 fix.Fix(result, rewriteSession);
             }
-            rewriteSession.Rewrite();
+            rewriteSession.TryRewrite();
         }
 
         public void FixInProject(IQuickFix fix, QualifiedSelection selection, Type inspectionType, IEnumerable<IInspectionResult> results)
@@ -159,7 +159,7 @@ public void FixInProject(IQuickFix fix, QualifiedSelection selection, Type inspe
 
                 fix.Fix(result, rewriteSession);
             }
-            rewriteSession.Rewrite();
+            rewriteSession.TryRewrite();
         }
 
         public void FixAll(IQuickFix fix, Type inspectionType, IEnumerable<IInspectionResult> results)
@@ -181,7 +181,7 @@ public void FixAll(IQuickFix fix, Type inspectionType, IEnumerable<IInspectionRe
 
                 fix.Fix(result, rewriteSession);
             }
-            rewriteSession.Rewrite();
+            rewriteSession.TryRewrite();
         }
 
         public bool HasQuickFixes(IInspectionResult inspectionResult)
diff --git a/Rubberduck.Parsing/Rewriter/AttributesRewriteSession.cs b/Rubberduck.Parsing/Rewriter/AttributesRewriteSession.cs
@@ -23,14 +23,17 @@ protected override IExecutableModuleRewriter ModuleRewriter(QualifiedModuleName
             return RewriterProvider.AttributesModuleRewriter(module);
         }
 
-        protected override void RewriteInternal()
+        protected override bool TryRewriteInternal()
         {
             //The suspension ensures that only one parse gets executed instead of two for each rewritten module.
             var result = _parseManager.OnSuspendParser(this, new[] {ParserState.Ready}, ExecuteAllRewriters);
             if(result != SuspensionResult.Completed)
             {
                 Logger.Warn($"Rewriting attribute modules did not succeed. suspension result = {result}");
+                return false;
             }
+
+            return true;
         }
 
         private void ExecuteAllRewriters()
diff --git a/Rubberduck.Parsing/Rewriter/CodePaneRewriteSession.cs b/Rubberduck.Parsing/Rewriter/CodePaneRewriteSession.cs
@@ -23,13 +23,15 @@ protected override IExecutableModuleRewriter ModuleRewriter(QualifiedModuleName
             return RewriterProvider.CodePaneModuleRewriter(module);
         }
 
-        protected override void RewriteInternal()
+        protected override bool TryRewriteInternal()
         {
             foreach (var rewriter in CheckedOutModuleRewriters.Values)
             {
                 rewriter.Rewrite();
             }
             _parseManager.OnParseRequested(this);
+
+            return true;
         }
     }
 }
diff --git a/Rubberduck.Parsing/Rewriter/IRewriteSession.cs b/Rubberduck.Parsing/Rewriter/IRewriteSession.cs
@@ -6,7 +6,7 @@ namespace Rubberduck.Parsing.Rewriter
     public interface IRewriteSession
     {
         IModuleRewriter CheckOutModuleRewriter(QualifiedModuleName module);
-        void Rewrite();
+        bool TryRewrite();
         bool IsInvalidated { get; }
         void Invalidate();
         CodeKind TargetCodeKind { get; }
diff --git a/Rubberduck.Parsing/Rewriter/RewriteSessionBase.cs b/Rubberduck.Parsing/Rewriter/RewriteSessionBase.cs
@@ -40,32 +40,32 @@ public IModuleRewriter CheckOutModuleRewriter(QualifiedModuleName module)
 
         protected abstract IExecutableModuleRewriter ModuleRewriter(QualifiedModuleName module);
 
-        public void Rewrite()
+        public bool TryRewrite()
         {
             if (!CheckedOutModuleRewriters.Any())
             {
-                return;
+                return false;
             }
 
             lock (_invalidationLockObject)
             {
                 if (_isInvalidated)
                 {
                     Logger.Warn("Tried to execute Rewrite on a RewriteSession that was already invalidated.");
-                    return;
+                    return false;
                 }
             }
 
             if (!_rewritingAllowed(this))
             {
-                Logger.Warn("Tried to execute Rewrite on a RewriteSession when rewriting was no longer allowed.");
-                return;
+                Logger.Debug("Tried to execute Rewrite on a RewriteSession when rewriting was no longer allowed.");
+                return false;
             }
 
-            RewriteInternal();
+            return TryRewriteInternal();
         }
 
-        protected abstract void RewriteInternal();
+        protected abstract bool TryRewriteInternal();
 
         private bool _isInvalidated = false;
         public bool IsInvalidated
diff --git a/Rubberduck.Refactorings/EncapsulateField/EncapsulateFieldRefactoring.cs b/Rubberduck.Refactorings/EncapsulateField/EncapsulateFieldRefactoring.cs
@@ -41,7 +41,7 @@ public void Refactor()
 
             var rewriteSession = _rewritingManager.CheckOutCodePaneSession();
             AddProperty(rewriteSession);
-            rewriteSession.Rewrite();
+            rewriteSession.TryRewrite();
         }
 
         public void Refactor(QualifiedSelection target)
diff --git a/Rubberduck.Refactorings/ExtractInterface/ExtractInterfaceRefactoring.cs b/Rubberduck.Refactorings/ExtractInterface/ExtractInterfaceRefactoring.cs
@@ -123,7 +123,7 @@ private void AddInterfaceInternal()
             AddInterfaceMembersToClass(rewriter);
 
             //We have to reparse here already, because 
-            rewriteSession.Rewrite();
+            rewriteSession.TryRewrite();
         }
 
         private void AddInterfaceClass(Declaration implementingClass, string interfaceName, string interfaceBody)
diff --git a/Rubberduck.Refactorings/ImplementInterface/ImplementInterfaceRefactoring.cs b/Rubberduck.Refactorings/ImplementInterface/ImplementInterfaceRefactoring.cs
@@ -82,7 +82,7 @@ public void Refactor(QualifiedSelection selection)
             var rewriteSession = _rewritingManager.CheckOutCodePaneSession();
             var rewriter = rewriteSession.CheckOutModuleRewriter(_targetClass.QualifiedModuleName);
             ImplementMissingMembers(rewriter);
-            rewriteSession.Rewrite();
+            rewriteSession.TryRewrite();
 
             if (oldSelection.HasValue)
             {
diff --git a/Rubberduck.Refactorings/IntroduceField/IntroduceFieldRefactoring.cs b/Rubberduck.Refactorings/IntroduceField/IntroduceFieldRefactoring.cs
@@ -86,7 +86,7 @@ private void PromoteVariable(Declaration target)
             rewriter.Remove(target);
             AddField(rewriter, target);
 
-            rewriteSession.Rewrite();
+            rewriteSession.TryRewrite();
 
             if (oldSelection.HasValue)
             {
diff --git a/Rubberduck.Refactorings/IntroduceParameter/IntroduceParameterRefactoring.cs b/Rubberduck.Refactorings/IntroduceParameter/IntroduceParameterRefactoring.cs
@@ -104,7 +104,7 @@ private void PromoteVariable(Declaration target)
                 UpdateSignature(target, rewriteSession);
                 rewriter.Remove(target);
 
-                rewriteSession.Rewrite();
+                rewriteSession.TryRewrite();
 
                 if (oldSelection.HasValue && !pane.IsWrappingNullReference)
                 {
diff --git a/Rubberduck.Refactorings/MoveCloserToUsage/MoveCloserToUsageRefactoring.cs b/Rubberduck.Refactorings/MoveCloserToUsage/MoveCloserToUsageRefactoring.cs
@@ -112,7 +112,7 @@ private void MoveCloserToUsage()
                 InsertNewDeclaration(rewriteSession);
                 RemoveOldDeclaration(rewriteSession);
                 UpdateOtherModules(rewriteSession);
-                rewriteSession.Rewrite();
+                rewriteSession.TryRewrite();
 
                 if (oldSelection.HasValue && !pane.IsWrappingNullReference)
                 {
diff --git a/Rubberduck.Refactorings/RemoveParameters/RemoveParametersRefactoring.cs b/Rubberduck.Refactorings/RemoveParameters/RemoveParametersRefactoring.cs
@@ -115,7 +115,7 @@ private void RemoveParameters()
             AdjustReferences(_model.TargetDeclaration.References, _model.TargetDeclaration, rewritingSession);
             AdjustSignatures(rewritingSession);
 
-            rewritingSession.Rewrite();
+            rewritingSession.TryRewrite();
         }
 
         private void AdjustReferences(IEnumerable<IdentifierReference> references, Declaration method, IRewriteSession rewriteSession)
diff --git a/Rubberduck.Refactorings/Rename/RenameRefactoring.cs b/Rubberduck.Refactorings/Rename/RenameRefactoring.cs
@@ -103,7 +103,7 @@ private void RefactorImpl(Declaration inputTarget, IRenamePresenter presenter)
                 {
                     var rewriteSession = _rewritingManager.CheckOutCodePaneSession();
                     Rename(rewriteSession);
-                    rewriteSession.Rewrite();
+                    rewriteSession.TryRewrite();
                 }
             }
             catch (RuntimeBinderException rbEx)
diff --git a/Rubberduck.Refactorings/ReorderParameters/ReorderParametersRefactoring.cs b/Rubberduck.Refactorings/ReorderParameters/ReorderParametersRefactoring.cs
@@ -56,7 +56,7 @@ public void Refactor()
                 var rewriteSession = _rewritingManager.CheckOutCodePaneSession();
                 AdjustReferences(_model.TargetDeclaration.References, rewriteSession);
                 AdjustSignatures(rewriteSession);
-                rewriteSession.Rewrite();
+                rewriteSession.TryRewrite();
 
                 if (oldSelection.HasValue && !pane.IsWrappingNullReference)
                 {
diff --git a/RubberduckTests/PostProcessing/ModuleRewriterTests.cs b/RubberduckTests/PostProcessing/ModuleRewriterTests.cs
@@ -78,7 +78,7 @@ public void RewriterInsertsRewriterOutputAtLine1()
 
                 var rewriteSession = rewritingManager.CheckOutCodePaneSession();
                 var rewriter = rewriteSession.CheckOutModuleRewriter(component.QualifiedModuleName);
-                rewriteSession.Rewrite();
+                rewriteSession.TryRewrite();
 
                 Assert.AreEqual(content, rewriter.GetText());
             }
diff --git a/RubberduckTests/Rewriter/AttributesRewriteSessionTests.cs b/RubberduckTests/Rewriter/AttributesRewriteSessionTests.cs
@@ -26,7 +26,7 @@ public void UsesASuspendActionToRewrite()
             var module = new QualifiedModuleName("TestProject", string.Empty, "TestModule");
             rewriteSession.CheckOutModuleRewriter(module);
 
-            rewriteSession.Rewrite();
+            rewriteSession.TryRewrite();
 
             mockParseManager.Verify(m => m.OnSuspendParser(It.IsAny<object>(), It.IsAny<IEnumerable<ParserState>>(), It.IsAny<Action>(), It.IsAny<int>()), Times.Once);
         }
@@ -44,11 +44,43 @@ public void DoesNotCallRewriteOutsideTheSuspendAction()
             rewriteSession.CheckOutModuleRewriter(module);
             var (qmn, codeKind, mockRewriter) = mockRewriterProvider.RequestedRewriters().Single();
 
-            rewriteSession.Rewrite();
+            rewriteSession.TryRewrite();
 
             mockRewriter.Verify(m => m.Rewrite(), Times.Never);
         }
 
+        [Test]
+        [Category("Rewriter")]
+        public void TryRewriteReturnsFalseIfNotInvalidatedAndParsingAllowedAndSuspensionDoesNotComplete()
+        {
+            var parseManager = new Mock<IParseManager>();
+            parseManager.Setup(m => m.OnSuspendParser(It.IsAny<object>(), It.IsAny<IEnumerable<ParserState>>(), It.IsAny<Action>(), It.IsAny<int>()))
+                .Callback((object requestor, IEnumerable<ParserState> allowedStates, Action suspendAction, int timeout) => suspendAction())
+                .Returns((object requestor, IEnumerable<ParserState> allowedStates, Action suspendAction, int timeout) => SuspensionResult.UnexpectedError);
+
+            var rewriteSession = RewriteSession(parseManager.Object, session => true, out _);
+            var module = new QualifiedModuleName("TestProject", string.Empty, "TestModule");
+            rewriteSession.CheckOutModuleRewriter(module);
+            var actual = rewriteSession.TryRewrite();
+            Assert.IsFalse(actual);
+        }
+
+        [Test]
+        [Category("Rewriter")]
+        public void TryRewriteReturnsTrueIfNotInvalidatedAndParsingAllowedAndSuspensionCompletes()
+        {
+            var parseManager = new Mock<IParseManager>();
+            parseManager.Setup(m => m.OnSuspendParser(It.IsAny<object>(), It.IsAny<IEnumerable<ParserState>>(), It.IsAny<Action>(), It.IsAny<int>()))
+                .Callback((object requestor, IEnumerable<ParserState> allowedStates, Action suspendAction, int timeout) => suspendAction())
+                .Returns((object requestor, IEnumerable<ParserState> allowedStates, Action suspendAction, int timeout) => SuspensionResult.Completed);
+
+            var rewriteSession = RewriteSession(parseManager.Object, session => true, out _);
+            var module = new QualifiedModuleName("TestProject", string.Empty, "TestModule");
+            rewriteSession.CheckOutModuleRewriter(module);
+            var actual = rewriteSession.TryRewrite();
+            Assert.IsTrue(actual);
+        }
+
         [Test]
         [Category("Rewriter")]
         public void TargetsAttributesCode()
diff --git a/RubberduckTests/Rewriter/CodePaneRewriteSessionTests.cs b/RubberduckTests/Rewriter/CodePaneRewriteSessionTests.cs
@@ -25,7 +25,7 @@ public void RequestsParseAfterRewriteIfNotInvalidatedAndParsingAllowed()
             rewriteSession.CheckOutModuleRewriter(module);
             rewriteSession.CheckOutModuleRewriter(otherModule);
 
-            rewriteSession.Rewrite();
+            rewriteSession.TryRewrite();
 
             mockParseManager.Verify(m => m.OnParseRequested(It.IsAny<object>()), Times.Once);
         }
@@ -44,7 +44,7 @@ public void DoesNotCallRequestsParseAfterRewriteIfInvalidated()
             rewriteSession.Invalidate();
             rewriteSession.CheckOutModuleRewriter(otherModule);
 
-            rewriteSession.Rewrite();
+            rewriteSession.TryRewrite();
 
             mockParseManager.Verify(m => m.OnParseRequested(It.IsAny<object>()), Times.Never);
         }
@@ -62,7 +62,7 @@ public void DoesNotRequestsParseAfterRewriteIfNotParsingAllowed()
             rewriteSession.CheckOutModuleRewriter(module);
             rewriteSession.CheckOutModuleRewriter(otherModule);
 
-            rewriteSession.Rewrite();
+            rewriteSession.TryRewrite();
 
             mockParseManager.Verify(m => m.OnParseRequested(It.IsAny<object>()), Times.Never);
         }
@@ -75,11 +75,22 @@ public void DoesNotRequestParseIfNoRewritersAreCheckedOut()
             mockParseManager.Setup(m => m.OnParseRequested(It.IsAny<object>()));
             var rewriteSession = RewriteSession(mockParseManager.Object, session => true, out _);
 
-            rewriteSession.Rewrite();
+            rewriteSession.TryRewrite();
 
             mockParseManager.Verify(m => m.OnParseRequested(It.IsAny<object>()), Times.Never);
         }
 
+        [Test]
+        [Category("Rewriter")]
+        public void TryRewriteReturnsTrueIfNotInvalidatedAndParsingAllowed()
+        {
+            var rewriteSession = RewriteSession(session => true, out _);
+            var module = new QualifiedModuleName("TestProject", string.Empty, "TestModule");
+            rewriteSession.CheckOutModuleRewriter(module);
+            var actual = rewriteSession.TryRewrite();
+            Assert.IsTrue(actual);
+        }
+
         [Test]
         [Category("Rewriter")]
         public void TargetsCodePaneCode()
diff --git a/RubberduckTests/Rewriter/RewriteManagerTests.cs b/RubberduckTests/Rewriter/RewriteManagerTests.cs
diff --git a/RubberduckTests/Rewriter/RewriteSessionTestBase.cs b/RubberduckTests/Rewriter/RewriteSessionTestBase.cs

Original file line number	Diff line number	Diff line change
`@@ -78,7 +78,7 @@ public void Fix(IQuickFix fix, IInspectionResult result)`
`78`	`78`
`79`	`79`	`var rewriteSession = RewriteSession(fix.TargetCodeKind);`
`80`	`80`	`fix.Fix(result, rewriteSession);`
`81`		`- rewriteSession.Rewrite();`
	`81`	`+ rewriteSession.TryRewrite();`
`82`	`82`	`}`
`83`	`83`
`84`	`84`	`private IRewriteSession RewriteSession(CodeKind targetCodeKind)`
`@@ -115,7 +115,7 @@ public void FixInProcedure(IQuickFix fix, QualifiedMemberName? qualifiedMember,`
`115`	`115`
`116`	`116`	`fix.Fix(result, rewriteSession);`
`117`	`117`	`}`
`118`		`- rewriteSession.Rewrite();`
	`118`	`+ rewriteSession.TryRewrite();`
`119`	`119`	`}`
`120`	`120`
`121`	`121`	`public void FixInModule(IQuickFix fix, QualifiedSelection selection, Type inspectionType, IEnumerable<IInspectionResult> results)`
`@@ -137,7 +137,7 @@ public void FixInModule(IQuickFix fix, QualifiedSelection selection, Type inspec`
`137`	`137`
`138`	`138`	`fix.Fix(result, rewriteSession);`
`139`	`139`	`}`
`140`		`- rewriteSession.Rewrite();`
	`140`	`+ rewriteSession.TryRewrite();`
`141`	`141`	`}`
`142`	`142`
`143`	`143`	`public void FixInProject(IQuickFix fix, QualifiedSelection selection, Type inspectionType, IEnumerable<IInspectionResult> results)`
`@@ -159,7 +159,7 @@ public void FixInProject(IQuickFix fix, QualifiedSelection selection, Type inspe`
`159`	`159`
`160`	`160`	`fix.Fix(result, rewriteSession);`
`161`	`161`	`}`
`162`		`- rewriteSession.Rewrite();`
	`162`	`+ rewriteSession.TryRewrite();`
`163`	`163`	`}`
`164`	`164`
`165`	`165`	`public void FixAll(IQuickFix fix, Type inspectionType, IEnumerable<IInspectionResult> results)`
`@@ -181,7 +181,7 @@ public void FixAll(IQuickFix fix, Type inspectionType, IEnumerable<IInspectionRe`
`181`	`181`
`182`	`182`	`fix.Fix(result, rewriteSession);`
`183`	`183`	`}`
`184`		`- rewriteSession.Rewrite();`
	`184`	`+ rewriteSession.TryRewrite();`
`185`	`185`	`}`
`186`	`186`
`187`	`187`	`public bool HasQuickFixes(IInspectionResult inspectionResult)`
Original file line number	Diff line number	Diff line change
`@@ -23,14 +23,17 @@ protected override IExecutableModuleRewriter ModuleRewriter(QualifiedModuleName`
`23`	`23`	`return RewriterProvider.AttributesModuleRewriter(module);`
`24`	`24`	`}`
`25`	`25`
`26`		`- protected override void RewriteInternal()`
	`26`	`+ protected override bool TryRewriteInternal()`
`27`	`27`	`{`
`28`	`28`	`//The suspension ensures that only one parse gets executed instead of two for each rewritten module.`
`29`	`29`	`var result = _parseManager.OnSuspendParser(this, new[] {ParserState.Ready}, ExecuteAllRewriters);`
`30`	`30`	`if(result != SuspensionResult.Completed)`
`31`	`31`	`{`
`32`	`32`	`Logger.Warn($"Rewriting attribute modules did not succeed. suspension result = {result}");`
	`33`	`+ return false;`
`33`	`34`	`}`
	`35`	`+`
	`36`	`+ return true;`
`34`	`37`	`}`
`35`	`38`
`36`	`39`	`private void ExecuteAllRewriters()`
Original file line number	Diff line number	Diff line change
`@@ -23,13 +23,15 @@ protected override IExecutableModuleRewriter ModuleRewriter(QualifiedModuleName`
`23`	`23`	`return RewriterProvider.CodePaneModuleRewriter(module);`
`24`	`24`	`}`
`25`	`25`
`26`		`- protected override void RewriteInternal()`
	`26`	`+ protected override bool TryRewriteInternal()`
`27`	`27`	`{`
`28`	`28`	`foreach (var rewriter in CheckedOutModuleRewriters.Values)`
`29`	`29`	`{`
`30`	`30`	`rewriter.Rewrite();`
`31`	`31`	`}`
`32`	`32`	`_parseManager.OnParseRequested(this);`
	`33`	`+`
	`34`	`+ return true;`
`33`	`35`	`}`
`34`	`36`	`}`
`35`	`37`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@ namespace Rubberduck.Parsing.Rewriter`
`6`	`6`	`public interface IRewriteSession`
`7`	`7`	`{`
`8`	`8`	`IModuleRewriter CheckOutModuleRewriter(QualifiedModuleName module);`
`9`		`- void Rewrite();`
	`9`	`+ bool TryRewrite();`
`10`	`10`	`bool IsInvalidated { get; }`
`11`	`11`	`void Invalidate();`
`12`	`12`	`CodeKind TargetCodeKind { get; }`
Original file line number	Diff line number	Diff line change
`@@ -40,32 +40,32 @@ public IModuleRewriter CheckOutModuleRewriter(QualifiedModuleName module)`
`40`	`40`
`41`	`41`	`protected abstract IExecutableModuleRewriter ModuleRewriter(QualifiedModuleName module);`
`42`	`42`
`43`		`- public void Rewrite()`
	`43`	`+ public bool TryRewrite()`
`44`	`44`	`{`
`45`	`45`	`if (!CheckedOutModuleRewriters.Any())`
`46`	`46`	`{`
`47`		`- return;`
	`47`	`+ return false;`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`lock (_invalidationLockObject)`
`51`	`51`	`{`
`52`	`52`	`if (_isInvalidated)`
`53`	`53`	`{`
`54`	`54`	`Logger.Warn("Tried to execute Rewrite on a RewriteSession that was already invalidated.");`
`55`		`- return;`
	`55`	`+ return false;`
`56`	`56`	`}`
`57`	`57`	`}`
`58`	`58`
`59`	`59`	`if (!_rewritingAllowed(this))`
`60`	`60`	`{`
`61`		`- Logger.Warn("Tried to execute Rewrite on a RewriteSession when rewriting was no longer allowed.");`
`62`		`- return;`
	`61`	`+ Logger.Debug("Tried to execute Rewrite on a RewriteSession when rewriting was no longer allowed.");`
	`62`	`+ return false;`
`63`	`63`	`}`
`64`	`64`
`65`		`- RewriteInternal();`
	`65`	`+ return TryRewriteInternal();`
`66`	`66`	`}`
`67`	`67`
`68`		`- protected abstract void RewriteInternal();`
	`68`	`+ protected abstract bool TryRewriteInternal();`
`69`	`69`
`70`	`70`	`private bool _isInvalidated = false;`
`71`	`71`	`public bool IsInvalidated`
Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@ public void Refactor()`
`41`	`41`
`42`	`42`	`var rewriteSession = _rewritingManager.CheckOutCodePaneSession();`
`43`	`43`	`AddProperty(rewriteSession);`
`44`		`- rewriteSession.Rewrite();`
	`44`	`+ rewriteSession.TryRewrite();`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`public void Refactor(QualifiedSelection target)`
Original file line number	Diff line number	Diff line change
`@@ -123,7 +123,7 @@ private void AddInterfaceInternal()`
`123`	`123`	`AddInterfaceMembersToClass(rewriter);`
`124`	`124`
`125`	`125`	`//We have to reparse here already, because`
`126`		`- rewriteSession.Rewrite();`
	`126`	`+ rewriteSession.TryRewrite();`
`127`	`127`	`}`
`128`	`128`
`129`	`129`	`private void AddInterfaceClass(Declaration implementingClass, string interfaceName, string interfaceBody)`
Original file line number	Diff line number	Diff line change
`@@ -82,7 +82,7 @@ public void Refactor(QualifiedSelection selection)`
`82`	`82`	`var rewriteSession = _rewritingManager.CheckOutCodePaneSession();`
`83`	`83`	`var rewriter = rewriteSession.CheckOutModuleRewriter(_targetClass.QualifiedModuleName);`
`84`	`84`	`ImplementMissingMembers(rewriter);`
`85`		`- rewriteSession.Rewrite();`
	`85`	`+ rewriteSession.TryRewrite();`
`86`	`86`
`87`	`87`	`if (oldSelection.HasValue)`
`88`	`88`	`{`
Original file line number	Diff line number	Diff line change
`@@ -86,7 +86,7 @@ private void PromoteVariable(Declaration target)`
`86`	`86`	`rewriter.Remove(target);`
`87`	`87`	`AddField(rewriter, target);`
`88`	`88`
`89`		`- rewriteSession.Rewrite();`
	`89`	`+ rewriteSession.TryRewrite();`
`90`	`90`
`91`	`91`	`if (oldSelection.HasValue)`
`92`	`92`	`{`
Original file line number	Diff line number	Diff line change
`@@ -104,7 +104,7 @@ private void PromoteVariable(Declaration target)`
`104`	`104`	`UpdateSignature(target, rewriteSession);`
`105`	`105`	`rewriter.Remove(target);`
`106`	`106`
`107`		`- rewriteSession.Rewrite();`
	`107`	`+ rewriteSession.TryRewrite();`
`108`	`108`
`109`	`109`	`if (oldSelection.HasValue && !pane.IsWrappingNullReference)`
`110`	`110`	`{`