From 668f46f6632e027e89a35291a5f902af0e1f3d4a Mon Sep 17 00:00:00 2001 From: Max Doerner Date: Thu, 25 Oct 2018 01:00:38 +0200 Subject: [PATCH 01/59] Extract Rewrite out of the IModuleRewriter The extraction is performed into the new IExecutableModuleRewriter, which extends IModuleRewriter. This change allows to restrict the access to triggering the actual application of the changes. This will be important in the next commits. It was necessary to change some other functionality using the rewriter with dynamic arguments in order to avoid runtime binder exceptions. (It does not see the interfaces that get extended.) The first change was to the (I)ModuleRewriter itself. I added a new overload both for Replace and Remove taking an IParseTree. This is implemented using pattern matching to prefer execution for the ITerminalNode and then falling back to ParserRuleContext, which is always a valid downcast for IParseTree. This allows to avoid using dynamic to prefer the calls with ITerminalNode. The other changes were explicit casts of the second argument of Replace, which only accepts strings anyway and a change from dynamic to patterns matching in a quickfix. --- .../AccessSheetUsingCodeNameQuickFix.cs | 4 +-- .../QuickFixes/AddStepOneQuickFix.cs | 2 +- ...gnedByValParameterMakeLocalCopyQuickFix.cs | 4 +-- .../QuickFixes/ChangeIntegerToLongQuickFix.cs | 2 +- .../RemoveDuplicatedAnnotationQuickFix.cs | 2 +- .../RemoveEmptyElseBlockQuickFix.cs | 2 +- .../QuickFixes/RemoveEmptyIfBlockQuickFix.cs | 16 ++++----- .../RemoveExplicitByRefModifierQuickFix.cs | 2 +- .../QuickFixes/RemoveStepOneQuickFix.cs | 2 +- .../SpecifyExplicitByRefModifierQuickFix.cs | 2 +- .../SplitMultipleDeclarationsQuickFix.cs | 19 +++++++++-- .../Rewriter/IExecutableModuleRewriter.cs | 10 ++++++ .../Rewriter/IModuleRewriter.cs | 19 +++++++---- .../Rewriter/IModuleRewriterFactory.cs | 4 +-- Rubberduck.Parsing/Rewriter/ModuleRewriter.cs | 34 ++++++++++++++++++- .../Rewriter/ModuleRewriterFactory.cs | 4 +-- Rubberduck.Parsing/VBA/ModuleState.cs | 8 ++--- .../VBA/Parsing/IModuleParser.cs | 8 ++--- .../VBA/RubberduckParserState.cs | 12 +++---- .../EncapsulateFieldRefactoring.cs | 6 ++-- .../ExtractInterfaceRefactoring.cs | 2 +- .../ImplementInterfaceRefactoring.cs | 6 ++-- .../IntroduceFieldRefactoring.cs | 4 +-- .../IntroduceParameterRefactoring.cs | 2 +- .../MoveCloserToUsageRefactoring.cs | 2 +- .../RemoveParametersRefactoring.cs | 8 +++-- .../ReorderParametersRefactoring.cs | 2 +- 27 files changed, 126 insertions(+), 62 deletions(-) create mode 100644 Rubberduck.Parsing/Rewriter/IExecutableModuleRewriter.cs diff --git a/Rubberduck.CodeAnalysis/QuickFixes/AccessSheetUsingCodeNameQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/AccessSheetUsingCodeNameQuickFix.cs index 52c5864421..ad08179cc5 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/AccessSheetUsingCodeNameQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/AccessSheetUsingCodeNameQuickFix.cs @@ -35,7 +35,7 @@ public override void Fix(IInspectionResult result) var indexExprContext = referenceResult.Context.Parent.Parent as VBAParser.IndexExprContext ?? referenceResult.Context.Parent as VBAParser.IndexExprContext; - rewriter.Replace(indexExprContext, referenceResult.Properties.CodeName); + rewriter.Replace(indexExprContext, (string)referenceResult.Properties.CodeName); } else { @@ -67,7 +67,7 @@ public override void Fix(IInspectionResult result) foreach (var reference in sheetDeclaration.References) { - rewriter.Replace(reference.Context, referenceResult.Properties.CodeName); + rewriter.Replace(reference.Context, (string)referenceResult.Properties.CodeName); } rewriter.Remove(setStatement); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/AddStepOneQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/AddStepOneQuickFix.cs index 11a7f3618c..428ec78c89 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/AddStepOneQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/AddStepOneQuickFix.cs @@ -31,7 +31,7 @@ public override string Description(IInspectionResult result) public override void Fix(IInspectionResult result) { - IModuleRewriter rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); + IExecutableModuleRewriter rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); ForNextStmtContext context = result.Context as ForNextStmtContext; int toExpressionEnd = this.GetToExpressionEnd(context); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/AssignedByValParameterMakeLocalCopyQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/AssignedByValParameterMakeLocalCopyQuickFix.cs index 2446a71c7f..aa47035ae9 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/AssignedByValParameterMakeLocalCopyQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/AssignedByValParameterMakeLocalCopyQuickFix.cs @@ -103,7 +103,7 @@ private bool IsValidVariableName(string variableName) && !IsNameCollision(variableName); } - private void ReplaceAssignedByValParameterReferences(IModuleRewriter rewriter, Declaration target, string localIdentifier) + private void ReplaceAssignedByValParameterReferences(IExecutableModuleRewriter rewriter, Declaration target, string localIdentifier) { foreach (var identifierReference in target.References) { @@ -111,7 +111,7 @@ private void ReplaceAssignedByValParameterReferences(IModuleRewriter rewriter, D } } - private void InsertLocalVariableDeclarationAndAssignment(IModuleRewriter rewriter, Declaration target, string localIdentifier) + private void InsertLocalVariableDeclarationAndAssignment(IExecutableModuleRewriter rewriter, Declaration target, string localIdentifier) { var localVariableDeclaration = $"{Tokens.Dim} {localIdentifier} {Tokens.As} {target.AsTypeName}"; diff --git a/Rubberduck.CodeAnalysis/QuickFixes/ChangeIntegerToLongQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/ChangeIntegerToLongQuickFix.cs index ffcb191e1d..1ebcf98399 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/ChangeIntegerToLongQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/ChangeIntegerToLongQuickFix.cs @@ -178,7 +178,7 @@ private static int GetParameterIndex(VBAParser.ArgContext context) return Array.IndexOf(((VBAParser.ArgListContext)context.Parent).arg().ToArray(), context); } - private static void ReplaceTypeHint(RuleContext context, IModuleRewriter rewriter) + private static void ReplaceTypeHint(RuleContext context, IExecutableModuleRewriter rewriter) { var typeHintContext = ((ParserRuleContext)context).GetDescendent(); rewriter.Replace(typeHintContext, "&"); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RemoveDuplicatedAnnotationQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RemoveDuplicatedAnnotationQuickFix.cs index 929f2b3d79..508759ee69 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/RemoveDuplicatedAnnotationQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/RemoveDuplicatedAnnotationQuickFix.cs @@ -64,7 +64,7 @@ public override string Description(IInspectionResult result) => public override bool CanFixInProject => true; private static void RemoveAnnotationMarker(VBAParser.AnnotationListContext annotationList, - IAnnotation annotation, IModuleRewriter rewriter) + IAnnotation annotation, IExecutableModuleRewriter rewriter) { var index = Array.IndexOf(annotationList.annotation(), annotation.Context); rewriter.Remove(annotationList.AT(index)); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RemoveEmptyElseBlockQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RemoveEmptyElseBlockQuickFix.cs index 8d39887e7f..2968a5b88b 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/RemoveEmptyElseBlockQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/RemoveEmptyElseBlockQuickFix.cs @@ -25,7 +25,7 @@ public override void Fix(IInspectionResult result) UpdateContext((dynamic)result.Context, rewriter); } - private void UpdateContext(VBAParser.ElseBlockContext context, IModuleRewriter rewriter) + private void UpdateContext(VBAParser.ElseBlockContext context, IExecutableModuleRewriter rewriter) { var elseBlock = context.block(); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RemoveEmptyIfBlockQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RemoveEmptyIfBlockQuickFix.cs index 6760504a19..f928ecb161 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/RemoveEmptyIfBlockQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/RemoveEmptyIfBlockQuickFix.cs @@ -28,7 +28,7 @@ public override void Fix(IInspectionResult result) UpdateContext((dynamic)result.Context, rewriter); } - private void UpdateContext(VBAParser.IfStmtContext context, IModuleRewriter rewriter) + private void UpdateContext(VBAParser.IfStmtContext context, IExecutableModuleRewriter rewriter) { var elseBlock = context.elseBlock(); var elseIfBlock = context.elseIfBlock().FirstOrDefault(); @@ -63,7 +63,7 @@ private void UpdateContext(VBAParser.IfStmtContext context, IModuleRewriter rewr } } - private void UpdateContext(VBAParser.IfWithEmptyThenContext context, IModuleRewriter rewriter) + private void UpdateContext(VBAParser.IfWithEmptyThenContext context, IExecutableModuleRewriter rewriter) { var elseClause = context.singleLineElseClause(); if (context.singleLineElseClause().whiteSpace() != null) @@ -79,7 +79,7 @@ private void UpdateContext(VBAParser.IfWithEmptyThenContext context, IModuleRewr UpdateCondition((dynamic)context.booleanExpression().children[0], rewriter); } - private void UpdateContext(VBAParser.ElseIfBlockContext context, IModuleRewriter rewriter) + private void UpdateContext(VBAParser.ElseIfBlockContext context, IExecutableModuleRewriter rewriter) { if (BlockHasDeclaration(context.block())) { @@ -89,7 +89,7 @@ private void UpdateContext(VBAParser.ElseIfBlockContext context, IModuleRewriter rewriter.Remove(context); } - private void UpdateCondition(VBAParser.RelationalOpContext condition, IModuleRewriter rewriter) + private void UpdateCondition(VBAParser.RelationalOpContext condition, IExecutableModuleRewriter rewriter) { if (condition.EQ() != null) { @@ -121,7 +121,7 @@ private void UpdateCondition(VBAParser.RelationalOpContext condition, IModuleRew } } - private void UpdateCondition(VBAParser.LogicalNotOpContext condition, IModuleRewriter rewriter) + private void UpdateCondition(VBAParser.LogicalNotOpContext condition, IExecutableModuleRewriter rewriter) { if (condition.whiteSpace() != null) { @@ -133,17 +133,17 @@ private void UpdateCondition(VBAParser.LogicalNotOpContext condition, IModuleRew } } - private void UpdateCondition(VBAParser.LogicalAndOpContext condition, IModuleRewriter rewriter) + private void UpdateCondition(VBAParser.LogicalAndOpContext condition, IExecutableModuleRewriter rewriter) { rewriter.Replace(condition.AND(), "Or"); } - private void UpdateCondition(VBAParser.LogicalOrOpContext condition, IModuleRewriter rewriter) + private void UpdateCondition(VBAParser.LogicalOrOpContext condition, IExecutableModuleRewriter rewriter) { rewriter.Replace(condition.OR(), "And"); } - private void UpdateCondition(ParserRuleContext condition, IModuleRewriter rewriter) + private void UpdateCondition(ParserRuleContext condition, IExecutableModuleRewriter rewriter) { if (condition.GetText().Contains(' ')) { diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RemoveExplicitByRefModifierQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RemoveExplicitByRefModifierQuickFix.cs index f2cba020fc..66a0a0efcb 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/RemoveExplicitByRefModifierQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/RemoveExplicitByRefModifierQuickFix.cs @@ -69,7 +69,7 @@ private static int GetParameterIndex(VBAParser.ArgContext context) return Array.IndexOf(((VBAParser.ArgListContext)context.Parent).arg().ToArray(), context); } - private static void RemoveByRefIdentifier(IModuleRewriter rewriter, VBAParser.ArgContext context) + private static void RemoveByRefIdentifier(IExecutableModuleRewriter rewriter, VBAParser.ArgContext context) { if (context.BYREF() != null) { diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RemoveStepOneQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RemoveStepOneQuickFix.cs index 191e1ee909..88155453a9 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/RemoveStepOneQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/RemoveStepOneQuickFix.cs @@ -26,7 +26,7 @@ public RemoveStepOneQuickFix(RubberduckParserState state) public override void Fix(IInspectionResult result) { - IModuleRewriter rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); + IExecutableModuleRewriter rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); var context = result.Context; rewriter.Remove(context); } diff --git a/Rubberduck.CodeAnalysis/QuickFixes/SpecifyExplicitByRefModifierQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/SpecifyExplicitByRefModifierQuickFix.cs index 836f7539d2..6c2d5055f9 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/SpecifyExplicitByRefModifierQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/SpecifyExplicitByRefModifierQuickFix.cs @@ -72,7 +72,7 @@ private static int GetParameterIndex(VBAParser.ArgContext context) return Array.IndexOf(((VBAParser.ArgListContext)context.Parent).arg().ToArray(), context); } - private static void AddByRefIdentifier(IModuleRewriter rewriter, VBAParser.ArgContext context) + private static void AddByRefIdentifier(IExecutableModuleRewriter rewriter, VBAParser.ArgContext context) { if (context.BYREF() == null) { diff --git a/Rubberduck.CodeAnalysis/QuickFixes/SplitMultipleDeclarationsQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/SplitMultipleDeclarationsQuickFix.cs index ee6a27909b..b608d712a3 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/SplitMultipleDeclarationsQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/SplitMultipleDeclarationsQuickFix.cs @@ -1,4 +1,6 @@ +using System; using System.Text; +using Antlr4.Runtime; using Rubberduck.Inspections.Abstract; using Rubberduck.Inspections.Concrete; using Rubberduck.Parsing.Grammar; @@ -19,11 +21,22 @@ public SplitMultipleDeclarationsQuickFix(RubberduckParserState state) public override void Fix(IInspectionResult result) { - dynamic context = result.Context is VBAParser.ConstStmtContext + var context = result.Context is VBAParser.ConstStmtContext ? result.Context - : result.Context.Parent; + : (ParserRuleContext)result.Context.Parent; - var declarationsText = GetDeclarationsText(context); + string declarationsText; + switch (context) + { + case VBAParser.ConstStmtContext consts: + declarationsText = GetDeclarationsText(consts); + break; + case VBAParser.VariableStmtContext variables: + declarationsText = GetDeclarationsText(variables); + break; + default: + throw new NotSupportedException(); + } var rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); rewriter.Replace(context, declarationsText); diff --git a/Rubberduck.Parsing/Rewriter/IExecutableModuleRewriter.cs b/Rubberduck.Parsing/Rewriter/IExecutableModuleRewriter.cs new file mode 100644 index 0000000000..c7afaf2dc4 --- /dev/null +++ b/Rubberduck.Parsing/Rewriter/IExecutableModuleRewriter.cs @@ -0,0 +1,10 @@ +namespace Rubberduck.Parsing.Rewriter +{ + public interface IExecutableModuleRewriter : IModuleRewriter + { + /// + /// Rewrites the entire module / applies all changes. + /// + void Rewrite(); + } +} \ No newline at end of file diff --git a/Rubberduck.Parsing/Rewriter/IModuleRewriter.cs b/Rubberduck.Parsing/Rewriter/IModuleRewriter.cs index 393a53bc98..ed8da6744c 100644 --- a/Rubberduck.Parsing/Rewriter/IModuleRewriter.cs +++ b/Rubberduck.Parsing/Rewriter/IModuleRewriter.cs @@ -1,4 +1,4 @@ -using Antlr4.Runtime; +using Antlr4.Runtime; using Antlr4.Runtime.Misc; using Antlr4.Runtime.Tree; using Rubberduck.Parsing.Symbols; @@ -9,11 +9,6 @@ public interface IModuleRewriter { bool IsDirty { get; } - /// - /// Rewrites the entire module / applies all changes. - /// - void Rewrite(); - /// /// Removes all tokens for specified . Use method to apply changes. /// @@ -38,6 +33,12 @@ public interface IModuleRewriter /// The to remove. /// Removes a line that would be left empty by the removal of the identifier reference token. void Remove(ITerminalNode target); + /// + /// Removes all tokens for specified . Use method to apply changes. + /// + /// The to remove. + /// Removes a line that would be left empty by the removal of the identifier reference token. + void Remove(IParseTree target); /// /// Removes all tokens from the start of the first node to the end of the second node. @@ -71,6 +72,12 @@ public interface IModuleRewriter /// The to replace. /// The literal replacement for the expression. void Replace(ITerminalNode target, string content); + /// + /// Replaces specified token with specified content. Use method to apply changes. + /// + /// The to replace. + /// The literal replacement for the expression. + void Replace(IParseTree target, string content); /// /// Replaces specified interval with specified content. Use method to apply changes. diff --git a/Rubberduck.Parsing/Rewriter/IModuleRewriterFactory.cs b/Rubberduck.Parsing/Rewriter/IModuleRewriterFactory.cs index 3db5967268..5721cc3f25 100644 --- a/Rubberduck.Parsing/Rewriter/IModuleRewriterFactory.cs +++ b/Rubberduck.Parsing/Rewriter/IModuleRewriterFactory.cs @@ -5,7 +5,7 @@ namespace Rubberduck.Parsing.Rewriter { public interface IModuleRewriterFactory { - IModuleRewriter CodePaneRewriter(QualifiedModuleName module, ITokenStream tokenStream); - IModuleRewriter AttributesRewriter(QualifiedModuleName module, ITokenStream tokenStream); + IExecutableModuleRewriter CodePaneRewriter(QualifiedModuleName module, ITokenStream tokenStream); + IExecutableModuleRewriter AttributesRewriter(QualifiedModuleName module, ITokenStream tokenStream); } } diff --git a/Rubberduck.Parsing/Rewriter/ModuleRewriter.cs b/Rubberduck.Parsing/Rewriter/ModuleRewriter.cs index e54b52b567..4b2314a0c8 100644 --- a/Rubberduck.Parsing/Rewriter/ModuleRewriter.cs +++ b/Rubberduck.Parsing/Rewriter/ModuleRewriter.cs @@ -11,7 +11,7 @@ namespace Rubberduck.Parsing.Rewriter { - public class ModuleRewriter : IModuleRewriter + public class ModuleRewriter : IExecutableModuleRewriter { private readonly QualifiedModuleName _module; private readonly ISourceCodeHandler _sourceCodeHandler; @@ -73,6 +73,22 @@ public void Remove(IToken target) _rewriter.Delete(target); } + public void Remove(IParseTree target) + { + switch (target) + { + case ITerminalNode terminalNode: + Remove(terminalNode); + break; + case ParserRuleContext context: + Remove(context); + break; + default: + //It should be impossible to end up here. + throw new NotSupportedException(); + } + } + public void RemoveRange(int start, int stop) { _rewriter.Delete(start, stop); @@ -98,6 +114,22 @@ public void Replace(ITerminalNode target, string content) _rewriter.Replace(target.Symbol.TokenIndex, content); } + public void Replace(IParseTree target, string content) + { + switch (target) + { + case ITerminalNode terminalNode: + Replace(terminalNode, content); + break; + case ParserRuleContext context: + Replace(context, content); + break; + default: + //It should be impossible to end up here. + throw new NotSupportedException(); + } + } + public void Replace(Interval tokenInterval, string content) { _rewriter.Replace(tokenInterval.a, tokenInterval.b, content); diff --git a/Rubberduck.Parsing/Rewriter/ModuleRewriterFactory.cs b/Rubberduck.Parsing/Rewriter/ModuleRewriterFactory.cs index 7968186d3b..4fb978fffa 100644 --- a/Rubberduck.Parsing/Rewriter/ModuleRewriterFactory.cs +++ b/Rubberduck.Parsing/Rewriter/ModuleRewriterFactory.cs @@ -20,12 +20,12 @@ public ModuleRewriterFactory(ISourceCodeHandler codePaneSourceCodeHandler, ISour _attributesSourceCodeHandler = attributesSourceCodeHandler; } - public IModuleRewriter CodePaneRewriter(QualifiedModuleName module, ITokenStream tokenStream) + public IExecutableModuleRewriter CodePaneRewriter(QualifiedModuleName module, ITokenStream tokenStream) { return new ModuleRewriter(module, tokenStream, _codePaneSourceCodeHandlerr); } - public IModuleRewriter AttributesRewriter(QualifiedModuleName module, ITokenStream tokenStream) + public IExecutableModuleRewriter AttributesRewriter(QualifiedModuleName module, ITokenStream tokenStream) { return new ModuleRewriter(module, tokenStream, _attributesSourceCodeHandler); } diff --git a/Rubberduck.Parsing/VBA/ModuleState.cs b/Rubberduck.Parsing/VBA/ModuleState.cs index c85b52e2cd..2b4918e019 100644 --- a/Rubberduck.Parsing/VBA/ModuleState.cs +++ b/Rubberduck.Parsing/VBA/ModuleState.cs @@ -16,8 +16,8 @@ public class ModuleState { public ConcurrentDictionary Declarations { get; private set; } public ConcurrentDictionary UnresolvedMemberDeclarations { get; private set; } - public IModuleRewriter ModuleRewriter { get; private set; } - public IModuleRewriter AttributesRewriter { get; private set; } + public IExecutableModuleRewriter ModuleRewriter { get; private set; } + public IExecutableModuleRewriter AttributesRewriter { get; private set; } public IParseTree ParseTree { get; private set; } public IParseTree AttributesPassParseTree { get; private set; } public ParserState State { get; private set; } @@ -79,7 +79,7 @@ public ModuleState(SyntaxErrorException moduleException) IsNew = true; } - public ModuleState SetCodePaneRewriter(QualifiedModuleName module, IModuleRewriter codePaneRewriter) + public ModuleState SetCodePaneRewriter(QualifiedModuleName module, IExecutableModuleRewriter codePaneRewriter) { ModuleRewriter = codePaneRewriter; return this; @@ -144,7 +144,7 @@ public ModuleState SetMembersAllowingAttributes(IDictionary<(string scopeIdentif return this; } - public ModuleState SetAttributesRewriter(IModuleRewriter rewriter) + public ModuleState SetAttributesRewriter(IExecutableModuleRewriter rewriter) { AttributesRewriter = rewriter; return this; diff --git a/Rubberduck.Parsing/VBA/Parsing/IModuleParser.cs b/Rubberduck.Parsing/VBA/Parsing/IModuleParser.cs index 6c7289f6ae..776e919e2b 100644 --- a/Rubberduck.Parsing/VBA/Parsing/IModuleParser.cs +++ b/Rubberduck.Parsing/VBA/Parsing/IModuleParser.cs @@ -18,8 +18,8 @@ public ModuleParseResults( IEnumerable annotations, IDictionary<(string scopeIdentifier, DeclarationType scopeType), Attributes> attributes, IDictionary<(string scopeIdentifier, DeclarationType scopeType), ParserRuleContext> membersAllowingAttributes, - IModuleRewriter codePaneRewriter, - IModuleRewriter attributesRewriter + IExecutableModuleRewriter codePaneRewriter, + IExecutableModuleRewriter attributesRewriter ) { CodePaneParseTree = codePaneParseTree; @@ -38,8 +38,8 @@ IModuleRewriter attributesRewriter public IEnumerable Annotations { get; } public IDictionary<(string scopeIdentifier, DeclarationType scopeType), Attributes> Attributes { get; } public IDictionary<(string scopeIdentifier, DeclarationType scopeType), ParserRuleContext> MembersAllowingAttributes { get; } - public IModuleRewriter CodePaneRewriter { get; } - public IModuleRewriter AttributesRewriter { get; } + public IExecutableModuleRewriter CodePaneRewriter { get; } + public IExecutableModuleRewriter AttributesRewriter { get; } } public interface IModuleParser diff --git a/Rubberduck.Parsing/VBA/RubberduckParserState.cs b/Rubberduck.Parsing/VBA/RubberduckParserState.cs index 4cfd0e1ad9..938679b663 100644 --- a/Rubberduck.Parsing/VBA/RubberduckParserState.cs +++ b/Rubberduck.Parsing/VBA/RubberduckParserState.cs @@ -844,7 +844,7 @@ private bool RemoveKeysFromCollections(IEnumerable keys) return success; } - public void SetCodePaneRewriter(QualifiedModuleName module, IModuleRewriter codePaneRewriter) + public void SetCodePaneRewriter(QualifiedModuleName module, IExecutableModuleRewriter codePaneRewriter) { _moduleStates[module].SetCodePaneRewriter(module, codePaneRewriter); } @@ -929,24 +929,24 @@ public bool IsDirty() return false; } - public IModuleRewriter GetRewriter(IVBComponent component) + public IExecutableModuleRewriter GetRewriter(IVBComponent component) { var qualifiedModuleName = new QualifiedModuleName(component); return GetRewriter(qualifiedModuleName); } - public IModuleRewriter GetRewriter(QualifiedModuleName qualifiedModuleName) + public IExecutableModuleRewriter GetRewriter(QualifiedModuleName qualifiedModuleName) { return _moduleStates[qualifiedModuleName].ModuleRewriter; } - public IModuleRewriter GetRewriter(Declaration declaration) + public IExecutableModuleRewriter GetRewriter(Declaration declaration) { var qualifiedModuleName = declaration.QualifiedSelection.QualifiedName; return GetRewriter(qualifiedModuleName); } - public IModuleRewriter GetAttributeRewriter(QualifiedModuleName qualifiedModuleName) + public IExecutableModuleRewriter GetAttributeRewriter(QualifiedModuleName qualifiedModuleName) { return _moduleStates[qualifiedModuleName].AttributesRewriter; } @@ -1067,7 +1067,7 @@ private void ClearAsTypeDeclarationPointingToReference(QualifiedModuleName refer } - public void AddAttributesRewriter(QualifiedModuleName module, IModuleRewriter attributesRewriter) + public void AddAttributesRewriter(QualifiedModuleName module, IExecutableModuleRewriter attributesRewriter) { var key = module; _moduleStates[key].SetAttributesRewriter(attributesRewriter); diff --git a/Rubberduck.Refactorings/EncapsulateField/EncapsulateFieldRefactoring.cs b/Rubberduck.Refactorings/EncapsulateField/EncapsulateFieldRefactoring.cs index 0c51cd0b8a..49798c650d 100644 --- a/Rubberduck.Refactorings/EncapsulateField/EncapsulateFieldRefactoring.cs +++ b/Rubberduck.Refactorings/EncapsulateField/EncapsulateFieldRefactoring.cs @@ -16,7 +16,7 @@ public class EncapsulateFieldRefactoring : IRefactoring private readonly IRefactoringPresenterFactory _factory; private EncapsulateFieldModel _model; - private readonly HashSet _referenceRewriters = new HashSet(); + private readonly HashSet _referenceRewriters = new HashSet(); public EncapsulateFieldRefactoring(IVBE vbe, IIndenter indenter, IRefactoringPresenterFactory factory) { @@ -71,7 +71,7 @@ public void Refactor(Declaration target) Refactor(); } - private void AddProperty(IModuleRewriter rewriter) + private void AddProperty(IExecutableModuleRewriter rewriter) { UpdateReferences(); SetFieldToPrivate(rewriter); @@ -120,7 +120,7 @@ private void UpdateReferences() } } - private void SetFieldToPrivate(IModuleRewriter rewriter) + private void SetFieldToPrivate(IExecutableModuleRewriter rewriter) { if (_model.TargetDeclaration.Accessibility != Accessibility.Private) { diff --git a/Rubberduck.Refactorings/ExtractInterface/ExtractInterfaceRefactoring.cs b/Rubberduck.Refactorings/ExtractInterface/ExtractInterfaceRefactoring.cs index 7fd434af56..69997a2486 100644 --- a/Rubberduck.Refactorings/ExtractInterface/ExtractInterfaceRefactoring.cs +++ b/Rubberduck.Refactorings/ExtractInterface/ExtractInterfaceRefactoring.cs @@ -121,7 +121,7 @@ private void AddInterface() } } - private void AddInterfaceMembersToClass(IModuleRewriter rewriter) + private void AddInterfaceMembersToClass(IExecutableModuleRewriter rewriter) { var implementInterfaceRefactoring = new ImplementInterfaceRefactoring(_vbe, _model.State, _messageBox); implementInterfaceRefactoring.Refactor(_model.Members.Select(m => m.Member).ToList(), rewriter, _model.InterfaceName); diff --git a/Rubberduck.Refactorings/ImplementInterface/ImplementInterfaceRefactoring.cs b/Rubberduck.Refactorings/ImplementInterface/ImplementInterfaceRefactoring.cs index 03bbfce5ce..f78f800f8c 100644 --- a/Rubberduck.Refactorings/ImplementInterface/ImplementInterfaceRefactoring.cs +++ b/Rubberduck.Refactorings/ImplementInterface/ImplementInterfaceRefactoring.cs @@ -99,12 +99,12 @@ public void Refactor(Declaration target) throw new NotSupportedException(); } - internal void Refactor(List members, IModuleRewriter rewriter, string interfaceName) + internal void Refactor(List members, IExecutableModuleRewriter rewriter, string interfaceName) { AddItems(members, rewriter, interfaceName); } - private void ImplementMissingMembers(IModuleRewriter rewriter) + private void ImplementMissingMembers(IExecutableModuleRewriter rewriter) { var implemented = _targetClass.Members .Where(decl => decl is ModuleBodyElementDeclaration member && ReferenceEquals(member.InterfaceImplemented, _targetInterface)) @@ -119,7 +119,7 @@ private void ImplementMissingMembers(IModuleRewriter rewriter) AddItems(nonImplementedMembers, rewriter, _targetInterface.IdentifierName); } - private void AddItems(IEnumerable missingMembers, IModuleRewriter rewriter, string interfaceName) + private void AddItems(IEnumerable missingMembers, IExecutableModuleRewriter rewriter, string interfaceName) { var missingMembersText = missingMembers.Aggregate(string.Empty, (current, member) => current + Environment.NewLine + GetInterfaceMember(member, interfaceName)); diff --git a/Rubberduck.Refactorings/IntroduceField/IntroduceFieldRefactoring.cs b/Rubberduck.Refactorings/IntroduceField/IntroduceFieldRefactoring.cs index 5e9054cf5c..80a5040ae8 100644 --- a/Rubberduck.Refactorings/IntroduceField/IntroduceFieldRefactoring.cs +++ b/Rubberduck.Refactorings/IntroduceField/IntroduceFieldRefactoring.cs @@ -71,7 +71,7 @@ public void Refactor(Declaration target) PromoteVariable(rewriter, target); } - private void PromoteVariable(IModuleRewriter rewriter, Declaration target) + private void PromoteVariable(IExecutableModuleRewriter rewriter, Declaration target) { if (new[] { DeclarationType.ClassModule, DeclarationType.ProceduralModule }.Contains(target.ParentDeclaration.DeclarationType)) { @@ -99,7 +99,7 @@ private void PromoteVariable(IModuleRewriter rewriter, Declaration target) rewriter.Rewrite(); } - private void AddField(IModuleRewriter rewriter, Declaration target) + private void AddField(IExecutableModuleRewriter rewriter, Declaration target) { var content = $"{Tokens.Private} {target.IdentifierName} {Tokens.As} {target.AsTypeName}\r\n"; var members = _state.DeclarationFinder.Members(target.QualifiedName.QualifiedModuleName) diff --git a/Rubberduck.Refactorings/IntroduceParameter/IntroduceParameterRefactoring.cs b/Rubberduck.Refactorings/IntroduceParameter/IntroduceParameterRefactoring.cs index 3e38a05439..85e43dbe5e 100644 --- a/Rubberduck.Refactorings/IntroduceParameter/IntroduceParameterRefactoring.cs +++ b/Rubberduck.Refactorings/IntroduceParameter/IntroduceParameterRefactoring.cs @@ -19,7 +19,7 @@ public class IntroduceParameterRefactoring : IRefactoring private readonly IList _declarations; private readonly IMessageBox _messageBox; - private readonly HashSet _rewriters = new HashSet(); + private readonly HashSet _rewriters = new HashSet(); private static readonly DeclarationType[] ValidDeclarationTypes = { diff --git a/Rubberduck.Refactorings/MoveCloserToUsage/MoveCloserToUsageRefactoring.cs b/Rubberduck.Refactorings/MoveCloserToUsage/MoveCloserToUsageRefactoring.cs index 11d83ce0a5..dd5ae4f942 100644 --- a/Rubberduck.Refactorings/MoveCloserToUsage/MoveCloserToUsageRefactoring.cs +++ b/Rubberduck.Refactorings/MoveCloserToUsage/MoveCloserToUsageRefactoring.cs @@ -24,7 +24,7 @@ public class MoveCloserToUsageRefactoring : IRefactoring private readonly IMessageBox _messageBox; private Declaration _target; - private readonly HashSet _rewriters = new HashSet(); + private readonly HashSet _rewriters = new HashSet(); public MoveCloserToUsageRefactoring(IVBE vbe, RubberduckParserState state, IMessageBox messageBox) { diff --git a/Rubberduck.Refactorings/RemoveParameters/RemoveParametersRefactoring.cs b/Rubberduck.Refactorings/RemoveParameters/RemoveParametersRefactoring.cs index d11367a9f0..0246b69023 100644 --- a/Rubberduck.Refactorings/RemoveParameters/RemoveParametersRefactoring.cs +++ b/Rubberduck.Refactorings/RemoveParameters/RemoveParametersRefactoring.cs @@ -2,6 +2,8 @@ using System.Collections.Generic; using System.Diagnostics; using System.Linq; +using Antlr4.Runtime; +using Antlr4.Runtime.Tree; using Rubberduck.Common; using Rubberduck.Interaction; using Rubberduck.Parsing; @@ -19,7 +21,7 @@ public class RemoveParametersRefactoring : IRefactoring private readonly IVBE _vbe; private readonly IRefactoringPresenterFactory _factory; private RemoveParametersModel _model; - private readonly HashSet _rewriters = new HashSet(); + private readonly HashSet _rewriters = new HashSet(); public RemoveParametersRefactoring(IVBE vbe, IRefactoringPresenterFactory factory) { @@ -182,7 +184,7 @@ private void RemoveCallArguments(VBAParser.ArgumentListContext argList, Qualifie var index = i == 0 ? 0 : argList.children.IndexOf(args[i - 1]) + 1; for (var j = index; j < argList.children.Count; j++) { - rewriter.Remove((dynamic)argList.children[j]); + rewriter.Remove(argList.children[j]); } break; } @@ -278,7 +280,7 @@ private void RemoveSignatureParameters(Declaration target) //Issue 4319. If there are 3 or more arguments and the user elects to remove 2 or more of //the last arguments, then we need to specifically remove the trailing comma from //the last 'kept' argument. - private void RemoveTrailingComma(IModuleRewriter rewriter, VBAParser.ArgumentListContext argList = null, bool usesNamedParams = false) + private void RemoveTrailingComma(IExecutableModuleRewriter rewriter, VBAParser.ArgumentListContext argList = null, bool usesNamedParams = false) { var commaLocator = RetrieveTrailingCommaInfo(_model.RemoveParameters, _model.Parameters); if (!commaLocator.RequiresTrailingCommaRemoval) diff --git a/Rubberduck.Refactorings/ReorderParameters/ReorderParametersRefactoring.cs b/Rubberduck.Refactorings/ReorderParameters/ReorderParametersRefactoring.cs index 6e1bb934a7..54cfd1b896 100644 --- a/Rubberduck.Refactorings/ReorderParameters/ReorderParametersRefactoring.cs +++ b/Rubberduck.Refactorings/ReorderParameters/ReorderParametersRefactoring.cs @@ -20,7 +20,7 @@ public class ReorderParametersRefactoring : IRefactoring private readonly IRefactoringPresenterFactory _factory; private ReorderParametersModel _model; private readonly IMessageBox _messageBox; - private readonly HashSet _rewriters = new HashSet(); + private readonly HashSet _rewriters = new HashSet(); private readonly IProjectsProvider _projectsProvider; public ReorderParametersRefactoring(IVBE vbe, IRefactoringPresenterFactory factory, IMessageBox messageBox, IProjectsProvider projectsProvider) From 41d327e38bc90f310e21834e2a32c1e6535cab0d Mon Sep 17 00:00:00 2001 From: Max Doerner Date: Sat, 27 Oct 2018 14:14:42 +0200 Subject: [PATCH 02/59] Introduce the IRewriteSession and IRewritingManager These two are meant to build the foundation for a new way to manage rewriting modules in a consistent fashion. When a feature wants to rewrite a module, it needs to have the IRewritingManager injected. Then it can request a IRewriteSession from it, either for code pane rewrites or attributes rewrites. The sessions manage the rewriting of all checked out rewriters and function as a point to perform pre- and post-rewrite actions in a consistent manner. The manager and sessions are set up such that only one active rewrite session may ever perform a successful rewrite: the manager will invalidate all active rewrite sessions on the first rewrite of an active rewrite session. (To coordinate this a callback gets passed to the freshly created sessions.) The current setup of the StateTokenStreamCache is temporary only; a change to only storing ITokenStreams on the RubberduckParserState is envisioned for the future. --- .../Rewriter/AttributesRewriteSession.cs | 41 ++++++++ .../Rewriter/CodePaneRewriteSession.cs | 33 +++++++ .../Rewriter/IRewriteSession.cs | 12 +++ .../Rewriter/IRewriteSessionFactory.cs | 10 ++ .../Rewriter/IRewriterProvider.cs | 10 ++ .../Rewriter/IRewritingManager.cs | 9 ++ .../Rewriter/ITokenStreamCache.cs | 11 +++ .../Rewriter/RewriteSessionBase.cs | 82 ++++++++++++++++ .../Rewriter/RewriteSessionFactory.cs | 27 ++++++ .../Rewriter/RewriterProvider.cs | 29 ++++++ .../Rewriter/RewritingManager.cs | 93 +++++++++++++++++++ .../Rewriter/StateTokenStreamCache.cs | 27 ++++++ 12 files changed, 384 insertions(+) create mode 100644 Rubberduck.Parsing/Rewriter/AttributesRewriteSession.cs create mode 100644 Rubberduck.Parsing/Rewriter/CodePaneRewriteSession.cs create mode 100644 Rubberduck.Parsing/Rewriter/IRewriteSession.cs create mode 100644 Rubberduck.Parsing/Rewriter/IRewriteSessionFactory.cs create mode 100644 Rubberduck.Parsing/Rewriter/IRewriterProvider.cs create mode 100644 Rubberduck.Parsing/Rewriter/IRewritingManager.cs create mode 100644 Rubberduck.Parsing/Rewriter/ITokenStreamCache.cs create mode 100644 Rubberduck.Parsing/Rewriter/RewriteSessionBase.cs create mode 100644 Rubberduck.Parsing/Rewriter/RewriteSessionFactory.cs create mode 100644 Rubberduck.Parsing/Rewriter/RewriterProvider.cs create mode 100644 Rubberduck.Parsing/Rewriter/RewritingManager.cs create mode 100644 Rubberduck.Parsing/Rewriter/StateTokenStreamCache.cs diff --git a/Rubberduck.Parsing/Rewriter/AttributesRewriteSession.cs b/Rubberduck.Parsing/Rewriter/AttributesRewriteSession.cs new file mode 100644 index 0000000000..8719806c9c --- /dev/null +++ b/Rubberduck.Parsing/Rewriter/AttributesRewriteSession.cs @@ -0,0 +1,41 @@ +using System; +using Rubberduck.Parsing.VBA; +using Rubberduck.VBEditor; + +namespace Rubberduck.Parsing.Rewriter +{ + public class AttributesRewriteSession : RewriteSessionBase + { + private readonly RubberduckParserState _state; + + public AttributesRewriteSession(RubberduckParserState state, IRewriterProvider rewriterProvider, + Func rewritingAllowed) + : base(rewriterProvider, rewritingAllowed) + { + _state = state; + } + + protected override IExecutableModuleRewriter ModuleRewriter(QualifiedModuleName module) + { + return RewriterProvider.CodePaneModuleRewriter(module); + } + + protected override void RewriteInternal() + { + //The suspension ensures that only one parse gets executed instead of two for each rewritten module. + var result = _state.OnSuspendParser(this, new[] {ParserState.Ready}, RewriteAllRewriters); + if(result != SuspensionResult.Completed) + { + Logger.Warn($"Rewriting attribute modules did not succeed. suspension result = {result}"); + } + } + + private void RewriteAllRewriters() + { + foreach (var rewriter in CheckedOutModuleRewriters.Values) + { + rewriter.Rewrite(); + } + } + } +} \ No newline at end of file diff --git a/Rubberduck.Parsing/Rewriter/CodePaneRewriteSession.cs b/Rubberduck.Parsing/Rewriter/CodePaneRewriteSession.cs new file mode 100644 index 0000000000..4b731d7bc7 --- /dev/null +++ b/Rubberduck.Parsing/Rewriter/CodePaneRewriteSession.cs @@ -0,0 +1,33 @@ +using System; +using Rubberduck.Parsing.VBA; +using Rubberduck.VBEditor; + +namespace Rubberduck.Parsing.Rewriter +{ + public class CodePaneRewriteSession : RewriteSessionBase + { + private readonly RubberduckParserState _state; + + public CodePaneRewriteSession(RubberduckParserState state, IRewriterProvider rewriterProvider, + Func rewritingAllowed) + : base(rewriterProvider, rewritingAllowed) + { + _state = state; + } + + + protected override IExecutableModuleRewriter ModuleRewriter(QualifiedModuleName module) + { + return RewriterProvider.CodePaneModuleRewriter(module); + } + + protected override void RewriteInternal() + { + foreach (var rewriter in CheckedOutModuleRewriters.Values) + { + rewriter.Rewrite(); + } + _state.OnParseRequested(this); + } + } +} \ No newline at end of file diff --git a/Rubberduck.Parsing/Rewriter/IRewriteSession.cs b/Rubberduck.Parsing/Rewriter/IRewriteSession.cs new file mode 100644 index 0000000000..b4488592a4 --- /dev/null +++ b/Rubberduck.Parsing/Rewriter/IRewriteSession.cs @@ -0,0 +1,12 @@ +using Rubberduck.VBEditor; + +namespace Rubberduck.Parsing.Rewriter +{ + public interface IRewriteSession + { + IModuleRewriter CheckOutModuleRewriter(QualifiedModuleName module); + void Rewrite(); + bool IsInvalidated { get; } + void Invalidate(); + } +} \ No newline at end of file diff --git a/Rubberduck.Parsing/Rewriter/IRewriteSessionFactory.cs b/Rubberduck.Parsing/Rewriter/IRewriteSessionFactory.cs new file mode 100644 index 0000000000..d4047a36d2 --- /dev/null +++ b/Rubberduck.Parsing/Rewriter/IRewriteSessionFactory.cs @@ -0,0 +1,10 @@ +using System; + +namespace Rubberduck.Parsing.Rewriter +{ + public interface IRewriteSessionFactory + { + IRewriteSession CodePaneSession(Func rewritingAllowed); + IRewriteSession AttributesSession(Func rewritingAllowed); + } +} \ No newline at end of file diff --git a/Rubberduck.Parsing/Rewriter/IRewriterProvider.cs b/Rubberduck.Parsing/Rewriter/IRewriterProvider.cs new file mode 100644 index 0000000000..2766c114e5 --- /dev/null +++ b/Rubberduck.Parsing/Rewriter/IRewriterProvider.cs @@ -0,0 +1,10 @@ +using Rubberduck.VBEditor; + +namespace Rubberduck.Parsing.Rewriter +{ + public interface IRewriterProvider + { + IExecutableModuleRewriter CodePaneModuleRewriter(QualifiedModuleName module); + IExecutableModuleRewriter AttributesModuleRewriter(QualifiedModuleName module); + } +} \ No newline at end of file diff --git a/Rubberduck.Parsing/Rewriter/IRewritingManager.cs b/Rubberduck.Parsing/Rewriter/IRewritingManager.cs new file mode 100644 index 0000000000..150b8adefe --- /dev/null +++ b/Rubberduck.Parsing/Rewriter/IRewritingManager.cs @@ -0,0 +1,9 @@ +namespace Rubberduck.Parsing.Rewriter +{ + public interface IRewritingManager + { + IRewriteSession CheckOutCodePaneSession(); + IRewriteSession CheckOutAttributesSession(); + void InvalidateAllSessions(); + } +} \ No newline at end of file diff --git a/Rubberduck.Parsing/Rewriter/ITokenStreamCache.cs b/Rubberduck.Parsing/Rewriter/ITokenStreamCache.cs new file mode 100644 index 0000000000..eedd6b8549 --- /dev/null +++ b/Rubberduck.Parsing/Rewriter/ITokenStreamCache.cs @@ -0,0 +1,11 @@ +using Antlr4.Runtime; +using Rubberduck.VBEditor; + +namespace Rubberduck.Parsing.Rewriter +{ + public interface ITokenStreamCache + { + ITokenStream CodePaneTokenStream(QualifiedModuleName module); + ITokenStream AttributesTokenStream(QualifiedModuleName module); + } +} \ No newline at end of file diff --git a/Rubberduck.Parsing/Rewriter/RewriteSessionBase.cs b/Rubberduck.Parsing/Rewriter/RewriteSessionBase.cs new file mode 100644 index 0000000000..45546a2f75 --- /dev/null +++ b/Rubberduck.Parsing/Rewriter/RewriteSessionBase.cs @@ -0,0 +1,82 @@ +using System; +using System.Collections.Generic; +using NLog; +using Rubberduck.VBEditor; + +namespace Rubberduck.Parsing.Rewriter +{ + public abstract class RewriteSessionBase : IRewriteSession + { + protected readonly IDictionary CheckedOutModuleRewriters = new Dictionary(); + protected readonly IRewriterProvider RewriterProvider; + + private readonly Func _rewritingAllowed; + + protected readonly Logger Logger = LogManager.GetCurrentClassLogger(); + private readonly object _invalidationLockObject = new object(); + + + protected RewriteSessionBase(IRewriterProvider rewriterProvider, Func rewritingAllowed) + { + RewriterProvider = rewriterProvider; + _rewritingAllowed = rewritingAllowed; + } + + + public IModuleRewriter CheckOutModuleRewriter(QualifiedModuleName module) + { + if (CheckedOutModuleRewriters.TryGetValue(module, out var rewriter)) + { + return rewriter; + } + + rewriter = ModuleRewriter(module); + CheckedOutModuleRewriters.Add(module, rewriter); + return rewriter; + } + + protected abstract IExecutableModuleRewriter ModuleRewriter(QualifiedModuleName module); + + public void Rewrite() + { + lock (_invalidationLockObject) + { + if (_isInvalidated) + { + Logger.Warn("Tried to execute Rewrite on a RewriteSession that was already invalidated."); + return; + } + } + + if (!_rewritingAllowed(this)) + { + Logger.Warn("Tried to execute Rewrite on a RewriteSession when rewriting was no longer allowed."); + return; + } + + RewriteInternal(); + } + + protected abstract void RewriteInternal(); + + private bool _isInvalidated = false; + public bool IsInvalidated + { + get + { + lock (_invalidationLockObject) + { + return _isInvalidated; + } + } + } + + public void Invalidate() + { + lock(_invalidationLockObject) + { + _isInvalidated = true; + } + } + } +} \ No newline at end of file diff --git a/Rubberduck.Parsing/Rewriter/RewriteSessionFactory.cs b/Rubberduck.Parsing/Rewriter/RewriteSessionFactory.cs new file mode 100644 index 0000000000..d0f81ddbd1 --- /dev/null +++ b/Rubberduck.Parsing/Rewriter/RewriteSessionFactory.cs @@ -0,0 +1,27 @@ +using System; +using Rubberduck.Parsing.VBA; + +namespace Rubberduck.Parsing.Rewriter +{ + public class RewriteSessionFactory : IRewriteSessionFactory + { + private readonly RubberduckParserState _state; + private readonly IRewriterProvider _rewriterProvider; + + public RewriteSessionFactory(RubberduckParserState state, IRewriterProvider rewriterProvider) + { + _state = state; + _rewriterProvider = rewriterProvider; + } + + public IRewriteSession CodePaneSession(Func rewritingAllowed) + { + return new CodePaneRewriteSession(_state, _rewriterProvider, rewritingAllowed); + } + + public IRewriteSession AttributesSession(Func rewritingAllowed) + { + return new AttributesRewriteSession(_state, _rewriterProvider, rewritingAllowed); + } + } +} \ No newline at end of file diff --git a/Rubberduck.Parsing/Rewriter/RewriterProvider.cs b/Rubberduck.Parsing/Rewriter/RewriterProvider.cs new file mode 100644 index 0000000000..23df1fb818 --- /dev/null +++ b/Rubberduck.Parsing/Rewriter/RewriterProvider.cs @@ -0,0 +1,29 @@ +using Rubberduck.VBEditor; + +namespace Rubberduck.Parsing.Rewriter +{ + public class RewriterProvider : IRewriterProvider + { + private ITokenStreamCache _tokenStreamCache; + private IModuleRewriterFactory _rewriterFactory; + + public RewriterProvider(ITokenStreamCache tokenStreamCache, IModuleRewriterFactory rewriterFactory) + { + _tokenStreamCache = tokenStreamCache; + _rewriterFactory = rewriterFactory; + } + + + public IExecutableModuleRewriter CodePaneModuleRewriter(QualifiedModuleName module) + { + var tokenStream = _tokenStreamCache.CodePaneTokenStream(module); + return _rewriterFactory.CodePaneRewriter(module, tokenStream); + } + + public IExecutableModuleRewriter AttributesModuleRewriter(QualifiedModuleName module) + { + var tokenStream = _tokenStreamCache.AttributesTokenStream(module); + return _rewriterFactory.AttributesRewriter(module, tokenStream); + } + } +} \ No newline at end of file diff --git a/Rubberduck.Parsing/Rewriter/RewritingManager.cs b/Rubberduck.Parsing/Rewriter/RewritingManager.cs new file mode 100644 index 0000000000..d8c9e155dd --- /dev/null +++ b/Rubberduck.Parsing/Rewriter/RewritingManager.cs @@ -0,0 +1,93 @@ +using System; +using System.Collections.Generic; + +namespace Rubberduck.Parsing.Rewriter +{ + public class RewritingManager : IRewritingManager + { + private readonly HashSet _activeCodePaneSessions = new HashSet(); + private readonly HashSet _activeAttributesSessions = new HashSet(); + + private readonly IRewriteSessionFactory _sessionFactory; + + private readonly object _invalidationLockObject = new object(); + + public RewritingManager(IRewriteSessionFactory sessionFactory) + { + _sessionFactory = sessionFactory; + } + + + public IRewriteSession CheckOutCodePaneSession() + { + var newSession = _sessionFactory.CodePaneSession(TryAllowExclusiveRewrite); + lock (_invalidationLockObject) + { + _activeCodePaneSessions.Add(newSession); + } + + return newSession; + } + + public IRewriteSession CheckOutAttributesSession() + { + var newSession = _sessionFactory.AttributesSession(TryAllowExclusiveRewrite); + lock (_invalidationLockObject) + { + _activeAttributesSessions.Add(newSession); + } + + return newSession; + } + + private bool TryAllowExclusiveRewrite(IRewriteSession rewriteSession) + { + lock (_invalidationLockObject) + { + if (!IsCurrentlyActive(rewriteSession)) + { + return false; + } + + InvalidateAllSessionsInternal(); + return true; + } + } + + private bool IsCurrentlyActive(IRewriteSession rewriteSession) + { + switch (rewriteSession) + { + case AttributesRewriteSession attributeSession: + return _activeAttributesSessions.Contains(attributeSession); + case CodePaneRewriteSession codePaneSession: + return _activeAttributesSessions.Contains(codePaneSession); + default: + throw new NotSupportedException(nameof(rewriteSession)); + } + } + + public void InvalidateAllSessions() + { + lock (_invalidationLockObject) + { + InvalidateAllSessionsInternal(); + } + } + + private void InvalidateAllSessionsInternal() + { + foreach (var rewriteSession in _activeCodePaneSessions) + { + rewriteSession.Invalidate(); + } + _activeCodePaneSessions.Clear(); + + foreach (var rewriteSession in _activeAttributesSessions) + { + rewriteSession.Invalidate(); + } + _activeAttributesSessions.Clear(); + } + } +} \ No newline at end of file diff --git a/Rubberduck.Parsing/Rewriter/StateTokenStreamCache.cs b/Rubberduck.Parsing/Rewriter/StateTokenStreamCache.cs new file mode 100644 index 0000000000..7ba464e164 --- /dev/null +++ b/Rubberduck.Parsing/Rewriter/StateTokenStreamCache.cs @@ -0,0 +1,27 @@ +using Antlr4.Runtime; +using Rubberduck.Parsing.VBA; +using Rubberduck.VBEditor; + +namespace Rubberduck.Parsing.Rewriter +{ + public class StateTokenStreamCache : ITokenStreamCache + { + private readonly RubberduckParserState _state; + + public StateTokenStreamCache(RubberduckParserState state) + { + _state = state; + } + + + public ITokenStream CodePaneTokenStream(QualifiedModuleName module) + { + return _state.GetRewriter(module).TokenStream; + } + + public ITokenStream AttributesTokenStream(QualifiedModuleName module) + { + return _state.GetAttributeRewriter(module).TokenStream; + } + } +} \ No newline at end of file From 31c4bb010bf230dca24b14d0543628218957703d Mon Sep 17 00:00:00 2001 From: Max Doerner Date: Sat, 27 Oct 2018 15:10:59 +0200 Subject: [PATCH 03/59] Wire up the IRewritingManager When parsing, all rewrite sessions get invalidated because any change, like removing components, changing referenced projects or their priority or reparsing components may invalidate the basis for a rewrite or make the underlying component inaccessible. --- Rubberduck.API/VBA/Parser.cs | 2 - .../Root/RubberduckIoCInstaller.cs | 7 +++ Rubberduck.Parsing/VBA/ParseCoordinator.cs | 9 +++- .../VBA/SynchronousParseCoordinator.cs | 18 +++++--- RubberduckTests/Mocks/MockParser.cs | 45 ++++++++++++++----- 5 files changed, 61 insertions(+), 20 deletions(-) diff --git a/Rubberduck.API/VBA/Parser.cs b/Rubberduck.API/VBA/Parser.cs index 727e638298..31495a0ed8 100644 --- a/Rubberduck.API/VBA/Parser.cs +++ b/Rubberduck.API/VBA/Parser.cs @@ -5,13 +5,11 @@ using System.Linq; using System.Runtime.InteropServices; using System.Threading; -using Rubberduck.Common; using Rubberduck.Parsing.ComReflection; using Rubberduck.Parsing.PreProcessing; using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.Symbols.DeclarationLoaders; using Rubberduck.Parsing.VBA; -using Rubberduck.Parsing.Symbols; using Rubberduck.Parsing.UIContext; using Rubberduck.Parsing.VBA.ComReferenceLoading; using Rubberduck.Parsing.VBA.DeclarationCaching; diff --git a/Rubberduck.Main/Root/RubberduckIoCInstaller.cs b/Rubberduck.Main/Root/RubberduckIoCInstaller.cs index 4dda7dbdee..77494ea791 100644 --- a/Rubberduck.Main/Root/RubberduckIoCInstaller.cs +++ b/Rubberduck.Main/Root/RubberduckIoCInstaller.cs @@ -122,6 +122,10 @@ public void Install(IWindsorContainer container, IConfigurationStore store) RegisterParsingEngine(container); RegisterTypeLibApi(container); + container.Register(Component.For() + .ImplementedBy() + .LifestyleSingleton()); + container.Register(Component.For() .LifestyleSingleton()); container.Register(Component.For() @@ -288,6 +292,9 @@ private void RegisterSpecialFactories(IWindsorContainer container) container.Register(Component.For() .ImplementedBy() .LifestyleSingleton()); + container.Register(Component.For() + .ImplementedBy() + .LifestyleSingleton()); } private void RegisterQuickFixes(IWindsorContainer container, Assembly[] assembliesToRegister) diff --git a/Rubberduck.Parsing/VBA/ParseCoordinator.cs b/Rubberduck.Parsing/VBA/ParseCoordinator.cs index e8685888d3..eec03d5602 100644 --- a/Rubberduck.Parsing/VBA/ParseCoordinator.cs +++ b/Rubberduck.Parsing/VBA/ParseCoordinator.cs @@ -8,6 +8,7 @@ using System.Diagnostics; using System.Linq; using NLog; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.VBA.Extensions; using Rubberduck.VBEditor.SafeComWrappers.Abstract; @@ -27,6 +28,7 @@ public class ParseCoordinator : IParseCoordinator private readonly IProjectManager _projectManager; private readonly IParsingCacheService _parsingCacheService; private readonly IParserStateManager _parserStateManager; + private readonly IRewritingManager _rewritingManager; private readonly ConcurrentStack _requestorStack; private bool _isSuspended; @@ -35,7 +37,8 @@ public ParseCoordinator( IParsingStageService parsingStageService, IParsingCacheService parsingCacheService, IProjectManager projectManager, - IParserStateManager parserStateManager) + IParserStateManager parserStateManager, + IRewritingManager rewritingManager = null) { if (state == null) { @@ -63,6 +66,7 @@ public ParseCoordinator( _projectManager = projectManager; _parsingCacheService = parsingCacheService; _parserStateManager = parserStateManager; + _rewritingManager = rewritingManager; state.ParseRequest += ReparseRequested; state.SuspendRequest += SuspendRequested; @@ -433,6 +437,9 @@ protected void ParseAllInternal(object requestor, CancellationToken token) _parserStateManager.SetStatusAndFireStateChanged(requestor, ParserState.Started, token); token.ThrowIfCancellationRequested(); + _rewritingManager?.InvalidateAllSessions(); + token.ThrowIfCancellationRequested(); + _projectManager.RefreshProjects(); token.ThrowIfCancellationRequested(); diff --git a/Rubberduck.Parsing/VBA/SynchronousParseCoordinator.cs b/Rubberduck.Parsing/VBA/SynchronousParseCoordinator.cs index 3bf284076c..ce3d5acd6d 100644 --- a/Rubberduck.Parsing/VBA/SynchronousParseCoordinator.cs +++ b/Rubberduck.Parsing/VBA/SynchronousParseCoordinator.cs @@ -1,5 +1,6 @@ using System; using System.Threading; +using Rubberduck.Parsing.Rewriter; namespace Rubberduck.Parsing.VBA { @@ -10,13 +11,16 @@ public SynchronousParseCoordinator( IParsingStageService parsingStageService, IParsingCacheService parsingCacheService, IProjectManager projectManager, - IParserStateManager parserStateManager) : base( - state, - parsingStageService, - parsingCacheService, - projectManager, - parserStateManager) - { } + IParserStateManager parserStateManager, + IRewritingManager rewritingManager = null) + :base( + state, + parsingStageService, + parsingCacheService, + projectManager, + parserStateManager, + rewritingManager) + {} public override void BeginParse(object sender) { diff --git a/RubberduckTests/Mocks/MockParser.cs b/RubberduckTests/Mocks/MockParser.cs index 2cba9b7e40..779531698a 100644 --- a/RubberduckTests/Mocks/MockParser.cs +++ b/RubberduckTests/Mocks/MockParser.cs @@ -43,22 +43,27 @@ public static RubberduckParserState ParseString(string inputCode, out QualifiedM return parser.State; } - public static SynchronousParseCoordinator Create(IVBE vbe, string serializedDeclarationsPath = null) + public static (SynchronousParseCoordinator parser, IRewritingManager rewritingManager) CreateWithRewriteManager(IVBE vbe, string serializedComProjectsPath = null) { var vbeEvents = MockVbeEvents.CreateMockVbeEvents(new Moq.Mock()); var declarationFinderFactory = new DeclarationFinderFactory(); var projectRepository = new ProjectsRepository(vbe); var state = new RubberduckParserState(vbe, projectRepository, declarationFinderFactory, vbeEvents.Object); - return Create(vbe, state, projectRepository, serializedDeclarationsPath); + return CreateWithRewriteManager(vbe, state, projectRepository, serializedComProjectsPath); + } + + public static SynchronousParseCoordinator Create(IVBE vbe, string serializedDeclarationsPath = null) + { + return CreateWithRewriteManager(vbe, serializedDeclarationsPath).parser; } - public static SynchronousParseCoordinator Create(IVBE vbe, RubberduckParserState state, IProjectsRepository projectRepository, string serializedDeclarationsPath = null) + public static (SynchronousParseCoordinator parser, IRewritingManager rewritingManager) CreateWithRewriteManager(IVBE vbe, RubberduckParserState state, IProjectsRepository projectRepository, string serializedComProjectsPath = null) { var vbeVersion = double.Parse(vbe.Version, CultureInfo.InvariantCulture); var compilationArgumentsProvider = MockCompilationArgumentsProvider(vbeVersion); var compilationsArgumentsCache = new CompilationArgumentsCache(compilationArgumentsProvider); - var path = serializedDeclarationsPath ?? + var path = serializedComProjectsPath ?? Path.Combine(Path.GetDirectoryName(Assembly.GetAssembly(typeof(MockParser)).Location), "TestFiles", "Resolver"); var preprocessorErrorListenerFactory = new PreprocessingParseErrorListenerFactory(); var preprocessorParser = new VBAPreprocessorParser(preprocessorErrorListenerFactory, preprocessorErrorListenerFactory); @@ -126,13 +131,25 @@ public static SynchronousParseCoordinator Create(IVBE vbe, RubberduckParserState supertypeClearer, compilationsArgumentsCache ); + var tokenStreamCache = new StateTokenStreamCache(state); + var rewriterProvider = new RewriterProvider(tokenStreamCache, moduleRewriterFactory); + var rewriteSessionFactory = new RewriteSessionFactory(state, rewriterProvider); + var rewritingManager = new RewritingManager(rewriteSessionFactory); - return new SynchronousParseCoordinator( + var parser = new SynchronousParseCoordinator( state, parsingStageService, parsingCacheService, projectManager, - parserStateManager); + parserStateManager, + rewritingManager); + + return (parser, rewritingManager); + } + + public static SynchronousParseCoordinator Create(IVBE vbe, RubberduckParserState state, IProjectsRepository projectRepository, string serializedComProjectsPath = null) + { + return CreateWithRewriteManager(vbe, state, projectRepository, serializedComProjectsPath).parser; } private static ICompilationArgumentsProvider MockCompilationArgumentsProvider(double vbeVersion) @@ -147,13 +164,21 @@ private static ICompilationArgumentsProvider MockCompilationArgumentsProvider(do return compilationArgumentsProvider; } - public static RubberduckParserState CreateAndParse(IVBE vbe, string serializedDeclarationsPath = null) + public static (RubberduckParserState state, IRewritingManager rewritingManager) CreateAndParseWithRewritingManager(IVBE vbe, string serializedComProjectsPath = null) { - var parser = Create(vbe, serializedDeclarationsPath); + var (parser, rewritingManager) = CreateWithRewriteManager(vbe, serializedComProjectsPath); parser.Parse(new CancellationTokenSource()); - if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } - return parser.State; + return (parser.State, rewritingManager); + } + + public static RubberduckParserState CreateAndParse(IVBE vbe, string serializedComProjectsPath = null) + { + return CreateAndParseWithRewritingManager(vbe, serializedComProjectsPath).state; } private static readonly HashSet ProceduralTypes = From 52be1e0358db418cab3d9fa5b206e2d4498d60e3 Mon Sep 17 00:00:00 2001 From: Max Doerner Date: Sat, 27 Oct 2018 15:20:13 +0200 Subject: [PATCH 04/59] Expose the IRewritingManager on the RubberduckParserState This change is to be reverted later. It allows to decouple the work necessary to change the users of the IModuleRewriter to use the IRewritingManager from the work necessary to constructor inject the IRewritingManager into them. (The latter is a lot of work in the tests.) Here, property injection is used because the construction of the RewritingManager ultimately depends on the RubberduckParserState to be there. --- Rubberduck.Parsing/VBA/ParseCoordinator.cs | 4 ++++ Rubberduck.Parsing/VBA/RubberduckParserState.cs | 5 ++++- 2 files changed, 8 insertions(+), 1 deletion(-) diff --git a/Rubberduck.Parsing/VBA/ParseCoordinator.cs b/Rubberduck.Parsing/VBA/ParseCoordinator.cs index eec03d5602..a8a1490cf1 100644 --- a/Rubberduck.Parsing/VBA/ParseCoordinator.cs +++ b/Rubberduck.Parsing/VBA/ParseCoordinator.cs @@ -72,6 +72,10 @@ public ParseCoordinator( state.SuspendRequest += SuspendRequested; _requestorStack = new ConcurrentStack(); + + //todo: Remove this again in favor of injection of the IRewritingManager into the callers RubberduckParserState.RewritingManager. + //This gets property injected here because the construction of the rewritingManager ultimately depend on the RubberduckParserState. + state.RewritingManager = rewritingManager; } // In production, the cancellation token should be accessed inside the CancellationSyncObject diff --git a/Rubberduck.Parsing/VBA/RubberduckParserState.cs b/Rubberduck.Parsing/VBA/RubberduckParserState.cs index 938679b663..254cba8fc8 100644 --- a/Rubberduck.Parsing/VBA/RubberduckParserState.cs +++ b/Rubberduck.Parsing/VBA/RubberduckParserState.cs @@ -1066,13 +1066,16 @@ private void ClearAsTypeDeclarationPointingToReference(QualifiedModuleName refer } } - public void AddAttributesRewriter(QualifiedModuleName module, IExecutableModuleRewriter attributesRewriter) { var key = module; _moduleStates[key].SetAttributesRewriter(attributesRewriter); } + //todo: Remove this again in favor of injection of the IRewritingManager into the callers. + public IRewritingManager RewritingManager { get; internal set; } + + private bool _isDisposed; public void Dispose() { From e28fadde094d96f436955b791741099664906f77 Mon Sep 17 00:00:00 2001 From: Max Doerner Date: Sat, 27 Oct 2018 16:22:06 +0200 Subject: [PATCH 05/59] Optionally pass a IRewriteSession to quickfixes This is a first step to make them use the IRewriteSession model. Passing it is, will allow the QuickFixProvider to pass in the same session for all results when fixing more than one resulte.g. for FixAll. --- Rubberduck.CodeAnalysis/Inspections/Abstract/QuickFixBase.cs | 3 ++- .../QuickFixes/AccessSheetUsingCodeNameQuickFix.cs | 3 ++- .../QuickFixes/AddIdentifierToWhiteListQuickFix.cs | 3 ++- Rubberduck.CodeAnalysis/QuickFixes/AddStepOneQuickFix.cs | 2 +- .../QuickFixes/ApplicationWorksheetFunctionQuickFix.cs | 3 ++- .../QuickFixes/AssignedByValParameterMakeLocalCopyQuickFix.cs | 2 +- .../QuickFixes/ChangeDimToPrivateQuickFix.cs | 3 ++- .../QuickFixes/ChangeIntegerToLongQuickFix.cs | 2 +- .../QuickFixes/ChangeProcedureToFunctionQuickFix.cs | 3 ++- .../QuickFixes/ConvertToProcedureQuickFix.cs | 3 ++- .../QuickFixes/DeclareAsExplicitVariantQuickFix.cs | 3 ++- Rubberduck.CodeAnalysis/QuickFixes/EncapsulateFieldQuickFix.cs | 3 ++- Rubberduck.CodeAnalysis/QuickFixes/IgnoreOnceQuickFix.cs | 3 ++- .../QuickFixes/IntroduceLocalVariableQuickFix.cs | 3 ++- .../QuickFixes/IsMissingOnInappropriateArgumentQuickFix.cs | 3 ++- .../QuickFixes/MakeSingleLineParameterQuickFix.cs | 3 ++- .../QuickFixes/MoveFieldCloserToUsageQuickFix.cs | 3 ++- Rubberduck.CodeAnalysis/QuickFixes/OptionExplicitQuickFix.cs | 3 ++- .../QuickFixes/PassParameterByReferenceQuickFix.cs | 3 ++- .../QuickFixes/PassParameterByValueQuickFix.cs | 3 ++- Rubberduck.CodeAnalysis/QuickFixes/RemoveCommentQuickFix.cs | 3 ++- .../QuickFixes/RemoveDuplicatedAnnotationQuickFix.cs | 2 +- .../QuickFixes/RemoveEmptyElseBlockQuickFix.cs | 2 +- .../QuickFixes/RemoveEmptyIfBlockQuickFix.cs | 2 +- .../QuickFixes/RemoveExplicitByRefModifierQuickFix.cs | 2 +- .../QuickFixes/RemoveExplicitCallStatmentQuickFix.cs | 3 ++- .../QuickFixes/RemoveExplicitLetStatementQuickFix.cs | 3 ++- Rubberduck.CodeAnalysis/QuickFixes/RemoveLocalErrorQuickFix.cs | 3 ++- .../QuickFixes/RemoveOptionBaseStatementQuickFix.cs | 3 ++- Rubberduck.CodeAnalysis/QuickFixes/RemoveStepOneQuickFix.cs | 2 +- .../QuickFixes/RemoveStopKeywordQuickFix.cs | 3 ++- Rubberduck.CodeAnalysis/QuickFixes/RemoveTypeHintsQuickFix.cs | 3 ++- .../QuickFixes/RemoveUnassignedIdentifierQuickFix.cs | 3 ++- .../QuickFixes/RemoveUnassignedVariableUsageQuickFix.cs | 3 ++- .../QuickFixes/RemoveUnusedDeclarationQuickFix.cs | 3 ++- .../QuickFixes/RemoveUnusedParameterQuickFix.cs | 3 ++- .../QuickFixes/RenameDeclarationQuickFix.cs | 3 ++- .../QuickFixes/ReplaceEmptyStringLiteralStatementQuickFix.cs | 3 ++- .../QuickFixes/ReplaceGlobalModifierQuickFix.cs | 3 ++- .../ReplaceIfElseWithConditionalStatementQuickFix.cs | 3 ++- .../QuickFixes/ReplaceObsoleteCommentMarkerQuickFix.cs | 3 ++- .../QuickFixes/ReplaceObsoleteErrorStatementQuickFix.cs | 3 ++- .../QuickFixes/RestoreErrorHandlingQuickFix.cs | 3 ++- .../QuickFixes/SetExplicitVariantReturnTypeQuickFix.cs | 3 ++- .../QuickFixes/SpecifyExplicitByRefModifierQuickFix.cs | 2 +- .../QuickFixes/SpecifyExplicitPublicModifierQuickFix.cs | 3 ++- .../QuickFixes/SplitMultipleDeclarationsQuickFix.cs | 3 ++- .../QuickFixes/UntypedFunctionUsageQuickFix.cs | 3 ++- .../QuickFixes/UseSetKeywordForObjectAssignmentQuickFix.cs | 3 ++- .../QuickFixes/WriteOnlyPropertyQuickFix.cs | 3 ++- Rubberduck.Parsing/Inspections/Abstract/IQuickFix.cs | 3 ++- 51 files changed, 93 insertions(+), 51 deletions(-) diff --git a/Rubberduck.CodeAnalysis/Inspections/Abstract/QuickFixBase.cs b/Rubberduck.CodeAnalysis/Inspections/Abstract/QuickFixBase.cs index 124c229ec5..9d684db1ec 100644 --- a/Rubberduck.CodeAnalysis/Inspections/Abstract/QuickFixBase.cs +++ b/Rubberduck.CodeAnalysis/Inspections/Abstract/QuickFixBase.cs @@ -3,6 +3,7 @@ using System.Linq; using NLog; using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.VBA; using Rubberduck.Parsing.VBA.Extensions; @@ -39,7 +40,7 @@ public void RemoveInspections(params Type[] inspections) _supportedInspections = _supportedInspections.Except(inspections).ToHashSet(); } - public abstract void Fix(IInspectionResult result); + public abstract void Fix(IInspectionResult result, IRewriteSession rewriteSession = null); public abstract string Description(IInspectionResult result); public abstract bool CanFixInProcedure { get; } diff --git a/Rubberduck.CodeAnalysis/QuickFixes/AccessSheetUsingCodeNameQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/AccessSheetUsingCodeNameQuickFix.cs index ad08179cc5..0669973444 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/AccessSheetUsingCodeNameQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/AccessSheetUsingCodeNameQuickFix.cs @@ -6,6 +6,7 @@ using Rubberduck.Parsing; using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes @@ -20,7 +21,7 @@ public AccessSheetUsingCodeNameQuickFix(RubberduckParserState state) _state = state; } - public override void Fix(IInspectionResult result) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) { var referenceResult = (IdentifierReferenceInspectionResult)result; diff --git a/Rubberduck.CodeAnalysis/QuickFixes/AddIdentifierToWhiteListQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/AddIdentifierToWhiteListQuickFix.cs index 5c7dc054fd..a175c4c54d 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/AddIdentifierToWhiteListQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/AddIdentifierToWhiteListQuickFix.cs @@ -2,6 +2,7 @@ using Rubberduck.Inspections.Abstract; using Rubberduck.Inspections.Concrete; using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Settings; using Rubberduck.SettingsProvider; @@ -17,7 +18,7 @@ public AddIdentifierToWhiteListQuickFix(IPersistanceService()); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/ChangeDimToPrivateQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/ChangeDimToPrivateQuickFix.cs index a83c0499d3..0a6722630b 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/ChangeDimToPrivateQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/ChangeDimToPrivateQuickFix.cs @@ -2,6 +2,7 @@ using Rubberduck.Inspections.Concrete; using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes @@ -16,7 +17,7 @@ public ChangeDimToPrivateQuickFix(RubberduckParserState state) _state = state; } - public override void Fix(IInspectionResult result) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) { var rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/ChangeIntegerToLongQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/ChangeIntegerToLongQuickFix.cs index 1ebcf98399..b537da2d14 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/ChangeIntegerToLongQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/ChangeIntegerToLongQuickFix.cs @@ -23,7 +23,7 @@ public ChangeIntegerToLongQuickFix(RubberduckParserState state) _state = state; } - public override void Fix(IInspectionResult result) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) { var rewriter = _state.GetRewriter(result.Target); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/ChangeProcedureToFunctionQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/ChangeProcedureToFunctionQuickFix.cs index d85ce81c22..fcfd26ea76 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/ChangeProcedureToFunctionQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/ChangeProcedureToFunctionQuickFix.cs @@ -5,6 +5,7 @@ using Rubberduck.Parsing; using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.Symbols; using Rubberduck.Parsing.VBA; @@ -20,7 +21,7 @@ public ChangeProcedureToFunctionQuickFix(RubberduckParserState state) _state = state; } - public override void Fix(IInspectionResult result) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) { var parameterizedDeclaration = (IParameterizedDeclaration) result.Target; var arg = parameterizedDeclaration.Parameters.Cast().First(p => p.IsByRef || p.IsImplicitByRef); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/ConvertToProcedureQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/ConvertToProcedureQuickFix.cs index 9b037f0e3a..afd57a0db8 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/ConvertToProcedureQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/ConvertToProcedureQuickFix.cs @@ -6,6 +6,7 @@ using Rubberduck.Parsing; using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.Symbols; using Rubberduck.Parsing.VBA; @@ -21,7 +22,7 @@ public ConvertToProcedureQuickFix(RubberduckParserState state) _state = state; } - public override void Fix(IInspectionResult result) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) { switch (result.Context) { diff --git a/Rubberduck.CodeAnalysis/QuickFixes/DeclareAsExplicitVariantQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/DeclareAsExplicitVariantQuickFix.cs index 28a0db45bd..e0bc881be3 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/DeclareAsExplicitVariantQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/DeclareAsExplicitVariantQuickFix.cs @@ -3,6 +3,7 @@ using Rubberduck.Inspections.Concrete; using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes @@ -17,7 +18,7 @@ public DeclareAsExplicitVariantQuickFix(RubberduckParserState state) _state = state; } - public override void Fix(IInspectionResult result) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) { var rewriter = _state.GetRewriter(result.Target); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/EncapsulateFieldQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/EncapsulateFieldQuickFix.cs index 01b8545c1a..919de89b2a 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/EncapsulateFieldQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/EncapsulateFieldQuickFix.cs @@ -1,6 +1,7 @@ using Rubberduck.Inspections.Abstract; using Rubberduck.Inspections.Concrete; using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.VBA; using Rubberduck.Refactorings.EncapsulateField; using Rubberduck.SmartIndenter; @@ -23,7 +24,7 @@ public EncapsulateFieldQuickFix(IVBE vbe, RubberduckParserState state, IIndenter _indenter = indenter; } - public override void Fix(IInspectionResult result) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) { using (var view = new EncapsulateFieldDialog(new EncapsulateFieldViewModel(_state, _indenter))) { diff --git a/Rubberduck.CodeAnalysis/QuickFixes/IgnoreOnceQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/IgnoreOnceQuickFix.cs index 65ae67fd15..ce7052146a 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/IgnoreOnceQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/IgnoreOnceQuickFix.cs @@ -8,6 +8,7 @@ using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Inspections; using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes @@ -26,7 +27,7 @@ public IgnoreOnceQuickFix(RubberduckParserState state, IEnumerable public override bool CanFixInModule => false; public override bool CanFixInProject => false; - public override void Fix(IInspectionResult result) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) { var annotationText = $"'@Ignore {result.Inspection.AnnotationName}"; diff --git a/Rubberduck.CodeAnalysis/QuickFixes/IntroduceLocalVariableQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/IntroduceLocalVariableQuickFix.cs index eb17717cc4..847e9b30fd 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/IntroduceLocalVariableQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/IntroduceLocalVariableQuickFix.cs @@ -5,6 +5,7 @@ using Rubberduck.Parsing; using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes @@ -23,7 +24,7 @@ public IntroduceLocalVariableQuickFix(RubberduckParserState state) public override bool CanFixInModule => true; public override bool CanFixInProject => true; - public override void Fix(IInspectionResult result) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) { var identifierContext = result.Target.Context; var enclosingStatmentContext = identifierContext.GetAncestor(); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/IsMissingOnInappropriateArgumentQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/IsMissingOnInappropriateArgumentQuickFix.cs index 2b13021482..65fb994536 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/IsMissingOnInappropriateArgumentQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/IsMissingOnInappropriateArgumentQuickFix.cs @@ -6,6 +6,7 @@ using Rubberduck.Parsing; using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.Symbols; using Rubberduck.Parsing.VBA; @@ -21,7 +22,7 @@ public IsMissingOnInappropriateArgumentQuickFix(RubberduckParserState state) _state = state; } - public override void Fix(IInspectionResult result) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) { if (!(result.Properties is ParameterDeclaration parameter)) { diff --git a/Rubberduck.CodeAnalysis/QuickFixes/MakeSingleLineParameterQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/MakeSingleLineParameterQuickFix.cs index 2bd56531a8..0c0e97956e 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/MakeSingleLineParameterQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/MakeSingleLineParameterQuickFix.cs @@ -1,6 +1,7 @@ using Rubberduck.Inspections.Abstract; using Rubberduck.Inspections.Concrete; using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.VBA; using Rubberduck.Parsing.VBA.Extensions; @@ -16,7 +17,7 @@ public MakeSingleLineParameterQuickFix(RubberduckParserState state) _state = state; } - public override void Fix(IInspectionResult result) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) { var rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/MoveFieldCloserToUsageQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/MoveFieldCloserToUsageQuickFix.cs index 9a5634222f..7ac6c44185 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/MoveFieldCloserToUsageQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/MoveFieldCloserToUsageQuickFix.cs @@ -2,6 +2,7 @@ using Rubberduck.Inspections.Concrete; using Rubberduck.Interaction; using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.VBA; using Rubberduck.Refactorings.MoveCloserToUsage; using Rubberduck.Resources.Inspections; @@ -23,7 +24,7 @@ public MoveFieldCloserToUsageQuickFix(IVBE vbe, RubberduckParserState state, IMe _messageBox = messageBox; } - public override void Fix(IInspectionResult result) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) { var refactoring = new MoveCloserToUsageRefactoring(_vbe, _state, _messageBox); refactoring.Refactor(result.Target); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/OptionExplicitQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/OptionExplicitQuickFix.cs index b223170ef9..49135709cc 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/OptionExplicitQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/OptionExplicitQuickFix.cs @@ -3,6 +3,7 @@ using Rubberduck.Inspections.Concrete; using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes @@ -17,7 +18,7 @@ public OptionExplicitQuickFix(RubberduckParserState state) _state = state; } - public override void Fix(IInspectionResult result) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) { var rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); rewriter.InsertBefore(0, Tokens.Option + ' ' + Tokens.Explicit + Environment.NewLine + Environment.NewLine); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/PassParameterByReferenceQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/PassParameterByReferenceQuickFix.cs index 590f81c512..8be2a9860f 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/PassParameterByReferenceQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/PassParameterByReferenceQuickFix.cs @@ -2,6 +2,7 @@ using Rubberduck.Inspections.Concrete; using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes @@ -16,7 +17,7 @@ public PassParameterByReferenceQuickFix(RubberduckParserState state) _state = state; } - public override void Fix(IInspectionResult result) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) { var rewriter = _state.GetRewriter(result.Target); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/PassParameterByValueQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/PassParameterByValueQuickFix.cs index 0689f17bfd..077a6b7a30 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/PassParameterByValueQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/PassParameterByValueQuickFix.cs @@ -4,6 +4,7 @@ using Rubberduck.Inspections.Concrete; using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.Symbols; using Rubberduck.Parsing.VBA; using Rubberduck.VBEditor; @@ -20,7 +21,7 @@ public PassParameterByValueQuickFix(RubberduckParserState state) _state = state; } - public override void Fix(IInspectionResult result) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) { if (result.Target.ParentDeclaration.DeclarationType == DeclarationType.Event || _state.DeclarationFinder.FindAllInterfaceMembers().Contains(result.Target.ParentDeclaration)) diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RemoveCommentQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RemoveCommentQuickFix.cs index 6f9e55c905..90fea1b043 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/RemoveCommentQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/RemoveCommentQuickFix.cs @@ -1,6 +1,7 @@ using Rubberduck.Inspections.Abstract; using Rubberduck.Inspections.Concrete; using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes @@ -15,7 +16,7 @@ public RemoveCommentQuickFix(RubberduckParserState state) _state = state; } - public override void Fix(IInspectionResult result) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) { var rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); rewriter.Remove(result.Context); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RemoveDuplicatedAnnotationQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RemoveDuplicatedAnnotationQuickFix.cs index 508759ee69..c0f62838d6 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/RemoveDuplicatedAnnotationQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/RemoveDuplicatedAnnotationQuickFix.cs @@ -21,7 +21,7 @@ public RemoveDuplicatedAnnotationQuickFix(RubberduckParserState state) _state = state; } - public override void Fix(IInspectionResult result) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) { var rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RemoveEmptyElseBlockQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RemoveEmptyElseBlockQuickFix.cs index 2968a5b88b..bcb9ad9b8f 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/RemoveEmptyElseBlockQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/RemoveEmptyElseBlockQuickFix.cs @@ -17,7 +17,7 @@ public RemoveEmptyElseBlockQuickFix(RubberduckParserState state) _state = state; } - public override void Fix(IInspectionResult result) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) { var rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RemoveEmptyIfBlockQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RemoveEmptyIfBlockQuickFix.cs index f928ecb161..26bf7c9923 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/RemoveEmptyIfBlockQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/RemoveEmptyIfBlockQuickFix.cs @@ -21,7 +21,7 @@ public RemoveEmptyIfBlockQuickFix(RubberduckParserState state) _state = state; } - public override void Fix(IInspectionResult result) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) { var rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RemoveExplicitByRefModifierQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RemoveExplicitByRefModifierQuickFix.cs index 66a0a0efcb..225582c16e 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/RemoveExplicitByRefModifierQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/RemoveExplicitByRefModifierQuickFix.cs @@ -21,7 +21,7 @@ public RemoveExplicitByRefModifierQuickFix(RubberduckParserState state) _state = state; } - public override void Fix(IInspectionResult result) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) { var context = (VBAParser.ArgContext) result.Context; diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RemoveExplicitCallStatmentQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RemoveExplicitCallStatmentQuickFix.cs index 09e0a7b902..8aef5ff215 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/RemoveExplicitCallStatmentQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/RemoveExplicitCallStatmentQuickFix.cs @@ -2,6 +2,7 @@ using Rubberduck.Inspections.Concrete; using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes @@ -16,7 +17,7 @@ public RemoveExplicitCallStatmentQuickFix(RubberduckParserState state) _state = state; } - public override void Fix(IInspectionResult result) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) { var rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RemoveExplicitLetStatementQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RemoveExplicitLetStatementQuickFix.cs index bb891e8a67..4d617dabf2 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/RemoveExplicitLetStatementQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/RemoveExplicitLetStatementQuickFix.cs @@ -3,6 +3,7 @@ using Rubberduck.Inspections.Concrete; using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes @@ -17,7 +18,7 @@ public RemoveExplicitLetStatementQuickFix(RubberduckParserState state) _state = state; } - public override void Fix(IInspectionResult result) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) { var rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RemoveLocalErrorQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RemoveLocalErrorQuickFix.cs index 1982d006b4..73c19cd37c 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/RemoveLocalErrorQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/RemoveLocalErrorQuickFix.cs @@ -2,6 +2,7 @@ using Rubberduck.Inspections.Concrete; using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes @@ -16,7 +17,7 @@ public RemoveLocalErrorQuickFix(RubberduckParserState state) _state = state; } - public override void Fix(IInspectionResult result) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) { var errorStmt = (VBAParser.OnErrorStmtContext)result.Context; diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RemoveOptionBaseStatementQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RemoveOptionBaseStatementQuickFix.cs index 2b202958aa..b946277096 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/RemoveOptionBaseStatementQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/RemoveOptionBaseStatementQuickFix.cs @@ -1,6 +1,7 @@ using Rubberduck.Inspections.Abstract; using Rubberduck.Inspections.Concrete; using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes @@ -15,7 +16,7 @@ public RemoveOptionBaseStatementQuickFix(RubberduckParserState state) _state = state; } - public override void Fix(IInspectionResult result) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) { var rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); rewriter.Remove(result.Context); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RemoveStepOneQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RemoveStepOneQuickFix.cs index 88155453a9..0a94043ddb 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/RemoveStepOneQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/RemoveStepOneQuickFix.cs @@ -24,7 +24,7 @@ public RemoveStepOneQuickFix(RubberduckParserState state) public override string Description(IInspectionResult result) => Resources.Inspections.QuickFixes.RemoveStepOneQuickFix; - public override void Fix(IInspectionResult result) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) { IExecutableModuleRewriter rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); var context = result.Context; diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RemoveStopKeywordQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RemoveStopKeywordQuickFix.cs index b4bb155545..bb61ae64fd 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/RemoveStopKeywordQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/RemoveStopKeywordQuickFix.cs @@ -1,6 +1,7 @@ using Rubberduck.Inspections.Abstract; using Rubberduck.Inspections.Concrete; using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes @@ -15,7 +16,7 @@ public RemoveStopKeywordQuickFix(RubberduckParserState state) _state = state; } - public override void Fix(IInspectionResult result) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) { var rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); rewriter.Remove(result.Context); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RemoveTypeHintsQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RemoveTypeHintsQuickFix.cs index 964837b6c6..ddaa597a4f 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/RemoveTypeHintsQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/RemoveTypeHintsQuickFix.cs @@ -3,6 +3,7 @@ using Rubberduck.Parsing; using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.Symbols; using Rubberduck.Parsing.VBA; @@ -18,7 +19,7 @@ public RemoveTypeHintsQuickFix(RubberduckParserState state) _state = state; } - public override void Fix(IInspectionResult result) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) { if (!string.IsNullOrWhiteSpace(result.Target.TypeHint)) { diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RemoveUnassignedIdentifierQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RemoveUnassignedIdentifierQuickFix.cs index e85da40746..4d314052ef 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/RemoveUnassignedIdentifierQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/RemoveUnassignedIdentifierQuickFix.cs @@ -1,6 +1,7 @@ using Rubberduck.Inspections.Abstract; using Rubberduck.Inspections.Concrete; using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes @@ -15,7 +16,7 @@ public RemoveUnassignedIdentifierQuickFix(RubberduckParserState state) _state = state; } - public override void Fix(IInspectionResult result) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) { var rewriter = _state.GetRewriter(result.Target); rewriter.Remove(result.Target); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RemoveUnassignedVariableUsageQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RemoveUnassignedVariableUsageQuickFix.cs index 5a2465ac06..d4d3d08ccf 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/RemoveUnassignedVariableUsageQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/RemoveUnassignedVariableUsageQuickFix.cs @@ -4,6 +4,7 @@ using Rubberduck.Parsing; using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.Symbols; using Rubberduck.Parsing.VBA; @@ -19,7 +20,7 @@ public RemoveUnassignedVariableUsageQuickFix(RubberduckParserState state) _state = state; } - public override void Fix(IInspectionResult result) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) { var rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RemoveUnusedDeclarationQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RemoveUnusedDeclarationQuickFix.cs index 395707237b..0ae3f345f9 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/RemoveUnusedDeclarationQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/RemoveUnusedDeclarationQuickFix.cs @@ -1,6 +1,7 @@ using Rubberduck.Inspections.Abstract; using Rubberduck.Inspections.Concrete; using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes @@ -18,7 +19,7 @@ public RemoveUnusedDeclarationQuickFix(RubberduckParserState state) _state = state; } - public override void Fix(IInspectionResult result) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) { var rewriter = _state.GetRewriter(result.Target); rewriter.Remove(result.Target); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RemoveUnusedParameterQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RemoveUnusedParameterQuickFix.cs index 77017f84c4..0bc2aef419 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/RemoveUnusedParameterQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/RemoveUnusedParameterQuickFix.cs @@ -2,6 +2,7 @@ using Rubberduck.Inspections.Concrete; using Rubberduck.Interaction; using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.VBA; using Rubberduck.Refactorings.RemoveParameters; using Rubberduck.UI.Refactorings.RemoveParameters; @@ -23,7 +24,7 @@ public RemoveUnusedParameterQuickFix(IVBE vbe, RubberduckParserState state, IMes _messageBox = messageBox; } - public override void Fix(IInspectionResult result) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) { using (var dialog = new RemoveParametersDialog(new RemoveParametersViewModel(_state))) { diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RenameDeclarationQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RenameDeclarationQuickFix.cs index ab6c2817a8..75d0ef30ae 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/RenameDeclarationQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/RenameDeclarationQuickFix.cs @@ -3,6 +3,7 @@ using Rubberduck.Inspections.Concrete; using Rubberduck.Interaction; using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.VBA; using Rubberduck.Refactorings.Rename; using Rubberduck.Resources; @@ -25,7 +26,7 @@ public RenameDeclarationQuickFix(IVBE vbe, RubberduckParserState state, IMessage _messageBox = messageBox; } - public override void Fix(IInspectionResult result) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) { using (var view = new RenameDialog(new RenameViewModel(_state))) { diff --git a/Rubberduck.CodeAnalysis/QuickFixes/ReplaceEmptyStringLiteralStatementQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/ReplaceEmptyStringLiteralStatementQuickFix.cs index cc62ac489b..a2284ebb23 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/ReplaceEmptyStringLiteralStatementQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/ReplaceEmptyStringLiteralStatementQuickFix.cs @@ -1,6 +1,7 @@ using Rubberduck.Inspections.Abstract; using Rubberduck.Inspections.Concrete; using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes @@ -15,7 +16,7 @@ public ReplaceEmptyStringLiteralStatementQuickFix(RubberduckParserState state) _state = state; } - public override void Fix(IInspectionResult result) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) { var rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); rewriter.Replace(result.Context, "vbNullString"); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/ReplaceGlobalModifierQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/ReplaceGlobalModifierQuickFix.cs index 2b1da070b5..c99e7e1670 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/ReplaceGlobalModifierQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/ReplaceGlobalModifierQuickFix.cs @@ -4,6 +4,7 @@ using Rubberduck.Parsing; using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes @@ -18,7 +19,7 @@ public ReplaceGlobalModifierQuickFix(RubberduckParserState state) _state = state; } - public override void Fix(IInspectionResult result) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) { var rewriter = _state.GetRewriter(result.Target); rewriter.Replace(((ParserRuleContext)result.Context.Parent.Parent).GetDescendent(), Tokens.Public); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/ReplaceIfElseWithConditionalStatementQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/ReplaceIfElseWithConditionalStatementQuickFix.cs index 502957de05..9e5180b67e 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/ReplaceIfElseWithConditionalStatementQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/ReplaceIfElseWithConditionalStatementQuickFix.cs @@ -3,6 +3,7 @@ using Rubberduck.Parsing; using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.Symbols; using Rubberduck.Parsing.VBA; @@ -18,7 +19,7 @@ public ReplaceIfElseWithConditionalStatementQuickFix(RubberduckParserState state _state = state; } - public override void Fix(IInspectionResult result) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) { var ifContext = (VBAParser.IfStmtContext) result.Context; var letStmt = ifContext.block().GetDescendent(); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/ReplaceObsoleteCommentMarkerQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/ReplaceObsoleteCommentMarkerQuickFix.cs index be1aba443a..56b173af26 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/ReplaceObsoleteCommentMarkerQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/ReplaceObsoleteCommentMarkerQuickFix.cs @@ -2,6 +2,7 @@ using Rubberduck.Inspections.Concrete; using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes @@ -16,7 +17,7 @@ public ReplaceObsoleteCommentMarkerQuickFix(RubberduckParserState state) _state = state; } - public override void Fix(IInspectionResult result) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) { var rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); var context = (VBAParser.RemCommentContext) result.Context; diff --git a/Rubberduck.CodeAnalysis/QuickFixes/ReplaceObsoleteErrorStatementQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/ReplaceObsoleteErrorStatementQuickFix.cs index 2006d98ab9..36134df642 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/ReplaceObsoleteErrorStatementQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/ReplaceObsoleteErrorStatementQuickFix.cs @@ -2,6 +2,7 @@ using Rubberduck.Inspections.Concrete; using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes @@ -16,7 +17,7 @@ public ReplaceObsoleteErrorStatementQuickFix(RubberduckParserState state) _state = state; } - public override void Fix(IInspectionResult result) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) { var rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); var context = (VBAParser.ErrorStmtContext) result.Context; diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RestoreErrorHandlingQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RestoreErrorHandlingQuickFix.cs index 02f053724c..73cb76157e 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/RestoreErrorHandlingQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/RestoreErrorHandlingQuickFix.cs @@ -5,6 +5,7 @@ using Rubberduck.Parsing; using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes @@ -20,7 +21,7 @@ public RestoreErrorHandlingQuickFix(RubberduckParserState state) _state = state; } - public override void Fix(IInspectionResult result) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) { var exitStatement = "Exit "; VBAParser.BlockContext block; diff --git a/Rubberduck.CodeAnalysis/QuickFixes/SetExplicitVariantReturnTypeQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/SetExplicitVariantReturnTypeQuickFix.cs index b7247fdfdd..5e046355b8 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/SetExplicitVariantReturnTypeQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/SetExplicitVariantReturnTypeQuickFix.cs @@ -2,6 +2,7 @@ using Rubberduck.Inspections.Concrete; using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.Symbols; using Rubberduck.Parsing.VBA; @@ -17,7 +18,7 @@ public SetExplicitVariantReturnTypeQuickFix(RubberduckParserState state) _state = state; } - public override void Fix(IInspectionResult result) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) { var rewriter = _state.GetRewriter(result.Target); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/SpecifyExplicitByRefModifierQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/SpecifyExplicitByRefModifierQuickFix.cs index 6c2d5055f9..39d861bee0 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/SpecifyExplicitByRefModifierQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/SpecifyExplicitByRefModifierQuickFix.cs @@ -21,7 +21,7 @@ public SpecifyExplicitByRefModifierQuickFix(RubberduckParserState state) _state = state; } - public override void Fix(IInspectionResult result) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) { var context = (VBAParser.ArgContext)result.Context; diff --git a/Rubberduck.CodeAnalysis/QuickFixes/SpecifyExplicitPublicModifierQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/SpecifyExplicitPublicModifierQuickFix.cs index 0192284930..7e13182f23 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/SpecifyExplicitPublicModifierQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/SpecifyExplicitPublicModifierQuickFix.cs @@ -1,6 +1,7 @@ using Rubberduck.Inspections.Abstract; using Rubberduck.Inspections.Concrete; using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes @@ -15,7 +16,7 @@ public SpecifyExplicitPublicModifierQuickFix(RubberduckParserState state) _state = state; } - public override void Fix(IInspectionResult result) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) { var rewriter = _state.GetRewriter(result.Target); rewriter.InsertBefore(result.Context.Start.TokenIndex, "Public "); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/SplitMultipleDeclarationsQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/SplitMultipleDeclarationsQuickFix.cs index b608d712a3..3ca396076f 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/SplitMultipleDeclarationsQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/SplitMultipleDeclarationsQuickFix.cs @@ -5,6 +5,7 @@ using Rubberduck.Inspections.Concrete; using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes @@ -19,7 +20,7 @@ public SplitMultipleDeclarationsQuickFix(RubberduckParserState state) _state = state; } - public override void Fix(IInspectionResult result) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) { var context = result.Context is VBAParser.ConstStmtContext ? result.Context diff --git a/Rubberduck.CodeAnalysis/QuickFixes/UntypedFunctionUsageQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/UntypedFunctionUsageQuickFix.cs index 35f113ef81..ba7e5f92b2 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/UntypedFunctionUsageQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/UntypedFunctionUsageQuickFix.cs @@ -5,6 +5,7 @@ using Rubberduck.Inspections.Concrete; using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes @@ -19,7 +20,7 @@ public UntypedFunctionUsageQuickFix(RubberduckParserState state) _state = state; } - public override void Fix(IInspectionResult result) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) { var rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); rewriter.InsertAfter(result.Context.Stop.TokenIndex, "$"); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/UseSetKeywordForObjectAssignmentQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/UseSetKeywordForObjectAssignmentQuickFix.cs index 541d6b361f..332b02e49f 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/UseSetKeywordForObjectAssignmentQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/UseSetKeywordForObjectAssignmentQuickFix.cs @@ -1,6 +1,7 @@ using Rubberduck.Inspections.Abstract; using Rubberduck.Inspections.Concrete; using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes @@ -15,7 +16,7 @@ public UseSetKeywordForObjectAssignmentQuickFix(RubberduckParserState state) _state = state; } - public override void Fix(IInspectionResult result) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) { var rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); rewriter.InsertBefore(result.Context.Start.TokenIndex, "Set "); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/WriteOnlyPropertyQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/WriteOnlyPropertyQuickFix.cs index 00966ef0d6..0d9cc12122 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/WriteOnlyPropertyQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/WriteOnlyPropertyQuickFix.cs @@ -4,6 +4,7 @@ using Rubberduck.Inspections.Concrete; using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.Symbols; using Rubberduck.Parsing.VBA; @@ -19,7 +20,7 @@ public WriteOnlyPropertyQuickFix(RubberduckParserState state) _state = state; } - public override void Fix(IInspectionResult result) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) { var parameters = ((IParameterizedDeclaration) result.Target).Parameters.Cast().ToList(); diff --git a/Rubberduck.Parsing/Inspections/Abstract/IQuickFix.cs b/Rubberduck.Parsing/Inspections/Abstract/IQuickFix.cs index 89f3a91a0e..31134db667 100644 --- a/Rubberduck.Parsing/Inspections/Abstract/IQuickFix.cs +++ b/Rubberduck.Parsing/Inspections/Abstract/IQuickFix.cs @@ -1,11 +1,12 @@ using System; using System.Collections.Generic; +using Rubberduck.Parsing.Rewriter; namespace Rubberduck.Parsing.Inspections.Abstract { public interface IQuickFix { - void Fix(IInspectionResult result); + void Fix(IInspectionResult result, IRewriteSession rewriteSession = null); string Description(IInspectionResult result); bool CanFixInProcedure { get; } From ee12ff52a93b6b7d6fa8a93397837ee082bcd15d Mon Sep 17 00:00:00 2001 From: Max Doerner Date: Sat, 27 Oct 2018 18:59:33 +0200 Subject: [PATCH 06/59] Provide IRewriteSessions to quickfixes in QuickFixProvider This change ensures that whenever a fix is used for multiple results, the same IRewriteSession is used. --- .../Inspections/Abstract/QuickFixBase.cs | 4 +- .../QuickFixes/QuickFixProvider.cs | 76 ++++++++++++++----- .../Inspections/Abstract/IQuickFix.cs | 2 + .../Rewriter/RewriteSessionBase.cs | 6 ++ 4 files changed, 66 insertions(+), 22 deletions(-) diff --git a/Rubberduck.CodeAnalysis/Inspections/Abstract/QuickFixBase.cs b/Rubberduck.CodeAnalysis/Inspections/Abstract/QuickFixBase.cs index 9d684db1ec..3c6cfad8e1 100644 --- a/Rubberduck.CodeAnalysis/Inspections/Abstract/QuickFixBase.cs +++ b/Rubberduck.CodeAnalysis/Inspections/Abstract/QuickFixBase.cs @@ -4,8 +4,8 @@ using NLog; using Rubberduck.Parsing.Inspections.Abstract; using Rubberduck.Parsing.Rewriter; -using Rubberduck.Parsing.VBA; using Rubberduck.Parsing.VBA.Extensions; +using Rubberduck.Parsing.VBA.Parsing; namespace Rubberduck.Inspections.Abstract { @@ -40,6 +40,8 @@ public void RemoveInspections(params Type[] inspections) _supportedInspections = _supportedInspections.Except(inspections).ToHashSet(); } + public virtual CodeKind TargetCodeKind => CodeKind.CodePaneCode; + public abstract void Fix(IInspectionResult result, IRewriteSession rewriteSession = null); public abstract string Description(IInspectionResult result); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/QuickFixProvider.cs b/Rubberduck.CodeAnalysis/QuickFixes/QuickFixProvider.cs index a69621f420..c27e466d11 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/QuickFixProvider.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/QuickFixProvider.cs @@ -4,7 +4,9 @@ using System.Linq; using Microsoft.CSharp.RuntimeBinder; using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.VBA; +using Rubberduck.Parsing.VBA.Parsing; using Rubberduck.VBEditor; namespace Rubberduck.Inspections.QuickFixes @@ -74,17 +76,39 @@ public void Fix(IQuickFix fix, IInspectionResult result) return; } - fix.Fix(result); + var rewriteSession = RewriteSession(fix.TargetCodeKind); + fix.Fix(result, rewriteSession); + rewriteSession.Rewrite(); + _state.RewriteAllModules(); _state.OnParseRequested(this); } + private IRewriteSession RewriteSession(CodeKind targetCodeKind) + { + switch (targetCodeKind) + { + case CodeKind.CodePaneCode: + return _state.RewritingManager.CheckOutCodePaneSession(); + case CodeKind.AttributesCode: + return _state.RewritingManager.CheckOutAttributesSession(); + default: + throw new NotSupportedException(nameof(targetCodeKind)); + } + } + public void FixInProcedure(IQuickFix fix, QualifiedMemberName? qualifiedMember, Type inspectionType, IEnumerable results) { Debug.Assert(qualifiedMember.HasValue, "Null qualified member."); var filteredResults = results.Where(result => result.Inspection.GetType() == inspectionType && result.QualifiedMemberName == qualifiedMember).ToList(); + if (!filteredResults.Any()) + { + return; + } + + var rewriteSession = RewriteSession(fix.TargetCodeKind); foreach (var result in filteredResults) { if (!CanFix(fix, result)) @@ -94,18 +118,22 @@ public void FixInProcedure(IQuickFix fix, QualifiedMemberName? qualifiedMember, fix.Fix(result); } + rewriteSession.Rewrite(); - if (filteredResults.Any()) - { - _state.RewriteAllModules(); - _state.OnParseRequested(this); - } + _state.RewriteAllModules(); + _state.OnParseRequested(this); } public void FixInModule(IQuickFix fix, QualifiedSelection selection, Type inspectionType, IEnumerable results) { var filteredResults = results.Where(result => result.Inspection.GetType() == inspectionType && result.QualifiedSelection.QualifiedName == selection.QualifiedName).ToList(); + if (!filteredResults.Any()) + { + return; + } + + var rewriteSession = RewriteSession(fix.TargetCodeKind); foreach (var result in filteredResults) { if (!CanFix(fix, result)) @@ -115,18 +143,22 @@ public void FixInModule(IQuickFix fix, QualifiedSelection selection, Type inspec fix.Fix(result); } + rewriteSession.Rewrite(); - if (filteredResults.Any()) - { - _state.RewriteAllModules(); - _state.OnParseRequested(this); - } + _state.RewriteAllModules(); + _state.OnParseRequested(this); } public void FixInProject(IQuickFix fix, QualifiedSelection selection, Type inspectionType, IEnumerable results) { var filteredResults = results.Where(result => result.Inspection.GetType() == inspectionType && result.QualifiedSelection.QualifiedName.ProjectId == selection.QualifiedName.ProjectId).ToList(); + if (!filteredResults.Any()) + { + return; + } + + var rewriteSession = RewriteSession(fix.TargetCodeKind); foreach (var result in filteredResults) { if (!CanFix(fix, result)) @@ -136,18 +168,22 @@ public void FixInProject(IQuickFix fix, QualifiedSelection selection, Type inspe fix.Fix(result); } + rewriteSession.Rewrite(); - if (filteredResults.Any()) - { - _state.RewriteAllModules(); - _state.OnParseRequested(this); - } + _state.RewriteAllModules(); + _state.OnParseRequested(this); } public void FixAll(IQuickFix fix, Type inspectionType, IEnumerable results) { var filteredResults = results.Where(result => result.Inspection.GetType() == inspectionType).ToArray(); + if (!filteredResults.Any()) + { + return; + } + + var rewriteSession = RewriteSession(fix.TargetCodeKind); foreach (var result in filteredResults) { if (!CanFix(fix, result)) @@ -157,12 +193,10 @@ public void FixAll(IQuickFix fix, Type inspectionType, IEnumerable SupportedInspections { get; } + CodeKind TargetCodeKind { get; } void RegisterInspections(params Type[] inspections); void RemoveInspections(params Type[] inspections); diff --git a/Rubberduck.Parsing/Rewriter/RewriteSessionBase.cs b/Rubberduck.Parsing/Rewriter/RewriteSessionBase.cs index 45546a2f75..9256d35c22 100644 --- a/Rubberduck.Parsing/Rewriter/RewriteSessionBase.cs +++ b/Rubberduck.Parsing/Rewriter/RewriteSessionBase.cs @@ -1,5 +1,6 @@ using System; using System.Collections.Generic; +using System.Linq; using NLog; using Rubberduck.VBEditor; @@ -39,6 +40,11 @@ public IModuleRewriter CheckOutModuleRewriter(QualifiedModuleName module) public void Rewrite() { + if (!CheckedOutModuleRewriters.Any()) + { + return; + } + lock (_invalidationLockObject) { if (_isInvalidated) From 0eb245db401149dfc71f9bd313d010d25029b3d8 Mon Sep 17 00:00:00 2001 From: Max Doerner Date: Wed, 31 Oct 2018 00:16:58 +0100 Subject: [PATCH 07/59] Make the quickfixes use the IRewritesession (DOES NOT COMPILE) The tests are still pending; that is another undertaking. --- .../Inspections/Abstract/QuickFixBase.cs | 2 +- .../VariableRequiresSetAssignmentEvaluator.cs | 8 +- .../AccessSheetUsingCodeNameQuickFix.cs | 14 ++-- .../QuickFixes/AddStepOneQuickFix.cs | 25 +++---- .../ApplicationWorksheetFunctionQuickFix.cs | 13 +--- ...gnedByValParameterMakeLocalCopyQuickFix.cs | 18 ++--- .../QuickFixes/ChangeDimToPrivateQuickFix.cs | 13 +--- .../QuickFixes/ChangeIntegerToLongQuickFix.cs | 30 ++++---- .../ChangeProcedureToFunctionQuickFix.cs | 25 +++---- .../QuickFixes/ConvertToProcedureQuickFix.cs | 25 +++---- .../DeclareAsExplicitVariantQuickFix.cs | 13 +--- .../QuickFixes/EncapsulateFieldQuickFix.cs | 2 +- .../QuickFixes/IgnoreOnceQuickFix.cs | 6 +- .../IntroduceLocalVariableQuickFix.cs | 14 ++-- ...sMissingOnInappropriateArgumentQuickFix.cs | 14 ++-- .../MakeSingleLineParameterQuickFix.cs | 13 +--- .../MoveFieldCloserToUsageQuickFix.cs | 2 +- .../QuickFixes/OptionExplicitQuickFix.cs | 13 +--- .../PassParameterByReferenceQuickFix.cs | 13 +--- .../PassParameterByValueQuickFix.cs | 26 ++++--- .../QuickFixes/RemoveCommentQuickFix.cs | 13 +--- .../RemoveDuplicatedAnnotationQuickFix.cs | 20 ++--- .../RemoveEmptyElseBlockQuickFix.cs | 20 ++--- .../QuickFixes/RemoveEmptyIfBlockQuickFix.cs | 74 +++++++++++++------ .../RemoveExplicitByRefModifierQuickFix.cs | 22 +++--- ...=> RemoveExplicitCallStatementQuickFix.cs} | 15 ++-- .../RemoveExplicitLetStatementQuickFix.cs | 13 +--- .../QuickFixes/RemoveLocalErrorQuickFix.cs | 13 +--- .../RemoveOptionBaseStatementQuickFix.cs | 13 +--- .../QuickFixes/RemoveStepOneQuickFix.cs | 15 ++-- .../QuickFixes/RemoveStopKeywordQuickFix.cs | 13 +--- .../QuickFixes/RemoveTypeHintsQuickFix.cs | 15 ++-- .../RemoveUnassignedIdentifierQuickFix.cs | 13 +--- .../RemoveUnassignedVariableUsageQuickFix.cs | 14 +--- .../RemoveUnusedDeclarationQuickFix.cs | 13 +--- .../RemoveUnusedParameterQuickFix.cs | 2 +- .../QuickFixes/RenameDeclarationQuickFix.cs | 2 +- ...laceEmptyStringLiteralStatementQuickFix.cs | 13 +--- .../ReplaceGlobalModifierQuickFix.cs | 13 +--- ...eIfElseWithConditionalStatementQuickFix.cs | 14 +--- .../ReplaceObsoleteCommentMarkerQuickFix.cs | 13 +--- .../ReplaceObsoleteErrorStatementQuickFix.cs | 13 +--- .../RestoreErrorHandlingQuickFix.cs | 14 ++-- .../SetExplicitVariantReturnTypeQuickFix.cs | 13 +--- .../SpecifyExplicitByRefModifierQuickFix.cs | 22 +++--- .../SpecifyExplicitPublicModifierQuickFix.cs | 13 +--- .../SplitMultipleDeclarationsQuickFix.cs | 13 +--- .../UntypedFunctionUsageQuickFix.cs | 13 +--- ...seSetKeywordForObjectAssignmentQuickFix.cs | 13 +--- .../QuickFixes/WriteOnlyPropertyQuickFix.cs | 15 ++-- .../Inspections/Abstract/IQuickFix.cs | 2 +- .../Rewriter/AttributesRewriteSession.cs | 4 +- ...emoveExplicitCallStatementQuickFixTests.cs | 2 +- 53 files changed, 312 insertions(+), 457 deletions(-) rename Rubberduck.CodeAnalysis/QuickFixes/{RemoveExplicitCallStatmentQuickFix.cs => RemoveExplicitCallStatementQuickFix.cs} (74%) diff --git a/Rubberduck.CodeAnalysis/Inspections/Abstract/QuickFixBase.cs b/Rubberduck.CodeAnalysis/Inspections/Abstract/QuickFixBase.cs index 3c6cfad8e1..b4f13d3c09 100644 --- a/Rubberduck.CodeAnalysis/Inspections/Abstract/QuickFixBase.cs +++ b/Rubberduck.CodeAnalysis/Inspections/Abstract/QuickFixBase.cs @@ -42,7 +42,7 @@ public void RemoveInspections(params Type[] inspections) public virtual CodeKind TargetCodeKind => CodeKind.CodePaneCode; - public abstract void Fix(IInspectionResult result, IRewriteSession rewriteSession = null); + public abstract void Fix(IInspectionResult result, IRewriteSession rewriteSession); public abstract string Description(IInspectionResult result); public abstract bool CanFixInProcedure { get; } diff --git a/Rubberduck.CodeAnalysis/Inspections/Concrete/VariableRequiresSetAssignmentEvaluator.cs b/Rubberduck.CodeAnalysis/Inspections/Concrete/VariableRequiresSetAssignmentEvaluator.cs index 9f4d01922e..7e000bbf67 100644 --- a/Rubberduck.CodeAnalysis/Inspections/Concrete/VariableRequiresSetAssignmentEvaluator.cs +++ b/Rubberduck.CodeAnalysis/Inspections/Concrete/VariableRequiresSetAssignmentEvaluator.cs @@ -13,8 +13,8 @@ public static class VariableRequiresSetAssignmentEvaluator /// Determines whether the 'Set' keyword is required (whether it's present or not) for the specified identifier reference. /// /// The identifier reference to analyze - /// The parser state - public static bool RequiresSetAssignment(IdentifierReference reference, RubberduckParserState state) + /// The parser state + public static bool RequiresSetAssignment(IdentifierReference reference, IDeclarationFinderProvider declarationFinderProvider) { if (!reference.IsAssignment) { @@ -89,7 +89,7 @@ public static bool RequiresSetAssignment(IdentifierReference reference, Rubberdu // todo resolve expression return type - var memberRefs = state.DeclarationFinder.IdentifierReferences(reference.ParentScoping.QualifiedName); + var memberRefs = declarationFinderProvider.DeclarationFinder.IdentifierReferences(reference.ParentScoping.QualifiedName); var lastRef = memberRefs.LastOrDefault(r => !Equals(r, reference) && r.Context.GetAncestor() == letStmtContext); if (lastRef?.Declaration.AsTypeDeclaration?.DeclarationType.HasFlag(DeclarationType.ClassModule) ?? false) { @@ -104,7 +104,7 @@ public static bool RequiresSetAssignment(IdentifierReference reference, Rubberdu // is the reference referring to something else in scope that's a object? var project = Declaration.GetProjectParent(reference.ParentScoping); var module = Declaration.GetModuleParent(reference.ParentScoping); - return state.DeclarationFinder.MatchName(expression.GetText().ToLowerInvariant()) + return declarationFinderProvider.DeclarationFinder.MatchName(expression.GetText().ToLowerInvariant()) .Any(decl => (decl.DeclarationType.HasFlag(DeclarationType.ClassModule) || Tokens.Object.Equals(decl.AsTypeName)) && AccessibilityCheck.IsAccessible(project, module, reference.ParentScoping, decl)); } diff --git a/Rubberduck.CodeAnalysis/QuickFixes/AccessSheetUsingCodeNameQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/AccessSheetUsingCodeNameQuickFix.cs index 0669973444..ff8b7fdb8e 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/AccessSheetUsingCodeNameQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/AccessSheetUsingCodeNameQuickFix.cs @@ -11,21 +11,21 @@ namespace Rubberduck.Inspections.QuickFixes { - public class AccessSheetUsingCodeNameQuickFix : QuickFixBase + public sealed class AccessSheetUsingCodeNameQuickFix : QuickFixBase { - private readonly RubberduckParserState _state; + private readonly IDeclarationFinderProvider _declarationFinderProvider; - public AccessSheetUsingCodeNameQuickFix(RubberduckParserState state) + public AccessSheetUsingCodeNameQuickFix(IDeclarationFinderProvider declarationFinderProvider) : base(typeof(SheetAccessedUsingStringInspection)) { - _state = state; + _declarationFinderProvider = declarationFinderProvider; } - public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { var referenceResult = (IdentifierReferenceInspectionResult)result; - var rewriter = _state.GetRewriter(referenceResult.QualifiedName); + var rewriter = rewriteSession.CheckOutModuleRewriter(referenceResult.QualifiedName); var setStatement = referenceResult.Context.GetAncestor(); if (setStatement == null) @@ -43,7 +43,7 @@ public override void Fix(IInspectionResult result, IRewriteSession rewriteSessio // Sheet assigned to variable var sheetVariableName = setStatement.lExpression().GetText(); - var sheetDeclaration = _state.DeclarationFinder.MatchName(sheetVariableName) + var sheetDeclaration = _declarationFinderProvider.DeclarationFinder.MatchName(sheetVariableName) .First(declaration => { var moduleBodyElement = declaration.Context.GetAncestor(); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/AddStepOneQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/AddStepOneQuickFix.cs index a077e3b2b4..1eb99baf18 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/AddStepOneQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/AddStepOneQuickFix.cs @@ -2,21 +2,16 @@ using Rubberduck.Inspections.Concrete; using Rubberduck.Parsing.Inspections.Abstract; using Rubberduck.Parsing.Rewriter; -using Rubberduck.Parsing.VBA; using System; using static Rubberduck.Parsing.Grammar.VBAParser; namespace Rubberduck.Inspections.QuickFixes { - public class AddStepOneQuickFix : QuickFixBase + public sealed class AddStepOneQuickFix : QuickFixBase { - private readonly RubberduckParserState _state; - - public AddStepOneQuickFix(RubberduckParserState state) + public AddStepOneQuickFix() : base(typeof(StepIsNotSpecifiedInspection)) - { - _state = state; - } + {} public override bool CanFixInProcedure => true; @@ -29,20 +24,20 @@ public override string Description(IInspectionResult result) return Resources.Inspections.QuickFixes.AddStepOneQuickFix; } - public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { - IExecutableModuleRewriter rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); - ForNextStmtContext context = result.Context as ForNextStmtContext; + var rewriter = rewriteSession.CheckOutModuleRewriter(result.QualifiedSelection.QualifiedName); + var context = result.Context as ForNextStmtContext; - int toExpressionEnd = this.GetToExpressionEnd(context); + var toExpressionEnd = GetToExpressionEnd(context); rewriter.InsertAfter(toExpressionEnd, " Step 1"); } - private int GetToExpressionEnd(ForNextStmtContext context) + private static int GetToExpressionEnd(ForNextStmtContext context) { - int toNodeIndex = context.TO().Symbol.TokenIndex; + var toNodeIndex = context.TO().Symbol.TokenIndex; - foreach(ExpressionContext expressionChild in context.expression()) + foreach(var expressionChild in context.expression()) { if (expressionChild.Stop.TokenIndex > toNodeIndex) { diff --git a/Rubberduck.CodeAnalysis/QuickFixes/ApplicationWorksheetFunctionQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/ApplicationWorksheetFunctionQuickFix.cs index 9a0c10333d..d17b552f66 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/ApplicationWorksheetFunctionQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/ApplicationWorksheetFunctionQuickFix.cs @@ -2,23 +2,18 @@ using Rubberduck.Inspections.Concrete; using Rubberduck.Parsing.Inspections.Abstract; using Rubberduck.Parsing.Rewriter; -using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes { public sealed class ApplicationWorksheetFunctionQuickFix : QuickFixBase { - private readonly RubberduckParserState _state; - - public ApplicationWorksheetFunctionQuickFix(RubberduckParserState state) + public ApplicationWorksheetFunctionQuickFix() : base(typeof(ApplicationWorksheetFunctionInspection)) - { - _state = state; - } + {} - public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { - var rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); + var rewriter = rewriteSession.CheckOutModuleRewriter(result.QualifiedSelection.QualifiedName); rewriter.InsertBefore(result.Context.Start.TokenIndex, "WorksheetFunction."); } diff --git a/Rubberduck.CodeAnalysis/QuickFixes/AssignedByValParameterMakeLocalCopyQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/AssignedByValParameterMakeLocalCopyQuickFix.cs index b387dff513..bb4a3ed35d 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/AssignedByValParameterMakeLocalCopyQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/AssignedByValParameterMakeLocalCopyQuickFix.cs @@ -19,17 +19,17 @@ namespace Rubberduck.Inspections.QuickFixes public sealed class AssignedByValParameterMakeLocalCopyQuickFix : QuickFixBase { private readonly IAssignedByValParameterQuickFixDialogFactory _dialogFactory; - private readonly RubberduckParserState _parserState; + private readonly IDeclarationFinderProvider _declarationFinderProvider; private Declaration _quickFixTarget; - public AssignedByValParameterMakeLocalCopyQuickFix(RubberduckParserState state, IAssignedByValParameterQuickFixDialogFactory dialogFactory) + public AssignedByValParameterMakeLocalCopyQuickFix(IDeclarationFinderProvider declarationFinderProvider, IAssignedByValParameterQuickFixDialogFactory dialogFactory) : base(typeof(AssignedByValParameterInspection)) { _dialogFactory = dialogFactory; - _parserState = state; + _declarationFinderProvider = declarationFinderProvider; } - public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { Debug.Assert(result.Target.Context.Parent is VBAParser.ArgListContext); Debug.Assert(null != ((ParserRuleContext)result.Target.Context.Parent.Parent).GetChild()); @@ -42,7 +42,7 @@ public override void Fix(IInspectionResult result, IRewriteSession rewriteSessio return; } - var rewriter = _parserState.GetRewriter(result.Target); + var rewriter = rewriteSession.CheckOutModuleRewriter(result.Target.QualifiedModuleName); ReplaceAssignedByValParameterReferences(rewriter, result.Target, localIdentifier); InsertLocalVariableDeclarationAndAssignment(rewriter, result.Target, localIdentifier); } @@ -76,7 +76,7 @@ private string PromptForLocalVariableName(Declaration target) } private bool IsNameCollision(string newName) - => _parserState.DeclarationFinder.FindNewDeclarationNameConflicts(newName, _quickFixTarget).Any(); + => _declarationFinderProvider.DeclarationFinder.FindNewDeclarationNameConflicts(newName, _quickFixTarget).Any(); private string GetDefaultLocalIdentifier(Declaration target) { @@ -103,7 +103,7 @@ private bool IsValidVariableName(string variableName) && !IsNameCollision(variableName); } - private void ReplaceAssignedByValParameterReferences(IExecutableModuleRewriter rewriter, Declaration target, string localIdentifier) + private void ReplaceAssignedByValParameterReferences(IModuleRewriter rewriter, Declaration target, string localIdentifier) { foreach (var identifierReference in target.References) { @@ -111,12 +111,12 @@ private void ReplaceAssignedByValParameterReferences(IExecutableModuleRewriter r } } - private void InsertLocalVariableDeclarationAndAssignment(IExecutableModuleRewriter rewriter, Declaration target, string localIdentifier) + private void InsertLocalVariableDeclarationAndAssignment(IModuleRewriter rewriter, Declaration target, string localIdentifier) { var localVariableDeclaration = $"{Tokens.Dim} {localIdentifier} {Tokens.As} {target.AsTypeName}"; var requiresAssignmentUsingSet = - target.References.Any(refItem => VariableRequiresSetAssignmentEvaluator.RequiresSetAssignment(refItem, _parserState)); + target.References.Any(refItem => VariableRequiresSetAssignmentEvaluator.RequiresSetAssignment(refItem, _declarationFinderProvider)); var localVariableAssignment = $"{(requiresAssignmentUsingSet ? $"{Tokens.Set} " : string.Empty)}{localIdentifier} = {target.IdentifierName}"; diff --git a/Rubberduck.CodeAnalysis/QuickFixes/ChangeDimToPrivateQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/ChangeDimToPrivateQuickFix.cs index 0a6722630b..1d9f7e4e2b 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/ChangeDimToPrivateQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/ChangeDimToPrivateQuickFix.cs @@ -3,23 +3,18 @@ using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Inspections.Abstract; using Rubberduck.Parsing.Rewriter; -using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes { public sealed class ChangeDimToPrivateQuickFix : QuickFixBase { - private readonly RubberduckParserState _state; - - public ChangeDimToPrivateQuickFix(RubberduckParserState state) + public ChangeDimToPrivateQuickFix() : base(typeof(ModuleScopeDimKeywordInspection)) - { - _state = state; - } + {} - public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { - var rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); + var rewriter = rewriteSession.CheckOutModuleRewriter(result.QualifiedSelection.QualifiedName); var context = (VBAParser.VariableStmtContext)result.Context.Parent.Parent; rewriter.Replace(context.DIM(), Tokens.Private); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/ChangeIntegerToLongQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/ChangeIntegerToLongQuickFix.cs index b537da2d14..5bca967550 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/ChangeIntegerToLongQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/ChangeIntegerToLongQuickFix.cs @@ -13,19 +13,19 @@ namespace Rubberduck.Inspections.QuickFixes { - public class ChangeIntegerToLongQuickFix : QuickFixBase + public sealed class ChangeIntegerToLongQuickFix : QuickFixBase { - private readonly RubberduckParserState _state; + private readonly IDeclarationFinderProvider _declarationFinderProvider; - public ChangeIntegerToLongQuickFix(RubberduckParserState state) + public ChangeIntegerToLongQuickFix(IDeclarationFinderProvider declarationFinderProvider) : base(typeof(IntegerDataTypeInspection)) { - _state = state; + _declarationFinderProvider = declarationFinderProvider; } - public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { - var rewriter = _state.GetRewriter(result.Target); + var rewriter = rewriteSession.CheckOutModuleRewriter(result.Target.QualifiedModuleName); if (result.Target.HasTypeHint) { @@ -66,7 +66,7 @@ public override void Fix(IInspectionResult result, IRewriteSession rewriteSessio } } - var interfaceMembers = _state.DeclarationFinder.FindAllInterfaceMembers().ToArray(); + var interfaceMembers = _declarationFinderProvider.DeclarationFinder.FindAllInterfaceMembers().ToArray(); ParserRuleContext matchingInterfaceMemberContext; @@ -80,11 +80,11 @@ public override void Fix(IInspectionResult result, IRewriteSession rewriteSessio var interfaceParameterIndex = GetParameterIndex((VBAParser.ArgContext)result.Context); var implementationMembers = - _state.DeclarationFinder.FindInterfaceImplementationMembers(interfaceMembers.First( + _declarationFinderProvider.DeclarationFinder.FindInterfaceImplementationMembers(interfaceMembers.First( member => member.Context == matchingInterfaceMemberContext)).ToHashSet(); var parameterDeclarations = - _state.DeclarationFinder.UserDeclarations(DeclarationType.Parameter) + _declarationFinderProvider.DeclarationFinder.UserDeclarations(DeclarationType.Parameter) .Where(p => implementationMembers.Contains(p.ParentDeclaration)) .Cast() .ToArray(); @@ -96,7 +96,7 @@ public override void Fix(IInspectionResult result, IRewriteSession rewriteSessio if (parameterIndex == interfaceParameterIndex) { - var parameterRewriter = _state.GetRewriter(parameter); + var parameterRewriter = rewriteSession.CheckOutModuleRewriter(parameter.QualifiedModuleName); if (parameter.HasTypeHint) { @@ -116,14 +116,14 @@ public override void Fix(IInspectionResult result, IRewriteSession rewriteSessio if (matchingInterfaceMemberContext != null) { var functionDeclarations = - _state.DeclarationFinder.FindInterfaceImplementationMembers( + _declarationFinderProvider.DeclarationFinder.FindInterfaceImplementationMembers( interfaceMembers.First(member => member.Context == matchingInterfaceMemberContext)) .Cast() .ToHashSet(); foreach (var function in functionDeclarations) { - var functionRewriter = _state.GetRewriter(function); + var functionRewriter = rewriteSession.CheckOutModuleRewriter(function.QualifiedModuleName); if (function.HasTypeHint) { @@ -143,14 +143,14 @@ public override void Fix(IInspectionResult result, IRewriteSession rewriteSessio if (matchingInterfaceMemberContext != null) { var propertyGetDeclarations = - _state.DeclarationFinder.FindInterfaceImplementationMembers( + _declarationFinderProvider.DeclarationFinder.FindInterfaceImplementationMembers( interfaceMembers.First(member => member.Context == matchingInterfaceMemberContext)) .Cast() .ToHashSet(); foreach (var propertyGet in propertyGetDeclarations) { - var propertyGetRewriter = _state.GetRewriter(propertyGet); + var propertyGetRewriter = rewriteSession.CheckOutModuleRewriter(propertyGet.QualifiedModuleName); if (propertyGet.HasTypeHint) { @@ -178,7 +178,7 @@ private static int GetParameterIndex(VBAParser.ArgContext context) return Array.IndexOf(((VBAParser.ArgListContext)context.Parent).arg().ToArray(), context); } - private static void ReplaceTypeHint(RuleContext context, IExecutableModuleRewriter rewriter) + private static void ReplaceTypeHint(RuleContext context, IModuleRewriter rewriter) { var typeHintContext = ((ParserRuleContext)context).GetDescendent(); rewriter.Replace(typeHintContext, "&"); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/ChangeProcedureToFunctionQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/ChangeProcedureToFunctionQuickFix.cs index fcfd26ea76..2103a637e4 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/ChangeProcedureToFunctionQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/ChangeProcedureToFunctionQuickFix.cs @@ -7,41 +7,36 @@ using Rubberduck.Parsing.Inspections.Abstract; using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.Symbols; -using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes { public sealed class ChangeProcedureToFunctionQuickFix : QuickFixBase { - private readonly RubberduckParserState _state; - - public ChangeProcedureToFunctionQuickFix(RubberduckParserState state) + public ChangeProcedureToFunctionQuickFix() : base(typeof(ProcedureCanBeWrittenAsFunctionInspection)) - { - _state = state; - } + {} - public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { var parameterizedDeclaration = (IParameterizedDeclaration) result.Target; - var arg = parameterizedDeclaration.Parameters.Cast().First(p => p.IsByRef || p.IsImplicitByRef); + var arg = parameterizedDeclaration.Parameters.First(p => p.IsByRef || p.IsImplicitByRef); var argIndex = parameterizedDeclaration.Parameters.ToList().IndexOf(arg); - UpdateSignature(result.Target, arg); + UpdateSignature(result.Target, arg, rewriteSession); foreach (var reference in result.Target.References) { - UpdateCall(reference, argIndex); + UpdateCall(reference, argIndex, rewriteSession); } } public override string Description(IInspectionResult result) => Resources.Inspections.QuickFixes.ProcedureShouldBeFunctionInspectionQuickFix; - private void UpdateSignature(Declaration target, ParameterDeclaration arg) + private void UpdateSignature(Declaration target, ParameterDeclaration arg, IRewriteSession rewriteSession) { var subStmt = (VBAParser.SubStmtContext) target.Context; var argContext = (VBAParser.ArgContext)arg.Context; - var rewriter = _state.GetRewriter(target); + var rewriter = rewriteSession.CheckOutModuleRewriter(target.QualifiedModuleName); rewriter.Replace(subStmt.SUB(), Tokens.Function); rewriter.Replace(subStmt.END_SUB(), "End Function"); @@ -61,9 +56,9 @@ private void UpdateSignature(Declaration target, ParameterDeclaration arg) rewriter.InsertBefore(subStmt.END_SUB().Symbol.TokenIndex, returnStmt); } - private void UpdateCall(IdentifierReference reference, int argIndex) + private void UpdateCall(IdentifierReference reference, int argIndex, IRewriteSession rewriteSession) { - var rewriter = _state.GetRewriter(reference.QualifiedModuleName); + var rewriter = rewriteSession.CheckOutModuleRewriter(reference.QualifiedModuleName); var callStmtContext = reference.Context.GetAncestor(); var argListContext = callStmtContext.GetChild(); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/ConvertToProcedureQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/ConvertToProcedureQuickFix.cs index afd57a0db8..bea1f27609 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/ConvertToProcedureQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/ConvertToProcedureQuickFix.cs @@ -8,37 +8,32 @@ using Rubberduck.Parsing.Inspections.Abstract; using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.Symbols; -using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes { public sealed class ConvertToProcedureQuickFix : QuickFixBase { - private readonly RubberduckParserState _state; - - public ConvertToProcedureQuickFix(RubberduckParserState state) + public ConvertToProcedureQuickFix() : base(typeof(NonReturningFunctionInspection), typeof(FunctionReturnValueNotUsedInspection)) - { - _state = state; - } + {} - public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { + var rewriter = rewriteSession.CheckOutModuleRewriter(result.Target.QualifiedModuleName); + switch (result.Context) { case VBAParser.FunctionStmtContext functionContext: - ConvertFunction(result, functionContext); + ConvertFunction(result, functionContext, rewriter); break; case VBAParser.PropertyGetStmtContext propertyGetContext: - ConvertPropertyGet(result, propertyGetContext); + ConvertPropertyGet(result, propertyGetContext, rewriter); break; } } - private void ConvertFunction(IInspectionResult result, VBAParser.FunctionStmtContext functionContext) + private void ConvertFunction(IInspectionResult result, VBAParser.FunctionStmtContext functionContext, IModuleRewriter rewriter) { - var rewriter = _state.GetRewriter(result.Target); - var asTypeContext = functionContext.GetChild(); if (asTypeContext != null) { @@ -60,10 +55,8 @@ private void ConvertFunction(IInspectionResult result, VBAParser.FunctionStmtCon } } - private void ConvertPropertyGet(IInspectionResult result, VBAParser.PropertyGetStmtContext propertyGetContext) + private void ConvertPropertyGet(IInspectionResult result, VBAParser.PropertyGetStmtContext propertyGetContext, IModuleRewriter rewriter) { - var rewriter = _state.GetRewriter(result.Target); - var asTypeContext = propertyGetContext.GetChild(); if (asTypeContext != null) { diff --git a/Rubberduck.CodeAnalysis/QuickFixes/DeclareAsExplicitVariantQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/DeclareAsExplicitVariantQuickFix.cs index e0bc881be3..fa4beeaa94 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/DeclareAsExplicitVariantQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/DeclareAsExplicitVariantQuickFix.cs @@ -4,23 +4,18 @@ using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Inspections.Abstract; using Rubberduck.Parsing.Rewriter; -using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes { public sealed class DeclareAsExplicitVariantQuickFix : QuickFixBase { - private readonly RubberduckParserState _state; - - public DeclareAsExplicitVariantQuickFix(RubberduckParserState state) + public DeclareAsExplicitVariantQuickFix() : base(typeof(VariableTypeNotDeclaredInspection)) - { - _state = state; - } + {} - public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { - var rewriter = _state.GetRewriter(result.Target); + var rewriter = rewriteSession.CheckOutModuleRewriter(result.Target.QualifiedModuleName); ParserRuleContext identifierNode = result.Context is VBAParser.VariableSubStmtContext || result.Context is VBAParser.ConstSubStmtContext diff --git a/Rubberduck.CodeAnalysis/QuickFixes/EncapsulateFieldQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/EncapsulateFieldQuickFix.cs index 919de89b2a..59c6024d8b 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/EncapsulateFieldQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/EncapsulateFieldQuickFix.cs @@ -24,7 +24,7 @@ public EncapsulateFieldQuickFix(IVBE vbe, RubberduckParserState state, IIndenter _indenter = indenter; } - public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { using (var view = new EncapsulateFieldDialog(new EncapsulateFieldViewModel(_state, _indenter))) { diff --git a/Rubberduck.CodeAnalysis/QuickFixes/IgnoreOnceQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/IgnoreOnceQuickFix.cs index ce7052146a..a5aa066e0b 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/IgnoreOnceQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/IgnoreOnceQuickFix.cs @@ -27,12 +27,12 @@ public IgnoreOnceQuickFix(RubberduckParserState state, IEnumerable public override bool CanFixInModule => false; public override bool CanFixInProject => false; - public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { var annotationText = $"'@Ignore {result.Inspection.AnnotationName}"; int annotationLine; - string codeLine; + //TODO: Make this use the parse tree instead of the code module. var component = _state.ProjectsProvider.Component(result.QualifiedSelection.QualifiedName); using (var module = component.CodeModule) { @@ -54,7 +54,7 @@ public override void Fix(IInspectionResult result, IRewriteSession rewriteSessio var commentContext = listener.Contexts.LastOrDefault(i => i.Stop.TokenIndex <= result.Context.Start.TokenIndex); var commented = commentContext?.Stop.Line + 1 == annotationLine; - var rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); + var rewriter = rewriteSession.CheckOutModuleRewriter(result.QualifiedSelection.QualifiedName); if (commented) { diff --git a/Rubberduck.CodeAnalysis/QuickFixes/IntroduceLocalVariableQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/IntroduceLocalVariableQuickFix.cs index 847e9b30fd..a4fca60ca3 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/IntroduceLocalVariableQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/IntroduceLocalVariableQuickFix.cs @@ -6,30 +6,26 @@ using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Inspections.Abstract; using Rubberduck.Parsing.Rewriter; -using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes { public sealed class IntroduceLocalVariableQuickFix : QuickFixBase { - private readonly RubberduckParserState _state; - - public IntroduceLocalVariableQuickFix(RubberduckParserState state) + public IntroduceLocalVariableQuickFix() : base(typeof(UndeclaredVariableInspection)) - { - _state = state; - } + {} public override bool CanFixInProcedure => true; public override bool CanFixInModule => true; public override bool CanFixInProject => true; - public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { var identifierContext = result.Target.Context; var enclosingStatmentContext = identifierContext.GetAncestor(); var instruction = IdentifierDeclarationText(result.Target.IdentifierName, EndOfStatementText(enclosingStatmentContext), FrontPadding(enclosingStatmentContext)); - _state.GetRewriter(result.Target).InsertBefore(enclosingStatmentContext.Start.TokenIndex, instruction); + var rewriter = rewriteSession.CheckOutModuleRewriter(result.Target.QualifiedModuleName); + rewriter.InsertBefore(enclosingStatmentContext.Start.TokenIndex, instruction); } private string EndOfStatementText(VBAParser.BlockStmtContext context) diff --git a/Rubberduck.CodeAnalysis/QuickFixes/IsMissingOnInappropriateArgumentQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/IsMissingOnInappropriateArgumentQuickFix.cs index 65fb994536..8a69d25d85 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/IsMissingOnInappropriateArgumentQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/IsMissingOnInappropriateArgumentQuickFix.cs @@ -12,17 +12,17 @@ namespace Rubberduck.Inspections.QuickFixes { - public class IsMissingOnInappropriateArgumentQuickFix : QuickFixBase + public sealed class IsMissingOnInappropriateArgumentQuickFix : QuickFixBase { - private readonly RubberduckParserState _state; + private readonly IDeclarationFinderProvider _declarationFinderProvider; - public IsMissingOnInappropriateArgumentQuickFix(RubberduckParserState state) + public IsMissingOnInappropriateArgumentQuickFix(IDeclarationFinderProvider declarationFinderProvider) : base(typeof(IsMissingOnInappropriateArgumentInspection)) { - _state = state; + _declarationFinderProvider = declarationFinderProvider; } - public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { if (!(result.Properties is ParameterDeclaration parameter)) { @@ -31,7 +31,7 @@ public override void Fix(IInspectionResult result, IRewriteSession rewriteSessio return; } - var rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); + var rewriter = rewriteSession.CheckOutModuleRewriter(result.QualifiedSelection.QualifiedName); if (!result.Context.TryGetAncestor(out var context)) { Logger.Trace("IsMissingOnInappropriateArgumentQuickFix could not locate containing LExprContext for replacement."); @@ -109,7 +109,7 @@ private string UninitializedComparisonForParameter(ParameterDeclaration paramete case DeclarationType.ClassModule: return $"{parameter.IdentifierName} Is {Tokens.Nothing}"; case DeclarationType.Enumeration: - var members = _state.DeclarationFinder.AllDeclarations.OfType() + var members = _declarationFinderProvider.DeclarationFinder.AllDeclarations.OfType() .FirstOrDefault(decl => ReferenceEquals(decl.ParentDeclaration, parameter.AsTypeDeclaration) && decl.Expression.Equals("0")); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/MakeSingleLineParameterQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/MakeSingleLineParameterQuickFix.cs index 0c0e97956e..a3c79a807e 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/MakeSingleLineParameterQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/MakeSingleLineParameterQuickFix.cs @@ -2,24 +2,19 @@ using Rubberduck.Inspections.Concrete; using Rubberduck.Parsing.Inspections.Abstract; using Rubberduck.Parsing.Rewriter; -using Rubberduck.Parsing.VBA; using Rubberduck.Parsing.VBA.Extensions; namespace Rubberduck.Inspections.QuickFixes { public sealed class MakeSingleLineParameterQuickFix : QuickFixBase { - private readonly RubberduckParserState _state; - - public MakeSingleLineParameterQuickFix(RubberduckParserState state) + public MakeSingleLineParameterQuickFix() : base(typeof(MultilineParameterInspection)) - { - _state = state; - } + {} - public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { - var rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); + var rewriter = rewriteSession.CheckOutModuleRewriter(result.QualifiedSelection.QualifiedName); var parameter = result.Context.GetText() .Replace("_", "") diff --git a/Rubberduck.CodeAnalysis/QuickFixes/MoveFieldCloserToUsageQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/MoveFieldCloserToUsageQuickFix.cs index 7ac6c44185..e3c3528c98 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/MoveFieldCloserToUsageQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/MoveFieldCloserToUsageQuickFix.cs @@ -24,7 +24,7 @@ public MoveFieldCloserToUsageQuickFix(IVBE vbe, RubberduckParserState state, IMe _messageBox = messageBox; } - public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { var refactoring = new MoveCloserToUsageRefactoring(_vbe, _state, _messageBox); refactoring.Refactor(result.Target); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/OptionExplicitQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/OptionExplicitQuickFix.cs index 49135709cc..f5f729013b 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/OptionExplicitQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/OptionExplicitQuickFix.cs @@ -4,23 +4,18 @@ using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Inspections.Abstract; using Rubberduck.Parsing.Rewriter; -using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes { public sealed class OptionExplicitQuickFix : QuickFixBase { - private readonly RubberduckParserState _state; - - public OptionExplicitQuickFix(RubberduckParserState state) + public OptionExplicitQuickFix() : base(typeof(OptionExplicitInspection)) - { - _state = state; - } + {} - public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { - var rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); + var rewriter = rewriteSession.CheckOutModuleRewriter(result.QualifiedSelection.QualifiedName); rewriter.InsertBefore(0, Tokens.Option + ' ' + Tokens.Explicit + Environment.NewLine + Environment.NewLine); } diff --git a/Rubberduck.CodeAnalysis/QuickFixes/PassParameterByReferenceQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/PassParameterByReferenceQuickFix.cs index 8be2a9860f..f4debba3f2 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/PassParameterByReferenceQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/PassParameterByReferenceQuickFix.cs @@ -3,23 +3,18 @@ using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Inspections.Abstract; using Rubberduck.Parsing.Rewriter; -using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes { public sealed class PassParameterByReferenceQuickFix : QuickFixBase { - private readonly RubberduckParserState _state; - - public PassParameterByReferenceQuickFix(RubberduckParserState state) + public PassParameterByReferenceQuickFix() : base(typeof(AssignedByValParameterInspection)) - { - _state = state; - } + {} - public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { - var rewriter = _state.GetRewriter(result.Target); + var rewriter = rewriteSession.CheckOutModuleRewriter(result.Target.QualifiedModuleName); var token = ((VBAParser.ArgContext)result.Target.Context).BYVAL().Symbol; rewriter.Replace(token, Tokens.ByRef); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/PassParameterByValueQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/PassParameterByValueQuickFix.cs index 077a6b7a30..374299fd16 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/PassParameterByValueQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/PassParameterByValueQuickFix.cs @@ -13,6 +13,7 @@ namespace Rubberduck.Inspections.QuickFixes { public sealed class PassParameterByValueQuickFix : QuickFixBase { + //TODO: Change this to IDeclarationFinderProvider once the FIXME below is handled. private readonly RubberduckParserState _state; public PassParameterByValueQuickFix(RubberduckParserState state) @@ -21,26 +22,26 @@ public PassParameterByValueQuickFix(RubberduckParserState state) _state = state; } - public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { if (result.Target.ParentDeclaration.DeclarationType == DeclarationType.Event || _state.DeclarationFinder.FindAllInterfaceMembers().Contains(result.Target.ParentDeclaration)) { - FixMethods(result.Target); + FixMethods(result.Target, rewriteSession); } else { - FixMethod((VBAParser.ArgContext)result.Target.Context, result.QualifiedSelection); + FixMethod((VBAParser.ArgContext)result.Target.Context, result.QualifiedSelection, rewriteSession); } } public override string Description(IInspectionResult result) => Resources.Inspections.QuickFixes.PassParameterByValueQuickFix; - private void FixMethods(Declaration target) + private void FixMethods(Declaration target, IRewriteSession rewriteSession) { var declarationParameters = - _state.AllUserDeclarations.Where(declaration => declaration.DeclarationType == DeclarationType.Parameter && - Equals(declaration.ParentDeclaration, target.ParentDeclaration)) + _state.DeclarationFinder.UserDeclarations(DeclarationType.Parameter) + .Where(declaration => Equals(declaration.ParentDeclaration, target.ParentDeclaration)) .OrderBy(o => o.Selection.StartLine) .ThenBy(t => t.Selection.StartColumn) .ToList(); @@ -51,6 +52,7 @@ private void FixMethods(Declaration target) return; // should only happen if the parse results are stale; prevents a crash in that case } + //FIXME: Make this use the DeclarationFinder. var members = target.ParentDeclaration.DeclarationType == DeclarationType.Event ? _state.AllUserDeclarations.FindHandlersForEvent(target.ParentDeclaration) .Select(s => s.Item2) @@ -60,23 +62,23 @@ private void FixMethods(Declaration target) foreach (var member in members) { var parameters = - _state.AllUserDeclarations.Where(declaration => declaration.DeclarationType == DeclarationType.Parameter && - Equals(declaration.ParentDeclaration, member)) + _state.DeclarationFinder.UserDeclarations(DeclarationType.Parameter) + .Where(declaration => Equals(declaration.ParentDeclaration, member)) .OrderBy(o => o.Selection.StartLine) .ThenBy(t => t.Selection.StartColumn) .ToList(); FixMethod((VBAParser.ArgContext)parameters[parameterIndex].Context, - parameters[parameterIndex].QualifiedSelection); + parameters[parameterIndex].QualifiedSelection, rewriteSession); } FixMethod((VBAParser.ArgContext)declarationParameters[parameterIndex].Context, - declarationParameters[parameterIndex].QualifiedSelection); + declarationParameters[parameterIndex].QualifiedSelection, rewriteSession); } - private void FixMethod(VBAParser.ArgContext context, QualifiedSelection qualifiedSelection) + private void FixMethod(VBAParser.ArgContext context, QualifiedSelection qualifiedSelection, IRewriteSession rewriteSession) { - var rewriter = _state.GetRewriter(qualifiedSelection.QualifiedName); + var rewriter = rewriteSession.CheckOutModuleRewriter(qualifiedSelection.QualifiedName); if (context.BYREF() != null) { rewriter.Replace(context.BYREF(), Tokens.ByVal); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RemoveCommentQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RemoveCommentQuickFix.cs index 90fea1b043..e17409f5f0 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/RemoveCommentQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/RemoveCommentQuickFix.cs @@ -2,23 +2,18 @@ using Rubberduck.Inspections.Concrete; using Rubberduck.Parsing.Inspections.Abstract; using Rubberduck.Parsing.Rewriter; -using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes { public sealed class RemoveCommentQuickFix : QuickFixBase { - private readonly RubberduckParserState _state; - - public RemoveCommentQuickFix(RubberduckParserState state) + public RemoveCommentQuickFix() : base(typeof(ObsoleteCommentSyntaxInspection)) - { - _state = state; - } + {} - public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { - var rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); + var rewriter = rewriteSession.CheckOutModuleRewriter(result.QualifiedSelection.QualifiedName); rewriter.Remove(result.Context); } diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RemoveDuplicatedAnnotationQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RemoveDuplicatedAnnotationQuickFix.cs index c0f62838d6..f2255c9058 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/RemoveDuplicatedAnnotationQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/RemoveDuplicatedAnnotationQuickFix.cs @@ -7,28 +7,24 @@ using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Inspections.Abstract; using Rubberduck.Parsing.Rewriter; -using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes { - public class RemoveDuplicatedAnnotationQuickFix : QuickFixBase + public sealed class RemoveDuplicatedAnnotationQuickFix : QuickFixBase { - private readonly RubberduckParserState _state; - - public RemoveDuplicatedAnnotationQuickFix(RubberduckParserState state) + public RemoveDuplicatedAnnotationQuickFix() : base(typeof(DuplicatedAnnotationInspection)) - { - _state = state; - } + {} - public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { - var rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); + var rewriter = rewriteSession.CheckOutModuleRewriter(result.QualifiedSelection.QualifiedName); var duplicateAnnotations = result.Target.Annotations .Where(annotation => annotation.AnnotationType == result.Properties.AnnotationType) .OrderBy(annotation => annotation.Context.Start.StartIndex) - .Skip(1); + .Skip(1) + .ToList(); var duplicatesPerAnnotationList = duplicateAnnotations .Select(annotation => (VBAParser.AnnotationListContext) annotation.Context.Parent) @@ -64,7 +60,7 @@ public override string Description(IInspectionResult result) => public override bool CanFixInProject => true; private static void RemoveAnnotationMarker(VBAParser.AnnotationListContext annotationList, - IAnnotation annotation, IExecutableModuleRewriter rewriter) + IAnnotation annotation, IModuleRewriter rewriter) { var index = Array.IndexOf(annotationList.annotation(), annotation.Context); rewriter.Remove(annotationList.AT(index)); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RemoveEmptyElseBlockQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RemoveEmptyElseBlockQuickFix.cs index bcb9ad9b8f..83ace83be6 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/RemoveEmptyElseBlockQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/RemoveEmptyElseBlockQuickFix.cs @@ -3,29 +3,23 @@ using Rubberduck.Parsing.Inspections.Abstract; using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Rewriter; -using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes { - class RemoveEmptyElseBlockQuickFix : QuickFixBase + public sealed class RemoveEmptyElseBlockQuickFix : QuickFixBase { - private readonly RubberduckParserState _state; - - public RemoveEmptyElseBlockQuickFix(RubberduckParserState state) + public RemoveEmptyElseBlockQuickFix() : base(typeof(EmptyElseBlockInspection)) - { - _state = state; - } + {} - public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { - var rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); + var rewriter = rewriteSession.CheckOutModuleRewriter(result.QualifiedSelection.QualifiedName); - //dynamic used since it's not known at run-time - UpdateContext((dynamic)result.Context, rewriter); + UpdateContext((VBAParser.ElseBlockContext)result.Context, rewriter); } - private void UpdateContext(VBAParser.ElseBlockContext context, IExecutableModuleRewriter rewriter) + private void UpdateContext(VBAParser.ElseBlockContext context, IModuleRewriter rewriter) { var elseBlock = context.block(); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RemoveEmptyIfBlockQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RemoveEmptyIfBlockQuickFix.cs index 26bf7c9923..0b3cfa4da6 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/RemoveEmptyIfBlockQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/RemoveEmptyIfBlockQuickFix.cs @@ -7,28 +7,36 @@ using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Inspections.Abstract; using Rubberduck.Parsing.Rewriter; -using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes { - internal sealed class RemoveEmptyIfBlockQuickFix : QuickFixBase + public sealed class RemoveEmptyIfBlockQuickFix : QuickFixBase { - private readonly RubberduckParserState _state; - - public RemoveEmptyIfBlockQuickFix(RubberduckParserState state) + public RemoveEmptyIfBlockQuickFix() : base(typeof(EmptyIfBlockInspection)) - { - _state = state; - } + {} - public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { - var rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); - - UpdateContext((dynamic)result.Context, rewriter); + var rewriter = rewriteSession.CheckOutModuleRewriter(result.QualifiedSelection.QualifiedName); + + switch (result.Context) + { + case VBAParser.IfStmtContext ifContext: + UpdateContext(ifContext, rewriter); + break; + case VBAParser.IfWithEmptyThenContext ifWithEmtyThenContext: + UpdateContext(ifWithEmtyThenContext, rewriter); + break; + case VBAParser.ElseIfBlockContext elseIfBlockContext: + UpdateContext(elseIfBlockContext, rewriter); + break; + default: + throw new NotSupportedException(nameof(result.Context)); + } } - private void UpdateContext(VBAParser.IfStmtContext context, IExecutableModuleRewriter rewriter) + private void UpdateContext(VBAParser.IfStmtContext context, IModuleRewriter rewriter) { var elseBlock = context.elseBlock(); var elseIfBlock = context.elseIfBlock().FirstOrDefault(); @@ -55,7 +63,7 @@ private void UpdateContext(VBAParser.IfStmtContext context, IExecutableModuleRew } Debug.Assert(context.booleanExpression().children.Count == 1); - UpdateCondition((dynamic)context.booleanExpression().children[0], rewriter); + UpdateConditionDependingOnType((ParserRuleContext)context.booleanExpression().children[0], rewriter); } else { @@ -63,7 +71,7 @@ private void UpdateContext(VBAParser.IfStmtContext context, IExecutableModuleRew } } - private void UpdateContext(VBAParser.IfWithEmptyThenContext context, IExecutableModuleRewriter rewriter) + private void UpdateContext(VBAParser.IfWithEmptyThenContext context, IModuleRewriter rewriter) { var elseClause = context.singleLineElseClause(); if (context.singleLineElseClause().whiteSpace() != null) @@ -76,10 +84,10 @@ private void UpdateContext(VBAParser.IfWithEmptyThenContext context, IExecutable } Debug.Assert(context.booleanExpression().children.Count == 1); - UpdateCondition((dynamic)context.booleanExpression().children[0], rewriter); + UpdateConditionDependingOnType((ParserRuleContext)context.booleanExpression().children[0], rewriter); } - private void UpdateContext(VBAParser.ElseIfBlockContext context, IExecutableModuleRewriter rewriter) + private void UpdateContext(VBAParser.ElseIfBlockContext context, IModuleRewriter rewriter) { if (BlockHasDeclaration(context.block())) { @@ -89,7 +97,29 @@ private void UpdateContext(VBAParser.ElseIfBlockContext context, IExecutableModu rewriter.Remove(context); } - private void UpdateCondition(VBAParser.RelationalOpContext condition, IExecutableModuleRewriter rewriter) + private void UpdateConditionDependingOnType(ParserRuleContext context, IModuleRewriter rewriter) + { + switch (context) + { + case VBAParser.RelationalOpContext condition: + UpdateCondition(condition, rewriter); + break; + case VBAParser.LogicalNotOpContext condition: + UpdateCondition(condition, rewriter); + break; + case VBAParser.LogicalAndOpContext condition: + UpdateCondition(condition, rewriter); + break; + case VBAParser.LogicalOrOpContext condition: + UpdateCondition(condition, rewriter); + break; + default: + UpdateCondition(context, rewriter); + break; + } + } + + private void UpdateCondition(VBAParser.RelationalOpContext condition, IModuleRewriter rewriter) { if (condition.EQ() != null) { @@ -121,7 +151,7 @@ private void UpdateCondition(VBAParser.RelationalOpContext condition, IExecutabl } } - private void UpdateCondition(VBAParser.LogicalNotOpContext condition, IExecutableModuleRewriter rewriter) + private void UpdateCondition(VBAParser.LogicalNotOpContext condition, IModuleRewriter rewriter) { if (condition.whiteSpace() != null) { @@ -133,17 +163,17 @@ private void UpdateCondition(VBAParser.LogicalNotOpContext condition, IExecutabl } } - private void UpdateCondition(VBAParser.LogicalAndOpContext condition, IExecutableModuleRewriter rewriter) + private void UpdateCondition(VBAParser.LogicalAndOpContext condition, IModuleRewriter rewriter) { rewriter.Replace(condition.AND(), "Or"); } - private void UpdateCondition(VBAParser.LogicalOrOpContext condition, IExecutableModuleRewriter rewriter) + private void UpdateCondition(VBAParser.LogicalOrOpContext condition, IModuleRewriter rewriter) { rewriter.Replace(condition.OR(), "And"); } - private void UpdateCondition(ParserRuleContext condition, IExecutableModuleRewriter rewriter) + private void UpdateCondition(ParserRuleContext condition, IModuleRewriter rewriter) { if (condition.GetText().Contains(' ')) { diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RemoveExplicitByRefModifierQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RemoveExplicitByRefModifierQuickFix.cs index 225582c16e..f82e3fd211 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/RemoveExplicitByRefModifierQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/RemoveExplicitByRefModifierQuickFix.cs @@ -11,23 +11,23 @@ namespace Rubberduck.Inspections.QuickFixes { - public class RemoveExplicitByRefModifierQuickFix : QuickFixBase + public sealed class RemoveExplicitByRefModifierQuickFix : QuickFixBase { - private readonly RubberduckParserState _state; + private readonly IDeclarationFinderProvider _declarationFinderProvider; - public RemoveExplicitByRefModifierQuickFix(RubberduckParserState state) + public RemoveExplicitByRefModifierQuickFix(IDeclarationFinderProvider declarationFinderProvider) : base(typeof(RedundantByRefModifierInspection)) { - _state = state; + _declarationFinderProvider = declarationFinderProvider; } - public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { var context = (VBAParser.ArgContext) result.Context; - RemoveByRefIdentifier(_state.GetRewriter(result.QualifiedSelection.QualifiedName), context); + RemoveByRefIdentifier(rewriteSession.CheckOutModuleRewriter(result.QualifiedSelection.QualifiedName), context); - var interfaceMembers = _state.DeclarationFinder.FindAllInterfaceMembers().ToArray(); + var interfaceMembers = _declarationFinderProvider.DeclarationFinder.FindAllInterfaceMembers().ToArray(); var matchingInterfaceMemberContext = interfaceMembers.Select(member => member.Context).FirstOrDefault(c => c == context.Parent.Parent); @@ -36,11 +36,11 @@ public override void Fix(IInspectionResult result, IRewriteSession rewriteSessio var interfaceParameterIndex = GetParameterIndex(context); var implementationMembers = - _state.DeclarationFinder.FindInterfaceImplementationMembers(interfaceMembers.First( + _declarationFinderProvider.DeclarationFinder.FindInterfaceImplementationMembers(interfaceMembers.First( member => member.Context == matchingInterfaceMemberContext)).ToHashSet(); var parameters = - _state.DeclarationFinder.UserDeclarations(DeclarationType.Parameter) + _declarationFinderProvider.DeclarationFinder.UserDeclarations(DeclarationType.Parameter) .Where(p => implementationMembers.Contains(p.ParentDeclaration)) .Cast() .ToArray(); @@ -52,7 +52,7 @@ public override void Fix(IInspectionResult result, IRewriteSession rewriteSessio if (parameterIndex == interfaceParameterIndex) { - RemoveByRefIdentifier(_state.GetRewriter(parameter), parameterContext); + RemoveByRefIdentifier(rewriteSession.CheckOutModuleRewriter(parameter.QualifiedModuleName), parameterContext); } } } @@ -69,7 +69,7 @@ private static int GetParameterIndex(VBAParser.ArgContext context) return Array.IndexOf(((VBAParser.ArgListContext)context.Parent).arg().ToArray(), context); } - private static void RemoveByRefIdentifier(IExecutableModuleRewriter rewriter, VBAParser.ArgContext context) + private static void RemoveByRefIdentifier(IModuleRewriter rewriter, VBAParser.ArgContext context) { if (context.BYREF() != null) { diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RemoveExplicitCallStatmentQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RemoveExplicitCallStatementQuickFix.cs similarity index 74% rename from Rubberduck.CodeAnalysis/QuickFixes/RemoveExplicitCallStatmentQuickFix.cs rename to Rubberduck.CodeAnalysis/QuickFixes/RemoveExplicitCallStatementQuickFix.cs index 8aef5ff215..88601e6c97 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/RemoveExplicitCallStatmentQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/RemoveExplicitCallStatementQuickFix.cs @@ -3,23 +3,18 @@ using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Inspections.Abstract; using Rubberduck.Parsing.Rewriter; -using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes { - public sealed class RemoveExplicitCallStatmentQuickFix : QuickFixBase + public sealed class RemoveExplicitCallStatementQuickFix : QuickFixBase { - private readonly RubberduckParserState _state; - - public RemoveExplicitCallStatmentQuickFix(RubberduckParserState state) + public RemoveExplicitCallStatementQuickFix() : base(typeof(ObsoleteCallStatementInspection)) - { - _state = state; - } + {} - public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { - var rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); + var rewriter = rewriteSession.CheckOutModuleRewriter(result.QualifiedSelection.QualifiedName); var context = (VBAParser.CallStmtContext)result.Context; rewriter.Remove(context.CALL()); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RemoveExplicitLetStatementQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RemoveExplicitLetStatementQuickFix.cs index 4d617dabf2..286635fc54 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/RemoveExplicitLetStatementQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/RemoveExplicitLetStatementQuickFix.cs @@ -4,23 +4,18 @@ using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Inspections.Abstract; using Rubberduck.Parsing.Rewriter; -using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes { public sealed class RemoveExplicitLetStatementQuickFix : QuickFixBase { - private readonly RubberduckParserState _state; - - public RemoveExplicitLetStatementQuickFix(RubberduckParserState state) + public RemoveExplicitLetStatementQuickFix() : base(typeof(ObsoleteLetStatementInspection)) - { - _state = state; - } + {} - public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { - var rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); + var rewriter = rewriteSession.CheckOutModuleRewriter(result.QualifiedSelection.QualifiedName); var context = (VBAParser.LetStmtContext) result.Context; rewriter.Remove(context.LET()); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RemoveLocalErrorQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RemoveLocalErrorQuickFix.cs index 73c19cd37c..aedb0bbbe4 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/RemoveLocalErrorQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/RemoveLocalErrorQuickFix.cs @@ -3,25 +3,20 @@ using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Inspections.Abstract; using Rubberduck.Parsing.Rewriter; -using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes { public sealed class RemoveLocalErrorQuickFix : QuickFixBase { - private readonly RubberduckParserState _state; - - public RemoveLocalErrorQuickFix(RubberduckParserState state) + public RemoveLocalErrorQuickFix() : base(typeof(OnLocalErrorInspection)) - { - _state = state; - } + {} - public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { var errorStmt = (VBAParser.OnErrorStmtContext)result.Context; - var rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); + var rewriter = rewriteSession.CheckOutModuleRewriter(result.QualifiedSelection.QualifiedName); rewriter.Replace(errorStmt.ON_LOCAL_ERROR(), Tokens.On + " " + Tokens.Error); } diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RemoveOptionBaseStatementQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RemoveOptionBaseStatementQuickFix.cs index b946277096..a980f9d34c 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/RemoveOptionBaseStatementQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/RemoveOptionBaseStatementQuickFix.cs @@ -2,23 +2,18 @@ using Rubberduck.Inspections.Concrete; using Rubberduck.Parsing.Inspections.Abstract; using Rubberduck.Parsing.Rewriter; -using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes { public sealed class RemoveOptionBaseStatementQuickFix : QuickFixBase { - private readonly RubberduckParserState _state; - - public RemoveOptionBaseStatementQuickFix(RubberduckParserState state) + public RemoveOptionBaseStatementQuickFix() : base(typeof(RedundantOptionInspection)) - { - _state = state; - } + {} - public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { - var rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); + var rewriter = rewriteSession.CheckOutModuleRewriter(result.QualifiedSelection.QualifiedName); rewriter.Remove(result.Context); } diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RemoveStepOneQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RemoveStepOneQuickFix.cs index 0a94043ddb..676f013f1e 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/RemoveStepOneQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/RemoveStepOneQuickFix.cs @@ -2,19 +2,14 @@ using Rubberduck.Inspections.Concrete; using Rubberduck.Parsing.Inspections.Abstract; using Rubberduck.Parsing.Rewriter; -using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes { - public class RemoveStepOneQuickFix : QuickFixBase + public sealed class RemoveStepOneQuickFix : QuickFixBase { - private readonly RubberduckParserState _state; - - public RemoveStepOneQuickFix(RubberduckParserState state) + public RemoveStepOneQuickFix() : base(typeof(StepOneIsRedundantInspection)) - { - _state = state; - } + {} public override bool CanFixInProcedure => true; @@ -24,9 +19,9 @@ public RemoveStepOneQuickFix(RubberduckParserState state) public override string Description(IInspectionResult result) => Resources.Inspections.QuickFixes.RemoveStepOneQuickFix; - public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { - IExecutableModuleRewriter rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); + var rewriter = rewriteSession.CheckOutModuleRewriter(result.QualifiedSelection.QualifiedName); var context = result.Context; rewriter.Remove(context); } diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RemoveStopKeywordQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RemoveStopKeywordQuickFix.cs index bb61ae64fd..18929a6c69 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/RemoveStopKeywordQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/RemoveStopKeywordQuickFix.cs @@ -2,23 +2,18 @@ using Rubberduck.Inspections.Concrete; using Rubberduck.Parsing.Inspections.Abstract; using Rubberduck.Parsing.Rewriter; -using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes { public sealed class RemoveStopKeywordQuickFix : QuickFixBase { - private readonly RubberduckParserState _state; - - public RemoveStopKeywordQuickFix(RubberduckParserState state) + public RemoveStopKeywordQuickFix() : base(typeof(StopKeywordInspection)) - { - _state = state; - } + {} - public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { - var rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); + var rewriter = rewriteSession.CheckOutModuleRewriter(result.QualifiedSelection.QualifiedName); rewriter.Remove(result.Context); } diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RemoveTypeHintsQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RemoveTypeHintsQuickFix.cs index ddaa597a4f..c1ab54b6cf 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/RemoveTypeHintsQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/RemoveTypeHintsQuickFix.cs @@ -5,25 +5,20 @@ using Rubberduck.Parsing.Inspections.Abstract; using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.Symbols; -using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes { public sealed class RemoveTypeHintsQuickFix : QuickFixBase { - private readonly RubberduckParserState _state; - - public RemoveTypeHintsQuickFix(RubberduckParserState state) + public RemoveTypeHintsQuickFix() : base(typeof(ObsoleteTypeHintInspection)) - { - _state = state; - } + {} - public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { if (!string.IsNullOrWhiteSpace(result.Target.TypeHint)) { - var rewriter = _state.GetRewriter(result.Target); + var rewriter = rewriteSession.CheckOutModuleRewriter(result.Target.QualifiedModuleName); var typeHintContext = result.Context.GetDescendent(); rewriter.Remove(typeHintContext); @@ -56,11 +51,11 @@ public override void Fix(IInspectionResult result, IRewriteSession rewriteSessio foreach (var reference in result.Target.References) { - var rewriter = _state.GetRewriter(reference.QualifiedModuleName); var context = reference.Context.GetDescendent(); if (context != null) { + var rewriter = rewriteSession.CheckOutModuleRewriter(reference.QualifiedModuleName); rewriter.Remove(context); } } diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RemoveUnassignedIdentifierQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RemoveUnassignedIdentifierQuickFix.cs index 4d314052ef..e2c0ab47fb 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/RemoveUnassignedIdentifierQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/RemoveUnassignedIdentifierQuickFix.cs @@ -2,23 +2,18 @@ using Rubberduck.Inspections.Concrete; using Rubberduck.Parsing.Inspections.Abstract; using Rubberduck.Parsing.Rewriter; -using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes { public sealed class RemoveUnassignedIdentifierQuickFix : QuickFixBase { - private readonly RubberduckParserState _state; - - public RemoveUnassignedIdentifierQuickFix(RubberduckParserState state) + public RemoveUnassignedIdentifierQuickFix() : base(typeof(VariableNotAssignedInspection)) - { - _state = state; - } + {} - public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { - var rewriter = _state.GetRewriter(result.Target); + var rewriter = rewriteSession.CheckOutModuleRewriter(result.Target.QualifiedModuleName); rewriter.Remove(result.Target); } diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RemoveUnassignedVariableUsageQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RemoveUnassignedVariableUsageQuickFix.cs index d4d3d08ccf..20d23aea67 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/RemoveUnassignedVariableUsageQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/RemoveUnassignedVariableUsageQuickFix.cs @@ -5,24 +5,18 @@ using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Inspections.Abstract; using Rubberduck.Parsing.Rewriter; -using Rubberduck.Parsing.Symbols; -using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes { public sealed class RemoveUnassignedVariableUsageQuickFix : QuickFixBase { - private readonly RubberduckParserState _state; - - public RemoveUnassignedVariableUsageQuickFix(RubberduckParserState state) + public RemoveUnassignedVariableUsageQuickFix() : base(typeof(UnassignedVariableUsageInspection)) - { - _state = state; - } + {} - public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { - var rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); + var rewriter = rewriteSession.CheckOutModuleRewriter(result.QualifiedSelection.QualifiedName); var assignmentContext = result.Context.GetAncestor() ?? (ParserRuleContext)result.Context.GetAncestor(); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RemoveUnusedDeclarationQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RemoveUnusedDeclarationQuickFix.cs index 0ae3f345f9..515bf8d2ac 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/RemoveUnusedDeclarationQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/RemoveUnusedDeclarationQuickFix.cs @@ -2,7 +2,6 @@ using Rubberduck.Inspections.Concrete; using Rubberduck.Parsing.Inspections.Abstract; using Rubberduck.Parsing.Rewriter; -using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes { @@ -11,17 +10,13 @@ namespace Rubberduck.Inspections.QuickFixes /// public sealed class RemoveUnusedDeclarationQuickFix : QuickFixBase { - private readonly RubberduckParserState _state; - - public RemoveUnusedDeclarationQuickFix(RubberduckParserState state) + public RemoveUnusedDeclarationQuickFix() : base(typeof(ConstantNotUsedInspection), typeof(ProcedureNotUsedInspection), typeof(VariableNotUsedInspection), typeof(LineLabelNotUsedInspection)) - { - _state = state; - } + {} - public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { - var rewriter = _state.GetRewriter(result.Target); + var rewriter = rewriteSession.CheckOutModuleRewriter(result.Target.QualifiedModuleName); rewriter.Remove(result.Target); } diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RemoveUnusedParameterQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RemoveUnusedParameterQuickFix.cs index 0bc2aef419..04128d2407 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/RemoveUnusedParameterQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/RemoveUnusedParameterQuickFix.cs @@ -24,7 +24,7 @@ public RemoveUnusedParameterQuickFix(IVBE vbe, RubberduckParserState state, IMes _messageBox = messageBox; } - public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { using (var dialog = new RemoveParametersDialog(new RemoveParametersViewModel(_state))) { diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RenameDeclarationQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RenameDeclarationQuickFix.cs index 75d0ef30ae..877bd29186 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/RenameDeclarationQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/RenameDeclarationQuickFix.cs @@ -26,7 +26,7 @@ public RenameDeclarationQuickFix(IVBE vbe, RubberduckParserState state, IMessage _messageBox = messageBox; } - public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { using (var view = new RenameDialog(new RenameViewModel(_state))) { diff --git a/Rubberduck.CodeAnalysis/QuickFixes/ReplaceEmptyStringLiteralStatementQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/ReplaceEmptyStringLiteralStatementQuickFix.cs index a2284ebb23..27bfec7e25 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/ReplaceEmptyStringLiteralStatementQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/ReplaceEmptyStringLiteralStatementQuickFix.cs @@ -2,23 +2,18 @@ using Rubberduck.Inspections.Concrete; using Rubberduck.Parsing.Inspections.Abstract; using Rubberduck.Parsing.Rewriter; -using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes { public sealed class ReplaceEmptyStringLiteralStatementQuickFix : QuickFixBase { - private readonly RubberduckParserState _state; - - public ReplaceEmptyStringLiteralStatementQuickFix(RubberduckParserState state) + public ReplaceEmptyStringLiteralStatementQuickFix() : base(typeof(EmptyStringLiteralInspection)) - { - _state = state; - } + {} - public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { - var rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); + var rewriter = rewriteSession.CheckOutModuleRewriter(result.QualifiedSelection.QualifiedName); rewriter.Replace(result.Context, "vbNullString"); } diff --git a/Rubberduck.CodeAnalysis/QuickFixes/ReplaceGlobalModifierQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/ReplaceGlobalModifierQuickFix.cs index c99e7e1670..0c31e2fc91 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/ReplaceGlobalModifierQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/ReplaceGlobalModifierQuickFix.cs @@ -5,23 +5,18 @@ using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Inspections.Abstract; using Rubberduck.Parsing.Rewriter; -using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes { public sealed class ReplaceGlobalModifierQuickFix : QuickFixBase { - private readonly RubberduckParserState _state; - - public ReplaceGlobalModifierQuickFix(RubberduckParserState state) + public ReplaceGlobalModifierQuickFix() : base(typeof(ObsoleteGlobalInspection)) - { - _state = state; - } + {} - public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { - var rewriter = _state.GetRewriter(result.Target); + var rewriter = rewriteSession.CheckOutModuleRewriter(result.Target.QualifiedModuleName); rewriter.Replace(((ParserRuleContext)result.Context.Parent.Parent).GetDescendent(), Tokens.Public); } diff --git a/Rubberduck.CodeAnalysis/QuickFixes/ReplaceIfElseWithConditionalStatementQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/ReplaceIfElseWithConditionalStatementQuickFix.cs index 9e5180b67e..3020fc05bd 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/ReplaceIfElseWithConditionalStatementQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/ReplaceIfElseWithConditionalStatementQuickFix.cs @@ -4,22 +4,16 @@ using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Inspections.Abstract; using Rubberduck.Parsing.Rewriter; -using Rubberduck.Parsing.Symbols; -using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes { public sealed class ReplaceIfElseWithConditionalStatementQuickFix : QuickFixBase { - private readonly RubberduckParserState _state; - - public ReplaceIfElseWithConditionalStatementQuickFix(RubberduckParserState state) + public ReplaceIfElseWithConditionalStatementQuickFix() : base(typeof(BooleanAssignedInIfElseInspection)) - { - _state = state; - } + {} - public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { var ifContext = (VBAParser.IfStmtContext) result.Context; var letStmt = ifContext.block().GetDescendent(); @@ -31,7 +25,7 @@ public override void Fix(IInspectionResult result, IRewriteSession rewriteSessio conditional = $"Not ({conditional})"; } - var rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); + var rewriter = rewriteSession.CheckOutModuleRewriter(result.QualifiedSelection.QualifiedName); rewriter.Replace(result.Context, $"{letStmt.lExpression().GetText()} = {conditional}"); } diff --git a/Rubberduck.CodeAnalysis/QuickFixes/ReplaceObsoleteCommentMarkerQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/ReplaceObsoleteCommentMarkerQuickFix.cs index 56b173af26..cc9129aef3 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/ReplaceObsoleteCommentMarkerQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/ReplaceObsoleteCommentMarkerQuickFix.cs @@ -3,23 +3,18 @@ using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Inspections.Abstract; using Rubberduck.Parsing.Rewriter; -using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes { public sealed class ReplaceObsoleteCommentMarkerQuickFix : QuickFixBase { - private readonly RubberduckParserState _state; - - public ReplaceObsoleteCommentMarkerQuickFix(RubberduckParserState state) + public ReplaceObsoleteCommentMarkerQuickFix() : base(typeof(ObsoleteCommentSyntaxInspection)) - { - _state = state; - } + {} - public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { - var rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); + var rewriter = rewriteSession.CheckOutModuleRewriter(result.QualifiedSelection.QualifiedName); var context = (VBAParser.RemCommentContext) result.Context; rewriter.Replace(context.REM(), "'"); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/ReplaceObsoleteErrorStatementQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/ReplaceObsoleteErrorStatementQuickFix.cs index 36134df642..35364228a8 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/ReplaceObsoleteErrorStatementQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/ReplaceObsoleteErrorStatementQuickFix.cs @@ -3,23 +3,18 @@ using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Inspections.Abstract; using Rubberduck.Parsing.Rewriter; -using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes { public sealed class ReplaceObsoleteErrorStatementQuickFix : QuickFixBase { - private readonly RubberduckParserState _state; - - public ReplaceObsoleteErrorStatementQuickFix(RubberduckParserState state) + public ReplaceObsoleteErrorStatementQuickFix() : base(typeof(ObsoleteErrorSyntaxInspection)) - { - _state = state; - } + {} - public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { - var rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); + var rewriter = rewriteSession.CheckOutModuleRewriter(result.QualifiedSelection.QualifiedName); var context = (VBAParser.ErrorStmtContext) result.Context; rewriter.Replace(context.ERROR(), "Err.Raise"); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RestoreErrorHandlingQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RestoreErrorHandlingQuickFix.cs index 73cb76157e..b96dc94f0e 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/RestoreErrorHandlingQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/RestoreErrorHandlingQuickFix.cs @@ -6,22 +6,18 @@ using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Inspections.Abstract; using Rubberduck.Parsing.Rewriter; -using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes { - public class RestoreErrorHandlingQuickFix : QuickFixBase + public sealed class RestoreErrorHandlingQuickFix : QuickFixBase { - private readonly RubberduckParserState _state; private const string LabelPrefix = "ErrorHandler"; - public RestoreErrorHandlingQuickFix(RubberduckParserState state) + public RestoreErrorHandlingQuickFix() : base(typeof(UnhandledOnErrorResumeNextInspection)) - { - _state = state; - } + {} - public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { var exitStatement = "Exit "; VBAParser.BlockContext block; @@ -53,7 +49,7 @@ public override void Fix(IInspectionResult result, IRewriteSession rewriteSessio block = bodyElementContext.subStmt().block(); } - var rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); + var rewriter = rewriteSession.CheckOutModuleRewriter(result.QualifiedSelection.QualifiedName); var context = (VBAParser.OnErrorStmtContext)result.Context; var labels = bodyElementContext.GetDescendents().ToArray(); var maximumExistingLabelIndex = GetMaximumExistingLabelIndex(labels); diff --git a/Rubberduck.CodeAnalysis/QuickFixes/SetExplicitVariantReturnTypeQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/SetExplicitVariantReturnTypeQuickFix.cs index 5e046355b8..06c5d27bed 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/SetExplicitVariantReturnTypeQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/SetExplicitVariantReturnTypeQuickFix.cs @@ -4,23 +4,18 @@ using Rubberduck.Parsing.Inspections.Abstract; using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.Symbols; -using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes { public sealed class SetExplicitVariantReturnTypeQuickFix : QuickFixBase { - private readonly RubberduckParserState _state; - - public SetExplicitVariantReturnTypeQuickFix(RubberduckParserState state) + public SetExplicitVariantReturnTypeQuickFix() :base(typeof(ImplicitVariantReturnTypeInspection)) - { - _state = state; - } + {} - public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { - var rewriter = _state.GetRewriter(result.Target); + var rewriter = rewriteSession.CheckOutModuleRewriter(result.Target.QualifiedModuleName); const string asTypeClause = " As Variant"; switch (result.Target.DeclarationType) diff --git a/Rubberduck.CodeAnalysis/QuickFixes/SpecifyExplicitByRefModifierQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/SpecifyExplicitByRefModifierQuickFix.cs index 39d861bee0..c6d18d0484 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/SpecifyExplicitByRefModifierQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/SpecifyExplicitByRefModifierQuickFix.cs @@ -11,23 +11,23 @@ namespace Rubberduck.Inspections.QuickFixes { - public class SpecifyExplicitByRefModifierQuickFix : QuickFixBase + public sealed class SpecifyExplicitByRefModifierQuickFix : QuickFixBase { - private readonly RubberduckParserState _state; + private readonly IDeclarationFinderProvider _declarationFinderProvider; - public SpecifyExplicitByRefModifierQuickFix(RubberduckParserState state) + public SpecifyExplicitByRefModifierQuickFix(IDeclarationFinderProvider declarationFinderProvider) : base(typeof(ImplicitByRefModifierInspection)) { - _state = state; + _declarationFinderProvider = declarationFinderProvider; } - public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { var context = (VBAParser.ArgContext)result.Context; - AddByRefIdentifier(_state.GetRewriter(result.QualifiedSelection.QualifiedName), context); + AddByRefIdentifier(rewriteSession.CheckOutModuleRewriter(result.QualifiedSelection.QualifiedName), context); - var interfaceMembers = _state.DeclarationFinder.FindAllInterfaceMembers().ToArray(); + var interfaceMembers = _declarationFinderProvider.DeclarationFinder.FindAllInterfaceMembers().ToArray(); var matchingInterfaceMemberContext = interfaceMembers.Select(member => member.Context).FirstOrDefault(c => c == context.Parent.Parent); @@ -39,11 +39,11 @@ public override void Fix(IInspectionResult result, IRewriteSession rewriteSessio var interfaceParameterIndex = GetParameterIndex(context); var implementationMembers = - _state.DeclarationFinder.FindInterfaceImplementationMembers(interfaceMembers.First( + _declarationFinderProvider.DeclarationFinder.FindInterfaceImplementationMembers(interfaceMembers.First( member => member.Context == matchingInterfaceMemberContext)).ToHashSet(); var parameters = - _state.DeclarationFinder.UserDeclarations(DeclarationType.Parameter) + _declarationFinderProvider.DeclarationFinder.UserDeclarations(DeclarationType.Parameter) .Where(p => implementationMembers.Contains(p.ParentDeclaration)) .Cast() .ToArray(); @@ -55,7 +55,7 @@ public override void Fix(IInspectionResult result, IRewriteSession rewriteSessio if (parameterIndex == interfaceParameterIndex) { - AddByRefIdentifier(_state.GetRewriter(parameter), parameterContext); + AddByRefIdentifier(rewriteSession.CheckOutModuleRewriter(parameter.QualifiedModuleName), parameterContext); } } @@ -72,7 +72,7 @@ private static int GetParameterIndex(VBAParser.ArgContext context) return Array.IndexOf(((VBAParser.ArgListContext)context.Parent).arg().ToArray(), context); } - private static void AddByRefIdentifier(IExecutableModuleRewriter rewriter, VBAParser.ArgContext context) + private static void AddByRefIdentifier(IModuleRewriter rewriter, VBAParser.ArgContext context) { if (context.BYREF() == null) { diff --git a/Rubberduck.CodeAnalysis/QuickFixes/SpecifyExplicitPublicModifierQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/SpecifyExplicitPublicModifierQuickFix.cs index 7e13182f23..5c95e0e80b 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/SpecifyExplicitPublicModifierQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/SpecifyExplicitPublicModifierQuickFix.cs @@ -2,23 +2,18 @@ using Rubberduck.Inspections.Concrete; using Rubberduck.Parsing.Inspections.Abstract; using Rubberduck.Parsing.Rewriter; -using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes { public sealed class SpecifyExplicitPublicModifierQuickFix : QuickFixBase { - private readonly RubberduckParserState _state; - - public SpecifyExplicitPublicModifierQuickFix(RubberduckParserState state) + public SpecifyExplicitPublicModifierQuickFix() : base(typeof(ImplicitPublicMemberInspection)) - { - _state = state; - } + {} - public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { - var rewriter = _state.GetRewriter(result.Target); + var rewriter = rewriteSession.CheckOutModuleRewriter(result.Target.QualifiedModuleName); rewriter.InsertBefore(result.Context.Start.TokenIndex, "Public "); } diff --git a/Rubberduck.CodeAnalysis/QuickFixes/SplitMultipleDeclarationsQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/SplitMultipleDeclarationsQuickFix.cs index 3ca396076f..fbd2796e6e 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/SplitMultipleDeclarationsQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/SplitMultipleDeclarationsQuickFix.cs @@ -6,21 +6,16 @@ using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Inspections.Abstract; using Rubberduck.Parsing.Rewriter; -using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes { public sealed class SplitMultipleDeclarationsQuickFix : QuickFixBase { - private readonly RubberduckParserState _state; - - public SplitMultipleDeclarationsQuickFix(RubberduckParserState state) + public SplitMultipleDeclarationsQuickFix() : base(typeof(MultipleDeclarationsInspection)) - { - _state = state; - } + {} - public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { var context = result.Context is VBAParser.ConstStmtContext ? result.Context @@ -39,7 +34,7 @@ public override void Fix(IInspectionResult result, IRewriteSession rewriteSessio throw new NotSupportedException(); } - var rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); + var rewriter = rewriteSession.CheckOutModuleRewriter(result.QualifiedSelection.QualifiedName); rewriter.Replace(context, declarationsText); } diff --git a/Rubberduck.CodeAnalysis/QuickFixes/UntypedFunctionUsageQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/UntypedFunctionUsageQuickFix.cs index ba7e5f92b2..5a2da9f884 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/UntypedFunctionUsageQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/UntypedFunctionUsageQuickFix.cs @@ -6,23 +6,18 @@ using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Inspections.Abstract; using Rubberduck.Parsing.Rewriter; -using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes { public sealed class UntypedFunctionUsageQuickFix : QuickFixBase { - private readonly RubberduckParserState _state; - - public UntypedFunctionUsageQuickFix(RubberduckParserState state) + public UntypedFunctionUsageQuickFix() : base(typeof(UntypedFunctionUsageInspection)) - { - _state = state; - } + {} - public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { - var rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); + var rewriter = rewriteSession.CheckOutModuleRewriter(result.QualifiedSelection.QualifiedName); rewriter.InsertAfter(result.Context.Stop.TokenIndex, "$"); } diff --git a/Rubberduck.CodeAnalysis/QuickFixes/UseSetKeywordForObjectAssignmentQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/UseSetKeywordForObjectAssignmentQuickFix.cs index 332b02e49f..fa50da1c06 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/UseSetKeywordForObjectAssignmentQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/UseSetKeywordForObjectAssignmentQuickFix.cs @@ -2,23 +2,18 @@ using Rubberduck.Inspections.Concrete; using Rubberduck.Parsing.Inspections.Abstract; using Rubberduck.Parsing.Rewriter; -using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes { public sealed class UseSetKeywordForObjectAssignmentQuickFix : QuickFixBase { - private readonly RubberduckParserState _state; - - public UseSetKeywordForObjectAssignmentQuickFix(RubberduckParserState state) + public UseSetKeywordForObjectAssignmentQuickFix() : base(typeof(ObjectVariableNotSetInspection)) - { - _state = state; - } + {} - public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { - var rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); + var rewriter = rewriteSession.CheckOutModuleRewriter(result.QualifiedSelection.QualifiedName); rewriter.InsertBefore(result.Context.Start.TokenIndex, "Set "); } diff --git a/Rubberduck.CodeAnalysis/QuickFixes/WriteOnlyPropertyQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/WriteOnlyPropertyQuickFix.cs index 0d9cc12122..05bd4916c6 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/WriteOnlyPropertyQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/WriteOnlyPropertyQuickFix.cs @@ -6,23 +6,18 @@ using Rubberduck.Parsing.Inspections.Abstract; using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.Symbols; -using Rubberduck.Parsing.VBA; namespace Rubberduck.Inspections.QuickFixes { public sealed class WriteOnlyPropertyQuickFix : QuickFixBase { - private readonly RubberduckParserState _state; - - public WriteOnlyPropertyQuickFix(RubberduckParserState state) + public WriteOnlyPropertyQuickFix() : base(typeof(WriteOnlyPropertyInspection)) - { - _state = state; - } + {} - public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) + public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { - var parameters = ((IParameterizedDeclaration) result.Target).Parameters.Cast().ToList(); + var parameters = ((IParameterizedDeclaration) result.Target).Parameters.ToList(); var signatureParams = parameters.Except(new[] {parameters.Last()}).Select(GetParamText); @@ -32,7 +27,7 @@ public override void Fix(IInspectionResult result, IRewriteSession rewriteSessio parameters.Last().AsTypeName, Environment.NewLine); - var rewriter = _state.GetRewriter(result.Target); + var rewriter = rewriteSession.CheckOutModuleRewriter(result.Target.QualifiedModuleName); rewriter.InsertBefore(result.Target.Context.Start.TokenIndex, propertyGet); } diff --git a/Rubberduck.Parsing/Inspections/Abstract/IQuickFix.cs b/Rubberduck.Parsing/Inspections/Abstract/IQuickFix.cs index 635e06386d..f84cc8c814 100644 --- a/Rubberduck.Parsing/Inspections/Abstract/IQuickFix.cs +++ b/Rubberduck.Parsing/Inspections/Abstract/IQuickFix.cs @@ -7,7 +7,7 @@ namespace Rubberduck.Parsing.Inspections.Abstract { public interface IQuickFix { - void Fix(IInspectionResult result, IRewriteSession rewriteSession = null); + void Fix(IInspectionResult result, IRewriteSession rewriteSession); string Description(IInspectionResult result); bool CanFixInProcedure { get; } diff --git a/Rubberduck.Parsing/Rewriter/AttributesRewriteSession.cs b/Rubberduck.Parsing/Rewriter/AttributesRewriteSession.cs index 8719806c9c..de94ed5b72 100644 --- a/Rubberduck.Parsing/Rewriter/AttributesRewriteSession.cs +++ b/Rubberduck.Parsing/Rewriter/AttributesRewriteSession.cs @@ -23,14 +23,14 @@ protected override IExecutableModuleRewriter ModuleRewriter(QualifiedModuleName protected override void RewriteInternal() { //The suspension ensures that only one parse gets executed instead of two for each rewritten module. - var result = _state.OnSuspendParser(this, new[] {ParserState.Ready}, RewriteAllRewriters); + var result = _state.OnSuspendParser(this, new[] {ParserState.Ready}, ExecuteAllRewriters); if(result != SuspensionResult.Completed) { Logger.Warn($"Rewriting attribute modules did not succeed. suspension result = {result}"); } } - private void RewriteAllRewriters() + private void ExecuteAllRewriters() { foreach (var rewriter in CheckedOutModuleRewriters.Values) { diff --git a/RubberduckTests/QuickFixes/RemoveExplicitCallStatementQuickFixTests.cs b/RubberduckTests/QuickFixes/RemoveExplicitCallStatementQuickFixTests.cs index 50cc939aa3..fdd4209b2a 100644 --- a/RubberduckTests/QuickFixes/RemoveExplicitCallStatementQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/RemoveExplicitCallStatementQuickFixTests.cs @@ -40,7 +40,7 @@ Sub Goo(arg1 As Integer, arg1 As String) var inspector = InspectionsHelper.GetInspector(inspection); var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - var fix = new RemoveExplicitCallStatmentQuickFix(state); + var fix = new RemoveExplicitCallStatementQuickFix(state); foreach (var result in inspectionResults) { fix.Fix(result); From 76426be60d75a41f00fadc36a3299f866ecbd7d0 Mon Sep 17 00:00:00 2001 From: Max Doerner Date: Thu, 1 Nov 2018 14:19:53 +0100 Subject: [PATCH 08/59] Adjust the quickfix tests to the new setup of rewriting In addition, the tests are streamlined to use methods from a base class in order to reduce code duplication. --- .../QuickFixes/QuickFixProvider.cs | 23 +- .../AccessSheetUsingCodeNameQuickFixTests.cs | 111 +-- .../QuickFixes/AddStepOneQuickFixTests.cs | 34 +- ...plicationWorksheetFunctionQuickFixTests.cs | 85 +-- ...yValParameterMakeLocalCopyQuickFixTests.cs | 16 +- .../ChangeDimToPrivateQuickFixTests.cs | 53 +- .../ChangeIntegerToLongQuickFixTests.cs | 672 +++++------------ .../ChangeProcedureToFunctionQuickFixTests.cs | 104 +-- .../ConvertToProcedureQuickFixTests.cs | 136 +--- .../DeclareAsExplicitVariantQuickFixTests.cs | 67 +- .../QuickFixes/IgnoreOnceQuickFixTests.cs | 694 +++++------------- .../IntroduceLocalVariableQuickFixTests.cs | 41 +- ...ingOnInappropriateArgumentQuickFixTests.cs | 28 +- .../MakeSingleLineParamegerQuickFixTests.cs | 27 +- .../MoveFieldCloserToUsageQuickFixTests.cs | 53 +- .../QuickFixes/OptionExplicitQuickFixTests.cs | 27 +- .../PassParameterByReferenceQuickFixTests.cs | 101 +-- .../PassParameterByValueQuickFixTests.cs | 129 ++-- .../QuickFixes/QuickFixBaseTests.cs | 4 +- .../QuickFixes/QuickFixProviderTests.cs | 5 +- .../QuickFixes/QuickFixTestBase.cs | 176 +++++ .../QuickFixes/RemoveCommentQuickFixTests.cs | 65 +- ...RemoveDuplicatedAnnotationQuickFixTests.cs | 111 +-- .../RemoveEmptyElseBlockQuickFixTests.cs | 27 +- .../RemoveEmptyIfBlockQuickFixTests.cs | 420 ++--------- ...emoveExplicitByRefModifierQuickFixTests.cs | 205 ++---- ...emoveExplicitCallStatementQuickFixTests.cs | 29 +- ...RemoveExplicitLetStatementQuickFixTests.cs | 27 +- .../RemoveLocalErrorQuickFixTests.cs | 26 +- .../RemoveOptionBaseStatementQuickFixTests.cs | 83 +-- .../QuickFixes/RemoveStepOneQuickFixTests.cs | 28 +- .../RemoveStopKeywordQuickFixTests.cs | 40 +- .../RemoveTypeHintsQuickFixTests.cs | 197 +---- ...RemoveUnassignedIdentifierQuickFixTests.cs | 57 +- ...oveUnassignedVariableUsageQuickFixTests.cs | 24 +- .../RemoveUnusedDeclarationQuickFixTests.cs | 149 +--- .../RemoveUnusedParameterQuickFixTests.cs | 8 +- ...mptyStringLiteralStatementQuickFixTests.cs | 27 +- .../ReplaceGlobalModifierQuickFixTests.cs | 25 +- ...seWithConditionalStatementQuickFixTests.cs | 64 +- ...placeObsoleteCommentMarkerQuickFixTests.cs | 64 +- ...laceObsoleteErrorStatementQuickFixTests.cs | 64 +- .../RestoreErrorHandlingQuickFixTests.cs | 144 +--- ...tExplicitVariantReturnTypeQuickFixTests.cs | 62 +- ...ecifyExplicitByRefModifierQuickFixTests.cs | 206 ++---- ...cifyExplicitPublicModifierQuickFixTests.cs | 25 +- .../SplitMultipleDeclarationsQuickFixTests.cs | 52 +- .../UntypedFunctionUsageQuickFixTests.cs | 10 +- ...KeywordForObjectAssignmentQuickFixTests.cs | 54 +- .../WriteOnlyPropertyQuickFixTests.cs | 55 +- 50 files changed, 1431 insertions(+), 3503 deletions(-) create mode 100644 RubberduckTests/QuickFixes/QuickFixTestBase.cs diff --git a/Rubberduck.CodeAnalysis/QuickFixes/QuickFixProvider.cs b/Rubberduck.CodeAnalysis/QuickFixes/QuickFixProvider.cs index c27e466d11..f273a4d5a7 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/QuickFixProvider.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/QuickFixProvider.cs @@ -79,9 +79,6 @@ public void Fix(IQuickFix fix, IInspectionResult result) var rewriteSession = RewriteSession(fix.TargetCodeKind); fix.Fix(result, rewriteSession); rewriteSession.Rewrite(); - - _state.RewriteAllModules(); - _state.OnParseRequested(this); } private IRewriteSession RewriteSession(CodeKind targetCodeKind) @@ -116,12 +113,9 @@ public void FixInProcedure(IQuickFix fix, QualifiedMemberName? qualifiedMember, continue; } - fix.Fix(result); + fix.Fix(result, rewriteSession); } rewriteSession.Rewrite(); - - _state.RewriteAllModules(); - _state.OnParseRequested(this); } public void FixInModule(IQuickFix fix, QualifiedSelection selection, Type inspectionType, IEnumerable results) @@ -141,12 +135,9 @@ public void FixInModule(IQuickFix fix, QualifiedSelection selection, Type inspec continue; } - fix.Fix(result); + fix.Fix(result, rewriteSession); } rewriteSession.Rewrite(); - - _state.RewriteAllModules(); - _state.OnParseRequested(this); } public void FixInProject(IQuickFix fix, QualifiedSelection selection, Type inspectionType, IEnumerable results) @@ -166,12 +157,9 @@ public void FixInProject(IQuickFix fix, QualifiedSelection selection, Type inspe continue; } - fix.Fix(result); + fix.Fix(result, rewriteSession); } rewriteSession.Rewrite(); - - _state.RewriteAllModules(); - _state.OnParseRequested(this); } public void FixAll(IQuickFix fix, Type inspectionType, IEnumerable results) @@ -191,12 +179,9 @@ public void FixAll(IQuickFix fix, Type inspectionType, IEnumerable new SheetAccessedUsingStringInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -52,14 +45,8 @@ Public Sub Foo() Sheet1.Range(""A1"") = ""foo"" End Sub"; - using (var state = ArrangeParserAndParse(inputCode, out var component)) - { - var inspection = new SheetAccessedUsingStringInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new AccessSheetUsingCodeNameQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new SheetAccessedUsingStringInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -76,14 +63,8 @@ Public Sub Foo() Sheet1.Range(""A1"") = ""foo"" End Sub"; - using (var state = ArrangeParserAndParse(inputCode, out var component)) - { - var inspection = new SheetAccessedUsingStringInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new AccessSheetUsingCodeNameQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new SheetAccessedUsingStringInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -111,15 +92,9 @@ End Sub Public Sub Bar(ws As Worksheet) End Sub"; - - using (var state = ArrangeParserAndParse(inputCode, out var component)) - { - var inspection = new SheetAccessedUsingStringInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new AccessSheetUsingCodeNameQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new SheetAccessedUsingStringInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -138,14 +113,8 @@ Public Sub Foo() End Sub"; - using (var state = ArrangeParserAndParse(inputCode, out var component)) - { - var inspection = new SheetAccessedUsingStringInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new AccessSheetUsingCodeNameQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new SheetAccessedUsingStringInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -166,14 +135,8 @@ Dim s As String Sheet1.Cells(1, 1) = ""foo"" End Sub"; - using (var state = ArrangeParserAndParse(inputCode, out var component)) - { - var inspection = new SheetAccessedUsingStringInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new AccessSheetUsingCodeNameQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new SheetAccessedUsingStringInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -194,14 +157,8 @@ Dim s As String Sheet1.Cells(1, 1) = ""foo"" End Sub"; - using (var state = ArrangeParserAndParse(inputCode, out var component)) - { - var inspection = new SheetAccessedUsingStringInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new AccessSheetUsingCodeNameQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new SheetAccessedUsingStringInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -230,14 +187,8 @@ Public Sub ws() Dim ws As Worksheet End Sub"; - using (var state = ArrangeParserAndParse(inputCode, out var component)) - { - var inspection = new SheetAccessedUsingStringInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new AccessSheetUsingCodeNameQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new SheetAccessedUsingStringInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -266,21 +217,21 @@ Public Sub ws() Dim ws As Worksheet End Sub"; - using (var state = ArrangeParserAndParse(inputCode, out var component)) - { - var inspection = new SheetAccessedUsingStringInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new SheetAccessedUsingStringInspection(state)); + Assert.AreEqual(expectedCode, actualCode); + } + - new AccessSheetUsingCodeNameQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + protected override IQuickFix QuickFix(RubberduckParserState state) + { + return new AccessSheetUsingCodeNameQuickFix(state); } - private static RubberduckParserState ArrangeParserAndParse(string inputCode, out IVBComponent component) + protected override IVBE TestVbe(string code, out IVBComponent component) { var builder = new MockVbeBuilder(); var project = builder.ProjectBuilder("VBAProject", ProjectProtection.Unprotected) - .AddComponent("Module1", ComponentType.StandardModule, inputCode) + .AddComponent("Module1", ComponentType.StandardModule, code) .AddComponent("Sheet1", ComponentType.Document, "", properties: new[] { @@ -298,9 +249,7 @@ private static RubberduckParserState ArrangeParserAndParse(string inputCode, out component = project.Object.VBComponents[0]; - var vbe = builder.AddProject(project).Build(); - - return MockParser.CreateAndParse(vbe.Object); + return builder.AddProject(project).Build().Object; } private static Mock CreateVBComponentPropertyMock(string propertyName, string propertyValue) diff --git a/RubberduckTests/QuickFixes/AddStepOneQuickFixTests.cs b/RubberduckTests/QuickFixes/AddStepOneQuickFixTests.cs index a462ac1ef4..2fcb80b433 100644 --- a/RubberduckTests/QuickFixes/AddStepOneQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/AddStepOneQuickFixTests.cs @@ -1,15 +1,13 @@ using NUnit.Framework; using Rubberduck.Inspections.Concrete; using Rubberduck.Inspections.QuickFixes; -using Rubberduck.Parsing.Inspections; -using RubberduckTests.Inspections; -using RubberduckTests.Mocks; -using System.Threading; +using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.VBA; namespace RubberduckTests.QuickFixes { [TestFixture] - public class AddStepOneQuickFixTests + public class AddStepOneQuickFixTests : QuickFixTestBase { [Test] [Category("QuickFixes")] @@ -27,7 +25,8 @@ public void AddStepOne_QuickFixWorks_Remove() Next End Sub"; - this.TestAddStepOneQuickFix(expectedCode, inputCode); + var actualCode = ApplyQuickFixToAllInspectionResults(inputCode, state => new StepIsNotSpecifiedInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -50,7 +49,8 @@ public void AddStepOne_QuickFixWorks_NestedLoops() Next End Sub"; - this.TestAddStepOneQuickFix(expectedCode, inputCode); + var actualCode = ApplyQuickFixToAllInspectionResults(inputCode, state => new StepIsNotSpecifiedInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -69,24 +69,14 @@ public void AddStepOne_QuickFixWorks_ComplexExpression() Next End Sub"; - this.TestAddStepOneQuickFix(expectedCode, inputCode); + var actualCode = ApplyQuickFixToAllInspectionResults(inputCode, state => new StepIsNotSpecifiedInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } - private void TestAddStepOneQuickFix(string expectedCode, string inputCode) - { - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - var state = MockParser.CreateAndParse(vbe.Object); - - var inspection = new StepIsNotSpecifiedInspection(state) { Severity = CodeInspectionSeverity.Warning }; - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - foreach (var inspectionResult in inspectionResults) - { - new AddStepOneQuickFix(state).Fix(inspectionResult); - } - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); + protected override IQuickFix QuickFix(RubberduckParserState state) + { + return new AddStepOneQuickFix(); } } } diff --git a/RubberduckTests/QuickFixes/ApplicationWorksheetFunctionQuickFixTests.cs b/RubberduckTests/QuickFixes/ApplicationWorksheetFunctionQuickFixTests.cs index 624cec7595..d005c6a09c 100644 --- a/RubberduckTests/QuickFixes/ApplicationWorksheetFunctionQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/ApplicationWorksheetFunctionQuickFixTests.cs @@ -1,16 +1,16 @@ -using System.Linq; -using System.Threading; -using NUnit.Framework; +using NUnit.Framework; using Rubberduck.Inspections.Concrete; using Rubberduck.Inspections.QuickFixes; +using Rubberduck.Parsing.Inspections.Abstract; using Rubberduck.Parsing.VBA; using Rubberduck.VBEditor.SafeComWrappers; +using Rubberduck.VBEditor.SafeComWrappers.Abstract; using RubberduckTests.Mocks; namespace RubberduckTests.QuickFixes { [TestFixture] - public class ApplicationWorksheetFunctionQuickFixTests + public class ApplicationWorksheetFunctionQuickFixTests : QuickFixTestBase { [Test] [Category("QuickFixes")] @@ -30,29 +30,8 @@ Dim foo As Double End Sub "; - var builder = new MockVbeBuilder(); - var project = builder.ProjectBuilder("VBAProject", ProjectProtection.Unprotected) - .AddComponent("Module1", ComponentType.StandardModule, inputCode) - .AddReference("Excel", MockVbeBuilder.LibraryPathMsExcel, 1, 8, true) - .Build(); - - var vbe = builder.AddProject(project).Build(); - - var parser = MockParser.Create(vbe.Object); - using (var state = parser.State) - { - parser.Parse(new CancellationTokenSource()); - if (state.Status >= ParserState.Error) - { - Assert.Inconclusive("Parser Error"); - } - - var inspection = new ApplicationWorksheetFunctionInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new ApplicationWorksheetFunctionQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(project.Object.VBComponents.First()).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new ApplicationWorksheetFunctionInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -77,29 +56,8 @@ End With End Sub "; - var builder = new MockVbeBuilder(); - var project = builder.ProjectBuilder("VBAProject", ProjectProtection.Unprotected) - .AddComponent("Module1", ComponentType.StandardModule, inputCode) - .AddReference("Excel", MockVbeBuilder.LibraryPathMsExcel, 1, 8, true) - .Build(); - - var vbe = builder.AddProject(project).Build(); - - var parser = MockParser.Create(vbe.Object); - using (var state = parser.State) - { - parser.Parse(new CancellationTokenSource()); - if (state.Status >= ParserState.Error) - { - Assert.Inconclusive("Parser Error"); - } - - var inspection = new ApplicationWorksheetFunctionInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new ApplicationWorksheetFunctionQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(project.Object.VBComponents.First()).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new ApplicationWorksheetFunctionInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -120,22 +78,27 @@ Dim foo As String End Sub "; + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new ApplicationWorksheetFunctionInspection(state)); + Assert.AreEqual(expectedCode, actualCode); + } + + + protected override IQuickFix QuickFix(RubberduckParserState state) + { + return new ApplicationWorksheetFunctionQuickFix(); + } + + protected override IVBE TestVbe(string code, out IVBComponent component) + { var builder = new MockVbeBuilder(); var project = builder.ProjectBuilder("VBAProject", ProjectProtection.Unprotected) - .AddComponent("Module1", ComponentType.StandardModule, inputCode) + .AddComponent("Module1", ComponentType.StandardModule, code) .AddReference("Excel", MockVbeBuilder.LibraryPathMsExcel, 1, 8, true) .Build(); - var vbe = builder.AddProject(project).Build(); - - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - var inspection = new ApplicationWorksheetFunctionInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new ApplicationWorksheetFunctionQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(project.Object.VBComponents.First()).GetText()); - } + var vbe = builder.AddProject(project).Build().Object; + component = project.Object.VBComponents[0]; + return vbe; } } } diff --git a/RubberduckTests/QuickFixes/AssignedByValParameterMakeLocalCopyQuickFixTests.cs b/RubberduckTests/QuickFixes/AssignedByValParameterMakeLocalCopyQuickFixTests.cs index e63d18be20..60bec95e82 100644 --- a/RubberduckTests/QuickFixes/AssignedByValParameterMakeLocalCopyQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/AssignedByValParameterMakeLocalCopyQuickFixTests.cs @@ -355,11 +355,12 @@ End Sub" private string ApplyLocalVariableQuickFixToCodeFragment(string inputCode, string userEnteredName = "") { - var vbe = BuildMockVBE(inputCode); + var vbe = BuildMockVBE(inputCode, out var component); var mockDialogFactory = BuildMockDialogFactory(userEnteredName); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var inspection = new AssignedByValParameterInspection(state); var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); @@ -369,14 +370,17 @@ private string ApplyLocalVariableQuickFixToCodeFragment(string inputCode, string Assert.Inconclusive("Inspection yielded no results."); } - new AssignedByValParameterMakeLocalCopyQuickFix(state, mockDialogFactory.Object).Fix(result); - return state.GetRewriter(vbe.Object.ActiveVBProject.VBComponents[0]).GetText(); + var rewriteSession = rewritingManager.CheckOutCodePaneSession(); + + new AssignedByValParameterMakeLocalCopyQuickFix(state, mockDialogFactory.Object).Fix(result, rewriteSession); + + return rewriteSession.CheckOutModuleRewriter(component.QualifiedModuleName).GetText(); } } - private Mock BuildMockVBE(string inputCode) + private Mock BuildMockVBE(string inputCode, out IVBComponent component) { - return MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _); + return MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); } private Mock BuildMockDialogFactory(string userEnteredName) diff --git a/RubberduckTests/QuickFixes/ChangeDimToPrivateQuickFixTests.cs b/RubberduckTests/QuickFixes/ChangeDimToPrivateQuickFixTests.cs index 763633b02b..96b4676842 100644 --- a/RubberduckTests/QuickFixes/ChangeDimToPrivateQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/ChangeDimToPrivateQuickFixTests.cs @@ -1,15 +1,13 @@ -using System.Linq; -using System.Threading; -using NUnit.Framework; +using NUnit.Framework; using Rubberduck.Inspections.Concrete; using Rubberduck.Inspections.QuickFixes; -using RubberduckTests.Mocks; -using RubberduckTests.Inspections; +using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.VBA; namespace RubberduckTests.QuickFixes { [TestFixture] - public class ChangeDimToPrivateQuickFixTests + public class ChangeDimToPrivateQuickFixTests : QuickFixTestBase { [Test] [Category("QuickFixes")] @@ -21,17 +19,8 @@ public void ModuleScopeDimKeyword_QuickFixWorks() const string expectedCode = @"Private foo As String"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ModuleScopeDimKeywordInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new ChangeDimToPrivateQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new ModuleScopeDimKeywordInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -46,17 +35,8 @@ public void ModuleScopeDimKeyword_QuickFixWorks_SplitDeclaration() @"Private _ foo As String"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ModuleScopeDimKeywordInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new ChangeDimToPrivateQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new ModuleScopeDimKeywordInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -71,18 +51,13 @@ public void ModuleScopeDimKeyword_QuickFixWorks_MultipleDeclarations() @"Private foo As String, _ bar As Integer"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ModuleScopeDimKeywordInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new ChangeDimToPrivateQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new ModuleScopeDimKeywordInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } + protected override IQuickFix QuickFix(RubberduckParserState state) + { + return new ChangeDimToPrivateQuickFix(); + } } } diff --git a/RubberduckTests/QuickFixes/ChangeIntegerToLongQuickFixTests.cs b/RubberduckTests/QuickFixes/ChangeIntegerToLongQuickFixTests.cs index 6425c95e39..d3f181af86 100644 --- a/RubberduckTests/QuickFixes/ChangeIntegerToLongQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/ChangeIntegerToLongQuickFixTests.cs @@ -1,16 +1,15 @@ -using System.Linq; -using System.Threading; +using System; using NUnit.Framework; using Rubberduck.Inspections.Concrete; using Rubberduck.Inspections.QuickFixes; using Rubberduck.Parsing.Grammar; -using Rubberduck.VBEditor.SafeComWrappers; -using RubberduckTests.Mocks; +using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.VBA; namespace RubberduckTests.QuickFixes { [TestFixture] - public class ChangeIntegerToLongQuickFixTests + public class ChangeIntegerToLongQuickFixTests : QuickFixTestBase { [Test] [Category("QuickFixes")] @@ -24,17 +23,8 @@ public void IntegerDataType_QuickFixWorks_Function() @"Function Foo() As Long End Function"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new IntegerDataTypeInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new ChangeIntegerToLongQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new IntegerDataTypeInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -49,17 +39,8 @@ public void IntegerDataType_QuickFixWorks_FunctionWithTypeHint() @"Function Foo&() End Function"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new IntegerDataTypeInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new ChangeIntegerToLongQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new IntegerDataTypeInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -74,17 +55,8 @@ public void IntegerDataType_QuickFixWorks_PropertyGet() @"Property Get Foo() As Long End Property"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new IntegerDataTypeInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new ChangeIntegerToLongQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new IntegerDataTypeInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -99,17 +71,8 @@ public void IntegerDataType_QuickFixWorks_PropertyGetWithTypeHint() @"Property Get Foo&() End Property"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new IntegerDataTypeInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new ChangeIntegerToLongQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new IntegerDataTypeInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -124,17 +87,8 @@ public void IntegerDataType_QuickFixWorks_Parameter() @"Sub Foo(arg As Long) End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new IntegerDataTypeInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new ChangeIntegerToLongQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new IntegerDataTypeInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -149,17 +103,8 @@ public void IntegerDataType_QuickFixWorks_ParameterWithTypeHint() @"Sub Foo(arg&) End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new IntegerDataTypeInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new ChangeIntegerToLongQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new IntegerDataTypeInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -176,17 +121,8 @@ Dim v As Integer Dim v As Long End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new IntegerDataTypeInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new ChangeIntegerToLongQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new IntegerDataTypeInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -202,18 +138,8 @@ Dim v% @"Sub Foo() Dim v& End Sub"; - - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new IntegerDataTypeInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new ChangeIntegerToLongQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new IntegerDataTypeInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -230,17 +156,8 @@ public void IntegerDataType_QuickFixWorks_Constant() Const c As Long = 0 End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new IntegerDataTypeInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new ChangeIntegerToLongQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new IntegerDataTypeInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -257,17 +174,8 @@ public void IntegerDataType_QuickFixWorks_ConstantWithTypeHint() Const c& = 0 End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new IntegerDataTypeInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new ChangeIntegerToLongQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new IntegerDataTypeInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -284,17 +192,8 @@ i as Integer i as Long End Type"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new IntegerDataTypeInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new ChangeIntegerToLongQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new IntegerDataTypeInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -311,697 +210,454 @@ public void IntegerDataType_QuickFixWorks_UserDefinedTypeUntypedNameMember() i() as Long End Type"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new IntegerDataTypeInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new ChangeIntegerToLongQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new IntegerDataTypeInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] [Category("QuickFixes")] public void IntegerDataType_QuickFixWorks_FunctionInterfaceImplementation() { - const string inputCode1 = + const string interfaceInputCode = @"Function Foo() As Integer End Function"; - const string inputCode2 = + const string implementationInputCode = @"Implements IClass1 Function IClass1_Foo() As Integer End Function"; - const string expectedCode1 = + const string expectedInterfaceCode = @"Function Foo() As Long End Function"; - const string expectedCode2 = + const string expectedImplementationCode = @"Implements IClass1 Function IClass1_Foo() As Long End Function"; - var builder = new MockVbeBuilder(); - var vbe = builder.ProjectBuilder("TestProject1", ProjectProtection.Unprotected) - .AddComponent("IClass1", ComponentType.ClassModule, inputCode1) - .AddComponent("Class1", ComponentType.ClassModule, inputCode2) - .AddProjectToVbeBuilder() - .Build(); - - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new IntegerDataTypeInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new ChangeIntegerToLongQuickFix(state).Fix(inspectionResults.First()); - - var project = vbe.Object.VBProjects[0]; - var interfaceComponent = project.VBComponents[0]; - var implementationComponent = project.VBComponents[1]; - - Assert.AreEqual(expectedCode1, state.GetRewriter(interfaceComponent).GetText(), "Wrong code in interface"); - Assert.AreEqual(expectedCode2, state.GetRewriter(implementationComponent).GetText(), "Wrong code in implementation"); - } + var (actualInterfaceCode, actualImplementationCode) = + ApplyQuickFixToFirstInspectionResultForImplementedInterface(interfaceInputCode, implementationInputCode, + state => new IntegerDataTypeInspection(state)); + Assert.AreEqual(expectedInterfaceCode, actualInterfaceCode, "Wrong code in interface"); + Assert.AreEqual(expectedImplementationCode, actualImplementationCode, "Wrong code in implementation"); } [Test] [Category("QuickFixes")] public void IntegerDataType_QuickFixWorks_FunctionInterfaceImplementationWithTypeHints() { - const string inputCode1 = + const string interfaceInputCode = @"Function Foo%() End Function"; - const string inputCode2 = + const string implementationInputCode = @"Implements IClass1 Function IClass1_Foo%() End Function"; - const string expectedCode1 = + const string expectedInterfaceCode = @"Function Foo&() End Function"; - const string expectedCode2 = + const string expectedImplementationCode = @"Implements IClass1 Function IClass1_Foo&() End Function"; - var builder = new MockVbeBuilder(); - var vbe = builder.ProjectBuilder("TestProject1", ProjectProtection.Unprotected) - .AddComponent("IClass1", ComponentType.ClassModule, inputCode1) - .AddComponent("Class1", ComponentType.ClassModule, inputCode2) - .AddProjectToVbeBuilder() - .Build(); - - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new IntegerDataTypeInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new ChangeIntegerToLongQuickFix(state).Fix(inspectionResults.First()); - - var project = vbe.Object.VBProjects[0]; - var interfaceComponent = project.VBComponents[0]; - var implementationComponent = project.VBComponents[1]; - - Assert.AreEqual(expectedCode1, state.GetRewriter(interfaceComponent).GetText(), "Wrong code in interface"); - Assert.AreEqual(expectedCode2, state.GetRewriter(implementationComponent).GetText(), "Wrong code in implementation"); - } + var (actualInterfaceCode, actualImplementationCode) = + ApplyQuickFixToFirstInspectionResultForImplementedInterface(interfaceInputCode, implementationInputCode, + state => new IntegerDataTypeInspection(state)); + Assert.AreEqual(expectedInterfaceCode, actualInterfaceCode, "Wrong code in interface"); + Assert.AreEqual(expectedImplementationCode, actualImplementationCode, "Wrong code in implementation"); } [Test] [Category("QuickFixes")] public void IntegerDataType_QuickFixWorks_FunctionInterfaceImplementationWithInterfaceTypeHint() { - const string inputCode1 = + const string interfaceInputCode = @"Function Foo%() End Function"; - const string inputCode2 = + const string implementationInputCode = @"Implements IClass1 Function IClass1_Foo() As Integer End Function"; - const string expectedCode1 = + const string expectedInterfaceCode = @"Function Foo&() End Function"; - const string expectedCode2 = + const string expectedImplementationCode = @"Implements IClass1 Function IClass1_Foo() As Long End Function"; - var builder = new MockVbeBuilder(); - var vbe = builder.ProjectBuilder("TestProject1", ProjectProtection.Unprotected) - .AddComponent("IClass1", ComponentType.ClassModule, inputCode1) - .AddComponent("Class1", ComponentType.ClassModule, inputCode2) - .AddProjectToVbeBuilder() - .Build(); - - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new IntegerDataTypeInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new ChangeIntegerToLongQuickFix(state).Fix(inspectionResults.First()); - - var project = vbe.Object.VBProjects[0]; - var interfaceComponent = project.VBComponents[0]; - var implementationComponent = project.VBComponents[1]; - - Assert.AreEqual(expectedCode1, state.GetRewriter(interfaceComponent).GetText(), "Wrong code in interface"); - Assert.AreEqual(expectedCode2, state.GetRewriter(implementationComponent).GetText(), "Wrong code in implementation"); - } + var (actualInterfaceCode, actualImplementationCode) = + ApplyQuickFixToFirstInspectionResultForImplementedInterface(interfaceInputCode, implementationInputCode, + state => new IntegerDataTypeInspection(state)); + Assert.AreEqual(expectedInterfaceCode, actualInterfaceCode, "Wrong code in interface"); + Assert.AreEqual(expectedImplementationCode, actualImplementationCode, "Wrong code in implementation"); } [Test] [Category("QuickFixes")] public void IntegerDataType_QuickFixWorks_FunctionInterfaceImplementationWithImplementationTypeHint() { - const string inputCode1 = + const string interfaceInputCode = @"Function Foo() As Integer End Function"; - const string inputCode2 = + const string implementationInputCode = @"Implements IClass1 Function IClass1_Foo%() End Function"; - const string expectedCode1 = + const string expectedInterfaceCode = @"Function Foo() As Long End Function"; - const string expectedCode2 = + const string expectedImplementationCode = @"Implements IClass1 Function IClass1_Foo&() End Function"; - var builder = new MockVbeBuilder(); - var vbe = builder.ProjectBuilder("TestProject1", ProjectProtection.Unprotected) - .AddComponent("IClass1", ComponentType.ClassModule, inputCode1) - .AddComponent("Class1", ComponentType.ClassModule, inputCode2) - .AddProjectToVbeBuilder() - .Build(); - - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new IntegerDataTypeInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new ChangeIntegerToLongQuickFix(state).Fix(inspectionResults.First()); - - var project = vbe.Object.VBProjects[0]; - var interfaceComponent = project.VBComponents[0]; - var implementationComponent = project.VBComponents[1]; - - Assert.AreEqual(expectedCode1, state.GetRewriter(interfaceComponent).GetText(), "Wrong code in interface"); - Assert.AreEqual(expectedCode2, state.GetRewriter(implementationComponent).GetText(), "Wrong code in implementation"); - } + var (actualInterfaceCode, actualImplementationCode) = + ApplyQuickFixToFirstInspectionResultForImplementedInterface(interfaceInputCode, implementationInputCode, + state => new IntegerDataTypeInspection(state)); + Assert.AreEqual(expectedInterfaceCode, actualInterfaceCode, "Wrong code in interface"); + Assert.AreEqual(expectedImplementationCode, actualImplementationCode, "Wrong code in implementation"); } [Test] [Category("QuickFixes")] public void IntegerDataType_QuickFixWorks_PropertyGetInterfaceImplementation() { - const string inputCode1 = + const string interfaceInputCode = @"Property Get Foo() As Integer End Property"; - const string inputCode2 = + const string implementationInputCode = @"Implements IClass1 Property Get IClass1_Foo() As Integer End Property"; - const string expectedCode1 = + const string expectedInterfaceCode = @"Property Get Foo() As Long End Property"; - const string expectedCode2 = + const string expectedImplementationCode = @"Implements IClass1 Property Get IClass1_Foo() As Long End Property"; - var builder = new MockVbeBuilder(); - var vbe = builder.ProjectBuilder("TestProject1", ProjectProtection.Unprotected) - .AddComponent("IClass1", ComponentType.ClassModule, inputCode1) - .AddComponent("Class1", ComponentType.ClassModule, inputCode2) - .AddProjectToVbeBuilder() - .Build(); - - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new IntegerDataTypeInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new ChangeIntegerToLongQuickFix(state).Fix(inspectionResults.First()); - - var project = vbe.Object.VBProjects[0]; - var interfaceComponent = project.VBComponents[0]; - var implementationComponent = project.VBComponents[1]; - - Assert.AreEqual(expectedCode1, state.GetRewriter(interfaceComponent).GetText(), "Wrong code in interface"); - Assert.AreEqual(expectedCode2, state.GetRewriter(implementationComponent).GetText(), "Wrong code in implementation"); - } + var (actualInterfaceCode, actualImplementationCode) = + ApplyQuickFixToFirstInspectionResultForImplementedInterface(interfaceInputCode, implementationInputCode, + state => new IntegerDataTypeInspection(state)); + Assert.AreEqual(expectedInterfaceCode, actualInterfaceCode, "Wrong code in interface"); + Assert.AreEqual(expectedImplementationCode, actualImplementationCode, "Wrong code in implementation"); } [Test] [Category("QuickFixes")] public void IntegerDataType_QuickFixWorks_PropertyGetInterfaceImplementationWithTypeHints() { - const string inputCode1 = + const string interfaceInputCode = @"Property Get Foo%() End Property"; - const string inputCode2 = + const string implementationInputCode = @"Implements IClass1 Property Get IClass1_Foo%() End Property"; - const string expectedCode1 = + const string expectedInterfaceCode = @"Property Get Foo&() End Property"; - const string expectedCode2 = + const string expectedImplementationCode = @"Implements IClass1 Property Get IClass1_Foo&() End Property"; - var builder = new MockVbeBuilder(); - var vbe = builder.ProjectBuilder("TestProject1", ProjectProtection.Unprotected) - .AddComponent("IClass1", ComponentType.ClassModule, inputCode1) - .AddComponent("Class1", ComponentType.ClassModule, inputCode2) - .AddProjectToVbeBuilder() - .Build(); - - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new IntegerDataTypeInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new ChangeIntegerToLongQuickFix(state).Fix(inspectionResults.First()); - - var project = vbe.Object.VBProjects[0]; - var interfaceComponent = project.VBComponents[0]; - var implementationComponent = project.VBComponents[1]; - - Assert.AreEqual(expectedCode1, state.GetRewriter(interfaceComponent).GetText(), "Wrong code in interface"); - Assert.AreEqual(expectedCode2, state.GetRewriter(implementationComponent).GetText(), "Wrong code in implementation"); - } + var (actualInterfaceCode, actualImplementationCode) = + ApplyQuickFixToFirstInspectionResultForImplementedInterface(interfaceInputCode, implementationInputCode, + state => new IntegerDataTypeInspection(state)); + Assert.AreEqual(expectedInterfaceCode, actualInterfaceCode, "Wrong code in interface"); + Assert.AreEqual(expectedImplementationCode, actualImplementationCode, "Wrong code in implementation"); } [Test] [Category("QuickFixes")] public void IntegerDataType_QuickFixWorks_PropertyGetInterfaceImplementationWithInterfaceTypeHint() { - const string inputCode1 = + const string interfaceInputCode = @"Property Get Foo%() End Property"; - const string inputCode2 = + const string implementationInputCode = @"Implements IClass1 Property Get IClass1_Foo() As Integer End Property"; - const string expectedCode1 = + const string expectedInterfaceCode = @"Property Get Foo&() End Property"; - const string expectedCode2 = + const string expectedImplementationCode = @"Implements IClass1 Property Get IClass1_Foo() As Long End Property"; - var builder = new MockVbeBuilder(); - var vbe = builder.ProjectBuilder("TestProject1", ProjectProtection.Unprotected) - .AddComponent("IClass1", ComponentType.ClassModule, inputCode1) - .AddComponent("Class1", ComponentType.ClassModule, inputCode2) - .AddProjectToVbeBuilder() - .Build(); - - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new IntegerDataTypeInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new ChangeIntegerToLongQuickFix(state).Fix(inspectionResults.First()); - - var project = vbe.Object.VBProjects[0]; - var interfaceComponent = project.VBComponents[0]; - var implementationComponent = project.VBComponents[1]; - - Assert.AreEqual(expectedCode1, state.GetRewriter(interfaceComponent).GetText(), "Wrong code in interface"); - Assert.AreEqual(expectedCode2, state.GetRewriter(implementationComponent).GetText(), "Wrong code in implementation"); - } + var (actualInterfaceCode, actualImplementationCode) = + ApplyQuickFixToFirstInspectionResultForImplementedInterface(interfaceInputCode, implementationInputCode, + state => new IntegerDataTypeInspection(state)); + Assert.AreEqual(expectedInterfaceCode, actualInterfaceCode, "Wrong code in interface"); + Assert.AreEqual(expectedImplementationCode, actualImplementationCode, "Wrong code in implementation"); } [Test] [Category("QuickFixes")] public void IntegerDataType_QuickFixWorks_PropertyGetInterfaceImplementationWithImplementationTypeHint() { - const string inputCode1 = + const string interfaceInputCode = @"Property Get Foo() As Integer End Property"; - const string inputCode2 = + const string implementationInputCode = @"Implements IClass1 Property Get IClass1_Foo%() End Property"; - const string expectedCode1 = + const string expectedInterfaceCode = @"Property Get Foo() As Long End Property"; - const string expectedCode2 = + const string expectedImplementationCode = @"Implements IClass1 Property Get IClass1_Foo&() End Property"; - var builder = new MockVbeBuilder(); - var vbe = builder.ProjectBuilder("TestProject1", ProjectProtection.Unprotected) - .AddComponent("IClass1", ComponentType.ClassModule, inputCode1) - .AddComponent("Class1", ComponentType.ClassModule, inputCode2) - .AddProjectToVbeBuilder() - .Build(); - - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new IntegerDataTypeInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new ChangeIntegerToLongQuickFix(state).Fix(inspectionResults.First()); - - var project = vbe.Object.VBProjects[0]; - var interfaceComponent = project.VBComponents[0]; - var implementationComponent = project.VBComponents[1]; - - Assert.AreEqual(expectedCode1, state.GetRewriter(interfaceComponent).GetText(), "Wrong code in interface"); - Assert.AreEqual(expectedCode2, state.GetRewriter(implementationComponent).GetText(), "Wrong code in implementation"); - } + var (actualInterfaceCode, actualImplementationCode) = + ApplyQuickFixToFirstInspectionResultForImplementedInterface(interfaceInputCode, implementationInputCode, + state => new IntegerDataTypeInspection(state)); + Assert.AreEqual(expectedInterfaceCode, actualInterfaceCode, "Wrong code in interface"); + Assert.AreEqual(expectedImplementationCode, actualImplementationCode, "Wrong code in implementation"); } [Test] [Category("QuickFixes")] public void IntegerDataType_QuickFixWorks_ParameterInterfaceImplementationWithTypeHints() { - const string inputCode1 = + const string interfaceInputCode = @"Sub Foo(arg1%) End Sub"; - const string inputCode2 = + const string implementationInputCode = @"Implements IClass1 Sub IClass1_Foo(arg1%) End Sub"; - const string expectedCode1 = + const string expectedInterfaceCode = @"Sub Foo(arg1&) End Sub"; - const string expectedCode2 = + const string expectedImplementationCode = @"Implements IClass1 Sub IClass1_Foo(arg1&) End Sub"; - var builder = new MockVbeBuilder(); - var vbe = builder.ProjectBuilder("TestProject1", ProjectProtection.Unprotected) - .AddComponent("IClass1", ComponentType.ClassModule, inputCode1) - .AddComponent("Class1", ComponentType.ClassModule, inputCode2) - .AddProjectToVbeBuilder() - .Build(); - - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new IntegerDataTypeInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new ChangeIntegerToLongQuickFix(state).Fix(inspectionResults.First()); - - var project = vbe.Object.VBProjects[0]; - var interfaceComponent = project.VBComponents[0]; - var implementationComponent = project.VBComponents[1]; - - Assert.AreEqual(expectedCode1, state.GetRewriter(interfaceComponent).GetText(), "Wrong code in interface"); - Assert.AreEqual(expectedCode2, state.GetRewriter(implementationComponent).GetText(), "Wrong code in implementation"); - } + var (actualInterfaceCode, actualImplementationCode) = + ApplyQuickFixToFirstInspectionResultForImplementedInterface(interfaceInputCode, implementationInputCode, + state => new IntegerDataTypeInspection(state)); + Assert.AreEqual(expectedInterfaceCode, actualInterfaceCode, "Wrong code in interface"); + Assert.AreEqual(expectedImplementationCode, actualImplementationCode, "Wrong code in implementation"); } [Test] [Category("QuickFixes")] public void IntegerDataType_QuickFixWorks_ParameterInterfaceImplementationWithInterfaceTypeHint() { - const string inputCode1 = + const string interfaceInputCode = @"Sub Foo(arg1%) End Sub"; - const string inputCode2 = + const string implementationInputCode = @"Implements IClass1 Sub IClass1_Foo(arg1 As Integer) End Sub"; - const string expectedCode1 = + const string expectedInterfaceCode = @"Sub Foo(arg1&) End Sub"; - const string expectedCode2 = + const string expectedImplementationCode = @"Implements IClass1 Sub IClass1_Foo(arg1 As Long) End Sub"; - var builder = new MockVbeBuilder(); - var vbe = builder.ProjectBuilder("TestProject1", ProjectProtection.Unprotected) - .AddComponent("IClass1", ComponentType.ClassModule, inputCode1) - .AddComponent("Class1", ComponentType.ClassModule, inputCode2) - .AddProjectToVbeBuilder() - .Build(); - - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new IntegerDataTypeInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new ChangeIntegerToLongQuickFix(state).Fix(inspectionResults.First()); - - var project = vbe.Object.VBProjects[0]; - var interfaceComponent = project.VBComponents[0]; - var implementationComponent = project.VBComponents[1]; - - Assert.AreEqual(expectedCode1, state.GetRewriter(interfaceComponent).GetText(), "Wrong code in interface"); - Assert.AreEqual(expectedCode2, state.GetRewriter(implementationComponent).GetText(), "Wrong code in implementation"); - } + var (actualInterfaceCode, actualImplementationCode) = + ApplyQuickFixToFirstInspectionResultForImplementedInterface(interfaceInputCode, implementationInputCode, + state => new IntegerDataTypeInspection(state)); + Assert.AreEqual(expectedInterfaceCode, actualInterfaceCode, "Wrong code in interface"); + Assert.AreEqual(expectedImplementationCode, actualImplementationCode, "Wrong code in implementation"); } [Test] [Category("QuickFixes")] public void IntegerDataType_QuickFixWorks_ParameterInterfaceImplementationWithImplementationTypeHint() { - const string inputCode1 = + const string interfaceInputCode = @"Sub Foo(arg1 As Integer) End Sub"; - const string inputCode2 = + const string implementationInputCode = @"Implements IClass1 Sub IClass1_Foo(arg1%) End Sub"; - const string expectedCode1 = + const string expectedInterfaceCode = @"Sub Foo(arg1 As Long) End Sub"; - const string expectedCode2 = + const string expectedImplementationCode = @"Implements IClass1 Sub IClass1_Foo(arg1&) End Sub"; - var builder = new MockVbeBuilder(); - var vbe = builder.ProjectBuilder("TestProject1", ProjectProtection.Unprotected) - .AddComponent("IClass1", ComponentType.ClassModule, inputCode1) - .AddComponent("Class1", ComponentType.ClassModule, inputCode2) - .AddProjectToVbeBuilder() - .Build(); - - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new IntegerDataTypeInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new ChangeIntegerToLongQuickFix(state).Fix(inspectionResults.First()); - - var project = vbe.Object.VBProjects[0]; - var interfaceComponent = project.VBComponents[0]; - var implementationComponent = project.VBComponents[1]; - - Assert.AreEqual(expectedCode1, state.GetRewriter(interfaceComponent).GetText(), "Wrong code in interface"); - Assert.AreEqual(expectedCode2, state.GetRewriter(implementationComponent).GetText(), "Wrong code in implementation"); - } + var (actualInterfaceCode, actualImplementationCode) = + ApplyQuickFixToFirstInspectionResultForImplementedInterface(interfaceInputCode, implementationInputCode, + state => new IntegerDataTypeInspection(state)); + Assert.AreEqual(expectedInterfaceCode, actualInterfaceCode, "Wrong code in interface"); + Assert.AreEqual(expectedImplementationCode, actualImplementationCode, "Wrong code in implementation"); } [Test] [Category("QuickFixes")] public void IntegerDataType_QuickFixWorks_ParameterInterfaceImplementation() { - const string inputCode1 = + const string interfaceInputCode = @"Sub Foo(arg1 As Integer) End Sub"; - const string inputCode2 = + const string implementationInputCode = @"Implements IClass1 Sub IClass1_Foo(arg1 As Integer) End Sub"; - const string expectedCode1 = + const string expectedInterfaceCode = @"Sub Foo(arg1 As Long) End Sub"; - const string expectedCode2 = + const string expectedImplementationCode = @"Implements IClass1 Sub IClass1_Foo(arg1 As Long) End Sub"; - var builder = new MockVbeBuilder(); - var vbe = builder.ProjectBuilder("TestProject1", ProjectProtection.Unprotected) - .AddComponent("IClass1", ComponentType.ClassModule, inputCode1) - .AddComponent("Class1", ComponentType.ClassModule, inputCode2) - .AddProjectToVbeBuilder() - .Build(); - - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new IntegerDataTypeInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new ChangeIntegerToLongQuickFix(state).Fix(inspectionResults.First()); - - var project = vbe.Object.VBProjects[0]; - var interfaceComponent = project.VBComponents[0]; - var implementationComponent = project.VBComponents[1]; - - Assert.AreEqual(expectedCode1, state.GetRewriter(interfaceComponent).GetText(), "Wrong code in interface"); - Assert.AreEqual(expectedCode2, state.GetRewriter(implementationComponent).GetText(), "Wrong code in implementation"); - } + var (actualInterfaceCode, actualImplementationCode) = + ApplyQuickFixToFirstInspectionResultForImplementedInterface(interfaceInputCode, implementationInputCode, + state => new IntegerDataTypeInspection(state)); + Assert.AreEqual(expectedInterfaceCode, actualInterfaceCode, "Wrong code in interface"); + Assert.AreEqual(expectedImplementationCode, actualImplementationCode, "Wrong code in implementation"); } [Test] [Category("QuickFixes")] public void IntegerDataType_QuickFixWorks_ParameterInterfaceImplementationWithDifferentName() { - const string inputCode1 = + const string interfaceInputCode = @"Sub Foo(arg1 As Integer) End Sub"; - const string inputCode2 = + const string implementationInputCode = @"Implements IClass1 Sub IClass1_Foo(arg2 As Integer) End Sub"; - const string expectedCode1 = + const string expectedInterfaceCode = @"Sub Foo(arg1 As Long) End Sub"; - const string expectedCode2 = + const string expectedImplementationCode = @"Implements IClass1 Sub IClass1_Foo(arg2 As Long) End Sub"; - var builder = new MockVbeBuilder(); - var vbe = builder.ProjectBuilder("TestProject1", ProjectProtection.Unprotected) - .AddComponent("IClass1", ComponentType.ClassModule, inputCode1) - .AddComponent("Class1", ComponentType.ClassModule, inputCode2) - .AddProjectToVbeBuilder() - .Build(); - - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new IntegerDataTypeInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new ChangeIntegerToLongQuickFix(state).Fix(inspectionResults.First()); - - var project = vbe.Object.VBProjects[0]; - var interfaceComponent = project.VBComponents[0]; - var implementationComponent = project.VBComponents[1]; - - Assert.AreEqual(expectedCode1, state.GetRewriter(interfaceComponent).GetText(), "Wrong code in interface"); - Assert.AreEqual(expectedCode2, state.GetRewriter(implementationComponent).GetText(), "Wrong code in implementation"); - } + var (actualInterfaceCode, actualImplementationCode) = + ApplyQuickFixToFirstInspectionResultForImplementedInterface(interfaceInputCode, implementationInputCode, + state => new IntegerDataTypeInspection(state)); + Assert.AreEqual(expectedInterfaceCode, actualInterfaceCode, "Wrong code in interface"); + Assert.AreEqual(expectedImplementationCode, actualImplementationCode, "Wrong code in implementation"); } [Test] [Category("QuickFixes")] public void IntegerDataType_QuickFixWorks_MultipleParameterInterfaceImplementation() { - const string inputCode1 = + const string interfaceInputCode = @"Sub Foo(arg1 As Integer, arg2 as Integer) End Sub"; - const string inputCode2 = + const string implementationInputCode = @"Implements IClass1 Sub IClass1_Foo(arg1 As Integer, arg2 as Integer) End Sub"; - const string expectedCode1 = + const string expectedInterfaceCode = @"Sub Foo(arg1 As Long, arg2 as Integer) End Sub"; - const string expectedCode2 = + const string expectedImplementationCode = @"Implements IClass1 Sub IClass1_Foo(arg1 As Long, arg2 as Integer) End Sub"; - var builder = new MockVbeBuilder(); - var vbe = builder.ProjectBuilder("TestProject1", ProjectProtection.Unprotected) - .AddComponent("IClass1", ComponentType.ClassModule, inputCode1) - .AddComponent("Class1", ComponentType.ClassModule, inputCode2) - .AddProjectToVbeBuilder() - .Build(); - - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new IntegerDataTypeInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new ChangeIntegerToLongQuickFix(state).Fix( - inspectionResults.First( - result => - ((VBAParser.ArgContext)result.Context).unrestrictedIdentifier() - .identifier() - .untypedIdentifier() - .identifierValue() - .GetText() == "arg1")); + Func conditionOnResultToFix = result => + ((VBAParser.ArgContext)result.Context).unrestrictedIdentifier() + .identifier() + .untypedIdentifier() + .identifierValue() + .GetText() == "arg1"; + var (actualInterfaceCode, actualImplementationCode) = + ApplyQuickFixToFirstInspectionResultForImplementedInterfaceSatisfyingPredicate(interfaceInputCode, implementationInputCode, + state => new IntegerDataTypeInspection(state), conditionOnResultToFix); + Assert.AreEqual(expectedInterfaceCode, actualInterfaceCode, "Wrong code in interface"); + Assert.AreEqual(expectedImplementationCode, actualImplementationCode, "Wrong code in implementation"); + } - var project = vbe.Object.VBProjects[0]; - var interfaceComponent = project.VBComponents[0]; - var implementationComponent = project.VBComponents[1]; - Assert.AreEqual(expectedCode1, state.GetRewriter(interfaceComponent).GetText(), "Wrong code in interface"); - Assert.AreEqual(expectedCode2, state.GetRewriter(implementationComponent).GetText(), "Wrong code in implementation"); - } + protected override IQuickFix QuickFix(RubberduckParserState state) + { + return new ChangeIntegerToLongQuickFix(state); } - } } diff --git a/RubberduckTests/QuickFixes/ChangeProcedureToFunctionQuickFixTests.cs b/RubberduckTests/QuickFixes/ChangeProcedureToFunctionQuickFixTests.cs index a21fc8f549..7c5419071d 100644 --- a/RubberduckTests/QuickFixes/ChangeProcedureToFunctionQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/ChangeProcedureToFunctionQuickFixTests.cs @@ -1,15 +1,13 @@ -using System.Linq; -using NUnit.Framework; -using RubberduckTests.Mocks; -using System.Threading; +using NUnit.Framework; using Rubberduck.Inspections.Concrete; using Rubberduck.Inspections.QuickFixes; -using RubberduckTests.Inspections; +using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.VBA; namespace RubberduckTests.QuickFixes { [TestFixture] - public class ChangeProcedureToFunctionQuickFixTests + public class ChangeProcedureToFunctionQuickFixTests : QuickFixTestBase { [Test] @@ -27,17 +25,8 @@ public void ProcedureShouldBeFunction_QuickFixWorks() Foo = arg1 End Function"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ProcedureCanBeWrittenAsFunctionInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new ChangeProcedureToFunctionQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new ProcedureCanBeWrittenAsFunctionInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -55,17 +44,8 @@ public void ProcedureShouldBeFunction_QuickFixWorks_NoAsTypeClauseInParam() Foo = arg1 End Function"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ProcedureCanBeWrittenAsFunctionInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new ChangeProcedureToFunctionQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new ProcedureCanBeWrittenAsFunctionInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -91,17 +71,8 @@ End Function Sub Goo(ByVal a As Integer) End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ProcedureCanBeWrittenAsFunctionInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new ChangeProcedureToFunctionQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new ProcedureCanBeWrittenAsFunctionInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -121,17 +92,8 @@ End Function Sub Goo(ByVal a As Integer) End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ProcedureCanBeWrittenAsFunctionInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new ChangeProcedureToFunctionQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new ProcedureCanBeWrittenAsFunctionInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -151,17 +113,8 @@ End Function Sub Goo(ByVal a As String) End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ProcedureCanBeWrittenAsFunctionInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new ChangeProcedureToFunctionQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new ProcedureCanBeWrittenAsFunctionInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -189,17 +142,8 @@ Private Function Foo(ByVal arg1 As Integer) As Integer Foo = arg1 End Function"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ProcedureCanBeWrittenAsFunctionInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new ChangeProcedureToFunctionQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new ProcedureCanBeWrittenAsFunctionInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -227,18 +171,14 @@ Dim fizz As Integer fizz = Foo(fizz) End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new ProcedureCanBeWrittenAsFunctionInspection(state)); + Assert.AreEqual(expectedCode, actualCode); + } - var inspection = new ProcedureCanBeWrittenAsFunctionInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - new ChangeProcedureToFunctionQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + protected override IQuickFix QuickFix(RubberduckParserState state) + { + return new ChangeProcedureToFunctionQuickFix(); } - } } diff --git a/RubberduckTests/QuickFixes/ConvertToProcedureQuickFixTests.cs b/RubberduckTests/QuickFixes/ConvertToProcedureQuickFixTests.cs index 9a3ad20c61..5ff6194f77 100644 --- a/RubberduckTests/QuickFixes/ConvertToProcedureQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/ConvertToProcedureQuickFixTests.cs @@ -3,13 +3,15 @@ using NUnit.Framework; using Rubberduck.Inspections.Concrete; using Rubberduck.Inspections.QuickFixes; +using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.VBA; using Rubberduck.VBEditor.SafeComWrappers; using RubberduckTests.Mocks; namespace RubberduckTests.QuickFixes { [TestFixture] - public class ConvertToProcedureQuickFixTests + public class ConvertToProcedureQuickFixTests : QuickFixTestBase { [Test] [Category("QuickFixes")] @@ -34,16 +36,8 @@ If True Then End If End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new FunctionReturnValueNotUsedInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new ConvertToProcedureQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new FunctionReturnValueNotUsedInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -72,16 +66,8 @@ End Sub Sub goo() End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new FunctionReturnValueNotUsedInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new ConvertToProcedureQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new FunctionReturnValueNotUsedInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -124,16 +110,19 @@ Dim testObj As IFoo .AddComponent("TestModule", ComponentType.StandardModule, callSiteCode) .AddProjectToVbeBuilder().Build(); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var inspection = new FunctionReturnValueNotUsedInspection(state); var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); + var rewriteSession = rewritingManager.CheckOutCodePaneSession(); - new ConvertToProcedureQuickFix(state).Fix(inspectionResults.First()); + new ConvertToProcedureQuickFix().Fix(inspectionResults.First(), rewriteSession); var component = vbe.Object.VBProjects[0].VBComponents[0]; - Assert.AreEqual(expectedInterfaceCode, state.GetRewriter(component).GetText()); + var actualCode = rewriteSession.CheckOutModuleRewriter(component.QualifiedModuleName).GetText(); + Assert.AreEqual(expectedInterfaceCode, actualCode); } } @@ -149,16 +138,8 @@ public void NonReturningFunction_QuickFixWorks_Function() @"Sub Foo() End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new NonReturningFunctionInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new ConvertToProcedureQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new NonReturningFunctionInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -173,16 +154,8 @@ public void GivenFunctionNameWithTypeHint_SubNameHasNoTypeHint() @"Sub Foo() End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new NonReturningFunctionInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new ConvertToProcedureQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new NonReturningFunctionInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -197,16 +170,8 @@ public void NonReturningFunction_QuickFixWorks_FunctionReturnsImplicitVariant() @"Sub Foo() End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new NonReturningFunctionInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new ConvertToProcedureQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new NonReturningFunctionInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -221,16 +186,8 @@ public void NonReturningFunction_QuickFixWorks_FunctionHasVariable() @"Sub Foo(ByVal b As Boolean) End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new NonReturningFunctionInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new ConvertToProcedureQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new NonReturningFunctionInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -245,16 +202,8 @@ public void GivenNonReturningPropertyGetter_QuickFixConvertsToSub() @"Sub Foo() End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new NonReturningFunctionInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new ConvertToProcedureQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new NonReturningFunctionInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -269,16 +218,8 @@ public void GivenNonReturningPropertyGetWithTypeHint_QuickFixDropsTypeHint() @"Sub Foo() End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new NonReturningFunctionInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new ConvertToProcedureQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new NonReturningFunctionInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -293,16 +234,8 @@ public void GivenImplicitVariantPropertyGetter_StillConvertsToSub() @"Sub Foo() End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new NonReturningFunctionInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new ConvertToProcedureQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new NonReturningFunctionInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -317,17 +250,14 @@ public void GivenParameterizedPropertyGetter_QuickFixKeepsParameter() @"Sub Foo(ByVal b As Boolean) End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new NonReturningFunctionInspection(state)); + Assert.AreEqual(expectedCode, actualCode); + } - var inspection = new NonReturningFunctionInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - new ConvertToProcedureQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + protected override IQuickFix QuickFix(RubberduckParserState state) + { + return new ConvertToProcedureQuickFix(); } - } } diff --git a/RubberduckTests/QuickFixes/DeclareAsExplicitVariantQuickFixTests.cs b/RubberduckTests/QuickFixes/DeclareAsExplicitVariantQuickFixTests.cs index 2111bbce0d..90d4a2cd79 100644 --- a/RubberduckTests/QuickFixes/DeclareAsExplicitVariantQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/DeclareAsExplicitVariantQuickFixTests.cs @@ -1,14 +1,13 @@ -using System.Linq; -using System.Threading; -using NUnit.Framework; +using NUnit.Framework; using Rubberduck.Inspections.Concrete; using Rubberduck.Inspections.QuickFixes; -using RubberduckTests.Mocks; +using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.VBA; namespace RubberduckTests.QuickFixes { [TestFixture] - public class DeclareAsExplicitVariantQuickFixTests + public class DeclareAsExplicitVariantQuickFixTests : QuickFixTestBase { [Test] @@ -23,15 +22,8 @@ public void VariableTypeNotDeclared_QuickFixWorks_Parameter() @"Sub Foo(arg1 As Variant) End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new VariableTypeNotDeclaredInspection(state); - new DeclareAsExplicitVariantQuickFix(state).Fix(inspection.GetInspectionResults(CancellationToken.None).First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new VariableTypeNotDeclaredInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -46,15 +38,8 @@ public void VariableTypeNotDeclared_QuickFixWorks_SubNameContainsParameterName() @"Sub Foo(Foo As Variant) End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new VariableTypeNotDeclaredInspection(state); - new DeclareAsExplicitVariantQuickFix(state).Fix(inspection.GetInspectionResults(CancellationToken.None).First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new VariableTypeNotDeclaredInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -71,15 +56,8 @@ Dim var1 Dim var1 As Variant End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new VariableTypeNotDeclaredInspection(state); - new DeclareAsExplicitVariantQuickFix(state).Fix(inspection.GetInspectionResults(CancellationToken.None).First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new VariableTypeNotDeclaredInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -94,15 +72,8 @@ public void VariableTypeNotDeclared_QuickFixWorks_ParameterWithoutDefaultValue() @"Sub Foo(ByVal Fizz As Variant) End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new VariableTypeNotDeclaredInspection(state); - new DeclareAsExplicitVariantQuickFix(state).Fix(inspection.GetInspectionResults(CancellationToken.None).First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new VariableTypeNotDeclaredInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -117,16 +88,14 @@ public void VariableTypeNotDeclared_QuickFixWorks_ParameterWithDefaultValue() @"Sub Foo(ByVal Fizz As Variant = False) End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new VariableTypeNotDeclaredInspection(state)); + Assert.AreEqual(expectedCode, actualCode); + } - var inspection = new VariableTypeNotDeclaredInspection(state); - new DeclareAsExplicitVariantQuickFix(state).Fix(inspection.GetInspectionResults(CancellationToken.None).First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + protected override IQuickFix QuickFix(RubberduckParserState state) + { + return new DeclareAsExplicitVariantQuickFix(); } - } } diff --git a/RubberduckTests/QuickFixes/IgnoreOnceQuickFixTests.cs b/RubberduckTests/QuickFixes/IgnoreOnceQuickFixTests.cs index 47a1c9413f..26969b84bf 100644 --- a/RubberduckTests/QuickFixes/IgnoreOnceQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/IgnoreOnceQuickFixTests.cs @@ -1,4 +1,6 @@ -using System.Linq; +using System; +using System.Collections.Generic; +using System.Linq; using System.Threading; using NUnit.Framework; using Rubberduck.Inspections.Concrete; @@ -7,7 +9,9 @@ using Rubberduck.VBEditor.SafeComWrappers; using RubberduckTests.Mocks; using RubberduckTests.Inspections; -using Rubberduck.Parsing.Inspections; +using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.VBEditor; +using Rubberduck.VBEditor.SafeComWrappers.Abstract; namespace RubberduckTests.QuickFixes { @@ -31,24 +35,8 @@ Dim foo As Double foo = Application.Pi End Sub"; - var builder = new MockVbeBuilder(); - var project = builder.ProjectBuilder("VBAProject", ProjectProtection.Unprotected) - .AddComponent("Module1", ComponentType.StandardModule, inputCode) - .AddReference("Excel", MockVbeBuilder.LibraryPathMsExcel, 1, 8, true) - .Build(); - - var vbe = builder.AddProject(project).Build(); - var component = vbe.Object.SelectedVBComponent; - - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - var inspection = new ApplicationWorksheetFunctionInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyIgnoreOnceToFirstResult(inputCode, state => new ApplicationWorksheetFunctionInspection(state), TestStandardModuleInExcelVbeSetup); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -66,16 +54,8 @@ Public Sub Foo(ByVal arg1 As String) Let arg1 = ""test"" End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - var inspection = new AssignedByValParameterInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyIgnoreOnceToFirstResult(inputCode, state => new AssignedByValParameterInspection(state), TestStandardModuleVbeSetup); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -93,17 +73,8 @@ public void ConstantNotUsed_IgnoreQuickFixWorks() Const const1 As Integer = 9 End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ConstantNotUsedInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyIgnoreOnceToFirstResult(inputCode, state => new ConstantNotUsedInspection(state), TestStandardModuleVbeSetup); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -121,17 +92,8 @@ public void EmptyStringLiteral_IgnoreQuickFixWorks() arg1 = """" End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new EmptyStringLiteralInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyIgnoreOnceToFirstResult(inputCode, state => new EmptyStringLiteralInspection(state), TestStandardModuleVbeSetup); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -145,16 +107,8 @@ public void EncapsulatePublicField_IgnoreQuickFixWorks() @"'@Ignore EncapsulatePublicField Public fizz As Boolean"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new EncapsulatePublicFieldInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyIgnoreOnceToFirstResult(inputCode, state => new EncapsulatePublicFieldInspection(state), TestStandardModuleVbeSetup); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -179,16 +133,8 @@ Public Sub Goo() Foo ""test"" End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new FunctionReturnValueNotUsedInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyIgnoreOnceToFirstResult(inputCode, state => new FunctionReturnValueNotUsedInspection(state), TestStandardModuleVbeSetup); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -211,16 +157,8 @@ Dim foo End Function "; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new VariableTypeNotDeclaredInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyIgnoreOnceToFirstResult(inputCode, state => new VariableTypeNotDeclaredInspection(state), TestStandardModuleVbeSetup); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -240,22 +178,8 @@ Dim arr1() As Variant arr1 = Range(""A1:B2"") End Sub"; - var builder = new MockVbeBuilder(); - var project = builder.ProjectBuilder("TestProject1", "TestProject1", ProjectProtection.Unprotected) - .AddComponent("Class1", ComponentType.ClassModule, inputCode) - .AddReference("Excel", MockVbeBuilder.LibraryPathMsExcel, 1, 8, true) - .Build(); - var component = project.Object.VBComponents[0]; - var vbe = builder.AddProject(project).Build(); - - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - var inspection = new ImplicitActiveSheetReferenceInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyIgnoreOnceToFirstResult(inputCode, state => new ImplicitActiveSheetReferenceInspection(state), TestClassInExcelVbeSetup); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -277,22 +201,8 @@ Dim sheet As Worksheet Set sheet = Worksheets(""Sheet1"") End Sub"; - var builder = new MockVbeBuilder(); - var project = builder.ProjectBuilder("TestProject1", "TestProject1", ProjectProtection.Unprotected) - .AddComponent("Class1", ComponentType.ClassModule, inputCode) - .AddReference("Excel", MockVbeBuilder.LibraryPathMsExcel, 1, 8, true) - .Build(); - var component = project.Object.VBComponents[0]; - var vbe = builder.AddProject(project).Build(); - - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - var inspection = new ImplicitActiveWorkbookReferenceInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyIgnoreOnceToFirstResult(inputCode, state => new ImplicitActiveWorkbookReferenceInspection(state), TestClassInExcelVbeSetup); + Assert.AreEqual(expectedCode, actualCode); } @@ -309,18 +219,8 @@ public void ImplicitByRefModifier_IgnoredQuickFixWorks() Sub Foo(arg1 As Integer) End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ImplicitByRefModifierInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyIgnoreOnceToFirstResult(inputCode, state => new ImplicitByRefModifierInspection(state), TestStandardModuleVbeSetup); + Assert.AreEqual(expectedCode, actualCode); } @@ -342,16 +242,8 @@ Sub Foo(ByVal arg1 as Integer) End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ImplicitPublicMemberInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyIgnoreOnceToFirstResult(inputCode, state => new ImplicitPublicMemberInspection(state), TestStandardModuleVbeSetup); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -367,16 +259,8 @@ public void ImplicitVariantReturnType_IgnoreQuickFixWorks() Function Foo() End Function"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ImplicitVariantReturnTypeInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyIgnoreOnceToFirstResult(inputCode, state => new ImplicitVariantReturnTypeInspection(state), TestStandardModuleVbeSetup); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -395,15 +279,8 @@ public void LabelNotUsed_IgnoreQuickFixWorks() label1: End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new LineLabelNotUsedInspection(state); - new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspection.GetInspectionResults(CancellationToken.None).First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyIgnoreOnceToFirstResult(inputCode, state => new LineLabelNotUsedInspection(state), TestStandardModuleVbeSetup); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -417,17 +294,8 @@ public void ModuleScopeDimKeyword_IgnoreQuickFixWorks() @"'@Ignore ModuleScopeDimKeyword Dim foo"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ModuleScopeDimKeywordInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyIgnoreOnceToFirstResult(inputCode, state => new ModuleScopeDimKeywordInspection(state), TestStandardModuleVbeSetup); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -447,16 +315,8 @@ Public Sub Foo() bar = ""test"" End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new MoveFieldCloserToUsageInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyIgnoreOnceToFirstResult(inputCode, state => new MoveFieldCloserToUsageInspection(state), TestStandardModuleVbeSetup); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -480,17 +340,8 @@ As _ Integer) End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new MultilineParameterInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyIgnoreOnceToFirstResult(inputCode, state => new MultilineParameterInspection(state), TestStandardModuleVbeSetup); + Assert.AreEqual(expectedCode, actualCode); } @@ -509,17 +360,8 @@ public void MultipleDeclarations_IgnoreQuickFixWorks() Dim var1 As Integer, var2 As String End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new MultipleDeclarationsInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyIgnoreOnceToFirstResult(inputCode, state => new MultipleDeclarationsInspection(state), TestStandardModuleVbeSetup); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -535,16 +377,8 @@ public void NonReturningFunction_IgnoreQuickFixWorks() Function Foo() As Boolean End Function"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new NonReturningFunctionInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyIgnoreOnceToFirstResult(inputCode, state => new NonReturningFunctionInspection(state), TestStandardModuleVbeSetup); + Assert.AreEqual(expectedCode, actualCode); } @@ -574,16 +408,8 @@ Dim target As Object End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ObjectVariableNotSetInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyIgnoreOnceToFirstResult(inputCode, state => new ObjectVariableNotSetInspection(state), TestStandardModuleVbeSetup); + Assert.AreEqual(expectedCode, actualCode); } @@ -611,22 +437,8 @@ Sub Goo(arg1 As Integer, arg1 As String) Call Foo End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ObsoleteCallStatementInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - var fix = new IgnoreOnceQuickFix(state, new[] { inspection }); - foreach (var result in inspectionResults) - { - fix.Fix(result); - } - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyIgnoreOnceToAllResults(inputCode, state => new ObsoleteCallStatementInspection(state), TestStandardModuleVbeSetup); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -640,17 +452,8 @@ public void ObsoleteCommentSyntax_IgnoreQuickFixWorks() @"'@Ignore ObsoleteCommentSyntax Rem test1"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ObsoleteCommentSyntaxInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyIgnoreOnceToFirstResult(inputCode, state => new ObsoleteCommentSyntaxInspection(state), TestStandardModuleVbeSetup); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -668,17 +471,8 @@ Error 91 Error 91 End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ObsoleteErrorSyntaxInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyIgnoreOnceToFirstResult(inputCode, state => new ObsoleteErrorSyntaxInspection(state), TestStandardModuleVbeSetup); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -692,16 +486,8 @@ public void ObsoleteGlobal_IgnoreQuickFixWorks() @"'@Ignore ObsoleteGlobal Global var1 As Integer"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ObsoleteGlobalInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyIgnoreOnceToFirstResult(inputCode, state => new ObsoleteGlobalInspection(state), TestStandardModuleVbeSetup); + Assert.AreEqual(expectedCode, actualCode); } @@ -726,17 +512,8 @@ Dim var2 As Integer Let var2 = var1 End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ObsoleteLetStatementInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyIgnoreOnceToFirstResult(inputCode, state => new ObsoleteLetStatementInspection(state), TestStandardModuleVbeSetup); + Assert.AreEqual(expectedCode, actualCode); } @@ -755,21 +532,8 @@ public void ObsoleteTypeHint_IgnoreQuickFixWorks() Foo = ""test"" End Function"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ObsoleteTypeHintInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - var fix = new IgnoreOnceQuickFix(state, new[] { inspection }); - foreach (var result in inspectionResults) - { - fix.Fix(result); - } - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyIgnoreOnceToFirstResult(inputCode, state => new ObsoleteTypeHintInspection(state), TestStandardModuleVbeSetup); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -783,17 +547,8 @@ public void OptionBaseOneSpecified_IgnoreQuickFixWorks() @"'@Ignore OptionBase Option Base 1"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new OptionBaseInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyIgnoreOnceToFirstResult(inputCode, state => new OptionBaseInspection(state), TestStandardModuleVbeSetup); + Assert.AreEqual(expectedCode, actualCode); } @@ -812,15 +567,8 @@ Sub Foo(ByRef _ arg1 As String) End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ParameterCanBeByValInspection(state); - new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspection.GetInspectionResults(CancellationToken.None).First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyIgnoreOnceToFirstResult(inputCode, state => new ParameterCanBeByValInspection(state), TestStandardModuleVbeSetup); + Assert.AreEqual(expectedCode, actualCode); } @@ -837,16 +585,8 @@ public void GivenPrivateSub_IgnoreQuickFixWorks() Private Sub Foo(ByVal arg1 as Integer) End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ParameterNotUsedInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyIgnoreOnceToFirstResult(inputCode, state => new ParameterNotUsedInspection(state), TestStandardModuleVbeSetup); + Assert.AreEqual(expectedCode, actualCode); } @@ -863,16 +603,8 @@ public void ProcedureNotUsed_IgnoreQuickFixWorks() Private Sub Foo(ByVal arg1 as Integer) End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ProcedureNotUsedInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyIgnoreOnceToFirstResult(inputCode, state => new ProcedureNotUsedInspection(state), TestStandardModuleVbeSetup); + Assert.AreEqual(expectedCode, actualCode); } @@ -891,17 +623,8 @@ Private Sub Foo(ByRef arg1 As Integer) arg1 = 42 End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ProcedureCanBeWrittenAsFunctionInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyIgnoreOnceToFirstResult(inputCode, state => new ProcedureCanBeWrittenAsFunctionInspection(state), TestStandardModuleVbeSetup); + Assert.AreEqual(expectedCode, actualCode); } @@ -918,18 +641,8 @@ public void RedundantByRefModifier_IgnoredQuickFixWorks() Sub Foo(ByRef arg1 As Integer) End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new RedundantByRefModifierInspection(state) { Severity = CodeInspectionSeverity.Hint }; - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyIgnoreOnceToFirstResult(inputCode, state => new RedundantByRefModifierInspection(state), TestStandardModuleVbeSetup); + Assert.AreEqual(expectedCode, actualCode); } @@ -948,22 +661,8 @@ Dim b As New Collection Dim b As New Collection End Sub"; - var builder = new MockVbeBuilder(); - var project = builder.ProjectBuilder("VBAProject", ProjectProtection.Unprotected) - .AddComponent("MyClass", ComponentType.ClassModule, inputCode) - .Build(); - var component = project.Object.VBComponents[0]; - var vbe = builder.AddProject(project).Build(); - - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new SelfAssignedDeclarationInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyIgnoreOnceToFirstResult(inputCode, state => new SelfAssignedDeclarationInspection(state), TestClassVbeSetup); + Assert.AreEqual(expectedCode, actualCode); } @@ -986,16 +685,8 @@ Dim bb As Boolean bb = b End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new UnassignedVariableUsageInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyIgnoreOnceToFirstResult(inputCode, state => new UnassignedVariableUsageInspection(state), TestStandardModuleVbeSetup); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -1024,7 +715,7 @@ Dim str As String var vbe = builder.AddProject(project).Build(); var component = project.Object.VBComponents[0]; - var parser = MockParser.Create(vbe.Object); + var (parser, rewritingManager) = MockParser.CreateWithRewriteManager(vbe.Object); using (var state = parser.State) { //FIXME reinstate and unignore tests @@ -1039,9 +730,12 @@ Dim str As String var inspection = new UntypedFunctionUsageInspection(state); var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); + var rewriteSession = rewritingManager.CheckOutCodePaneSession(); - new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); + new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspectionResults.First(), rewriteSession); + var actualCode = rewriteSession.CheckOutModuleRewriter(component.QualifiedModuleName).GetText(); + + Assert.AreEqual(expectedCode, actualCode); } } @@ -1065,13 +759,17 @@ Sub Ffffff() var component = project.Object.VBComponents[0]; var vbe = builder.AddProject(project).Build(); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var inspection = new UseMeaningfulNameInspection(state, UseMeaningfulNameInspectionTests.GetInspectionSettings().Object); var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); + var rewriteSession = rewritingManager.CheckOutCodePaneSession(); + + new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspectionResults.First(), rewriteSession); + var actualCode = rewriteSession.CheckOutModuleRewriter(component.QualifiedModuleName).GetText(); - new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); + Assert.AreEqual(expectedCode, actualCode); } } @@ -1091,15 +789,8 @@ Dim var1 as Integer Dim var1 as Integer End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new VariableNotAssignedInspection(state); - new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspection.GetInspectionResults(CancellationToken.None).First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyIgnoreOnceToFirstResult(inputCode, state => new VariableNotAssignedInspection(state), TestStandardModuleVbeSetup); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -1117,15 +808,8 @@ Dim var1 As String Dim var1 As String End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new VariableNotUsedInspection(state); - new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspection.GetInspectionResults(CancellationToken.None).First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyIgnoreOnceToFirstResult(inputCode, state => new VariableNotUsedInspection(state), TestStandardModuleVbeSetup); + Assert.AreEqual(expectedCode, actualCode); } @@ -1142,15 +826,8 @@ public void VariableTypeNotDeclared_IgnoreQuickFixWorks() Sub Foo(arg1) End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new VariableTypeNotDeclaredInspection(state); - new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspection.GetInspectionResults(CancellationToken.None).First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyIgnoreOnceToFirstResult(inputCode, state => new VariableTypeNotDeclaredInspection(state), TestStandardModuleVbeSetup); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -1166,23 +843,8 @@ public void WriteOnlyProperty_IgnoreQuickFixWorks() Property Let Foo(value) End Property"; - var builder = new MockVbeBuilder(); - var project = builder.ProjectBuilder("VBAProject", ProjectProtection.Unprotected) - .AddComponent("MyClass", ComponentType.ClassModule, inputCode) - .Build(); - var component = project.Object.VBComponents[0]; - var vbe = builder.AddProject(project).Build(); - - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new WriteOnlyPropertyInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyIgnoreOnceToFirstResult(inputCode, state => new WriteOnlyPropertyInspection(state), TestClassVbeSetup); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -1210,23 +872,8 @@ If True Then EndIf End Sub"; - var builder = new MockVbeBuilder(); - var project = builder.ProjectBuilder("VBAProject", ProjectProtection.Unprotected) - .AddComponent("MyClass", ComponentType.ClassModule, inputCode) - .Build(); - var component = project.Object.VBComponents[0]; - var vbe = builder.AddProject(project).Build(); - - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - var inspection = new BooleanAssignedInIfElseInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyIgnoreOnceToFirstResult(inputCode, state => new BooleanAssignedInIfElseInspection(state), TestClassVbeSetup); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -1245,22 +892,8 @@ public void IgnoreQuickFixAppendsToExistingAnnotation() x = 42 End Sub"; - var builder = new MockVbeBuilder(); - var project = builder.ProjectBuilder("VBAProject", ProjectProtection.Unprotected) - .AddComponent("MyClass", ComponentType.ClassModule, inputCode) - .Build(); - var component = project.Object.VBComponents[0]; - var vbe = builder.AddProject(project).Build(); - - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new UndeclaredVariableInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyIgnoreOnceToFirstResult(inputCode, state => new UndeclaredVariableInspection(state), TestClassVbeSetup); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -1280,22 +913,8 @@ public void IgnoreQuickFixAddsAnnotationAfterComment() x = 42 End Sub"; - var builder = new MockVbeBuilder(); - var project = builder.ProjectBuilder("VBAProject", ProjectProtection.Unprotected) - .AddComponent("MyClass", ComponentType.ClassModule, inputCode) - .Build(); - var component = project.Object.VBComponents[0]; - var vbe = builder.AddProject(project).Build(); - - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new UndeclaredVariableInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyIgnoreOnceToFirstResult(inputCode, state => new UndeclaredVariableInspection(state), TestClassVbeSetup); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -1315,22 +934,8 @@ Rem comment x = 42 End Sub"; - var builder = new MockVbeBuilder(); - var project = builder.ProjectBuilder("VBAProject", ProjectProtection.Unprotected) - .AddComponent("MyClass", ComponentType.ClassModule, inputCode) - .Build(); - var component = project.Object.VBComponents[0]; - var vbe = builder.AddProject(project).Build(); - - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new UndeclaredVariableInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyIgnoreOnceToFirstResult(inputCode, state => new UndeclaredVariableInspection(state), TestClassVbeSetup); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -1354,6 +959,44 @@ line _ x = 42 End Sub"; + var actualCode = ApplyIgnoreOnceToFirstResult(inputCode, state => new UndeclaredVariableInspection(state), TestClassVbeSetup); + Assert.AreEqual(expectedCode, actualCode); + } + + private string ApplyIgnoreOnceToFirstResult( + string inputCode, + Func inspectionFactory, + Func vbeSetup) + { + var (vbe, moduleName) = vbeSetup(inputCode); + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe); + using (state) + { + var inspection = inspectionFactory(state); + var inspectionResults = InspectionResults(inspection, state); + var resultToFix = inspectionResults.First(); + var rewriteSession = rewritingManager.CheckOutCodePaneSession(); + + var quickFix = new IgnoreOnceQuickFix(state, new[] {inspection}); + quickFix.Fix(resultToFix, rewriteSession); + + return rewriteSession.CheckOutModuleRewriter(moduleName).GetText(); + } + } + + private IEnumerable InspectionResults(IInspection inspection, RubberduckParserState state) + { + if (inspection is IParseTreeInspection) + { + var inspector = InspectionsHelper.GetInspector(inspection); + return inspector.FindIssuesAsync(state, CancellationToken.None).Result; + } + + return inspection.GetInspectionResults(CancellationToken.None); + } + + private (IVBE vbe, QualifiedModuleName moduleName) TestClassVbeSetup(string inputCode) + { var builder = new MockVbeBuilder(); var project = builder.ProjectBuilder("VBAProject", ProjectProtection.Unprotected) .AddComponent("MyClass", ComponentType.ClassModule, inputCode) @@ -1361,14 +1004,63 @@ line _ var component = project.Object.VBComponents[0]; var vbe = builder.AddProject(project).Build(); - using (var state = MockParser.CreateAndParse(vbe.Object)) + return (vbe.Object, component.QualifiedModuleName); + } + + private (IVBE vbe, QualifiedModuleName moduleName) TestStandardModuleVbeSetup(string inputCode) + { + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); + return (vbe.Object, component.QualifiedModuleName); + } + + private (IVBE vbe, QualifiedModuleName moduleName) TestClassInExcelVbeSetup(string inputCode) + { + var builder = new MockVbeBuilder(); + var project = builder.ProjectBuilder("TestProject1", "TestProject1", ProjectProtection.Unprotected) + .AddComponent("Class1", ComponentType.ClassModule, inputCode) + .AddReference("Excel", MockVbeBuilder.LibraryPathMsExcel, 1, 8, true) + .Build(); + var component = project.Object.VBComponents[0]; + var vbe = builder.AddProject(project).Build(); + + return (vbe.Object, component.QualifiedModuleName); + } + + private (IVBE vbe, QualifiedModuleName moduleName) TestStandardModuleInExcelVbeSetup(string inputCode) + { + var builder = new MockVbeBuilder(); + var project = builder.ProjectBuilder("VBAProject", ProjectProtection.Unprotected) + .AddComponent("Module1", ComponentType.StandardModule, inputCode) + .AddReference("Excel", MockVbeBuilder.LibraryPathMsExcel, 1, 8, true) + .Build(); + + var vbe = builder.AddProject(project).Build(); + var component = vbe.Object.SelectedVBComponent; + + return (vbe.Object, component.QualifiedModuleName); + } + + private string ApplyIgnoreOnceToAllResults( + string inputCode, + Func inspectionFactory, + Func vbeSetup) + { + var (vbe, moduleName) = vbeSetup(inputCode); + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe); + using (state) { + var inspection = inspectionFactory(state); + var inspectionResults = InspectionResults(inspection, state); + var rewriteSession = rewritingManager.CheckOutCodePaneSession(); - var inspection = new UndeclaredVariableInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); + var quickFix = new IgnoreOnceQuickFix(state, new[] { inspection }); + + foreach (var resultToFix in inspectionResults) + { + quickFix.Fix(resultToFix, rewriteSession); + } - new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); + return rewriteSession.CheckOutModuleRewriter(moduleName).GetText(); } } } diff --git a/RubberduckTests/QuickFixes/IntroduceLocalVariableQuickFixTests.cs b/RubberduckTests/QuickFixes/IntroduceLocalVariableQuickFixTests.cs index 3ba43ae5f4..86e48ecc89 100644 --- a/RubberduckTests/QuickFixes/IntroduceLocalVariableQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/IntroduceLocalVariableQuickFixTests.cs @@ -1,16 +1,13 @@ using NUnit.Framework; using Rubberduck.Inspections.Concrete; using Rubberduck.Inspections.QuickFixes; -using Rubberduck.Parsing.Inspections; -using RubberduckTests.Inspections; -using RubberduckTests.Mocks; -using System.Linq; -using System.Threading; +using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.VBA; namespace RubberduckTests.QuickFixes { [TestFixture] - public class IntroduceLocalVariableQuickFixTests + public class IntroduceLocalVariableQuickFixTests : QuickFixTestBase { [Test] [Category("QuickFixes")] @@ -33,7 +30,8 @@ For Each fooBar In Foo Next End Sub"; - TestInsertLocalVariableQuickFix(expectedCode, inputCode); + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new UndeclaredVariableInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -61,7 +59,8 @@ For Each fooBar In Foo.Items End With End Sub"; - TestInsertLocalVariableQuickFix(expectedCode, inputCode); + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new UndeclaredVariableInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -93,7 +92,8 @@ For Each fooBar In Foo Next End Sub"; - TestInsertLocalVariableQuickFix(expectedCode, inputCode); + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new UndeclaredVariableInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -117,7 +117,8 @@ For Each fooBar In Foo Next End Sub"; - TestInsertLocalVariableQuickFix(expectedCode, inputCode); + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new UndeclaredVariableInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -141,7 +142,8 @@ Dim fooBar As Variant Next End Sub"; - TestInsertLocalVariableQuickFix(expectedCode, inputCode); + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new UndeclaredVariableInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -158,21 +160,14 @@ public void IntroduceLocalVariable_QuickFixWorks_StatementSeperators() Dim bar As Collection : Dim fooBar As Variant : For Each fooBar In Foo : fooBar.Whatever : Next End Sub"; - TestInsertLocalVariableQuickFix(expectedCode, inputCode); + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new UndeclaredVariableInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } - private void TestInsertLocalVariableQuickFix(string expectedCode, string inputCode) - { - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - var state = MockParser.CreateAndParse(vbe.Object); - - var inspection = new UndeclaredVariableInspection(state) { Severity = CodeInspectionSeverity.Warning }; - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - new IntroduceLocalVariableQuickFix(state).Fix(inspectionResults.First()); - var actualCode = state.GetRewriter(component).GetText(); - Assert.AreEqual(expectedCode, actualCode); + protected override IQuickFix QuickFix(RubberduckParserState state) + { + return new IntroduceLocalVariableQuickFix(); } } } \ No newline at end of file diff --git a/RubberduckTests/QuickFixes/IsMissingOnInappropriateArgumentQuickFixTests.cs b/RubberduckTests/QuickFixes/IsMissingOnInappropriateArgumentQuickFixTests.cs index 0dbabd6bab..d65dfb22ef 100644 --- a/RubberduckTests/QuickFixes/IsMissingOnInappropriateArgumentQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/IsMissingOnInappropriateArgumentQuickFixTests.cs @@ -3,14 +3,17 @@ using NUnit.Framework; using Rubberduck.Inspections.Concrete; using Rubberduck.Inspections.QuickFixes; +using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.VBA; using Rubberduck.VBEditor.SafeComWrappers; +using Rubberduck.VBEditor.SafeComWrappers.Abstract; using RubberduckTests.Inspections; using RubberduckTests.Mocks; namespace RubberduckTests.QuickFixes { [TestFixture] - public class IsMissingOnInappropriateArgumentQuickFixTests + public class IsMissingOnInappropriateArgumentQuickFixTests : QuickFixTestBase { [Test] [Category("QuickFixes")] @@ -431,6 +434,16 @@ End Sub } private string ArrangeAndApplyQuickFix(string code) + { + return ApplyQuickFixToFirstInspectionResult(code, state => new IsMissingOnInappropriateArgumentInspection(state)); + } + + protected override IQuickFix QuickFix(RubberduckParserState state) + { + return new IsMissingOnInappropriateArgumentQuickFix(state); + } + + protected override IVBE TestVbe(string code, out IVBComponent component) { var builder = new MockVbeBuilder(); var project = builder.ProjectBuilder("TestProject1", "TestProject1", ProjectProtection.Unprotected) @@ -438,17 +451,8 @@ private string ArrangeAndApplyQuickFix(string code) .AddReference("VBA", MockVbeBuilder.LibraryPathVBA, 4, 2, true) .Build(); var vbe = builder.AddProject(project).Build(); - var component = project.Object.VBComponents.FirstOrDefault(); - - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - var inspection = new IsMissingOnInappropriateArgumentInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new IsMissingOnInappropriateArgumentQuickFix(state).Fix(inspectionResults.First()); - return state.GetRewriter(component).GetText(); - } + component = project.Object.VBComponents.First(); + return vbe.Object; } } } diff --git a/RubberduckTests/QuickFixes/MakeSingleLineParamegerQuickFixTests.cs b/RubberduckTests/QuickFixes/MakeSingleLineParamegerQuickFixTests.cs index a7bd271652..49d59d0d3e 100644 --- a/RubberduckTests/QuickFixes/MakeSingleLineParamegerQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/MakeSingleLineParamegerQuickFixTests.cs @@ -1,15 +1,13 @@ -using System.Linq; -using System.Threading; -using NUnit.Framework; +using NUnit.Framework; using Rubberduck.Inspections.Concrete; using Rubberduck.Inspections.QuickFixes; -using RubberduckTests.Mocks; -using RubberduckTests.Inspections; +using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.VBA; namespace RubberduckTests.QuickFixes { [TestFixture] - public class MakeSingleLineParamegerQuickFixTests + public class MakeSingleLineParamegerQuickFixTests : QuickFixTestBase { [Test] [Category("QuickFixes")] @@ -28,17 +26,14 @@ As _ ByVal Var1 As Integer) End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - var inspection = new MultilineParameterInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new MakeSingleLineParameterQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new MultilineParameterInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } + + protected override IQuickFix QuickFix(RubberduckParserState state) + { + return new MakeSingleLineParameterQuickFix(); + } } } diff --git a/RubberduckTests/QuickFixes/MoveFieldCloserToUsageQuickFixTests.cs b/RubberduckTests/QuickFixes/MoveFieldCloserToUsageQuickFixTests.cs index b93a489064..21dfce0cdb 100644 --- a/RubberduckTests/QuickFixes/MoveFieldCloserToUsageQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/MoveFieldCloserToUsageQuickFixTests.cs @@ -4,7 +4,6 @@ using Moq; using Rubberduck.Inspections.Concrete; using Rubberduck.Inspections.QuickFixes; -using Rubberduck.UI; using RubberduckTests.Mocks; using Rubberduck.Interaction; @@ -29,15 +28,8 @@ Dim bar As String bar = ""test"" End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - var inspection = new MoveFieldCloserToUsageInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new MoveFieldCloserToUsageQuickFix(vbe.Object, state, new Mock().Object).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, component.CodeModule.Content()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -72,20 +64,13 @@ Private Sub FooBar() End Sub "; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - var inspection = new MoveFieldCloserToUsageInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new MoveFieldCloserToUsageQuickFix(vbe.Object, state, new Mock().Object).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, component.CodeModule.Content()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode); + Assert.AreEqual(expectedCode, actualCode); } [Test] [Category("QuickFixes")] - public void MoveFieldCloserToUsage_QuickFixWorks_SingleLineThenStatemente() + public void MoveFieldCloserToUsage_QuickFixWorks_SingleLineThenStatement() { const string inputCode = @"Private bar As String @@ -101,15 +86,8 @@ Dim bar As String If True Then bar = ""test"" End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - var inspection = new MoveFieldCloserToUsageInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new MoveFieldCloserToUsageQuickFix(vbe.Object, state, new Mock().Object).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, component.CodeModule.Content()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -130,14 +108,25 @@ Dim bar As String If True Then Else bar = ""test"" End Sub"; + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode); + Assert.AreEqual(expectedCode, actualCode); + } + + private string ApplyQuickFixToFirstInspectionResult(string inputCode) + { var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var inspection = new MoveFieldCloserToUsageInspection(state); var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); + var resultToFix = inspectionResults.First(); + var rewriteSession = rewritingManager.CheckOutCodePaneSession(); + var quickFix = new MoveFieldCloserToUsageQuickFix(vbe.Object, state, new Mock().Object); + + quickFix.Fix(resultToFix, rewriteSession); - new MoveFieldCloserToUsageQuickFix(vbe.Object, state, new Mock().Object).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, component.CodeModule.Content()); + return component.CodeModule.Content(); } } } diff --git a/RubberduckTests/QuickFixes/OptionExplicitQuickFixTests.cs b/RubberduckTests/QuickFixes/OptionExplicitQuickFixTests.cs index 40d3ff85e9..7ca6ee3025 100644 --- a/RubberduckTests/QuickFixes/OptionExplicitQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/OptionExplicitQuickFixTests.cs @@ -1,15 +1,13 @@ -using System.Linq; -using System.Threading; -using NUnit.Framework; +using NUnit.Framework; using Rubberduck.Inspections.Concrete; using Rubberduck.Inspections.QuickFixes; -using RubberduckTests.Mocks; -using RubberduckTests.Inspections; +using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.VBA; namespace RubberduckTests.QuickFixes { [TestFixture] - public class OptionExplicitQuickFixTests + public class OptionExplicitQuickFixTests : QuickFixTestBase { [Test] [Category("QuickFixes")] @@ -21,17 +19,14 @@ public void NotAlreadySpecified_QuickFixWorks() "; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - var inspection = new OptionExplicitInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new OptionExplicitQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new OptionExplicitInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } + + protected override IQuickFix QuickFix(RubberduckParserState state) + { + return new OptionExplicitQuickFix(); + } } } diff --git a/RubberduckTests/QuickFixes/PassParameterByReferenceQuickFixTests.cs b/RubberduckTests/QuickFixes/PassParameterByReferenceQuickFixTests.cs index bc014e453d..58f2bc0a90 100644 --- a/RubberduckTests/QuickFixes/PassParameterByReferenceQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/PassParameterByReferenceQuickFixTests.cs @@ -1,58 +1,50 @@ -using System.Linq; -using System.Threading; using NUnit.Framework; -using Moq; using Rubberduck.Inspections.Concrete; using Rubberduck.Inspections.QuickFixes; -using Rubberduck.VBEditor.SafeComWrappers.Abstract; -using RubberduckTests.Mocks; +using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.VBA; namespace RubberduckTests.QuickFixes { [TestFixture] - public class PassParameterByReferenceQuickFixTests + public class PassParameterByReferenceQuickFixTests : QuickFixTestBase { [Test] [Category("QuickFixes")] public void AssignedByValParameter_PassByReferenceQuickFixWorks() { - string inputCode = - @"Public Sub Foo(Optional ByVal barByVal As String = ""XYZ"") + const string inputCode = @"Public Sub Foo(Optional ByVal barByVal As String = ""XYZ"") Let barByVal = ""test"" End Sub"; - string expectedCode = - @"Public Sub Foo(Optional ByRef barByVal As String = ""XYZ"") + const string expectedCode = @"Public Sub Foo(Optional ByRef barByVal As String = ""XYZ"") Let barByVal = ""test"" End Sub"; - var quickFixResult = ApplyPassParameterByReferenceQuickFixToVBAFragment(inputCode); - Assert.AreEqual(expectedCode, quickFixResult); + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new AssignedByValParameterInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] [Category("QuickFixes")] public void AssignedByValParameter_PassByReferenceQuickFixWorks_ByValParameterIsOneOfSeveral() { - var inputCode = - @"Public Sub Foo(ByRef firstArg As Long, Optional ByVal barByVal As String = """", secondArg as Double) + const string inputCode = @"Public Sub Foo(ByRef firstArg As Long, Optional ByVal barByVal As String = """", secondArg as Double) Let barByVal = ""test"" End Sub"; - var expectedCode = - @"Public Sub Foo(ByRef firstArg As Long, Optional ByRef barByVal As String = """", secondArg as Double) + const string expectedCode = @"Public Sub Foo(ByRef firstArg As Long, Optional ByRef barByVal As String = """", secondArg as Double) Let barByVal = ""test"" End Sub"; - var quickFixResult = ApplyPassParameterByReferenceQuickFixToVBAFragment(inputCode); - Assert.AreEqual(expectedCode, quickFixResult); + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new AssignedByValParameterInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] [Category("QuickFixes")] public void AssignedByValParameter_PassByReferenceQuickFixWorks_LineContinued1() { - var inputCode = - @" + const string inputCode = @" Private Sub Foo(Optional ByVal _ bar _ As _ @@ -63,10 +55,8 @@ As _ Long) bar = 42 End Sub -" - ; - var expectedCode = - @" +"; + const string expectedCode = @" Private Sub Foo(Optional ByRef _ bar _ As _ @@ -77,26 +67,23 @@ As _ Long) bar = 42 End Sub -" - ; - var quickFixResult = ApplyPassParameterByReferenceQuickFixToVBAFragment(inputCode); - Assert.AreEqual(expectedCode, quickFixResult); +"; + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new AssignedByValParameterInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] [Category("QuickFixes")] public void AssignedByValParameter_PassByReferenceQuickFixWorks_LineContinued2() { - var inputCode = - @"Private Sub Foo(ByVal barByVal As Long, ByVal _xByValbar As Long, ByVal _ + const string inputCode = @"Private Sub Foo(ByVal barByVal As Long, ByVal _xByValbar As Long, ByVal _ barTwo _ As _ Long) barTwo = 42 End Sub "; - var expectedCode = - @"Private Sub Foo(ByVal barByVal As Long, ByVal _xByValbar As Long, ByRef _ + const string expectedCode = @"Private Sub Foo(ByVal barByVal As Long, ByVal _xByValbar As Long, ByRef _ barTwo _ As _ Long) @@ -104,24 +91,22 @@ As _ End Sub "; - var quickFixResult = ApplyPassParameterByReferenceQuickFixToVBAFragment(inputCode); - Assert.AreEqual(expectedCode, quickFixResult); + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new AssignedByValParameterInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] [Category("QuickFixes")] public void AssignedByValParameter_PassByReferenceQuickFixWorks_LineContinued3() { - var inputCode = - @"Private Sub Foo(ByVal barByVal As Long, ByVal barTwoon As Long, ByVal _ + const string inputCode = @"Private Sub Foo(ByVal barByVal As Long, ByVal barTwoon As Long, ByVal _ barTwo _ As _ Long) barTwo = 42 End Sub "; - var expectedCode = - @"Private Sub Foo(ByVal barByVal As Long, ByVal barTwoon As Long, ByRef _ + const string expectedCode = @"Private Sub Foo(ByVal barByVal As Long, ByVal barTwoon As Long, ByRef _ barTwo _ As _ Long) @@ -129,23 +114,21 @@ As _ End Sub "; - var quickFixResult = ApplyPassParameterByReferenceQuickFixToVBAFragment(inputCode); - Assert.AreEqual(expectedCode, quickFixResult); + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new AssignedByValParameterInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] [Category("QuickFixes")] public void AssignedByValParameter_PassByReferenceQuickFixWorks_LineContinued4() { - var inputCode = - @"Private Sub Foo(ByVal barByVal As Long, ByVal barTwoon As Long, ByVal barTwo _ + const string inputCode = @"Private Sub Foo(ByVal barByVal As Long, ByVal barTwoon As Long, ByVal barTwo _ As _ Long) barTwo = 42 End Sub "; - var expectedCode = - @"Private Sub Foo(ByVal barByVal As Long, ByVal barTwoon As Long, ByRef barTwo _ + const string expectedCode = @"Private Sub Foo(ByVal barByVal As Long, ByVal barTwoon As Long, ByRef barTwo _ As _ Long) barTwo = 42 @@ -153,8 +136,8 @@ End Sub "; - var quickFixResult = ApplyPassParameterByReferenceQuickFixToVBAFragment(inputCode); - Assert.AreEqual(expectedCode, quickFixResult); + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new AssignedByValParameterInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -162,8 +145,7 @@ End Sub public void AssignedByValParameter_PassByReferenceQuickFixWorks_LineContinued5() { //weaponized code test - var inputCode = -@"Sub DoSomething( _ + const string inputCode = @"Sub DoSomething( _ ByVal foo As Long, _ ByRef _ bar, _ @@ -175,8 +157,7 @@ ByRef barbecue _ End Sub "; - var expectedCode = -@"Sub DoSomething( _ + const string expectedCode = @"Sub DoSomething( _ ByRef foo As Long, _ ByRef _ bar, _ @@ -187,26 +168,14 @@ ByRef barbecue _ bar + foo / barbecue End Sub "; - var quickFixResult = ApplyPassParameterByReferenceQuickFixToVBAFragment(inputCode); - Assert.AreEqual(expectedCode, quickFixResult); + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new AssignedByValParameterInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } - private string ApplyPassParameterByReferenceQuickFixToVBAFragment(string inputCode) - { - var vbe = BuildMockVBEStandardModuleForVBAFragment(inputCode); - using(var state = MockParser.CreateAndParse(vbe.Object)) - { - var inspection = new AssignedByValParameterInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new PassParameterByReferenceQuickFix(state).Fix(inspectionResults.First()); - return state.GetRewriter(vbe.Object.ActiveVBProject.VBComponents[0]).GetText(); - } - } - private Mock BuildMockVBEStandardModuleForVBAFragment(string inputCode) + protected override IQuickFix QuickFix(RubberduckParserState state) { - return MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _); + return new PassParameterByReferenceQuickFix(); } } } diff --git a/RubberduckTests/QuickFixes/PassParameterByValueQuickFixTests.cs b/RubberduckTests/QuickFixes/PassParameterByValueQuickFixTests.cs index 01b41f76f2..5b4ab08207 100644 --- a/RubberduckTests/QuickFixes/PassParameterByValueQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/PassParameterByValueQuickFixTests.cs @@ -3,13 +3,15 @@ using NUnit.Framework; using Rubberduck.Inspections.Concrete; using Rubberduck.Inspections.QuickFixes; +using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.VBA; using Rubberduck.VBEditor.SafeComWrappers; using RubberduckTests.Mocks; namespace RubberduckTests.QuickFixes { [TestFixture] - public class PassParameterByValueQuickFixTests + public class PassParameterByValueQuickFixTests : QuickFixTestBase { [Test] [Category("QuickFixes")] @@ -23,15 +25,8 @@ public void ParameterCanBeByVal_QuickFixWorks_SubNameStartsWithParamName() @"Sub foo(ByVal f) End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ParameterCanBeByValInspection(state); - new PassParameterByValueQuickFix(state).Fix(inspection.GetInspectionResults(CancellationToken.None).First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new ParameterCanBeByValInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -46,15 +41,8 @@ public void ParameterCanBeByVal_QuickFixWorks_PassedByUnspecified() @"Sub Foo(ByVal arg1 As String) End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ParameterCanBeByValInspection(state); - new PassParameterByValueQuickFix(state).Fix(inspection.GetInspectionResults(CancellationToken.None).First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new ParameterCanBeByValInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -69,15 +57,8 @@ public void ParameterCanBeByVal_QuickFixWorks_PassedByRef() @"Sub Foo(ByVal arg1 As String) End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ParameterCanBeByValInspection(state); - new PassParameterByValueQuickFix(state).Fix(inspection.GetInspectionResults(CancellationToken.None).First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new ParameterCanBeByValInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -94,15 +75,8 @@ public void ParameterCanBeByVal_QuickFixWorks_PassedByUnspecified_MultilineParam ByVal arg1 As String) End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ParameterCanBeByValInspection(state); - new PassParameterByValueQuickFix(state).Fix(inspection.GetInspectionResults(CancellationToken.None).First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new ParameterCanBeByValInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -119,15 +93,8 @@ public void ParameterCanBeByVal_QuickFixWorks_PassedByRef_MultilineParameter() arg1 As String) End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ParameterCanBeByValInspection(state); - new PassParameterByValueQuickFix(state).Fix(inspection.GetInspectionResults(CancellationToken.None).First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new ParameterCanBeByValInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -178,15 +145,22 @@ Private Sub IClass1_DoSomething(ByVal a As Integer, ByRef b As Integer) var component3 = project.Object.VBComponents["Class2"]; var vbe = builder.AddProject(project).Build(); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewriteManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var inspection = new ParameterCanBeByValInspection(state); - new PassParameterByValueQuickFix(state).Fix(inspection.GetInspectionResults(CancellationToken.None).First()); + var rewriteSession = rewriteManager.CheckOutCodePaneSession(); + + new PassParameterByValueQuickFix(state).Fix(inspection.GetInspectionResults(CancellationToken.None).First(), rewriteSession); - Assert.AreEqual(expectedCode1, state.GetRewriter(component1).GetText()); - Assert.AreEqual(expectedCode2, state.GetRewriter(component2).GetText()); - Assert.AreEqual(expectedCode3, state.GetRewriter(component3).GetText()); + var actualCode1 = rewriteSession.CheckOutModuleRewriter(component1.QualifiedModuleName).GetText(); + var actualCode2 = rewriteSession.CheckOutModuleRewriter(component2.QualifiedModuleName).GetText(); + var actualCode3 = rewriteSession.CheckOutModuleRewriter(component3.QualifiedModuleName).GetText(); + + Assert.AreEqual(expectedCode1, actualCode1); + Assert.AreEqual(expectedCode2, actualCode2); + Assert.AreEqual(expectedCode3, actualCode3); } } @@ -236,15 +210,22 @@ Private Sub abc_Foo(ByRef a As Integer, ByVal b As Integer) var component3 = project.Object.VBComponents["Class3"]; var vbe = builder.AddProject(project).Build(); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewriteManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var inspection = new ParameterCanBeByValInspection(state); - new PassParameterByValueQuickFix(state).Fix(inspection.GetInspectionResults(CancellationToken.None).First()); + var rewriteSession = rewriteManager.CheckOutCodePaneSession(); + + new PassParameterByValueQuickFix(state).Fix(inspection.GetInspectionResults(CancellationToken.None).First(), rewriteSession); + + var actualCode1 = rewriteSession.CheckOutModuleRewriter(component1.QualifiedModuleName).GetText(); + var actualCode2 = rewriteSession.CheckOutModuleRewriter(component2.QualifiedModuleName).GetText(); + var actualCode3 = rewriteSession.CheckOutModuleRewriter(component3.QualifiedModuleName).GetText(); - Assert.AreEqual(expectedCode1, state.GetRewriter(component1).GetText()); - Assert.AreEqual(expectedCode2, state.GetRewriter(component2).GetText()); - Assert.AreEqual(expectedCode3, state.GetRewriter(component3).GetText()); + Assert.AreEqual(expectedCode1, actualCode1); + Assert.AreEqual(expectedCode2, actualCode2); + Assert.AreEqual(expectedCode3, actualCode3); } } @@ -263,15 +244,8 @@ Debug.Print foo Debug.Print foo End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ParameterCanBeByValInspection(state); - new PassParameterByValueQuickFix(state).Fix(inspection.GetInspectionResults(CancellationToken.None).First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new ParameterCanBeByValInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } //https://github.com/rubberduck-vba/Rubberduck/issues/2408 @@ -289,15 +263,8 @@ Debug.Print foo Debug.Print foo End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ParameterCanBeByValInspection(state); - new PassParameterByValueQuickFix(state).Fix(inspection.GetInspectionResults(CancellationToken.None).First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new ParameterCanBeByValInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } //https://github.com/rubberduck-vba/Rubberduck/issues/2408 @@ -325,16 +292,14 @@ Byte _ Debug.Print foo End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new ParameterCanBeByValInspection(state)); + Assert.AreEqual(expectedCode, actualCode); + } - var inspection = new ParameterCanBeByValInspection(state); - new PassParameterByValueQuickFix(state).Fix(inspection.GetInspectionResults(CancellationToken.None).First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + protected override IQuickFix QuickFix(RubberduckParserState state) + { + return new PassParameterByValueQuickFix(state); } - } } diff --git a/RubberduckTests/QuickFixes/QuickFixBaseTests.cs b/RubberduckTests/QuickFixes/QuickFixBaseTests.cs index f277002bb1..e44e242864 100644 --- a/RubberduckTests/QuickFixes/QuickFixBaseTests.cs +++ b/RubberduckTests/QuickFixes/QuickFixBaseTests.cs @@ -16,7 +16,7 @@ public void QuickFixBase_Register() var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out _); using (var state = MockParser.CreateAndParse(vbe.Object)) { - var quickFix = new RemoveCommentQuickFix(state); + var quickFix = new RemoveCommentQuickFix(); quickFix.RegisterInspections(typeof(EmptyStringLiteralInspection)); Assert.IsTrue(quickFix.SupportedInspections.Contains(typeof(EmptyStringLiteralInspection))); @@ -30,7 +30,7 @@ public void QuickFixBase_Unregister() var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out _); using (var state = MockParser.CreateAndParse(vbe.Object)) { - var quickFix = new RemoveCommentQuickFix(state); + var quickFix = new RemoveCommentQuickFix(); quickFix.RemoveInspections(quickFix.SupportedInspections.ToArray()); Assert.IsFalse(quickFix.SupportedInspections.Any()); diff --git a/RubberduckTests/QuickFixes/QuickFixProviderTests.cs b/RubberduckTests/QuickFixes/QuickFixProviderTests.cs index 5c78ae2a9a..e746937caf 100644 --- a/RubberduckTests/QuickFixes/QuickFixProviderTests.cs +++ b/RubberduckTests/QuickFixes/QuickFixProviderTests.cs @@ -1,7 +1,6 @@ using System.Linq; using System.Threading; using NUnit.Framework; -using Rubberduck.Inspections; using Rubberduck.Inspections.Concrete; using Rubberduck.Inspections.QuickFixes; using Rubberduck.Parsing.Inspections.Abstract; @@ -52,7 +51,7 @@ Dim str As String var inspector = InspectionsHelper.GetInspector(inspection); var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - var quickFixProvider = new QuickFixProvider(state, new IQuickFix[] { new ReplaceEmptyStringLiteralStatementQuickFix(state) }); + var quickFixProvider = new QuickFixProvider(state, new IQuickFix[] { new ReplaceEmptyStringLiteralStatementQuickFix() }); Assert.AreEqual(1, quickFixProvider.QuickFixes(inspectionResults.First()).Count()); } } @@ -73,7 +72,7 @@ public void ResultDisablesFix() var inspection = new ConstantNotUsedInspection(state); var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - var quickFixProvider = new QuickFixProvider(state, new IQuickFix[] { new RemoveUnusedDeclarationQuickFix(state) }); + var quickFixProvider = new QuickFixProvider(state, new IQuickFix[] { new RemoveUnusedDeclarationQuickFix() }); var result = inspectionResults.First(); result.Properties.DisableFixes = nameof(RemoveUnusedDeclarationQuickFix); diff --git a/RubberduckTests/QuickFixes/QuickFixTestBase.cs b/RubberduckTests/QuickFixes/QuickFixTestBase.cs new file mode 100644 index 0000000000..13cf392308 --- /dev/null +++ b/RubberduckTests/QuickFixes/QuickFixTestBase.cs @@ -0,0 +1,176 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Threading; +using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.Rewriter; +using Rubberduck.Parsing.VBA; +using Rubberduck.VBEditor; +using Rubberduck.VBEditor.SafeComWrappers; +using Rubberduck.VBEditor.SafeComWrappers.Abstract; +using RubberduckTests.Inspections; +using RubberduckTests.Mocks; + +namespace RubberduckTests.QuickFixes +{ + public abstract class QuickFixTestBase + { + protected abstract IQuickFix QuickFix(RubberduckParserState state); + + protected virtual IVBE TestVbe(string code, out IVBComponent component) + { + return MockVbeBuilder.BuildFromSingleStandardModule(code, out component).Object; + } + + protected string ApplyQuickFixToFirstInspectionResult(string inputCode, + Func inspectionFactory) + { + return ApplyQuickFixToAppropriateInspectionResults( + inputCode, + inspectionFactory, + ApplyToFirstResult); + } + + private string ApplyQuickFixToAppropriateInspectionResults(string inputCode, + Func inspectionFactory, + Action, IRewriteSession> applyQuickFix) + { + var vbe = TestVbe(inputCode, out var component); + var (state, rewriteManager) = MockParser.CreateAndParseWithRewritingManager(vbe); + using (state) + { + var inspection = inspectionFactory(state); + var inspectionResults = InspectionResults(inspection, state); + var rewriteSession = rewriteManager.CheckOutCodePaneSession(); + + var quickFix = QuickFix(state); + + applyQuickFix(quickFix, inspectionResults, rewriteSession); + + return rewriteSession.CheckOutModuleRewriter(component.QualifiedModuleName).GetText(); + } + } + + private IEnumerable InspectionResults(IInspection inspection, RubberduckParserState state) + { + if (inspection is IParseTreeInspection) + { + var inspector = InspectionsHelper.GetInspector(inspection); + return inspector.FindIssuesAsync(state, CancellationToken.None).Result; + } + + return inspection.GetInspectionResults(CancellationToken.None); + } + + private void ApplyToFirstResult(IQuickFix quickFix, IEnumerable inspectionResults, IRewriteSession rewriteSession) + { + var resultToFix = inspectionResults.First(); + quickFix.Fix(resultToFix, rewriteSession); + } + + protected string ApplyQuickFixToAllInspectionResults(string inputCode, + Func inspectionFactory) + { + return ApplyQuickFixToAppropriateInspectionResults( + inputCode, + inspectionFactory, + ApplyToAllResults); + } + + private void ApplyToAllResults(IQuickFix quickFix, IEnumerable inspectionResults, IRewriteSession rewriteSession) + { + foreach (var inspectionResult in inspectionResults) + { + quickFix.Fix(inspectionResult, rewriteSession); + } + } + + + + protected (string interfaceCode, string implementationCode) ApplyQuickFixToFirstInspectionResultForImplementedInterface( + string interfaceInputCode, + string implementationInputCode, + Func inspectionFactory) + { + return ApplyQuickFixToAppropriateInspectionResultsForImplementedInterface( + interfaceInputCode, + implementationInputCode, + inspectionFactory, + ApplyToFirstResult); + } + + private (string interfaceCode, string implementationCode) ApplyQuickFixToAppropriateInspectionResultsForImplementedInterface( + string interfaceCode, + string implementationCode, + Func inspectionFactory, + Action, IRewriteSession> applyQuickFix) + { + var (vbe, interfaceModuleName, implementationModuleName) = TestVbeForImplementedInterface(interfaceCode, implementationCode); + + var (state, rewriteManager) = MockParser.CreateAndParseWithRewritingManager(vbe); + using (state) + { + var inspection = inspectionFactory(state); + var inspectionResults = InspectionResults(inspection, state); + var rewriteSession = rewriteManager.CheckOutCodePaneSession(); + + var quickFix = QuickFix(state); + + applyQuickFix(quickFix, inspectionResults, rewriteSession); + + var actualInterfaceCode = rewriteSession.CheckOutModuleRewriter(interfaceModuleName).GetText(); + var actualImplementationCode = rewriteSession.CheckOutModuleRewriter(implementationModuleName).GetText(); + + return (actualInterfaceCode, actualImplementationCode); + } + } + + protected virtual (IVBE vbe, QualifiedModuleName interfaceModuleName, QualifiedModuleName implemetingModuleName) TestVbeForImplementedInterface(string interfaceCode, string implementationCode) + { + var builder = new MockVbeBuilder(); + var vbe = builder.ProjectBuilder("TestProject1", ProjectProtection.Unprotected) + .AddComponent("IClass1", ComponentType.ClassModule, interfaceCode) + .AddComponent("Class1", ComponentType.ClassModule, implementationCode) + .AddProjectToVbeBuilder() + .Build().Object; + + var project = vbe.VBProjects[0]; + var interfaceComponent = project.VBComponents[0]; + var implementationComponent = project.VBComponents[1]; + + return (vbe, interfaceComponent.QualifiedModuleName, implementationComponent.QualifiedModuleName); + } + + protected (string interfaceCode, string implementationCode) ApplyQuickFixToFirstInspectionResultForImplementedInterfaceSatisfyingPredicate( + string interfaceInputCode, + string implementationInputCode, + Func inspectionFactory, + Func predicate) + { + var applyQuickFix = ApplyToFirstResultSatisfyingPredicateAction(predicate); + return ApplyQuickFixToAppropriateInspectionResultsForImplementedInterface( + interfaceInputCode, + implementationInputCode, + inspectionFactory, + applyQuickFix); + } + + private Action, IRewriteSession> ApplyToFirstResultSatisfyingPredicateAction(Func predicate) + { + return (quickFix, inspectionResults, rewriteSession) => + quickFix.Fix(inspectionResults.First(predicate), rewriteSession); + } + + protected string ApplyQuickFixToFirstInspectionResultSatisfyingPredicate( + string code, + Func inspectionFactory, + Func predicate) + { + var applyQuickFix = ApplyToFirstResultSatisfyingPredicateAction(predicate); + return ApplyQuickFixToAppropriateInspectionResults( + code, + inspectionFactory, + applyQuickFix); + } + } +} \ No newline at end of file diff --git a/RubberduckTests/QuickFixes/RemoveCommentQuickFixTests.cs b/RubberduckTests/QuickFixes/RemoveCommentQuickFixTests.cs index 8427b3b566..9d5481e0df 100644 --- a/RubberduckTests/QuickFixes/RemoveCommentQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/RemoveCommentQuickFixTests.cs @@ -1,15 +1,13 @@ -using System.Linq; -using System.Threading; -using NUnit.Framework; +using NUnit.Framework; using Rubberduck.Inspections.Concrete; using Rubberduck.Inspections.QuickFixes; -using RubberduckTests.Mocks; -using RubberduckTests.Inspections; +using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.VBA; namespace RubberduckTests.QuickFixes { [TestFixture] - public class RemoveCommentQuickFixTests + public class RemoveCommentQuickFixTests : QuickFixTestBase { [Test] [Category("QuickFixes")] @@ -21,17 +19,8 @@ public void ObsoleteCommentSyntax_QuickFixWorks_RemoveComment() const string expectedCode = @""; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ObsoleteCommentSyntaxInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RemoveCommentQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new ObsoleteCommentSyntaxInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -45,17 +34,8 @@ public void ObsoleteCommentSyntax_QuickFixWorks_RemoveCommentHasContinuation() const string expectedCode = @""; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ObsoleteCommentSyntaxInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RemoveCommentQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new ObsoleteCommentSyntaxInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -68,17 +48,8 @@ public void ObsoleteCommentSyntax_QuickFixWorks_RemoveComment_LineHasCode() const string expectedCode = @"Dim Foo As Integer: "; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ObsoleteCommentSyntaxInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RemoveCommentQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new ObsoleteCommentSyntaxInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -92,18 +63,14 @@ public void ObsoleteCommentSyntax_QuickFixWorks_RemoveComment_LineHasCodeAndCont const string expectedCode = @"Dim Foo As Integer: "; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new ObsoleteCommentSyntaxInspection(state)); + Assert.AreEqual(expectedCode, actualCode); + } - var inspection = new ObsoleteCommentSyntaxInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - new RemoveCommentQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + protected override IQuickFix QuickFix(RubberduckParserState state) + { + return new RemoveCommentQuickFix(); } - } } diff --git a/RubberduckTests/QuickFixes/RemoveDuplicatedAnnotationQuickFixTests.cs b/RubberduckTests/QuickFixes/RemoveDuplicatedAnnotationQuickFixTests.cs index 3ad52cdb6d..7241bc155b 100644 --- a/RubberduckTests/QuickFixes/RemoveDuplicatedAnnotationQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/RemoveDuplicatedAnnotationQuickFixTests.cs @@ -1,15 +1,15 @@ -using System.Linq; -using System.Threading; +using System; using NUnit.Framework; using Rubberduck.Inspections.Concrete; using Rubberduck.Inspections.QuickFixes; using Rubberduck.Parsing.Annotations; -using RubberduckTests.Mocks; +using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.VBA; namespace RubberduckTests.QuickFixes { [TestFixture] - public class RemoveDuplicatedAnnotationQuickFixTests + public class RemoveDuplicatedAnnotationQuickFixTests : QuickFixTestBase { [Test] [Category("QuickFixes")] @@ -26,15 +26,8 @@ Public Sub Foo Public Sub Foo End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - var inspection = new DuplicatedAnnotationInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new RemoveDuplicatedAnnotationQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new DuplicatedAnnotationInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -53,15 +46,8 @@ Public Sub Foo Public Sub Foo End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - var inspection = new DuplicatedAnnotationInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new RemoveDuplicatedAnnotationQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new DuplicatedAnnotationInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -80,15 +66,8 @@ Public Sub Foo Public Sub Foo End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - var inspection = new DuplicatedAnnotationInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new RemoveDuplicatedAnnotationQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new DuplicatedAnnotationInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -105,15 +84,8 @@ Public Sub Foo Public Sub Foo End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - var inspection = new DuplicatedAnnotationInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new RemoveDuplicatedAnnotationQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new DuplicatedAnnotationInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -130,15 +102,8 @@ Public Sub Foo Public Sub Foo End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - var inspection = new DuplicatedAnnotationInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new RemoveDuplicatedAnnotationQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new DuplicatedAnnotationInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -157,15 +122,8 @@ Public Sub Foo Public Sub Foo End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - var inspection = new DuplicatedAnnotationInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new RemoveDuplicatedAnnotationQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new DuplicatedAnnotationInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -184,15 +142,8 @@ Public Sub Foo Public Sub Foo End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - var inspection = new DuplicatedAnnotationInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new RemoveDuplicatedAnnotationQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new DuplicatedAnnotationInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -209,15 +160,8 @@ Public Sub Foo Public Sub Foo End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - var inspection = new DuplicatedAnnotationInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new RemoveDuplicatedAnnotationQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new DuplicatedAnnotationInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -238,16 +182,15 @@ Public Sub Foo '@TestMethod Public Sub Foo End Sub"; + Func conditionToFix = result => result.Properties.AnnotationType == AnnotationType.Obsolete; + var actualCode = ApplyQuickFixToFirstInspectionResultSatisfyingPredicate(inputCode, state => new DuplicatedAnnotationInspection(state), conditionToFix); + Assert.AreEqual(expectedCode, actualCode); + } - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - var inspection = new DuplicatedAnnotationInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - new RemoveDuplicatedAnnotationQuickFix(state).Fix(inspectionResults.First(result => result.Properties.AnnotationType == AnnotationType.Obsolete)); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + protected override IQuickFix QuickFix(RubberduckParserState state) + { + return new RemoveDuplicatedAnnotationQuickFix(); } } } diff --git a/RubberduckTests/QuickFixes/RemoveEmptyElseBlockQuickFixTests.cs b/RubberduckTests/QuickFixes/RemoveEmptyElseBlockQuickFixTests.cs index cfb0f2965d..6f74ae03b4 100644 --- a/RubberduckTests/QuickFixes/RemoveEmptyElseBlockQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/RemoveEmptyElseBlockQuickFixTests.cs @@ -1,15 +1,13 @@ -using System.Linq; -using System.Threading; -using NUnit.Framework; -using RubberduckTests.Mocks; +using NUnit.Framework; using Rubberduck.Inspections.Concrete; using Rubberduck.Inspections.QuickFixes; -using RubberduckTests.Inspections; +using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.VBA; namespace RubberduckTests.QuickFixes { [TestFixture] - public class RemoveEmptyElseBlockQuickFixTests + public class RemoveEmptyElseBlockQuickFixTests : QuickFixTestBase { [Test] [Category("QuickFixes")] @@ -28,19 +26,14 @@ If True Then End If End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - var inspection = new EmptyElseBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var actualResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RemoveEmptyElseBlockQuickFix(state).Fix(actualResults.First()); + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new EmptyElseBlockInspection(state)); + Assert.AreEqual(expectedCode, actualCode); + } - string actualRewrite = state.GetRewriter(component).GetText(); - Assert.AreEqual(expectedCode, actualRewrite); - } + protected override IQuickFix QuickFix(RubberduckParserState state) + { + return new RemoveEmptyElseBlockQuickFix(); } } } diff --git a/RubberduckTests/QuickFixes/RemoveEmptyIfBlockQuickFixTests.cs b/RubberduckTests/QuickFixes/RemoveEmptyIfBlockQuickFixTests.cs index d45ba2750f..dce1c00c4f 100644 --- a/RubberduckTests/QuickFixes/RemoveEmptyIfBlockQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/RemoveEmptyIfBlockQuickFixTests.cs @@ -1,15 +1,13 @@ -using System.Linq; -using System.Threading; -using NUnit.Framework; +using NUnit.Framework; using Rubberduck.Inspections.Concrete; using Rubberduck.Inspections.QuickFixes; -using RubberduckTests.Mocks; -using RubberduckTests.Inspections; +using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.VBA; namespace RubberduckTests.QuickFixes { [TestFixture] - public class RemoveEmptyIfBlockQuickFixTests + public class RemoveEmptyIfBlockQuickFixTests : QuickFixTestBase { [Test] [Category("QuickFixes")] @@ -25,18 +23,8 @@ End If End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new EmptyIfBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RemoveEmptyIfBlockQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new EmptyIfBlockInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -59,18 +47,8 @@ End Sub Sub Bar() End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new EmptyIfBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RemoveEmptyIfBlockQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new EmptyIfBlockInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -88,18 +66,8 @@ End If End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new EmptyIfBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RemoveEmptyIfBlockQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new EmptyIfBlockInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -128,18 +96,8 @@ Dim b End If End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new EmptyIfBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RemoveEmptyIfBlockQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new EmptyIfBlockInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -168,18 +126,8 @@ Dim b End If End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new EmptyIfBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RemoveEmptyIfBlockQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new EmptyIfBlockInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -209,18 +157,8 @@ Dim b End If End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new EmptyIfBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RemoveEmptyIfBlockQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new EmptyIfBlockInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -246,18 +184,8 @@ Dim b End If End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new EmptyIfBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RemoveEmptyIfBlockQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new EmptyIfBlockInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -285,18 +213,8 @@ Dim b End If End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new EmptyIfBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RemoveEmptyIfBlockQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new EmptyIfBlockInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -327,19 +245,8 @@ Dim b End If End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new EmptyIfBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RemoveEmptyIfBlockQuickFix(state).Fix(inspectionResults.First()); - - var rewrittenCode = state.GetRewriter(component).GetText(); - Assert.AreEqual(expectedCode, rewrittenCode); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new EmptyIfBlockInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -365,19 +272,8 @@ Dim b End If End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new EmptyIfBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RemoveEmptyIfBlockQuickFix(state).Fix(inspectionResults.First()); - - var rewrittenCode = state.GetRewriter(component).GetText(); - Assert.AreEqual(expectedCode, rewrittenCode); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new EmptyIfBlockInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -402,18 +298,8 @@ Dim d End If End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new EmptyIfBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RemoveEmptyIfBlockQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new EmptyIfBlockInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -438,18 +324,8 @@ Dim b End If End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new EmptyIfBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RemoveEmptyIfBlockQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new EmptyIfBlockInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -472,18 +348,8 @@ Dim d End If End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new EmptyIfBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RemoveEmptyIfBlockQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new EmptyIfBlockInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -503,18 +369,8 @@ If Not True Then End If End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new EmptyIfBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RemoveEmptyIfBlockQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new EmptyIfBlockInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -534,18 +390,8 @@ If True <> True Then End If End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new EmptyIfBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RemoveEmptyIfBlockQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new EmptyIfBlockInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -565,18 +411,8 @@ End If End If End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new EmptyIfBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RemoveEmptyIfBlockQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new EmptyIfBlockInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -596,18 +432,8 @@ End If End If End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new EmptyIfBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RemoveEmptyIfBlockQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new EmptyIfBlockInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -627,18 +453,8 @@ If True > True Then End If End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new EmptyIfBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RemoveEmptyIfBlockQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new EmptyIfBlockInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -658,18 +474,8 @@ End If End If End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new EmptyIfBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RemoveEmptyIfBlockQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new EmptyIfBlockInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -689,18 +495,8 @@ If True < True Then End If End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new EmptyIfBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RemoveEmptyIfBlockQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new EmptyIfBlockInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -720,18 +516,8 @@ If True Then End If End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new EmptyIfBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RemoveEmptyIfBlockQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new EmptyIfBlockInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -751,18 +537,8 @@ End If End If End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new EmptyIfBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RemoveEmptyIfBlockQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new EmptyIfBlockInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -782,18 +558,8 @@ If True Or True Then End If End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new EmptyIfBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RemoveEmptyIfBlockQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new EmptyIfBlockInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -813,18 +579,8 @@ If True And True Then End If End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new EmptyIfBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RemoveEmptyIfBlockQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new EmptyIfBlockInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -844,18 +600,8 @@ If Not (True Xor True) Then End If End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new EmptyIfBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RemoveEmptyIfBlockQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new EmptyIfBlockInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -875,18 +621,8 @@ If True Or True And True And True Then End If End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new EmptyIfBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RemoveEmptyIfBlockQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new EmptyIfBlockInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -906,18 +642,8 @@ If True And True And True And True Then End If End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new EmptyIfBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RemoveEmptyIfBlockQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new EmptyIfBlockInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -937,18 +663,8 @@ End If End If End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new EmptyIfBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RemoveEmptyIfBlockQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new EmptyIfBlockInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -968,18 +684,14 @@ End If End If End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new EmptyIfBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new EmptyIfBlockInspection(state)); + Assert.AreEqual(expectedCode, actualCode); + } - new RemoveEmptyIfBlockQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + protected override IQuickFix QuickFix(RubberduckParserState state) + { + return new RemoveEmptyIfBlockQuickFix(); } } } diff --git a/RubberduckTests/QuickFixes/RemoveExplicitByRefModifierQuickFixTests.cs b/RubberduckTests/QuickFixes/RemoveExplicitByRefModifierQuickFixTests.cs index 31befc14ce..d14c9df093 100644 --- a/RubberduckTests/QuickFixes/RemoveExplicitByRefModifierQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/RemoveExplicitByRefModifierQuickFixTests.cs @@ -1,18 +1,15 @@ -using System.Linq; -using System.Threading; +using System; using NUnit.Framework; using Rubberduck.Inspections.Concrete; using Rubberduck.Inspections.QuickFixes; using Rubberduck.Parsing.Grammar; -using Rubberduck.VBEditor.SafeComWrappers; -using RubberduckTests.Mocks; -using RubberduckTests.Inspections; -using Rubberduck.Parsing.Inspections; +using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.VBA; namespace RubberduckTests.QuickFixes { [TestFixture] - public class RemoveExplicitByRefModifierQuickFixTests + public class RemoveExplicitByRefModifierQuickFixTests : QuickFixTestBase { [Test] @@ -27,18 +24,8 @@ public void RedundantByRefModifier_QuickFixWorks_OptionalParameter() @"Sub Foo(Optional arg1 As Integer) End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new RedundantByRefModifierInspection(state) { Severity = CodeInspectionSeverity.Hint }; - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RemoveExplicitByRefModifierQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new RedundantByRefModifierInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -59,18 +46,8 @@ bar _ bar = 1 End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new RedundantByRefModifierInspection(state) { Severity = CodeInspectionSeverity.Hint }; - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RemoveExplicitByRefModifierQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new RedundantByRefModifierInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -89,18 +66,8 @@ public void RedundantByRefModifier_QuickFixWorks_LineContinuation() bar = 1 End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new RedundantByRefModifierInspection(state) { Severity = CodeInspectionSeverity.Hint }; - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RemoveExplicitByRefModifierQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new RedundantByRefModifierInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -121,172 +88,107 @@ bar _ bar = 1 End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new RedundantByRefModifierInspection(state) { Severity = CodeInspectionSeverity.Hint }; - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RemoveExplicitByRefModifierQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new RedundantByRefModifierInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] [Category("QuickFixes")] public void RedundantByRefModifier_QuickFixWorks_InterfaceImplementation() { - const string inputCode1 = + const string interfaceInputCode = @"Sub Foo(ByRef arg1 As Integer) End Sub"; - const string inputCode2 = + const string implementationInputCode = @"Implements IClass1 Sub IClass1_Foo(ByRef arg1 As Integer) End Sub"; - const string expectedCode1 = + const string expectedInterfaceCode = @"Sub Foo(arg1 As Integer) End Sub"; - const string expectedCode2 = + const string expectedImplementationCode = @"Implements IClass1 Sub IClass1_Foo(arg1 As Integer) End Sub"; - var builder = new MockVbeBuilder(); - var vbe = builder.ProjectBuilder("TestProject1", ProjectProtection.Unprotected) - .AddComponent("IClass1", ComponentType.ClassModule, inputCode1) - .AddComponent("Class1", ComponentType.ClassModule, inputCode2) - .AddProjectToVbeBuilder() - .Build(); - - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new RedundantByRefModifierInspection(state) { Severity = CodeInspectionSeverity.Hint }; - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RemoveExplicitByRefModifierQuickFix(state).Fix(inspectionResults.First()); - - var project = vbe.Object.VBProjects[0]; - var interfaceComponent = project.VBComponents[0]; - var implementationComponent = project.VBComponents[1]; - - Assert.AreEqual(expectedCode1, state.GetRewriter(interfaceComponent).GetText(), "Wrong code in interface"); - Assert.AreEqual(expectedCode2, state.GetRewriter(implementationComponent).GetText(), "Wrong code in implementation"); - } + var (actualInterfaceCode, actualImplementationCode) = + ApplyQuickFixToFirstInspectionResultForImplementedInterface(interfaceInputCode, implementationInputCode, + state => new RedundantByRefModifierInspection(state)); + Assert.AreEqual(expectedInterfaceCode, actualInterfaceCode, "Wrong code in interface"); + Assert.AreEqual(expectedImplementationCode, actualImplementationCode, "Wrong code in implementation"); } [Test] [Category("QuickFixes")] public void RedundantByRefModifier_QuickFixWorks_InterfaceImplementationDiffrentParameterName() { - const string inputCode1 = + const string interfaceInputCode = @"Sub Foo(ByRef arg1 As Integer) End Sub"; - const string inputCode2 = + const string implementationInputCode = @"Implements IClass1 Sub IClass1_Foo(ByRef arg2 As Integer) End Sub"; - const string expectedCode1 = + const string expectedInterfaceCode = @"Sub Foo(arg1 As Integer) End Sub"; - const string expectedCode2 = + const string expectedImplementationCode = @"Implements IClass1 Sub IClass1_Foo(arg2 As Integer) End Sub"; - var builder = new MockVbeBuilder(); - var vbe = builder.ProjectBuilder("TestProject1", ProjectProtection.Unprotected) - .AddComponent("IClass1", ComponentType.ClassModule, inputCode1) - .AddComponent("Class1", ComponentType.ClassModule, inputCode2) - .AddProjectToVbeBuilder() - .Build(); - - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new RedundantByRefModifierInspection(state) { Severity = CodeInspectionSeverity.Hint }; - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RemoveExplicitByRefModifierQuickFix(state).Fix(inspectionResults.First()); - - var project = vbe.Object.VBProjects[0]; - var interfaceComponent = project.VBComponents[0]; - var implementationComponent = project.VBComponents[1]; - - Assert.AreEqual(expectedCode1, state.GetRewriter(interfaceComponent).GetText(), "Wrong code in interface"); - Assert.AreEqual(expectedCode2, state.GetRewriter(implementationComponent).GetText(), "Wrong code in implementation"); - } + var (actualInterfaceCode, actualImplementationCode) = + ApplyQuickFixToFirstInspectionResultForImplementedInterface(interfaceInputCode, implementationInputCode, + state => new RedundantByRefModifierInspection(state)); + Assert.AreEqual(expectedInterfaceCode, actualInterfaceCode, "Wrong code in interface"); + Assert.AreEqual(expectedImplementationCode, actualImplementationCode, "Wrong code in implementation"); } [Test] [Category("QuickFixes")] public void RedundantByRefModifier_QuickFixWorks_InterfaceImplementationWithMultipleParameters() { - const string inputCode1 = + const string interfaceInputCode = @"Sub Foo(ByRef arg1 As Integer, ByRef arg2 as Integer) End Sub"; - const string inputCode2 = + const string implementationInputCode = @"Implements IClass1 Sub IClass1_Foo(ByRef arg1 As Integer, ByRef arg2 as Integer) End Sub"; - const string expectedCode1 = + const string expectedInterfaceCode = @"Sub Foo(arg1 As Integer, ByRef arg2 as Integer) End Sub"; - const string expectedCode2 = + const string expectedImplementationCode = @"Implements IClass1 Sub IClass1_Foo(arg1 As Integer, ByRef arg2 as Integer) End Sub"; - var builder = new MockVbeBuilder(); - var vbe = builder.ProjectBuilder("TestProject1", ProjectProtection.Unprotected) - .AddComponent("IClass1", ComponentType.ClassModule, inputCode1) - .AddComponent("Class1", ComponentType.ClassModule, inputCode2) - .AddProjectToVbeBuilder() - .Build(); - - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new RedundantByRefModifierInspection(state) { Severity = CodeInspectionSeverity.Hint }; - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RemoveExplicitByRefModifierQuickFix(state).Fix( - inspectionResults.First( - result => - ((VBAParser.ArgContext)result.Context).unrestrictedIdentifier() - .identifier() - .untypedIdentifier() - .identifierValue() - .GetText() == "arg1")); - - var project = vbe.Object.VBProjects[0]; - var interfaceComponent = project.VBComponents[0]; - var implementationComponent = project.VBComponents[1]; - - Assert.AreEqual(expectedCode1, state.GetRewriter(interfaceComponent).GetText(), "Wrong code in interface"); - Assert.AreEqual(expectedCode2, state.GetRewriter(implementationComponent).GetText(), "Wrong code in implementation"); - } + Func conditionOnResultToFix = result => + ((VBAParser.ArgContext)result.Context).unrestrictedIdentifier() + .identifier() + .untypedIdentifier() + .identifierValue() + .GetText() == "arg1"; + var (actualInterfaceCode, actualImplementationCode) = + ApplyQuickFixToFirstInspectionResultForImplementedInterfaceSatisfyingPredicate(interfaceInputCode, implementationInputCode, + state => new RedundantByRefModifierInspection(state), conditionOnResultToFix); + Assert.AreEqual(expectedInterfaceCode, actualInterfaceCode, "Wrong code in interface"); + Assert.AreEqual(expectedImplementationCode, actualImplementationCode, "Wrong code in implementation"); } [Test] @@ -301,19 +203,14 @@ public void RedundantByRefModifier_QuickFixWorks_PassByRef() @"Sub Foo(arg1 As Integer) End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new RedundantByRefModifierInspection(state) { Severity = CodeInspectionSeverity.Hint }; - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new RedundantByRefModifierInspection(state)); + Assert.AreEqual(expectedCode, actualCode); + } - new RemoveExplicitByRefModifierQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + protected override IQuickFix QuickFix(RubberduckParserState state) + { + return new RemoveExplicitByRefModifierQuickFix(state); } - } } diff --git a/RubberduckTests/QuickFixes/RemoveExplicitCallStatementQuickFixTests.cs b/RubberduckTests/QuickFixes/RemoveExplicitCallStatementQuickFixTests.cs index fdd4209b2a..b50d2ba040 100644 --- a/RubberduckTests/QuickFixes/RemoveExplicitCallStatementQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/RemoveExplicitCallStatementQuickFixTests.cs @@ -1,14 +1,13 @@ using NUnit.Framework; -using RubberduckTests.Mocks; -using System.Threading; using Rubberduck.Inspections.Concrete; using Rubberduck.Inspections.QuickFixes; -using RubberduckTests.Inspections; +using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.VBA; namespace RubberduckTests.QuickFixes { [TestFixture] - public class RemoveExplicitCallStatementQuickFixTests + public class RemoveExplicitCallStatementQuickFixTests : QuickFixTestBase { [Test] @@ -33,22 +32,14 @@ Sub Goo(arg1 As Integer, arg1 As String) Foo End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - var inspection = new ObsoleteCallStatementInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - var fix = new RemoveExplicitCallStatementQuickFix(state); - foreach (var result in inspectionResults) - { - fix.Fix(result); - } - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToAllInspectionResults(inputCode, state => new ObsoleteCallStatementInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } + + protected override IQuickFix QuickFix(RubberduckParserState state) + { + return new RemoveExplicitCallStatementQuickFix(); + } } } diff --git a/RubberduckTests/QuickFixes/RemoveExplicitLetStatementQuickFixTests.cs b/RubberduckTests/QuickFixes/RemoveExplicitLetStatementQuickFixTests.cs index 982045b730..c90fe12f6e 100644 --- a/RubberduckTests/QuickFixes/RemoveExplicitLetStatementQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/RemoveExplicitLetStatementQuickFixTests.cs @@ -1,15 +1,13 @@ -using System.Linq; -using NUnit.Framework; -using RubberduckTests.Mocks; -using System.Threading; +using NUnit.Framework; using Rubberduck.Inspections.Concrete; using Rubberduck.Inspections.QuickFixes; -using RubberduckTests.Inspections; +using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.VBA; namespace RubberduckTests.QuickFixes { [TestFixture] - public class RemoveExplicitLetStatementQuickFixTests + public class RemoveExplicitLetStatementQuickFixTests : QuickFixTestBase { [Test] @@ -32,17 +30,14 @@ Dim var2 As Integer var2 = var1 End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - var inspection = new ObsoleteLetStatementInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RemoveExplicitLetStatementQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new ObsoleteLetStatementInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } + + protected override IQuickFix QuickFix(RubberduckParserState state) + { + return new RemoveExplicitLetStatementQuickFix(); + } } } diff --git a/RubberduckTests/QuickFixes/RemoveLocalErrorQuickFixTests.cs b/RubberduckTests/QuickFixes/RemoveLocalErrorQuickFixTests.cs index e76341f226..d5529316df 100644 --- a/RubberduckTests/QuickFixes/RemoveLocalErrorQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/RemoveLocalErrorQuickFixTests.cs @@ -1,15 +1,13 @@ -using System.Linq; -using NUnit.Framework; -using RubberduckTests.Mocks; -using System.Threading; +using NUnit.Framework; using Rubberduck.Inspections.Concrete; using Rubberduck.Inspections.QuickFixes; -using RubberduckTests.Inspections; +using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.VBA; namespace RubberduckTests.QuickFixes { [TestFixture] - public class RemoveLocalErrorQuickFixTests + public class RemoveLocalErrorQuickFixTests : QuickFixTestBase { [TestCase("On Local Error GoTo 0")] [TestCase("On Local Error GoTo 1")] @@ -26,16 +24,14 @@ public void OptionBaseZeroStatement_QuickFixWorks_RemoveStatement(string stmt) {stmt.Replace("Local ", "")} End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - var inspection = new OnLocalErrorInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new OnLocalErrorInspection(state)); + Assert.AreEqual(expectedCode, actualCode); + } + - new RemoveLocalErrorQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + protected override IQuickFix QuickFix(RubberduckParserState state) + { + return new RemoveLocalErrorQuickFix(); } } } diff --git a/RubberduckTests/QuickFixes/RemoveOptionBaseStatementQuickFixTests.cs b/RubberduckTests/QuickFixes/RemoveOptionBaseStatementQuickFixTests.cs index dd924378fa..7e0082f69e 100644 --- a/RubberduckTests/QuickFixes/RemoveOptionBaseStatementQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/RemoveOptionBaseStatementQuickFixTests.cs @@ -1,104 +1,69 @@ -using System.Linq; -using NUnit.Framework; -using RubberduckTests.Mocks; -using System.Threading; +using NUnit.Framework; using Rubberduck.Inspections.Concrete; using Rubberduck.Inspections.QuickFixes; -using RubberduckTests.Inspections; +using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.VBA; namespace RubberduckTests.QuickFixes { [TestFixture] - public class RemoveOptionBaseStatementQuickFixTests + public class RemoveOptionBaseStatementQuickFixTests : QuickFixTestBase { [Test] [Category("QuickFixes")] public void OptionBaseZeroStatement_QuickFixWorks_RemoveStatement() { - var inputCode = "Option Base 0"; - var expectedCode = string.Empty; + const string inputCode = "Option Base 0"; + const string expectedCode = ""; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new RedundantOptionInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RemoveOptionBaseStatementQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new RedundantOptionInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] [Category("QuickFixes")] public void OptionBaseZeroStatement_QuickFixWorks_RemoveStatement_MultipleLines() { - var inputCode = - @"Option _ + const string inputCode = @"Option _ Base _ 0"; - var expectedCode = string.Empty; - - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { + const string expectedCode = ""; - var inspection = new RedundantOptionInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RemoveOptionBaseStatementQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new RedundantOptionInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] [Category("QuickFixes")] public void OptionBaseZeroStatement_QuickFixWorks_RemoveStatement_InstructionSeparator() { - var inputCode = "Option Explicit: Option Base 0: Option Base 1"; - - var expectedCode = "Option Explicit: : Option Base 1"; + const string inputCode = "Option Explicit: Option Base 0: Option Base 1"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { + const string expectedCode = "Option Explicit: : Option Base 1"; - var inspection = new RedundantOptionInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RemoveOptionBaseStatementQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new RedundantOptionInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] [Category("QuickFixes")] public void OptionBaseZeroStatement_QuickFixWorks_RemoveStatement_InstructionSeparatorAndMultipleLines() { - var inputCode = - @"Option Explicit: Option _ + const string inputCode = @"Option Explicit: Option _ Base _ 0: Option Base 1"; - var expectedCode = "Option Explicit: : Option Base 1"; + const string expectedCode = "Option Explicit: : Option Base 1"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new RedundantOptionInspection(state)); + Assert.AreEqual(expectedCode, actualCode); + } - var inspection = new RedundantOptionInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - new RemoveOptionBaseStatementQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + protected override IQuickFix QuickFix(RubberduckParserState state) + { + return new RemoveOptionBaseStatementQuickFix(); } - } } diff --git a/RubberduckTests/QuickFixes/RemoveStepOneQuickFixTests.cs b/RubberduckTests/QuickFixes/RemoveStepOneQuickFixTests.cs index b7a1d55c2a..b91c78038c 100644 --- a/RubberduckTests/QuickFixes/RemoveStepOneQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/RemoveStepOneQuickFixTests.cs @@ -1,16 +1,13 @@ using NUnit.Framework; using Rubberduck.Inspections.Concrete; using Rubberduck.Inspections.QuickFixes; -using Rubberduck.Parsing.Inspections; -using RubberduckTests.Inspections; -using RubberduckTests.Mocks; -using System.Linq; -using System.Threading; +using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.VBA; namespace RubberduckTests.QuickFixes { [TestFixture] - public class RemoveStepOneQuickFixTests + public class RemoveStepOneQuickFixTests : QuickFixTestBase { [Test] [Category("QuickFixes")] @@ -28,7 +25,8 @@ public void StepOne_QuickFixWorks_Remove() Next End Sub"; - TestStepOneQuickFix(expectedCode, inputCode); + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new StepOneIsRedundantInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -51,20 +49,14 @@ public void StepOne_QuickFixWorks_NestedLoops() Next End Sub"; - TestStepOneQuickFix(expectedCode, inputCode); + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new StepOneIsRedundantInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } - private void TestStepOneQuickFix(string expectedCode, string inputCode) - { - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - var state = MockParser.CreateAndParse(vbe.Object); - - var inspection = new StepOneIsRedundantInspection(state) { Severity = CodeInspectionSeverity.Warning }; - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - new RemoveStepOneQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); + protected override IQuickFix QuickFix(RubberduckParserState state) + { + return new RemoveStepOneQuickFix(); } } } diff --git a/RubberduckTests/QuickFixes/RemoveStopKeywordQuickFixTests.cs b/RubberduckTests/QuickFixes/RemoveStopKeywordQuickFixTests.cs index f230f6b4b4..6b6a14b434 100644 --- a/RubberduckTests/QuickFixes/RemoveStopKeywordQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/RemoveStopKeywordQuickFixTests.cs @@ -1,15 +1,13 @@ -using System.Linq; -using NUnit.Framework; -using RubberduckTests.Mocks; -using System.Threading; +using NUnit.Framework; using Rubberduck.Inspections.Concrete; using Rubberduck.Inspections.QuickFixes; -using RubberduckTests.Inspections; +using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.VBA; namespace RubberduckTests.QuickFixes { [TestFixture] - public class RemoveStopKeywordQuickFixTests + public class RemoveStopKeywordQuickFixTests : QuickFixTestBase { [Test] @@ -26,17 +24,8 @@ public void StopKeyword_QuickFixWorks_RemoveKeyword() End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new StopKeywordInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RemoveStopKeywordQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new StopKeywordInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -47,18 +36,13 @@ public void StopKeyword_QuickFixWorks_RemoveKeyword_InstructionSeparator() var expectedCode = "Sub Foo(): : End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new StopKeywordInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RemoveStopKeywordQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new StopKeywordInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } + protected override IQuickFix QuickFix(RubberduckParserState state) + { + return new RemoveStopKeywordQuickFix(); + } } } diff --git a/RubberduckTests/QuickFixes/RemoveTypeHintsQuickFixTests.cs b/RubberduckTests/QuickFixes/RemoveTypeHintsQuickFixTests.cs index 1f6e30fe10..ba47d4dce1 100644 --- a/RubberduckTests/QuickFixes/RemoveTypeHintsQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/RemoveTypeHintsQuickFixTests.cs @@ -1,14 +1,15 @@ -using System.Threading; -using NUnit.Framework; +using NUnit.Framework; using Rubberduck.Inspections.Concrete; using Rubberduck.Inspections.QuickFixes; +using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.VBA; using RubberduckTests.Mocks; namespace RubberduckTests.QuickFixes { [TestFixture] - public class RemoveTypeHintsQuickFixTests + public class RemoveTypeHintsQuickFixTests : QuickFixTestBase { [Test] @@ -21,21 +22,8 @@ public void ObsoleteTypeHint_QuickFixWorks_Field_LongTypeHint() const string expectedCode = @"Public Foo As Long"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ObsoleteTypeHintInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - var fix = new RemoveTypeHintsQuickFix(state); - foreach (var result in inspectionResults) - { - fix.Fix(result); - } - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToAllInspectionResults(inputCode, state => new ObsoleteTypeHintInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -48,21 +36,8 @@ public void ObsoleteTypeHint_QuickFixWorks_Field_IntegerTypeHint() const string expectedCode = @"Public Foo As Integer"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ObsoleteTypeHintInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - var fix = new RemoveTypeHintsQuickFix(state); - foreach (var result in inspectionResults) - { - fix.Fix(result); - } - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToAllInspectionResults(inputCode, state => new ObsoleteTypeHintInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -75,21 +50,8 @@ public void ObsoleteTypeHint_QuickFixWorks_Field_DoubleTypeHint() const string expectedCode = @"Public Foo As Double"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ObsoleteTypeHintInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - var fix = new RemoveTypeHintsQuickFix(state); - foreach (var result in inspectionResults) - { - fix.Fix(result); - } - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToAllInspectionResults(inputCode, state => new ObsoleteTypeHintInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -102,21 +64,8 @@ public void ObsoleteTypeHint_QuickFixWorks_Field_SingleTypeHint() const string expectedCode = @"Public Foo As Single"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ObsoleteTypeHintInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - var fix = new RemoveTypeHintsQuickFix(state); - foreach (var result in inspectionResults) - { - fix.Fix(result); - } - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToAllInspectionResults(inputCode, state => new ObsoleteTypeHintInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -129,21 +78,8 @@ public void ObsoleteTypeHint_QuickFixWorks_Field_DecimalTypeHint() const string expectedCode = @"Public Foo As Currency"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ObsoleteTypeHintInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - var fix = new RemoveTypeHintsQuickFix(state); - foreach (var result in inspectionResults) - { - fix.Fix(result); - } - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToAllInspectionResults(inputCode, state => new ObsoleteTypeHintInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -156,21 +92,8 @@ public void ObsoleteTypeHint_QuickFixWorks_Field_StringTypeHint() const string expectedCode = @"Public Foo As String"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ObsoleteTypeHintInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - var fix = new RemoveTypeHintsQuickFix(state); - foreach (var result in inspectionResults) - { - fix.Fix(result); - } - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToAllInspectionResults(inputCode, state => new ObsoleteTypeHintInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -187,21 +110,8 @@ public void ObsoleteTypeHint_QuickFixWorks_Function_StringTypeHint() Foo = ""test"" End Function"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ObsoleteTypeHintInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - var fix = new RemoveTypeHintsQuickFix(state); - foreach (var result in inspectionResults) - { - fix.Fix(result); - } - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToAllInspectionResults(inputCode, state => new ObsoleteTypeHintInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -218,21 +128,8 @@ public void ObsoleteTypeHint_QuickFixWorks_PropertyGet_StringTypeHint() Foo = ""test"" End Property"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ObsoleteTypeHintInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - var fix = new RemoveTypeHintsQuickFix(state); - foreach (var result in inspectionResults) - { - fix.Fix(result); - } - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToAllInspectionResults(inputCode, state => new ObsoleteTypeHintInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -249,21 +146,8 @@ public void ObsoleteTypeHint_QuickFixWorks_Parameter_StringTypeHint() Foo = ""test"" End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ObsoleteTypeHintInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - var fix = new RemoveTypeHintsQuickFix(state); - foreach (var result in inspectionResults) - { - fix.Fix(result); - } - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToAllInspectionResults(inputCode, state => new ObsoleteTypeHintInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -280,21 +164,8 @@ Dim buzz$ Dim buzz As String End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ObsoleteTypeHintInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - var fix = new RemoveTypeHintsQuickFix(state); - foreach (var result in inspectionResults) - { - fix.Fix(result); - } - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToAllInspectionResults(inputCode, state => new ObsoleteTypeHintInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -311,22 +182,14 @@ public void ObsoleteTypeHint_QuickFixWorks_Constant_StringTypeHint() Const buzz As String = """" End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ObsoleteTypeHintInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); + var actualCode = ApplyQuickFixToAllInspectionResults(inputCode, state => new ObsoleteTypeHintInspection(state)); + Assert.AreEqual(expectedCode, actualCode); + } - var fix = new RemoveTypeHintsQuickFix(state); - foreach (var result in inspectionResults) - { - fix.Fix(result); - } - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + protected override IQuickFix QuickFix(RubberduckParserState state) + { + return new RemoveTypeHintsQuickFix(); } - } } diff --git a/RubberduckTests/QuickFixes/RemoveUnassignedIdentifierQuickFixTests.cs b/RubberduckTests/QuickFixes/RemoveUnassignedIdentifierQuickFixTests.cs index c5e18d5f81..824745fec6 100644 --- a/RubberduckTests/QuickFixes/RemoveUnassignedIdentifierQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/RemoveUnassignedIdentifierQuickFixTests.cs @@ -1,14 +1,14 @@ -using System.Linq; -using System.Threading; +using System; using NUnit.Framework; using Rubberduck.Inspections.Concrete; using Rubberduck.Inspections.QuickFixes; -using RubberduckTests.Mocks; +using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.VBA; namespace RubberduckTests.QuickFixes { [TestFixture] - public class RemoveUnassignedIdentifierQuickFixTests + public class RemoveUnassignedIdentifierQuickFixTests : QuickFixTestBase { [Test] [Category("QuickFixes")] @@ -23,15 +23,8 @@ Dim var1 as Integer @"Sub Foo() End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new VariableNotAssignedInspection(state); - new RemoveUnassignedIdentifierQuickFix(state).Fix(inspection.GetInspectionResults(CancellationToken.None).First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new VariableNotAssignedInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -50,15 +43,8 @@ as _ @"Sub Foo() End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new VariableNotAssignedInspection(state); - new RemoveUnassignedIdentifierQuickFix(state).Fix(inspection.GetInspectionResults(CancellationToken.None).First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new VariableNotAssignedInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -75,16 +61,8 @@ public void UnassignedVariable_MultipleVariablesOnSingleLine_QuickFixWorks() Dim var1 As Integer End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new VariableNotAssignedInspection(state); - new RemoveUnassignedIdentifierQuickFix(state).Fix( - inspection.GetInspectionResults(CancellationToken.None).Single(s => s.Target.IdentifierName == "var2")); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new VariableNotAssignedInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -102,16 +80,15 @@ var2 As Boolean Dim var1 As Integer End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { + Func conditionToFix = result => result.Target.IdentifierName == "var2"; + var actualCode = ApplyQuickFixToFirstInspectionResultSatisfyingPredicate(inputCode, state => new VariableNotAssignedInspection(state), conditionToFix); + Assert.AreEqual(expectedCode, actualCode); + } - var inspection = new VariableNotAssignedInspection(state); - new RemoveUnassignedIdentifierQuickFix(state).Fix( - inspection.GetInspectionResults(CancellationToken.None).Single(s => s.Target.IdentifierName == "var2")); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + protected override IQuickFix QuickFix(RubberduckParserState state) + { + return new RemoveUnassignedIdentifierQuickFix(); } } } diff --git a/RubberduckTests/QuickFixes/RemoveUnassignedVariableUsageQuickFixTests.cs b/RubberduckTests/QuickFixes/RemoveUnassignedVariableUsageQuickFixTests.cs index 63c15f433a..f0b90d7d6c 100644 --- a/RubberduckTests/QuickFixes/RemoveUnassignedVariableUsageQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/RemoveUnassignedVariableUsageQuickFixTests.cs @@ -1,14 +1,13 @@ -using System.Linq; -using System.Threading; -using NUnit.Framework; +using NUnit.Framework; using Rubberduck.Inspections.Concrete; using Rubberduck.Inspections.QuickFixes; -using RubberduckTests.Mocks; +using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.VBA; namespace RubberduckTests.QuickFixes { [TestFixture] - public class RemoveUnassignedVariableUsageQuickFixTests + public class RemoveUnassignedVariableUsageQuickFixTests : QuickFixTestBase { [Test] @@ -29,15 +28,14 @@ Dim bb As Boolean End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - var inspection = new UnassignedVariableUsageInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new UnassignedVariableUsageInspection(state)); + Assert.AreEqual(expectedCode, actualCode); + } + - new RemoveUnassignedVariableUsageQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + protected override IQuickFix QuickFix(RubberduckParserState state) + { + return new RemoveUnassignedVariableUsageQuickFix(); } } } diff --git a/RubberduckTests/QuickFixes/RemoveUnusedDeclarationQuickFixTests.cs b/RubberduckTests/QuickFixes/RemoveUnusedDeclarationQuickFixTests.cs index 1b9915ec24..5638bee38d 100644 --- a/RubberduckTests/QuickFixes/RemoveUnusedDeclarationQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/RemoveUnusedDeclarationQuickFixTests.cs @@ -1,14 +1,13 @@ -using System.Linq; -using System.Threading; -using NUnit.Framework; +using NUnit.Framework; using Rubberduck.Inspections.Concrete; using Rubberduck.Inspections.QuickFixes; -using RubberduckTests.Mocks; +using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.VBA; namespace RubberduckTests.QuickFixes { [TestFixture] - public class RemoveUnusedDeclarationQuickFixTests + public class RemoveUnusedDeclarationQuickFixTests : QuickFixTestBase { [Test] [Category("QuickFixes")] @@ -23,19 +22,8 @@ public void ConstantNotUsed_QuickFixWorks() @"Public Sub Foo() End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ConstantNotUsedInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new RemoveUnusedDeclarationQuickFix(state).Fix(inspectionResults.First()); - - var rewriter = state.GetRewriter(component); - var rewrittenCode = rewriter.GetText(); - Assert.AreEqual(expectedCode, rewrittenCode); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new ConstantNotUsedInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } @@ -53,16 +41,8 @@ public void LabelNotUsed_QuickFixWorks() End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new LineLabelNotUsedInspection(state); - new RemoveUnusedDeclarationQuickFix(state).Fix(inspection.GetInspectionResults(CancellationToken.None).First()); - - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new LineLabelNotUsedInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -85,16 +65,8 @@ dim var1 as variant goto label1: End Sub"; ; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new LineLabelNotUsedInspection(state); - new RemoveUnusedDeclarationQuickFix(state).Fix(inspection.GetInspectionResults(CancellationToken.None).First()); - - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new LineLabelNotUsedInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -107,18 +79,8 @@ public void ProcedureNotUsed_QuickFixWorks() const string expectedCode = @""; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ProcedureNotUsedInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new RemoveUnusedDeclarationQuickFix(state).Fix(inspectionResults.First()); - - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new ProcedureNotUsedInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -134,16 +96,8 @@ Dim var1 As String @"Sub Foo() End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new VariableNotUsedInspection(state); - new RemoveUnusedDeclarationQuickFix(state).Fix(inspection.GetInspectionResults(CancellationToken.None).First()); - - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new VariableNotUsedInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } @@ -162,16 +116,8 @@ Dim var1 As String End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new VariableNotUsedInspection(state); - new RemoveUnusedDeclarationQuickFix(state).Fix(inspection.GetInspectionResults(CancellationToken.None).First()); - - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new VariableNotUsedInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -188,16 +134,8 @@ Dim var1 As String ' Comment ' Comment End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new VariableNotUsedInspection(state); - new RemoveUnusedDeclarationQuickFix(state).Fix(inspection.GetInspectionResults(CancellationToken.None).First()); - - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new VariableNotUsedInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -220,16 +158,8 @@ Dim var2 As String Foo = var2 End Function"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new VariableNotUsedInspection(state); - new RemoveUnusedDeclarationQuickFix(state).Fix(inspection.GetInspectionResults(CancellationToken.None).First()); - - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new VariableNotUsedInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } @@ -249,16 +179,8 @@ Dim var1 As String ' Comment End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new VariableNotUsedInspection(state); - new RemoveUnusedDeclarationQuickFix(state).Fix(inspection.GetInspectionResults(CancellationToken.None).First()); - - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new VariableNotUsedInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -281,16 +203,8 @@ Dim var2 As String Foo = var2 End Function"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new VariableNotUsedInspection(state); - new RemoveUnusedDeclarationQuickFix(state).Fix(inspection.GetInspectionResults(CancellationToken.None).First()); - - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new VariableNotUsedInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -313,17 +227,14 @@ Dim var2 As String Foo = var2 End Function"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new VariableNotUsedInspection(state)); + Assert.AreEqual(expectedCode, actualCode); + } - var inspection = new VariableNotUsedInspection(state); - new RemoveUnusedDeclarationQuickFix(state).Fix(inspection.GetInspectionResults(CancellationToken.None).First()); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); - } + protected override IQuickFix QuickFix(RubberduckParserState state) + { + return new RemoveUnusedDeclarationQuickFix(); } - } } diff --git a/RubberduckTests/QuickFixes/RemoveUnusedParameterQuickFixTests.cs b/RubberduckTests/QuickFixes/RemoveUnusedParameterQuickFixTests.cs index 3f39c47ad9..3440580bbd 100644 --- a/RubberduckTests/QuickFixes/RemoveUnusedParameterQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/RemoveUnusedParameterQuickFixTests.cs @@ -4,7 +4,6 @@ using Moq; using Rubberduck.Inspections.Concrete; using Rubberduck.Inspections.QuickFixes; -using Rubberduck.UI; using RubberduckTests.Mocks; using Rubberduck.Interaction; @@ -28,13 +27,16 @@ Private Sub Foo() End Sub"; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using(var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var inspection = new ParameterNotUsedInspection(state); var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); + var rewriteSession = rewritingManager.CheckOutCodePaneSession(); new RemoveUnusedParameterQuickFix(vbe.Object, state, new Mock().Object).Fix( - inspectionResults.First()); + inspectionResults.First(), rewriteSession); + Assert.AreEqual(expectedCode, component.CodeModule.Content()); } } diff --git a/RubberduckTests/QuickFixes/ReplaceEmptyStringLiteralStatementQuickFixTests.cs b/RubberduckTests/QuickFixes/ReplaceEmptyStringLiteralStatementQuickFixTests.cs index 7b2f1595a4..05fb6f3c73 100644 --- a/RubberduckTests/QuickFixes/ReplaceEmptyStringLiteralStatementQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/ReplaceEmptyStringLiteralStatementQuickFixTests.cs @@ -1,15 +1,13 @@ -using System.Linq; -using NUnit.Framework; -using RubberduckTests.Mocks; -using System.Threading; +using NUnit.Framework; using Rubberduck.Inspections.Concrete; using Rubberduck.Inspections.QuickFixes; -using RubberduckTests.Inspections; +using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.VBA; namespace RubberduckTests.QuickFixes { [TestFixture] - public class ReplaceEmptyStringLiteralStatementQuickFixTests + public class ReplaceEmptyStringLiteralStatementQuickFixTests : QuickFixTestBase { [Test] [Category("Inspections")] @@ -25,18 +23,13 @@ public void EmptyStringLiteral_QuickFixWorks() arg1 = vbNullString End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - var inspection = new EmptyStringLiteralInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new ReplaceEmptyStringLiteralStatementQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new EmptyStringLiteralInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } + protected override IQuickFix QuickFix(RubberduckParserState state) + { + return new ReplaceEmptyStringLiteralStatementQuickFix(); + } } } diff --git a/RubberduckTests/QuickFixes/ReplaceGlobalModifierQuickFixTests.cs b/RubberduckTests/QuickFixes/ReplaceGlobalModifierQuickFixTests.cs index 3d7181b4a0..3918ff935e 100644 --- a/RubberduckTests/QuickFixes/ReplaceGlobalModifierQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/ReplaceGlobalModifierQuickFixTests.cs @@ -1,15 +1,14 @@ -using System.Linq; -using System.Threading; -using NUnit.Framework; +using NUnit.Framework; using Rubberduck.Inspections.Concrete; using Rubberduck.Inspections.QuickFixes; -using RubberduckTests.Mocks; +using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.VBA; namespace RubberduckTests.QuickFixes { [TestFixture] - public class ReplaceGlobalModifierQuickFixTests + public class ReplaceGlobalModifierQuickFixTests : QuickFixTestBase { [Test] [Category("QuickFixes")] @@ -21,16 +20,14 @@ public void ObsoleteGlobal_QuickFixWorks() const string expectedCode = @"Public var1 As Integer"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - var inspection = new ObsoleteGlobalInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new ReplaceGlobalModifierQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new ObsoleteGlobalInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } + + protected override IQuickFix QuickFix(RubberduckParserState state) + { + return new ReplaceGlobalModifierQuickFix(); + } } } diff --git a/RubberduckTests/QuickFixes/ReplaceIfElseWithConditionalStatementQuickFixTests.cs b/RubberduckTests/QuickFixes/ReplaceIfElseWithConditionalStatementQuickFixTests.cs index 5c4e7c8258..24e21709b4 100644 --- a/RubberduckTests/QuickFixes/ReplaceIfElseWithConditionalStatementQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/ReplaceIfElseWithConditionalStatementQuickFixTests.cs @@ -1,15 +1,13 @@ -using System.Linq; -using System.Threading; -using NUnit.Framework; +using NUnit.Framework; using Rubberduck.Inspections.Concrete; using Rubberduck.Inspections.QuickFixes; -using RubberduckTests.Mocks; -using RubberduckTests.Inspections; +using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.VBA; namespace RubberduckTests.QuickFixes { [TestFixture] - public class ReplaceIfElseWithConditionalStatementQuickFixTests + public class ReplaceIfElseWithConditionalStatementQuickFixTests : QuickFixTestBase { [Test] [Category("QuickFixes")] @@ -31,17 +29,8 @@ Dim d As Boolean d = True End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new BooleanAssignedInIfElseInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new ReplaceIfElseWithConditionalStatementQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new BooleanAssignedInIfElseInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -64,17 +53,8 @@ Dim d As Boolean d = True Or False And False Xor True End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new BooleanAssignedInIfElseInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new ReplaceIfElseWithConditionalStatementQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new BooleanAssignedInIfElseInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -97,17 +77,8 @@ Dim d As Boolean d = Not (True) End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new BooleanAssignedInIfElseInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new ReplaceIfElseWithConditionalStatementQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new BooleanAssignedInIfElseInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -128,17 +99,14 @@ If True Then Fizz.Buzz = True End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new BooleanAssignedInIfElseInspection(state)); + Assert.AreEqual(expectedCode, actualCode); + } - var inspection = new BooleanAssignedInIfElseInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - new ReplaceIfElseWithConditionalStatementQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + protected override IQuickFix QuickFix(RubberduckParserState state) + { + return new ReplaceIfElseWithConditionalStatementQuickFix(); } } } diff --git a/RubberduckTests/QuickFixes/ReplaceObsoleteCommentMarkerQuickFixTests.cs b/RubberduckTests/QuickFixes/ReplaceObsoleteCommentMarkerQuickFixTests.cs index 6aaa16560a..262fff29a1 100644 --- a/RubberduckTests/QuickFixes/ReplaceObsoleteCommentMarkerQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/ReplaceObsoleteCommentMarkerQuickFixTests.cs @@ -1,15 +1,13 @@ -using System.Linq; -using System.Threading; -using NUnit.Framework; +using NUnit.Framework; using Rubberduck.Inspections.Concrete; using Rubberduck.Inspections.QuickFixes; -using RubberduckTests.Mocks; -using RubberduckTests.Inspections; +using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.VBA; namespace RubberduckTests.QuickFixes { [TestFixture] - public class ReplaceObsoleteCommentMarkerQuickFixTests + public class ReplaceObsoleteCommentMarkerQuickFixTests : QuickFixTestBase { [Test] [Category("QuickFixes")] @@ -21,17 +19,8 @@ public void ObsoleteCommentSyntax_QuickFixWorks_UpdateComment() const string expectedCode = @"' test1"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ObsoleteCommentSyntaxInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new ReplaceObsoleteCommentMarkerQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new ObsoleteCommentSyntaxInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -46,17 +35,8 @@ public void ObsoleteCommentSyntax_QuickFixWorks_UpdateCommentHasContinuation() @"' this is _ a comment"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ObsoleteCommentSyntaxInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new ReplaceObsoleteCommentMarkerQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new ObsoleteCommentSyntaxInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } @@ -70,17 +50,8 @@ public void ObsoleteCommentSyntax_QuickFixWorks_UpdateComment_LineHasCode() const string expectedCode = @"Dim Foo As Integer: ' This is a comment"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ObsoleteCommentSyntaxInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new ReplaceObsoleteCommentMarkerQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new ObsoleteCommentSyntaxInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -95,17 +66,14 @@ public void ObsoleteCommentSyntax_QuickFixWorks_UpdateComment_LineHasCodeAndCont @"Dim Foo As Integer: ' This is _ a comment"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new ObsoleteCommentSyntaxInspection(state)); + Assert.AreEqual(expectedCode, actualCode); + } - var inspection = new ObsoleteCommentSyntaxInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - new ReplaceObsoleteCommentMarkerQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + protected override IQuickFix QuickFix(RubberduckParserState state) + { + return new ReplaceObsoleteCommentMarkerQuickFix(); } } } diff --git a/RubberduckTests/QuickFixes/ReplaceObsoleteErrorStatementQuickFixTests.cs b/RubberduckTests/QuickFixes/ReplaceObsoleteErrorStatementQuickFixTests.cs index d176e0aede..5e60805765 100644 --- a/RubberduckTests/QuickFixes/ReplaceObsoleteErrorStatementQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/ReplaceObsoleteErrorStatementQuickFixTests.cs @@ -1,15 +1,13 @@ -using System.Linq; -using System.Threading; -using NUnit.Framework; +using NUnit.Framework; using Rubberduck.Inspections.Concrete; using Rubberduck.Inspections.QuickFixes; -using RubberduckTests.Mocks; -using RubberduckTests.Inspections; +using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.VBA; namespace RubberduckTests.QuickFixes { [TestFixture] - public class ReplaceObsoleteErrorStatementQuickFixTests + public class ReplaceObsoleteErrorStatementQuickFixTests : QuickFixTestBase { [Test] [Category("QuickFixes")] @@ -25,17 +23,8 @@ Error 91 Err.Raise 91 End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ObsoleteErrorSyntaxInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new ReplaceObsoleteErrorStatementQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new ObsoleteErrorSyntaxInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] [Category("QuickFixes")] @@ -57,17 +46,8 @@ Sub Foo() Err.Raise 91 End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ObsoleteErrorSyntaxInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new ReplaceObsoleteErrorStatementQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new ObsoleteErrorSyntaxInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -86,17 +66,8 @@ Err.Raise _ 91 End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ObsoleteErrorSyntaxInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new ReplaceObsoleteErrorStatementQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new ObsoleteErrorSyntaxInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } @@ -114,17 +85,14 @@ public void ObsoleteCommentSyntax_QuickFixWorks_UpdateComment_LineHasCode() Dim foo: Err.Raise 91 End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new ObsoleteErrorSyntaxInspection(state)); + Assert.AreEqual(expectedCode, actualCode); + } - var inspection = new ObsoleteErrorSyntaxInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - new ReplaceObsoleteErrorStatementQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + protected override IQuickFix QuickFix(RubberduckParserState state) + { + return new ReplaceObsoleteErrorStatementQuickFix(); } } } diff --git a/RubberduckTests/QuickFixes/RestoreErrorHandlingQuickFixTests.cs b/RubberduckTests/QuickFixes/RestoreErrorHandlingQuickFixTests.cs index a067f4b1f8..7d8f7b325b 100644 --- a/RubberduckTests/QuickFixes/RestoreErrorHandlingQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/RestoreErrorHandlingQuickFixTests.cs @@ -1,15 +1,13 @@ -using System.Linq; -using System.Threading; -using NUnit.Framework; +using NUnit.Framework; using Rubberduck.Inspections.Concrete; using Rubberduck.Inspections.QuickFixes; -using RubberduckTests.Inspections; -using RubberduckTests.Mocks; +using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.VBA; namespace RubberduckTests.QuickFixes { [TestFixture] - public class RestoreErrorHandlingQuickFixTests + public class RestoreErrorHandlingQuickFixTests : QuickFixTestBase { [Test] [Category("QuickFixes")] @@ -32,17 +30,8 @@ Resume Next End If End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - var inspection = new UnhandledOnErrorResumeNextInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RestoreErrorHandlingQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new UnhandledOnErrorResumeNextInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -66,17 +55,8 @@ Resume Next End If End Function"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - var inspection = new UnhandledOnErrorResumeNextInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RestoreErrorHandlingQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new UnhandledOnErrorResumeNextInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -100,17 +80,8 @@ Resume Next End If End Property"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - var inspection = new UnhandledOnErrorResumeNextInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RestoreErrorHandlingQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new UnhandledOnErrorResumeNextInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -138,17 +109,8 @@ Resume Next End If End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - var inspection = new UnhandledOnErrorResumeNextInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RestoreErrorHandlingQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new UnhandledOnErrorResumeNextInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -181,20 +143,8 @@ Resume Next End If End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - var inspection = new UnhandledOnErrorResumeNextInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var quickFix = new RestoreErrorHandlingQuickFix(state); - - foreach (var result in inspector.FindIssuesAsync(state, CancellationToken.None).Result) - { - quickFix.Fix(result); - } - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToAllInspectionResults(inputCode, state => new UnhandledOnErrorResumeNextInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -231,20 +181,8 @@ Resume Next End If End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - var inspection = new UnhandledOnErrorResumeNextInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var quickFix = new RestoreErrorHandlingQuickFix(state); - - foreach (var result in inspector.FindIssuesAsync(state, CancellationToken.None).Result) - { - quickFix.Fix(result); - } - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToAllInspectionResults(inputCode, state => new UnhandledOnErrorResumeNextInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -283,20 +221,8 @@ Resume Next End If End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - var inspection = new UnhandledOnErrorResumeNextInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var quickFix = new RestoreErrorHandlingQuickFix(state); - - foreach (var result in inspector.FindIssuesAsync(state, CancellationToken.None).Result) - { - quickFix.Fix(result); - } - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToAllInspectionResults(inputCode, state => new UnhandledOnErrorResumeNextInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -324,20 +250,8 @@ Resume Next End If End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - var inspection = new UnhandledOnErrorResumeNextInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var quickFix = new RestoreErrorHandlingQuickFix(state); - - foreach (var result in inspector.FindIssuesAsync(state, CancellationToken.None).Result) - { - quickFix.Fix(result); - } - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToAllInspectionResults(inputCode, state => new UnhandledOnErrorResumeNextInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -365,20 +279,14 @@ Resume Next End If End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - var inspection = new UnhandledOnErrorResumeNextInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var quickFix = new RestoreErrorHandlingQuickFix(state); + var actualCode = ApplyQuickFixToAllInspectionResults(inputCode, state => new UnhandledOnErrorResumeNextInspection(state)); + Assert.AreEqual(expectedCode, actualCode); + } - foreach (var result in inspector.FindIssuesAsync(state, CancellationToken.None).Result) - { - quickFix.Fix(result); - } - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + protected override IQuickFix QuickFix(RubberduckParserState state) + { + return new RestoreErrorHandlingQuickFix(); } } } diff --git a/RubberduckTests/QuickFixes/SetExplicitVariantReturnTypeQuickFixTests.cs b/RubberduckTests/QuickFixes/SetExplicitVariantReturnTypeQuickFixTests.cs index a64f037b6c..dad7d8ebf4 100644 --- a/RubberduckTests/QuickFixes/SetExplicitVariantReturnTypeQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/SetExplicitVariantReturnTypeQuickFixTests.cs @@ -1,14 +1,13 @@ -using System.Linq; -using System.Threading; -using NUnit.Framework; +using NUnit.Framework; using Rubberduck.Inspections.Concrete; using Rubberduck.Inspections.QuickFixes; -using RubberduckTests.Mocks; +using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.VBA; namespace RubberduckTests.QuickFixes { [TestFixture] - public class SetExplicitVariantReturnTypeQuickFixTests + public class SetExplicitVariantReturnTypeQuickFixTests : QuickFixTestBase { [Test] [Category("QuickFixes")] @@ -22,16 +21,8 @@ public void ImplicitVariantReturnType_QuickFixWorks_Function() @"Function Foo() As Variant End Function"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ImplicitVariantReturnTypeInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new SetExplicitVariantReturnTypeQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new ImplicitVariantReturnTypeInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -46,17 +37,8 @@ public void ImplicitVariantReturnType_QuickFixWorks_PropertyGet() @"Property Get Foo() As Variant End Property"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ImplicitVariantReturnTypeInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new SetExplicitVariantReturnTypeQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new ImplicitVariantReturnTypeInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -89,17 +71,8 @@ public void ImplicitVariantReturnType_QuickFixWorks_LibraryFunction() lpStartupInfo As STARTUPINFO, _ lpProcessInformation As PROCESS_INFORMATION) As Variant"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ImplicitVariantReturnTypeInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new SetExplicitVariantReturnTypeQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new ImplicitVariantReturnTypeInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -114,17 +87,14 @@ public void ImplicitVariantReturnType_QuickFixWorks_Function_HasComment() @"Function Foo() As Variant ' comment End Function"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ImplicitVariantReturnTypeInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new ImplicitVariantReturnTypeInspection(state)); + Assert.AreEqual(expectedCode, actualCode); + } - new SetExplicitVariantReturnTypeQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + protected override IQuickFix QuickFix(RubberduckParserState state) + { + return new SetExplicitVariantReturnTypeQuickFix(); } } } diff --git a/RubberduckTests/QuickFixes/SpecifyExplicitByRefModifierQuickFixTests.cs b/RubberduckTests/QuickFixes/SpecifyExplicitByRefModifierQuickFixTests.cs index d9c920353c..86e06cb435 100644 --- a/RubberduckTests/QuickFixes/SpecifyExplicitByRefModifierQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/SpecifyExplicitByRefModifierQuickFixTests.cs @@ -1,17 +1,15 @@ -using System.Linq; -using System.Threading; +using System; using NUnit.Framework; using Rubberduck.Inspections.Concrete; using Rubberduck.Inspections.QuickFixes; -using RubberduckTests.Mocks; -using RubberduckTests.Inspections; -using Rubberduck.VBEditor.SafeComWrappers; using Rubberduck.Parsing.Grammar; +using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.VBA; namespace RubberduckTests.QuickFixes { [TestFixture] - public class SpecifyExplicitByRefModifierQuickFixTests + public class SpecifyExplicitByRefModifierQuickFixTests : QuickFixTestBase { [Test] @@ -26,18 +24,8 @@ public void ImplicitByRefModifier_QuickFixWorks_ImplicitByRefParameter() @"Sub Foo(ByRef arg1 As Integer) End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ImplicitByRefModifierInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new SpecifyExplicitByRefModifierQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new ImplicitByRefModifierInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -52,18 +40,8 @@ public void ImplicitByRefModifier_QuickFixWorks_OptionalParameter() @"Sub Foo(Optional ByRef arg1 As Integer) End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ImplicitByRefModifierInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new SpecifyExplicitByRefModifierQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new ImplicitByRefModifierInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -84,18 +62,8 @@ ByRef bar _ bar = 1 End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ImplicitByRefModifierInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new SpecifyExplicitByRefModifierQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new ImplicitByRefModifierInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -114,18 +82,8 @@ public void ImplicitByRefModifier_QuickFixWorks_LineContinuation() bar = 1 End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ImplicitByRefModifierInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new SpecifyExplicitByRefModifierQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new ImplicitByRefModifierInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -146,173 +104,113 @@ ByRef bar _ bar = 1 End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ImplicitByRefModifierInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new SpecifyExplicitByRefModifierQuickFix(state).Fix(inspectionResults.First()); - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new ImplicitByRefModifierInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] [Category("QuickFixes")] public void ImplicitByRefModifier_QuickFixWorks_InterfaceImplementation() { - const string inputCode1 = + const string interfaceInputCode = @"Sub Foo(arg1 As Integer) End Sub"; - const string inputCode2 = + const string implementationInputCode = @"Implements IClass1 Sub IClass1_Foo(arg1 As Integer) End Sub"; - const string expectedCode1 = + const string expectedInterfaceCode = @"Sub Foo(ByRef arg1 As Integer) End Sub"; - const string expectedCode2 = + const string expectedImplementationCode = @"Implements IClass1 Sub IClass1_Foo(ByRef arg1 As Integer) End Sub"; - var builder = new MockVbeBuilder(); - var vbe = builder.ProjectBuilder("TestProject1", ProjectProtection.Unprotected) - .AddComponent("IClass1", ComponentType.ClassModule, inputCode1) - .AddComponent("Class1", ComponentType.ClassModule, inputCode2) - .AddProjectToVbeBuilder() - .Build(); - - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ImplicitByRefModifierInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new SpecifyExplicitByRefModifierQuickFix(state).Fix(inspectionResults.First()); - - var project = vbe.Object.VBProjects[0]; - var interfaceComponent = project.VBComponents[0]; - var implementationComponent = project.VBComponents[1]; - - Assert.AreEqual(expectedCode1, state.GetRewriter(interfaceComponent).GetText(), "Wrong code in interface"); - Assert.AreEqual(expectedCode2, state.GetRewriter(implementationComponent).GetText(), "Wrong code in implementation"); - } + var (actualInterfaceCode, actualImplementationCode) = + ApplyQuickFixToFirstInspectionResultForImplementedInterface(interfaceInputCode, implementationInputCode, + state => new ImplicitByRefModifierInspection(state)); + Assert.AreEqual(expectedInterfaceCode, actualInterfaceCode, "Wrong code in interface"); + Assert.AreEqual(expectedImplementationCode, actualImplementationCode, "Wrong code in implementation"); } [Test] [Category("QuickFixes")] public void ImplicitByRefModifier_QuickFixWorks_InterfaceImplementationDifferentParameterName() { - const string inputCode1 = + const string interfaceInputCode = @"Sub Foo(arg1 As Integer) End Sub"; - const string inputCode2 = + const string implementationInputCode = @"Implements IClass1 Sub IClass1_Foo(arg2 As Integer) End Sub"; - const string expectedCode1 = + const string expectedInterfaceCode = @"Sub Foo(ByRef arg1 As Integer) End Sub"; - const string expectedCode2 = + const string expectedImplementationCode = @"Implements IClass1 Sub IClass1_Foo(ByRef arg2 As Integer) End Sub"; - var builder = new MockVbeBuilder(); - var vbe = builder.ProjectBuilder("TestProject1", ProjectProtection.Unprotected) - .AddComponent("IClass1", ComponentType.ClassModule, inputCode1) - .AddComponent("Class1", ComponentType.ClassModule, inputCode2) - .AddProjectToVbeBuilder() - .Build(); - - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ImplicitByRefModifierInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new SpecifyExplicitByRefModifierQuickFix(state).Fix(inspectionResults.First()); - - var project = vbe.Object.VBProjects[0]; - var interfaceComponent = project.VBComponents[0]; - var implementationComponent = project.VBComponents[1]; - - Assert.AreEqual(expectedCode1, state.GetRewriter(interfaceComponent).GetText(), "Wrong code in interface"); - Assert.AreEqual(expectedCode2, state.GetRewriter(implementationComponent).GetText(), "Wrong code in implementation"); - } + var (actualInterfaceCode, actualImplementationCode) = + ApplyQuickFixToFirstInspectionResultForImplementedInterface(interfaceInputCode, implementationInputCode, + state => new ImplicitByRefModifierInspection(state)); + Assert.AreEqual(expectedInterfaceCode, actualInterfaceCode, "Wrong code in interface"); + Assert.AreEqual(expectedImplementationCode, actualImplementationCode, "Wrong code in implementation"); } [Test] [Category("QuickFixes")] public void ImplicitByRefModifier_QuickFixWorks_InterfaceImplementationWithMultipleParameters() { - const string inputCode1 = + const string interfaceInputCode = @"Sub Foo(arg1 As Integer, arg2 as Integer) End Sub"; - const string inputCode2 = + const string implementationInputCode = @"Implements IClass1 Sub IClass1_Foo(arg1 As Integer, arg2 as Integer) End Sub"; - const string expectedCode1 = + const string expectedInterfaceCode = @"Sub Foo(ByRef arg1 As Integer, arg2 as Integer) End Sub"; - const string expectedCode2 = + const string expectedImplementationCode = @"Implements IClass1 Sub IClass1_Foo(ByRef arg1 As Integer, arg2 as Integer) End Sub"; - var builder = new MockVbeBuilder(); - var vbe = builder.ProjectBuilder("TestProject1", ProjectProtection.Unprotected) - .AddComponent("IClass1", ComponentType.ClassModule, inputCode1) - .AddComponent("Class1", ComponentType.ClassModule, inputCode2) - .AddProjectToVbeBuilder() - .Build(); - - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ImplicitByRefModifierInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new SpecifyExplicitByRefModifierQuickFix(state).Fix( - inspectionResults.First( - result => - ((VBAParser.ArgContext)result.Context).unrestrictedIdentifier() - .identifier() - .untypedIdentifier() - .identifierValue() - .GetText() == "arg1")); - - var project = vbe.Object.VBProjects[0]; - var interfaceComponent = project.VBComponents[0]; - var implementationComponent = project.VBComponents[1]; - - Assert.AreEqual(expectedCode1, state.GetRewriter(interfaceComponent).GetText(), "Wrong code in interface"); - Assert.AreEqual(expectedCode2, state.GetRewriter(implementationComponent).GetText(), "Wrong code in implementation"); - } + Func conditionOnResultToFix = result => + ((VBAParser.ArgContext)result.Context).unrestrictedIdentifier() + .identifier() + .untypedIdentifier() + .identifierValue() + .GetText() == "arg1"; + var (actualInterfaceCode, actualImplementationCode) = + ApplyQuickFixToFirstInspectionResultForImplementedInterfaceSatisfyingPredicate(interfaceInputCode, implementationInputCode, + state => new ImplicitByRefModifierInspection(state), conditionOnResultToFix); + Assert.AreEqual(expectedInterfaceCode, actualInterfaceCode, "Wrong code in interface"); + Assert.AreEqual(expectedImplementationCode, actualImplementationCode, "Wrong code in implementation"); } + + protected override IQuickFix QuickFix(RubberduckParserState state) + { + return new SpecifyExplicitByRefModifierQuickFix(state); + } } } diff --git a/RubberduckTests/QuickFixes/SpecifyExplicitPublicModifierQuickFixTests.cs b/RubberduckTests/QuickFixes/SpecifyExplicitPublicModifierQuickFixTests.cs index 176346311a..9a3f6c7c97 100644 --- a/RubberduckTests/QuickFixes/SpecifyExplicitPublicModifierQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/SpecifyExplicitPublicModifierQuickFixTests.cs @@ -1,15 +1,14 @@ -using System.Linq; -using System.Threading; -using NUnit.Framework; +using NUnit.Framework; using Rubberduck.Inspections.Concrete; using Rubberduck.Inspections.QuickFixes; -using RubberduckTests.Mocks; +using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.VBA; namespace RubberduckTests.QuickFixes { [TestFixture] - public class SpecifyExplicitPublicModifierQuickFixTests + public class SpecifyExplicitPublicModifierQuickFixTests : QuickFixTestBase { [Test] [Category("QuickFixes")] @@ -27,16 +26,14 @@ public void ImplicitPublicMember_QuickFixWorks() End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - var inspection = new ImplicitPublicMemberInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new SpecifyExplicitPublicModifierQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new ImplicitPublicMemberInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } + + protected override IQuickFix QuickFix(RubberduckParserState state) + { + return new SpecifyExplicitPublicModifierQuickFix(); + } } } diff --git a/RubberduckTests/QuickFixes/SplitMultipleDeclarationsQuickFixTests.cs b/RubberduckTests/QuickFixes/SplitMultipleDeclarationsQuickFixTests.cs index 21fd6a9688..19e9f103be 100644 --- a/RubberduckTests/QuickFixes/SplitMultipleDeclarationsQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/SplitMultipleDeclarationsQuickFixTests.cs @@ -1,15 +1,13 @@ -using System.Linq; -using System.Threading; -using NUnit.Framework; +using NUnit.Framework; using Rubberduck.Inspections.Concrete; using Rubberduck.Inspections.QuickFixes; -using RubberduckTests.Mocks; -using RubberduckTests.Inspections; +using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.VBA; namespace RubberduckTests.QuickFixes { [TestFixture] - public class SplitMultipleDeclarationsQuickFixTests + public class SplitMultipleDeclarationsQuickFixTests : QuickFixTestBase { [Test] [Category("QuickFixes")] @@ -27,17 +25,8 @@ Dim var2 As String End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new MultipleDeclarationsInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new SplitMultipleDeclarationsQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new MultipleDeclarationsInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -56,17 +45,8 @@ public void MultipleDeclarations_QuickFixWorks_Constants() End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new MultipleDeclarationsInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new SplitMultipleDeclarationsQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new MultipleDeclarationsInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -85,18 +65,14 @@ Static var2 As String End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new MultipleDeclarationsInspection(state)); + Assert.AreEqual(expectedCode, actualCode); + } - var inspection = new MultipleDeclarationsInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - new SplitMultipleDeclarationsQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + protected override IQuickFix QuickFix(RubberduckParserState state) + { + return new SplitMultipleDeclarationsQuickFix(); } - } } diff --git a/RubberduckTests/QuickFixes/UntypedFunctionUsageQuickFixTests.cs b/RubberduckTests/QuickFixes/UntypedFunctionUsageQuickFixTests.cs index 560bed5297..bce200ed5c 100644 --- a/RubberduckTests/QuickFixes/UntypedFunctionUsageQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/UntypedFunctionUsageQuickFixTests.cs @@ -38,7 +38,7 @@ Dim str As String var vbe = builder.AddProject(project).Build(); var component = project.Object.VBComponents[0]; - var parser = MockParser.Create(vbe.Object); + var (parser, rewriteManager) = MockParser.CreateWithRewriteManager(vbe.Object); using (var state = parser.State) { // FIXME reinstate and unignore tests @@ -54,11 +54,13 @@ Dim str As String var inspection = new UntypedFunctionUsageInspection(state); var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - new UntypedFunctionUsageQuickFix(state).Fix(inspectionResults.First()); + var rewriteSession = rewriteManager.CheckOutCodePaneSession(); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); + new UntypedFunctionUsageQuickFix().Fix(inspectionResults.First(), rewriteSession); + + var actualCode = rewriteSession.CheckOutModuleRewriter(component.QualifiedModuleName).GetText(); + Assert.AreEqual(expectedCode, actualCode); } } - } } diff --git a/RubberduckTests/QuickFixes/UseSetKeywordForObjectAssignmentQuickFixTests.cs b/RubberduckTests/QuickFixes/UseSetKeywordForObjectAssignmentQuickFixTests.cs index d64bbdf68c..4afe818867 100644 --- a/RubberduckTests/QuickFixes/UseSetKeywordForObjectAssignmentQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/UseSetKeywordForObjectAssignmentQuickFixTests.cs @@ -1,21 +1,19 @@ -using System.Linq; -using System.Threading; -using NUnit.Framework; +using NUnit.Framework; using Rubberduck.Inspections.Concrete; using Rubberduck.Inspections.QuickFixes; -using RubberduckTests.Mocks; +using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.VBA; namespace RubberduckTests.QuickFixes { [TestFixture] - public class UseSetKeywordForObjectAssignmentQuickFixTests + public class UseSetKeywordForObjectAssignmentQuickFixTests : QuickFixTestBase { [Test] [Category("QuickFixes")] public void ObjectVariableNotSet_ForFunctionAssignment_ReturnsResult() { - var expectedResultCount = 2; - var input = + var inputCode = @" Private Function CombineRanges(ByVal source As Range, ByVal toCombine As Range) As Range If source Is Nothing Then @@ -34,30 +32,15 @@ If source Is Nothing Then End If End Function"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ObjectVariableNotSetInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None).ToList(); - - Assert.AreEqual(expectedResultCount, inspectionResults.Count); - var fix = new UseSetKeywordForObjectAssignmentQuickFix(state); - foreach (var result in inspectionResults) - { - fix.Fix(result); - } - - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToAllInspectionResults(inputCode, state => new ObjectVariableNotSetInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] [Category("QuickFixes")] public void ObjectVariableNotSet_ForPropertyGetAssignment_ReturnsResults() { - var expectedResultCount = 1; - var input = @" + var inputCode = @" Private m_example As MyObject Public Property Get Example() As MyObject Example = m_example @@ -71,23 +54,14 @@ Public Property Get Example() As MyObject End Property "; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new ObjectVariableNotSetInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None).ToList(); + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new ObjectVariableNotSetInspection(state)); + Assert.AreEqual(expectedCode, actualCode); + } - Assert.AreEqual(expectedResultCount, inspectionResults.Count); - var fix = new UseSetKeywordForObjectAssignmentQuickFix(state); - foreach (var result in inspectionResults) - { - fix.Fix(result); - } - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + protected override IQuickFix QuickFix(RubberduckParserState state) + { + return new UseSetKeywordForObjectAssignmentQuickFix(); } - } } diff --git a/RubberduckTests/QuickFixes/WriteOnlyPropertyQuickFixTests.cs b/RubberduckTests/QuickFixes/WriteOnlyPropertyQuickFixTests.cs index e81ca02c78..d07b1d1f6d 100644 --- a/RubberduckTests/QuickFixes/WriteOnlyPropertyQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/WriteOnlyPropertyQuickFixTests.cs @@ -1,15 +1,16 @@ -using System.Linq; -using System.Threading; -using NUnit.Framework; +using NUnit.Framework; using Rubberduck.Inspections.Concrete; using Rubberduck.Inspections.QuickFixes; +using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.VBA; using Rubberduck.VBEditor.SafeComWrappers; +using Rubberduck.VBEditor.SafeComWrappers.Abstract; using RubberduckTests.Mocks; namespace RubberduckTests.QuickFixes { [TestFixture] - public class WriteOnlyPropertyQuickFixTests + public class WriteOnlyPropertyQuickFixTests : QuickFixTestBase { [Test] [Category("QuickFixes")] @@ -26,18 +27,8 @@ End Property Property Let Foo(value) End Property"; - - var vbe = MockVbeBuilder.BuildFromSingleModule(inputCode, ComponentType.ClassModule, out var component); - - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new WriteOnlyPropertyInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new WriteOnlyPropertyQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new WriteOnlyPropertyInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -55,17 +46,8 @@ End Property Public Property Let Foo(ByVal value As Integer) End Property"; - var vbe = MockVbeBuilder.BuildFromSingleModule(inputCode, ComponentType.ClassModule, out var component); - - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new WriteOnlyPropertyInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - new WriteOnlyPropertyQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new WriteOnlyPropertyInspection(state)); + Assert.AreEqual(expectedCode, actualCode); } [Test] @@ -83,18 +65,19 @@ End Property Public Property Let Foo(value1, ByVal value2 As Integer, ByRef value3 As Long, value4 As Date, ByVal value5, value6 As String) End Property"; - var vbe = MockVbeBuilder.BuildFromSingleModule(inputCode, ComponentType.ClassModule, out var component); - - using (var state = MockParser.CreateAndParse(vbe.Object)) - { + var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new WriteOnlyPropertyInspection(state)); + Assert.AreEqual(expectedCode, actualCode); + } - var inspection = new WriteOnlyPropertyInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - new WriteOnlyPropertyQuickFix(state).Fix(inspectionResults.First()); - Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText()); - } + protected override IQuickFix QuickFix(RubberduckParserState state) + { + return new WriteOnlyPropertyQuickFix(); } + protected override IVBE TestVbe(string code, out IVBComponent component) + { + return MockVbeBuilder.BuildFromSingleModule(code, ComponentType.ClassModule, out component).Object; + } } } From 13f7f41204dc5248d3ea78fc054accf74c121283 Mon Sep 17 00:00:00 2001 From: Max Doerner Date: Thu, 1 Nov 2018 21:43:26 +0100 Subject: [PATCH 09/59] Remove RewriteAllModules from RubberduckParserState This is now handled via IRewriteSessions. --- .../QuickFixes/QuickFixProvider.cs | 10 +++++----- Rubberduck.Parsing/VBA/RubberduckParserState.cs | 8 -------- .../QuickFixes/QuickFixProviderTests.cs | 15 +++++++++------ 3 files changed, 14 insertions(+), 19 deletions(-) diff --git a/Rubberduck.CodeAnalysis/QuickFixes/QuickFixProvider.cs b/Rubberduck.CodeAnalysis/QuickFixes/QuickFixProvider.cs index f273a4d5a7..8f9bd99fee 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/QuickFixProvider.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/QuickFixProvider.cs @@ -13,12 +13,12 @@ namespace Rubberduck.Inspections.QuickFixes { public class QuickFixProvider : IQuickFixProvider { - private readonly RubberduckParserState _state; + private readonly IRewritingManager _rewritingManager; private readonly Dictionary> _quickFixes = new Dictionary>(); - public QuickFixProvider(RubberduckParserState state, IEnumerable quickFixes) + public QuickFixProvider(IRewritingManager rewritingManager, IEnumerable quickFixes) { - _state = state; + _rewritingManager = rewritingManager; foreach (var quickFix in quickFixes) { foreach (var supportedInspection in quickFix.SupportedInspections) @@ -86,9 +86,9 @@ private IRewriteSession RewriteSession(CodeKind targetCodeKind) switch (targetCodeKind) { case CodeKind.CodePaneCode: - return _state.RewritingManager.CheckOutCodePaneSession(); + return _rewritingManager.CheckOutCodePaneSession(); case CodeKind.AttributesCode: - return _state.RewritingManager.CheckOutAttributesSession(); + return _rewritingManager.CheckOutAttributesSession(); default: throw new NotSupportedException(nameof(targetCodeKind)); } diff --git a/Rubberduck.Parsing/VBA/RubberduckParserState.cs b/Rubberduck.Parsing/VBA/RubberduckParserState.cs index 254cba8fc8..734a034ba6 100644 --- a/Rubberduck.Parsing/VBA/RubberduckParserState.cs +++ b/Rubberduck.Parsing/VBA/RubberduckParserState.cs @@ -951,14 +951,6 @@ public IExecutableModuleRewriter GetAttributeRewriter(QualifiedModuleName qualif return _moduleStates[qualifiedModuleName].AttributesRewriter; } - public void RewriteAllModules() - { - foreach (var module in _moduleStates.Where(s => ProjectsProvider.Component(s.Key) != null)) - { - module.Value.ModuleRewriter.Rewrite(); - } - } - /// /// Removes the specified from the collection. /// diff --git a/RubberduckTests/QuickFixes/QuickFixProviderTests.cs b/RubberduckTests/QuickFixes/QuickFixProviderTests.cs index e746937caf..0cd08e2415 100644 --- a/RubberduckTests/QuickFixes/QuickFixProviderTests.cs +++ b/RubberduckTests/QuickFixes/QuickFixProviderTests.cs @@ -22,13 +22,14 @@ public void ProviderDoesNotKnowAboutInspection() End Sub"; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var inspection = new ConstantNotUsedInspection(state); var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - var quickFixProvider = new QuickFixProvider(state, new IQuickFix[] { }); + var quickFixProvider = new QuickFixProvider(rewritingManager, new IQuickFix[] { }); Assert.AreEqual(0, quickFixProvider.QuickFixes(inspectionResults.First()).Count()); } } @@ -44,14 +45,15 @@ Dim str As String End Sub"; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var inspection = new EmptyStringLiteralInspection(state); var inspector = InspectionsHelper.GetInspector(inspection); var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - var quickFixProvider = new QuickFixProvider(state, new IQuickFix[] { new ReplaceEmptyStringLiteralStatementQuickFix() }); + var quickFixProvider = new QuickFixProvider(rewritingManager, new IQuickFix[] { new ReplaceEmptyStringLiteralStatementQuickFix() }); Assert.AreEqual(1, quickFixProvider.QuickFixes(inspectionResults.First()).Count()); } } @@ -66,13 +68,14 @@ public void ResultDisablesFix() End Sub"; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var inspection = new ConstantNotUsedInspection(state); var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - var quickFixProvider = new QuickFixProvider(state, new IQuickFix[] { new RemoveUnusedDeclarationQuickFix() }); + var quickFixProvider = new QuickFixProvider(rewritingManager, new IQuickFix[] { new RemoveUnusedDeclarationQuickFix() }); var result = inspectionResults.First(); result.Properties.DisableFixes = nameof(RemoveUnusedDeclarationQuickFix); From 3deccdbc2f7c5f9e4ca985e8dd614b93aa3d6657 Mon Sep 17 00:00:00 2001 From: Max Doerner Date: Thu, 1 Nov 2018 23:02:57 +0100 Subject: [PATCH 10/59] Move creating ModuleRewriters out of the parser This is only a first step. The rewriters are still stored on the ModuleStates because providing a new one each time a rewriter is requested from the RubberduckParserState breaks the refactoring tests. Ultimately, the rewriters should only be created via the IRewriteSession. --- Rubberduck.API/VBA/Parser.cs | 20 +- .../Rewriter/StateTokenStreamCache.cs | 4 +- Rubberduck.Parsing/VBA/ModuleState.cs | 25 +- .../VBA/Parsing/IModuleParser.cs | 12 +- .../VBA/Parsing/ModuleParser.cs | 11 +- .../VBA/Parsing/ParseRunnerBase.cs | 8 +- .../VBA/RubberduckParserState.cs | 43 ++- .../CodeExplorer/CodeExplorerTests.cs | 291 +++++++++--------- RubberduckTests/Mocks/MockParser.cs | 22 +- ...RemoveUnassignedIdentifierQuickFixTests.cs | 4 +- 10 files changed, 242 insertions(+), 198 deletions(-) diff --git a/Rubberduck.API/VBA/Parser.cs b/Rubberduck.API/VBA/Parser.cs index 31495a0ed8..9c6f52ec1e 100644 --- a/Rubberduck.API/VBA/Parser.cs +++ b/Rubberduck.API/VBA/Parser.cs @@ -94,10 +94,17 @@ internal Parser(object vbe) : this() _vbeEvents = VBEEvents.Initialize(_vbe); var declarationFinderFactory = new ConcurrentlyConstructedDeclarationFinderFactory(); var projectRepository = new ProjectsRepository(_vbe); - _state = new RubberduckParserState(_vbe, projectRepository, declarationFinderFactory, _vbeEvents); - _state.StateChanged += _state_StateChanged; + var codePaneSourceCodeHandler = new CodePaneSourceCodeHandler(projectRepository); var sourceFileHandler = _vbe.TempSourceFileHandler; + var attributesSourceCodeHandler = new SourceFileHandlerSourceCodeHandlerAdapter(sourceFileHandler, projectRepository); + var moduleRewriterFactory = new ModuleRewriterFactory( + codePaneSourceCodeHandler, + attributesSourceCodeHandler); + + _state = new RubberduckParserState(_vbe, projectRepository, declarationFinderFactory, _vbeEvents, moduleRewriterFactory); + _state.StateChanged += _state_StateChanged; + var vbeVersion = double.Parse(_vbe.Version, CultureInfo.InvariantCulture); var predefinedCompilationConstants = new VBAPredefinedCompilationConstants(vbeVersion); var typeLibProvider = new TypeLibWrapperProvider(projectRepository); @@ -110,7 +117,6 @@ internal Parser(object vbe) : this() var mainTokenStreamParser = new VBATokenStreamParser(mainParseErrorListenerFactory, mainParseErrorListenerFactory); var tokenStreamProvider = new SimpleVBAModuleTokenStreamProvider(); var stringParser = new TokenStreamParserStringParserAdapterWithPreprocessing(tokenStreamProvider, mainTokenStreamParser, preprocessor); - var attributesSourceCodeHandler = new SourceFileHandlerSourceCodeHandlerAdapter(sourceFileHandler, projectRepository); var projectManager = new RepositoryProjectManager(projectRepository); var moduleToModuleReferenceManager = new ModuleToModuleReferenceManager(); var parserStateManager = new ParserStateManager(_state); @@ -130,15 +136,11 @@ internal Parser(object vbe) : this() //new RubberduckApiDeclarations(_state) } ); - var codePaneSourceCodeHandler = new CodePaneSourceCodeHandler(projectRepository); - var moduleRewriterFactory = new ModuleRewriterFactory( - codePaneSourceCodeHandler, - attributesSourceCodeHandler); + var moduleParser = new ModuleParser( codePaneSourceCodeHandler, attributesSourceCodeHandler, - stringParser, - moduleRewriterFactory); + stringParser); var parseRunner = new ParseRunner( _state, parserStateManager, diff --git a/Rubberduck.Parsing/Rewriter/StateTokenStreamCache.cs b/Rubberduck.Parsing/Rewriter/StateTokenStreamCache.cs index 7ba464e164..80e1b939a8 100644 --- a/Rubberduck.Parsing/Rewriter/StateTokenStreamCache.cs +++ b/Rubberduck.Parsing/Rewriter/StateTokenStreamCache.cs @@ -16,12 +16,12 @@ public StateTokenStreamCache(RubberduckParserState state) public ITokenStream CodePaneTokenStream(QualifiedModuleName module) { - return _state.GetRewriter(module).TokenStream; + return _state.GetCodePaneTokenStream(module); } public ITokenStream AttributesTokenStream(QualifiedModuleName module) { - return _state.GetAttributeRewriter(module).TokenStream; + return _state.GetAttributesTokenStream(module); } } } \ No newline at end of file diff --git a/Rubberduck.Parsing/VBA/ModuleState.cs b/Rubberduck.Parsing/VBA/ModuleState.cs index 2b4918e019..3762f665bf 100644 --- a/Rubberduck.Parsing/VBA/ModuleState.cs +++ b/Rubberduck.Parsing/VBA/ModuleState.cs @@ -8,7 +8,6 @@ using Rubberduck.Parsing.Symbols; using Rubberduck.Parsing.VBA.Parsing; using Rubberduck.Parsing.VBA.Parsing.ParsingExceptions; -using Rubberduck.VBEditor; namespace Rubberduck.Parsing.VBA { @@ -16,7 +15,9 @@ public class ModuleState { public ConcurrentDictionary Declarations { get; private set; } public ConcurrentDictionary UnresolvedMemberDeclarations { get; private set; } - public IExecutableModuleRewriter ModuleRewriter { get; private set; } + public ITokenStream CodePaneTokenStream { get; private set; } + public ITokenStream AttributesTokenStream { get; private set; } + public IExecutableModuleRewriter CodePaneRewriter { get; private set; } public IExecutableModuleRewriter AttributesRewriter { get; private set; } public IParseTree ParseTree { get; private set; } public IParseTree AttributesPassParseTree { get; private set; } @@ -79,9 +80,15 @@ public ModuleState(SyntaxErrorException moduleException) IsNew = true; } - public ModuleState SetCodePaneRewriter(QualifiedModuleName module, IExecutableModuleRewriter codePaneRewriter) + public ModuleState SetCodePaneTokenStream(ITokenStream codePaneTokenStream) { - ModuleRewriter = codePaneRewriter; + CodePaneTokenStream = codePaneTokenStream; + return this; + } + + public ModuleState SetCodePaneRewriter(IExecutableModuleRewriter codePaneRewriter) + { + CodePaneRewriter = codePaneRewriter; return this; } @@ -144,9 +151,15 @@ public ModuleState SetMembersAllowingAttributes(IDictionary<(string scopeIdentif return this; } - public ModuleState SetAttributesRewriter(IExecutableModuleRewriter rewriter) + public ModuleState SetAttributesTokenStream(ITokenStream attributesTokenStream) + { + AttributesTokenStream = attributesTokenStream; + return this; + } + + public ModuleState SetAttributesRewriter(IExecutableModuleRewriter attributesRewriter) { - AttributesRewriter = rewriter; + AttributesRewriter = attributesRewriter; return this; } diff --git a/Rubberduck.Parsing/VBA/Parsing/IModuleParser.cs b/Rubberduck.Parsing/VBA/Parsing/IModuleParser.cs index 776e919e2b..84e99308e4 100644 --- a/Rubberduck.Parsing/VBA/Parsing/IModuleParser.cs +++ b/Rubberduck.Parsing/VBA/Parsing/IModuleParser.cs @@ -18,8 +18,8 @@ public ModuleParseResults( IEnumerable annotations, IDictionary<(string scopeIdentifier, DeclarationType scopeType), Attributes> attributes, IDictionary<(string scopeIdentifier, DeclarationType scopeType), ParserRuleContext> membersAllowingAttributes, - IExecutableModuleRewriter codePaneRewriter, - IExecutableModuleRewriter attributesRewriter + ITokenStream codePaneTokenStream, + ITokenStream attributesTokenStream ) { CodePaneParseTree = codePaneParseTree; @@ -28,8 +28,8 @@ IExecutableModuleRewriter attributesRewriter Annotations = annotations; Attributes = attributes; MembersAllowingAttributes = membersAllowingAttributes; - CodePaneRewriter = codePaneRewriter; - AttributesRewriter = attributesRewriter; + CodePaneTokenStream = codePaneTokenStream; + AttributesTokenStream = attributesTokenStream; } public IParseTree CodePaneParseTree { get; } @@ -38,8 +38,8 @@ IExecutableModuleRewriter attributesRewriter public IEnumerable Annotations { get; } public IDictionary<(string scopeIdentifier, DeclarationType scopeType), Attributes> Attributes { get; } public IDictionary<(string scopeIdentifier, DeclarationType scopeType), ParserRuleContext> MembersAllowingAttributes { get; } - public IExecutableModuleRewriter CodePaneRewriter { get; } - public IExecutableModuleRewriter AttributesRewriter { get; } + public ITokenStream CodePaneTokenStream { get; } + public ITokenStream AttributesTokenStream { get; } } public interface IModuleParser diff --git a/Rubberduck.Parsing/VBA/Parsing/ModuleParser.cs b/Rubberduck.Parsing/VBA/Parsing/ModuleParser.cs index 73fe692afa..79021eecbd 100644 --- a/Rubberduck.Parsing/VBA/Parsing/ModuleParser.cs +++ b/Rubberduck.Parsing/VBA/Parsing/ModuleParser.cs @@ -9,7 +9,6 @@ using NLog; using Rubberduck.Parsing.Annotations; using Rubberduck.Parsing.Grammar; -using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.Symbols; using Rubberduck.Parsing.VBA.Parsing.ParsingExceptions; using Rubberduck.VBEditor; @@ -23,13 +22,11 @@ public class ModuleParser : IModuleParser private readonly ISourceCodeProvider _codePaneSourceCodeProvider; private readonly ISourceCodeProvider _attributesSourceCodeProvider; private readonly IStringParser _parser; - private readonly IModuleRewriterFactory _moduleRewriterFactory; private static readonly Logger Logger = LogManager.GetCurrentClassLogger(); - public ModuleParser(ISourceCodeProvider codePaneSourceCodeProvider, ISourceCodeProvider attributesSourceCodeProvider, IStringParser parser, IModuleRewriterFactory moduleRewriterFactory) + public ModuleParser(ISourceCodeProvider codePaneSourceCodeProvider, ISourceCodeProvider attributesSourceCodeProvider, IStringParser parser) { - _moduleRewriterFactory = moduleRewriterFactory; _codePaneSourceCodeProvider = codePaneSourceCodeProvider; _attributesSourceCodeProvider = attributesSourceCodeProvider; _parser = parser; @@ -86,7 +83,6 @@ private ModuleParseResults ParseInternal(QualifiedModuleName module, Cancellatio Logger.Trace($"ParseTaskID {taskId} begins code pane pass."); var (codePaneParseTree, codePaneTokenStream) = CodePanePassResults(module, cancellationToken, rewriter); - var codePaneRewriter = _moduleRewriterFactory.CodePaneRewriter(module, codePaneTokenStream); Logger.Trace($"ParseTaskID {taskId} finished code pane pass."); cancellationToken.ThrowIfCancellationRequested(); @@ -99,7 +95,6 @@ private ModuleParseResults ParseInternal(QualifiedModuleName module, Cancellatio Logger.Trace($"ParseTaskID {taskId} begins attributes pass."); var (attributesParseTree, attributesTokenStream) = AttributesPassResults(module, cancellationToken); - var attributesRewriter = _moduleRewriterFactory.AttributesRewriter(module, attributesTokenStream); Logger.Trace($"ParseTaskID {taskId} finished attributes pass."); cancellationToken.ThrowIfCancellationRequested(); @@ -115,8 +110,8 @@ private ModuleParseResults ParseInternal(QualifiedModuleName module, Cancellatio annotations, attributes, membersAllowingAttributes, - codePaneRewriter, - attributesRewriter + codePaneTokenStream, + attributesTokenStream ); diff --git a/Rubberduck.Parsing/VBA/Parsing/ParseRunnerBase.cs b/Rubberduck.Parsing/VBA/Parsing/ParseRunnerBase.cs index a2f54c925b..64dc7247b6 100644 --- a/Rubberduck.Parsing/VBA/Parsing/ParseRunnerBase.cs +++ b/Rubberduck.Parsing/VBA/Parsing/ParseRunnerBase.cs @@ -1,12 +1,8 @@ using System; using System.Collections.Generic; using System.Threading; -using System.Threading.Tasks; -using Antlr4.Runtime; -using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.VBA.Parsing.ParsingExceptions; using Rubberduck.VBEditor; -using Rubberduck.VBEditor.SourceCodeHandling; namespace Rubberduck.Parsing.VBA.Parsing { @@ -81,8 +77,8 @@ private void SaveModuleParseResultsOnState(QualifiedModuleName module, ModulePar _state.SetModuleAnnotations(module, results.Annotations); _state.SetModuleAttributes(module, results.Attributes); _state.SetMembersAllowingAttributes(module, results.MembersAllowingAttributes); - _state.SetCodePaneRewriter(module, results.CodePaneRewriter); - _state.AddAttributesRewriter(module, results.AttributesRewriter); + _state.SetCodePaneTokenStream(module, results.CodePaneTokenStream); + _state.SetAttributesTokenStream(module, results.AttributesTokenStream); // This really needs to go last //It does not reevaluate the overall parer state to avoid concurrent evaluation of all module states and for performance reasons. diff --git a/Rubberduck.Parsing/VBA/RubberduckParserState.cs b/Rubberduck.Parsing/VBA/RubberduckParserState.cs index 734a034ba6..7457b85d12 100644 --- a/Rubberduck.Parsing/VBA/RubberduckParserState.cs +++ b/Rubberduck.Parsing/VBA/RubberduckParserState.cs @@ -18,7 +18,6 @@ using Rubberduck.VBEditor.Events; using Rubberduck.VBEditor.SafeComWrappers; using Rubberduck.VBEditor.SafeComWrappers.Abstract; -using Antlr4.Runtime; using Rubberduck.Parsing.VBA.DeclarationCaching; using Rubberduck.Parsing.VBA.Parsing.ParsingExceptions; @@ -145,10 +144,12 @@ public sealed class RubberduckParserState : IDisposable, IDeclarationFinderProvi private readonly IVBEEvents _vbeEvents; private readonly IHostApplication _hostApp; private readonly IDeclarationFinderFactory _declarationFinderFactory; - + //TODO: Remove this again in a later PR when all rewriters get acquired via IRewriteSessions. + private readonly IModuleRewriterFactory _moduleRewriterFactory; + /// Provides event handling from the VBE. Static method must be already called prior to constructing the method. [SuppressMessage("ReSharper", "JoinNullCheckWithUsage")] - public RubberduckParserState(IVBE vbe, IProjectsRepository projectRepository, IDeclarationFinderFactory declarationFinderFactory, IVBEEvents vbeEvents) + public RubberduckParserState(IVBE vbe, IProjectsRepository projectRepository, IDeclarationFinderFactory declarationFinderFactory, IVBEEvents vbeEvents, IModuleRewriterFactory moduleRewriterFactory) { if (vbe == null) { @@ -170,9 +171,15 @@ public RubberduckParserState(IVBE vbe, IProjectsRepository projectRepository, ID throw new ArgumentNullException(nameof(vbeEvents)); } + if (moduleRewriterFactory == null) + { + throw new ArgumentNullException(nameof(moduleRewriterFactory)); + } + _vbe = vbe; _projectRepository = projectRepository; _declarationFinderFactory = declarationFinderFactory; + _moduleRewriterFactory = moduleRewriterFactory; _vbeEvents = vbeEvents; var values = Enum.GetValues(typeof(ParserState)); @@ -844,9 +851,12 @@ private bool RemoveKeysFromCollections(IEnumerable keys) return success; } - public void SetCodePaneRewriter(QualifiedModuleName module, IExecutableModuleRewriter codePaneRewriter) + public void SetCodePaneTokenStream(QualifiedModuleName module, ITokenStream codePaneTokenStream) { - _moduleStates[module].SetCodePaneRewriter(module, codePaneRewriter); + _moduleStates[module].SetCodePaneTokenStream(codePaneTokenStream); + + var rewriter = _moduleRewriterFactory.CodePaneRewriter(module, codePaneTokenStream); + _moduleStates[module].SetCodePaneRewriter(rewriter); } public void SaveContentHash(QualifiedModuleName module) @@ -931,13 +941,12 @@ public bool IsDirty() public IExecutableModuleRewriter GetRewriter(IVBComponent component) { - var qualifiedModuleName = new QualifiedModuleName(component); - return GetRewriter(qualifiedModuleName); + return GetRewriter(component.QualifiedModuleName); } public IExecutableModuleRewriter GetRewriter(QualifiedModuleName qualifiedModuleName) { - return _moduleStates[qualifiedModuleName].ModuleRewriter; + return _moduleStates[qualifiedModuleName].CodePaneRewriter; } public IExecutableModuleRewriter GetRewriter(Declaration declaration) @@ -951,6 +960,16 @@ public IExecutableModuleRewriter GetAttributeRewriter(QualifiedModuleName qualif return _moduleStates[qualifiedModuleName].AttributesRewriter; } + public ITokenStream GetCodePaneTokenStream(QualifiedModuleName qualifiedModuleName) + { + return _moduleStates[qualifiedModuleName].CodePaneTokenStream; + } + + public ITokenStream GetAttributesTokenStream(QualifiedModuleName qualifiedModuleName) + { + return _moduleStates[qualifiedModuleName].AttributesTokenStream; + } + /// /// Removes the specified from the collection. /// @@ -1058,10 +1077,12 @@ private void ClearAsTypeDeclarationPointingToReference(QualifiedModuleName refer } } - public void AddAttributesRewriter(QualifiedModuleName module, IExecutableModuleRewriter attributesRewriter) + public void SetAttributesTokenStream(QualifiedModuleName module, ITokenStream attributesTokenStream) { - var key = module; - _moduleStates[key].SetAttributesRewriter(attributesRewriter); + _moduleStates[module].SetAttributesTokenStream(attributesTokenStream); + + var rewriter = _moduleRewriterFactory.AttributesRewriter(module, attributesTokenStream); + _moduleStates[module].SetAttributesRewriter(rewriter); } //todo: Remove this again in favor of injection of the IRewritingManager into the callers. diff --git a/RubberduckTests/CodeExplorer/CodeExplorerTests.cs b/RubberduckTests/CodeExplorer/CodeExplorerTests.cs index 7e2211e59f..16b82c6378 100644 --- a/RubberduckTests/CodeExplorer/CodeExplorerTests.cs +++ b/RubberduckTests/CodeExplorer/CodeExplorerTests.cs @@ -15,14 +15,15 @@ using Rubberduck.VBEditor.SafeComWrappers; using Rubberduck.VBEditor.SafeComWrappers.Abstract; using RubberduckTests.Mocks; -using Rubberduck.Parsing.Symbols; using Rubberduck.Parsing.UIContext; using Rubberduck.SettingsProvider; using Rubberduck.VBEditor.ComManagement; using Rubberduck.Interaction; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.VBA.DeclarationCaching; using Rubberduck.UI.UnitTesting.Commands; using Rubberduck.UnitTesting; +using Rubberduck.VBEditor.SourceCodeHandling; namespace RubberduckTests.CodeExplorer { @@ -59,11 +60,10 @@ public void AddStdModule() var components = project.MockVBComponents; var vbe = builder.AddProject(project.Build()).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); var projectRepository = new ProjectsRepository(vbe.Object); var uiDispatcher = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var messageBox = new Mock(); var saveFileDialog = new Mock(); @@ -98,13 +98,12 @@ public bool AddStdModule_CanExecuteBasedOnProjectType(ProjectType projectType) var vbe = builder.AddProject(project.Build()).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); - + var projectRepository = new ProjectsRepository(vbe.Object); var uiDispatcher = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var vm = new CodeExplorerViewModel(new FolderHelper(state), state, null, _generalSettingsProvider.Object, _windowSettingsProvider.Object, uiDispatcher.Object, vbe.Object); vm.AddStdModuleCommand = new AddStdModuleCommand(new AddComponentCommand(vbe.Object)); @@ -130,14 +129,13 @@ public void AddClassModule() var components = project.MockVBComponents; var vbe = builder.AddProject(project.Build()).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); var projectRepository = new ProjectsRepository(vbe.Object); var uiDispatcher = new Mock(); var messageBox = new Mock(); var saveFileDialog = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var removeCommand = new RemoveCommand(saveFileDialog.Object, messageBox.Object, state.ProjectsProvider); var vm = new CodeExplorerViewModel(new FolderHelper(state), state, removeCommand, _generalSettingsProvider.Object, _windowSettingsProvider.Object, uiDispatcher.Object, vbe.Object); @@ -170,13 +168,12 @@ public bool AddClassModule_CanExecuteBasedOnProjectType(ProjectType projectType) var vbe = builder.AddProject(project.Build()).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); var projectRepository = new ProjectsRepository(vbe.Object); var uiDispatcher = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var vm = new CodeExplorerViewModel(new FolderHelper(state), state, null, _generalSettingsProvider.Object, _windowSettingsProvider.Object, uiDispatcher.Object, vbe.Object); vm.AddClassModuleCommand = new AddClassModuleCommand(new AddComponentCommand(vbe.Object)); @@ -202,14 +199,13 @@ public void AddUserForm() var components = project.MockVBComponents; var vbe = builder.AddProject(project.Build()).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); var projectRepository = new ProjectsRepository(vbe.Object); var uiDispatcher = new Mock(); var messageBox = new Mock(); var saveFileDialog = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var removeCommand = new RemoveCommand(saveFileDialog.Object, messageBox.Object, state.ProjectsProvider); var vm = new CodeExplorerViewModel(new FolderHelper(state), state, removeCommand, _generalSettingsProvider.Object, _windowSettingsProvider.Object, uiDispatcher.Object, vbe.Object); @@ -241,13 +237,12 @@ public bool AddUserForm_CanExecuteBasedOnProjectType(ProjectType projectType) .AddComponent("Module1", ComponentType.StandardModule, ""); - var vbe = builder.AddProject(project.Build()).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var vbe = builder.AddProject(project.Build()).Build(); var projectRepository = new ProjectsRepository(vbe.Object); var uiDispatcher = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var vm = new CodeExplorerViewModel(new FolderHelper(state), state, null, _generalSettingsProvider.Object, _windowSettingsProvider.Object, uiDispatcher.Object, vbe.Object); vm.AddUserFormCommand = new AddUserFormCommand(new AddComponentCommand(vbe.Object)); @@ -273,12 +268,11 @@ public void AddVBForm() var components = project.MockVBComponents; var vbe = builder.AddProject(project.Build()).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); var projectRepository = new ProjectsRepository(vbe.Object); var uiDispatcher = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var vm = new CodeExplorerViewModel(new FolderHelper(state), state, null, _generalSettingsProvider.Object, _windowSettingsProvider.Object, uiDispatcher.Object, vbe.Object); vm.AddVBFormCommand = new AddVBFormCommand(new AddComponentCommand(vbe.Object)); @@ -310,12 +304,12 @@ public bool AddVBForm_CanExecuteBasedOnProjectType(ProjectType projectType) var vbe = builder.AddProject(project.Build()).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var projectRepository = new ProjectsRepository(vbe.Object); var uiDispatcher = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var vm = new CodeExplorerViewModel(new FolderHelper(state), state, null, _generalSettingsProvider.Object, _windowSettingsProvider.Object, uiDispatcher.Object, vbe.Object); vm.AddVBFormCommand = new AddVBFormCommand(new AddComponentCommand(vbe.Object)); @@ -341,12 +335,12 @@ public void AddMDIForm() var components = project.MockVBComponents; var vbe = builder.AddProject(project.Build()).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var projectRepository = new ProjectsRepository(vbe.Object); var uiDispatcher = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var vm = new CodeExplorerViewModel(new FolderHelper(state), state, null, _generalSettingsProvider.Object, _windowSettingsProvider.Object, uiDispatcher.Object, vbe.Object); vm.AddMDIFormCommand = new AddMDIFormCommand(vbe.Object, new AddComponentCommand(vbe.Object)); @@ -378,12 +372,12 @@ public bool AddMDIForm_CanExecuteBasedOnProjectType(ProjectType projectType) var vbe = builder.AddProject(project.Build()).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var projectRepository = new ProjectsRepository(vbe.Object); var uiDispatcher = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var vm = new CodeExplorerViewModel(new FolderHelper(state), state, null, _generalSettingsProvider.Object, _windowSettingsProvider.Object, uiDispatcher.Object, vbe.Object); vm.AddMDIFormCommand = new AddMDIFormCommand(vbe.Object, new AddComponentCommand(vbe.Object)); @@ -408,12 +402,12 @@ public void AddMDIForm_CannotExecuteIfProjectAlreadyHasMDIForm() var vbe = builder.AddProject(project.Build()).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var projectRepository = new ProjectsRepository(vbe.Object); var uiDispatcher = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var vm = new CodeExplorerViewModel(new FolderHelper(state), state, null, _generalSettingsProvider.Object, _windowSettingsProvider.Object, uiDispatcher.Object, vbe.Object); vm.AddMDIFormCommand = new AddMDIFormCommand(vbe.Object, new AddComponentCommand(vbe.Object)); @@ -439,12 +433,12 @@ public void AddUserControlForm() var components = project.MockVBComponents; var vbe = builder.AddProject(project.Build()).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var projectRepository = new ProjectsRepository(vbe.Object); var uiDispatcher = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var vm = new CodeExplorerViewModel(new FolderHelper(state), state, null, _generalSettingsProvider.Object, _windowSettingsProvider.Object, uiDispatcher.Object, vbe.Object); vm.AddUserControlCommand = new AddUserControlCommand(new AddComponentCommand(vbe.Object)); @@ -476,12 +470,12 @@ public bool AddUserControl_CanExecuteBasedOnProjectType(ProjectType projectType) var vbe = builder.AddProject(project.Build()).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var projectRepository = new ProjectsRepository(vbe.Object); var uiDispatcher = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var vm = new CodeExplorerViewModel(new FolderHelper(state), state, null, _generalSettingsProvider.Object, _windowSettingsProvider.Object, uiDispatcher.Object, vbe.Object); vm.AddUserControlCommand = new AddUserControlCommand(new AddComponentCommand(vbe.Object)); @@ -507,12 +501,12 @@ public void AddPropertyPage() var components = project.MockVBComponents; var vbe = builder.AddProject(project.Build()).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var projectRepository = new ProjectsRepository(vbe.Object); var uiDispatcher = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var vm = new CodeExplorerViewModel(new FolderHelper(state), state, null, _generalSettingsProvider.Object, _windowSettingsProvider.Object, uiDispatcher.Object, vbe.Object); vm.AddPropertyPageCommand = new AddPropertyPageCommand(new AddComponentCommand(vbe.Object)); @@ -543,12 +537,12 @@ public bool AddPropertyPage_CanExecuteBasedOnProjectType(ProjectType projectType .AddComponent("Module1", ComponentType.StandardModule, ""); var vbe = builder.AddProject(project.Build()).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var projectRepository = new ProjectsRepository(vbe.Object); var uiDispatcher = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var vm = new CodeExplorerViewModel(new FolderHelper(state), state, null, _generalSettingsProvider.Object, _windowSettingsProvider.Object, uiDispatcher.Object, vbe.Object); vm.AddPropertyPageCommand = new AddPropertyPageCommand(new AddComponentCommand(vbe.Object)); @@ -574,12 +568,12 @@ public void AddUserDocument() var components = project.MockVBComponents; var vbe = builder.AddProject(project.Build()).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var projectRepository = new ProjectsRepository(vbe.Object); var uiDispatcher = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var vm = new CodeExplorerViewModel(new FolderHelper(state), state, null, _generalSettingsProvider.Object, _windowSettingsProvider.Object, uiDispatcher.Object, vbe.Object); vm.AddUserDocumentCommand = new AddUserDocumentCommand(new AddComponentCommand(vbe.Object)); @@ -610,12 +604,12 @@ public bool AddUserDocument_CanExecuteBasedOnProjectType(ProjectType projectType .AddComponent("Module1", ComponentType.StandardModule, ""); var vbe = builder.AddProject(project.Build()).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var projectRepository = new ProjectsRepository(vbe.Object); var uiDispatcher = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var vm = new CodeExplorerViewModel(new FolderHelper(state), state, null, _generalSettingsProvider.Object, _windowSettingsProvider.Object, uiDispatcher.Object, vbe.Object); vm.AddUserDocumentCommand = new AddUserDocumentCommand(new AddComponentCommand(vbe.Object)); @@ -641,7 +635,7 @@ public void AddTestModule() var components = project.MockVBComponents; var vbe = builder.AddProject(project.Build()).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var configLoader = new Mock(null, null, null, null, null, null, null, null); configLoader.Setup(c => c.LoadConfiguration()).Returns(GetDefaultUnitTestConfig()); @@ -649,7 +643,7 @@ public void AddTestModule() var saveFileDialog = new Mock(); var projectRepository = new ProjectsRepository(vbe.Object); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var removeCommand = new RemoveCommand(saveFileDialog.Object, messageBox.Object, state.ProjectsProvider); var vbeWrapper = vbe.Object; @@ -681,7 +675,7 @@ public void AddTestModuleWithStubs() var components = project.MockVBComponents; var vbe = builder.AddProject(project.Build()).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var configLoader = new Mock(null, null, null, null, null, null, null, null); configLoader.Setup(c => c.LoadConfiguration()).Returns(GetDefaultUnitTestConfig()); @@ -690,7 +684,7 @@ public void AddTestModuleWithStubs() var messageBox = new Mock(); var saveFileDialog = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var vbeWrapper = vbe.Object; var uiDispatcher = new Mock(); @@ -720,7 +714,7 @@ public void AddTestModuleWithStubs_DisabledWhenParameterIsProject() .AddComponent("Module1", ComponentType.StandardModule, ""); var vbe = builder.AddProject(project.Build()).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var configLoader = new Mock(null, null, null, null, null, null, null, null); configLoader.Setup(c => c.LoadConfiguration()).Returns(GetDefaultUnitTestConfig()); @@ -729,7 +723,7 @@ public void AddTestModuleWithStubs_DisabledWhenParameterIsProject() var messageBox = new Mock(); var saveFileDialog = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var vbeWrapper = vbe.Object; var uiDispatcher = new Mock(); @@ -758,7 +752,7 @@ public void AddTestModuleWithStubs_DisabledWhenParameterIsFolder() .AddComponent("Module1", ComponentType.StandardModule, ""); var vbe = builder.AddProject(project.Build()).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var configLoader = new Mock(null, null, null, null, null, null, null, null); configLoader.Setup(c => c.LoadConfiguration()).Returns(GetDefaultUnitTestConfig()); @@ -768,7 +762,7 @@ public void AddTestModuleWithStubs_DisabledWhenParameterIsFolder() var messageBox = new Mock(); var saveFileDialog = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var vbeWrapper = vbe.Object; var interaction = new Mock(); @@ -796,7 +790,7 @@ public void AddTestModuleWithStubs_DisabledWhenParameterIsModuleMember() .AddComponent("Module1", ComponentType.StandardModule, "Public Sub S()\r\nEnd Sub"); var vbe = builder.AddProject(project.Build()).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var configLoader = new Mock(null, null, null, null, null, null, null, null); configLoader.Setup(c => c.LoadConfiguration()).Returns(GetDefaultUnitTestConfig()); @@ -805,7 +799,7 @@ public void AddTestModuleWithStubs_DisabledWhenParameterIsModuleMember() var messageBox = new Mock(); var saveFileDialog = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var vbeWrapper = vbe.Object; var uiDispatcher = new Mock(); @@ -836,7 +830,7 @@ public void ImportModule() var components = project.MockVBComponents; var vbe = builder.AddProject(project.Build()).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var openFileDialog = new Mock(); openFileDialog.Setup(o => o.AddExtension); @@ -853,7 +847,7 @@ public void ImportModule() var messageBox = new Mock(); var saveFileDialog = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var removeCommand = new RemoveCommand(saveFileDialog.Object, messageBox.Object, state.ProjectsProvider); @@ -883,7 +877,7 @@ public void ImportMultipleModules() var components = project.MockVBComponents; var vbe = builder.AddProject(project.Build()).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var openFileDialog = new Mock(); openFileDialog.Setup(o => o.AddExtension); @@ -900,7 +894,7 @@ public void ImportMultipleModules() var messageBox = new Mock(); var saveFileDialog = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var removeCommand = new RemoveCommand(saveFileDialog.Object, messageBox.Object, state.ProjectsProvider); @@ -931,7 +925,7 @@ public void ImportModule_Cancel() var components = project.MockVBComponents; var vbe = builder.AddProject(project.Build()).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var openFileDialog = new Mock(); openFileDialog.Setup(o => o.AddExtension); @@ -948,7 +942,7 @@ public void ImportModule_Cancel() var messageBox = new Mock(); var saveFileDialog = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var removeCommand = new RemoveCommand(saveFileDialog.Object, messageBox.Object, state.ProjectsProvider); @@ -977,7 +971,7 @@ public void ExportModule_ExpectExecution() var project = projectMock.Build(); var vbe = builder.AddProject(project).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var component = projectMock.MockComponents.First(); var saveFileDialog = new Mock(); @@ -988,7 +982,7 @@ public void ExportModule_ExpectExecution() var projectRepository = new ProjectsRepository(vbe.Object); var messageBox = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var removeCommand = new RemoveCommand(saveFileDialog.Object, messageBox.Object, state.ProjectsProvider); @@ -1017,7 +1011,7 @@ public void ExportModule_CancelPressed_ExpectNoExecution() var project = projectMock.Build(); var vbe = builder.AddProject(project).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var component = projectMock.MockComponents.First(); var saveFileDialog = new Mock(); @@ -1028,7 +1022,7 @@ public void ExportModule_CancelPressed_ExpectNoExecution() var projectRepository = new ProjectsRepository(vbe.Object); var messageBox = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var removeCommand = new RemoveCommand(saveFileDialog.Object, messageBox.Object, state.ProjectsProvider); @@ -1059,7 +1053,7 @@ public void ExportProject_TestCanExecute_ExpectTrue() var project = projectMock.Build(); var vbe = builder.AddProject(project).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var component1 = project.Object.VBComponents[0]; var module1 = component1.CodeModule; @@ -1071,7 +1065,7 @@ public void ExportProject_TestCanExecute_ExpectTrue() var messageBox = new Mock(); var saveFileDialog = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var removeCommand = new RemoveCommand(saveFileDialog.Object, messageBox.Object, state.ProjectsProvider); @@ -1111,7 +1105,7 @@ public void ExportProject_TestExecute_OKPressed_ExpectExecution() project.SetupGet(m => m.FileName).Returns(projectFullPath); var vbe = builder.AddProject(project).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var component1 = project.Object.VBComponents[0]; var module1 = component1.CodeModule; @@ -1129,7 +1123,7 @@ public void ExportProject_TestExecute_OKPressed_ExpectExecution() var messageBox = new Mock(); var saveFileDialog = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var removeCommand = new RemoveCommand(saveFileDialog.Object, messageBox.Object, state.ProjectsProvider); @@ -1169,7 +1163,7 @@ public void ExportProject_TestExecute_CancelPressed_ExpectExecution() project.SetupGet(m => m.FileName).Returns(projectFullPath); var vbe = builder.AddProject(project).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var component1 = project.Object.VBComponents[0]; var module1 = component1.CodeModule; @@ -1187,7 +1181,7 @@ public void ExportProject_TestExecute_CancelPressed_ExpectExecution() var messageBox = new Mock(); var saveFileDialog = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var removeCommand = new RemoveCommand(saveFileDialog.Object, messageBox.Object, state.ProjectsProvider); @@ -1216,14 +1210,14 @@ public void OpenDesigner() var project = projectMock.Build(); var vbe = builder.AddProject(project).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var component = projectMock.MockComponents.First(); var projectRepository = new ProjectsRepository(vbe.Object); var messageBox = new Mock(); var saveFileDialog = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var removeCommand = new RemoveCommand(saveFileDialog.Object, messageBox.Object, state.ProjectsProvider); @@ -1256,7 +1250,7 @@ public void RemoveCommand_RemovesModuleWhenPromptOk() var project = projectMock.Build(); var vbe = builder.AddProject(project).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var component = project.Object.VBComponents[0]; @@ -1269,7 +1263,7 @@ public void RemoveCommand_RemovesModuleWhenPromptOk() messageBox.Setup(m => m.Confirm(It.IsAny(), It.IsAny(), It.IsAny())).Returns(ConfirmationOutcome.Yes); var projectRepository = new ProjectsRepository(vbe.Object); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var removeCommand = new RemoveCommand(saveFileDialog.Object, messageBox.Object, state.ProjectsProvider); @@ -1299,7 +1293,7 @@ public void RemoveCommand_CancelsWhenFilePromptCancels() var project = projectMock.Build(); var vbe = builder.AddProject(project).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var component = project.Object.VBComponents[0]; var saveFileDialog = new Mock(); @@ -1309,7 +1303,7 @@ public void RemoveCommand_CancelsWhenFilePromptCancels() messageBox.Setup(m => m.ConfirmYesNo(It.IsAny(), It.IsAny(), It.IsAny())).Returns(true); var projectRepository = new ProjectsRepository(vbe.Object); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var commands = new List { @@ -1343,7 +1337,7 @@ public void RemoveCommand_GivenMsgBoxNO_RemovesModuleNoExport() var project = projectMock.Build(); var vbe = builder.AddProject(project).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var component = project.Object.VBComponents[0]; var saveFileDialog = new Mock(); @@ -1353,7 +1347,7 @@ public void RemoveCommand_GivenMsgBoxNO_RemovesModuleNoExport() messageBox.Setup(m => m.Confirm(It.IsAny(), It.IsAny(), It.IsAny())).Returns(ConfirmationOutcome.No); var projectRepository = new ProjectsRepository(vbe.Object); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var removeCommand = new RemoveCommand(saveFileDialog.Object, messageBox.Object, state.ProjectsProvider); @@ -1383,7 +1377,7 @@ public void RemoveModule_Cancel() var project = projectMock.Build(); var vbe = builder.AddProject(project).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var component = project.Object.VBComponents[0]; var saveFileDialog = new Mock(); @@ -1393,7 +1387,7 @@ public void RemoveModule_Cancel() messageBox.Setup(m => m.Confirm(It.IsAny(), It.IsAny(), It.IsAny())).Returns(ConfirmationOutcome.Cancel); var projectRepository = new ProjectsRepository(vbe.Object); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var commands = new List { @@ -1434,13 +1428,13 @@ End Sub IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var projectRepository = new ProjectsRepository(vbe.Object); var messageBox = new Mock(); var saveFileDialog = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var removeCommand = new RemoveCommand(saveFileDialog.Object, messageBox.Object, state.ProjectsProvider); @@ -1473,13 +1467,13 @@ Dim d As Boolean IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var projectRepository = new ProjectsRepository(vbe.Object); var messageBox = new Mock(); var saveFileDialog = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var removeCommand = new RemoveCommand(saveFileDialog.Object, messageBox.Object, state.ProjectsProvider); @@ -1521,7 +1515,7 @@ End Sub var project = projectMock.Build(); var vbe = builder.AddProject(project).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var component1 = project.Object.VBComponents[0]; var module1 = component1.CodeModule; @@ -1532,7 +1526,7 @@ End Sub var messageBox = new Mock(); var saveFileDialog = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var removeCommand = new RemoveCommand(saveFileDialog.Object, messageBox.Object, state.ProjectsProvider); @@ -1584,7 +1578,7 @@ End Sub var project = projectMock.Build(); var vbe = builder.AddProject(project).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var component1 = project.Object.VBComponents[0]; var module1 = component1.CodeModule; @@ -1595,7 +1589,7 @@ End Sub var messageBox = new Mock(); var saveFileDialog = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var removeCommand = new RemoveCommand(saveFileDialog.Object, messageBox.Object, state.ProjectsProvider); @@ -1634,13 +1628,13 @@ Dim d As Boolean var project = projectMock.Build(); var vbe = builder.AddProject(project).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var projectRepository = new ProjectsRepository(vbe.Object); var messageBox = new Mock(); var saveFileDialog = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var removeCommand = new RemoveCommand(saveFileDialog.Object, messageBox.Object, state.ProjectsProvider); @@ -1687,7 +1681,7 @@ End Sub var project = projectMock.Build(); var vbe = builder.AddProject(project).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var component1 = project.Object.VBComponents[0]; var module1 = component1.CodeModule; @@ -1698,7 +1692,7 @@ End Sub var messageBox = new Mock(); var saveFileDialog = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var removeCommand = new RemoveCommand(saveFileDialog.Object, messageBox.Object, state.ProjectsProvider); @@ -1755,7 +1749,7 @@ End Sub var project = projectMock.Build(); var vbe = builder.AddProject(project).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var component1 = project.Object.VBComponents[0]; var module1 = component1.CodeModule; @@ -1766,7 +1760,7 @@ End Sub var messageBox = new Mock(); var saveFileDialog = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var removeCommand = new RemoveCommand(saveFileDialog.Object, messageBox.Object, state.ProjectsProvider); @@ -1806,13 +1800,13 @@ Dim d As Boolean var project = projectMock.Build(); var vbe = builder.AddProject(project).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var projectRepository = new ProjectsRepository(vbe.Object); var messageBox = new Mock(); var saveFileDialog = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var removeCommand = new RemoveCommand(saveFileDialog.Object, messageBox.Object, state.ProjectsProvider); @@ -1839,13 +1833,13 @@ public void ExpandAllNodes() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var projectRepository = new ProjectsRepository(vbe.Object); var messageBox = new Mock(); var saveFileDialog = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var uiDispatcher = new Mock(); var removeCommand = new RemoveCommand(saveFileDialog.Object, messageBox.Object, state.ProjectsProvider); @@ -1875,13 +1869,13 @@ public void ExpandAllNodes_StartingWithSubnode() .AddComponent("Comp2", ComponentType.ClassModule, @"'@Folder ""Bar""") .Build(); var vbe = builder.AddProject(project).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var projectRepository = new ProjectsRepository(vbe.Object); var messageBox = new Mock(); var saveFileDialog = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var uiDispatcher = new Mock(); var removeCommand = new RemoveCommand(saveFileDialog.Object, messageBox.Object, state.ProjectsProvider); @@ -1911,13 +1905,13 @@ public void CollapseAllNodes() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var projectRepository = new ProjectsRepository(vbe.Object); var messageBox = new Mock(); var saveFileDialog = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var uiDispatcher = new Mock(); var removeCommand = new RemoveCommand(saveFileDialog.Object, messageBox.Object, state.ProjectsProvider); @@ -1947,13 +1941,13 @@ public void CollapseAllNodes_StartingWithSubnode() .AddComponent("Comp2", ComponentType.ClassModule, @"'@Folder ""Bar""") .Build(); var vbe = builder.AddProject(project).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var projectRepository = new ProjectsRepository(vbe.Object); var messageBox = new Mock(); var saveFileDialog = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var uiDispatcher = new Mock(); var removeCommand = new RemoveCommand(saveFileDialog.Object, messageBox.Object, state.ProjectsProvider); @@ -1984,7 +1978,7 @@ public void SetSortByName_NotAlreadySelectedInMenu_ExpectTrue() var components = project.MockVBComponents; var vbe = builder.AddProject(project.Build()).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var commands = new List { new AddStdModuleCommand(new AddComponentCommand(vbe.Object)) }; @@ -1992,7 +1986,7 @@ public void SetSortByName_NotAlreadySelectedInMenu_ExpectTrue() var messageBox = new Mock(); var saveFileDialog = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var windowSettings = new WindowSettings @@ -2029,7 +2023,7 @@ public void SetSortByName_AlreadySelectedInMenu_ExpectTrue() var components = project.MockVBComponents; var vbe = builder.AddProject(project.Build()).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var commands = new List { new AddStdModuleCommand(new AddComponentCommand(vbe.Object)) }; @@ -2037,7 +2031,7 @@ public void SetSortByName_AlreadySelectedInMenu_ExpectTrue() var messageBox = new Mock(); var saveFileDialog = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var windowSettings = new WindowSettings @@ -2074,7 +2068,7 @@ public void SetSortByName_BothSortOptionsFalse_ExpectTrueOnlyForSortByName() var components = project.MockVBComponents; var vbe = builder.AddProject(project.Build()).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var commands = new List { new AddStdModuleCommand(new AddComponentCommand(vbe.Object)) }; @@ -2082,7 +2076,7 @@ public void SetSortByName_BothSortOptionsFalse_ExpectTrueOnlyForSortByName() var messageBox = new Mock(); var saveFileDialog = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var windowSettings = new WindowSettings @@ -2119,7 +2113,7 @@ public void SetSortByName_BothSortOptionsTrue_ExpectTrueOnlyForSortByName() var components = project.MockVBComponents; var vbe = builder.AddProject(project.Build()).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var commands = new List { new AddStdModuleCommand(new AddComponentCommand(vbe.Object)) }; @@ -2129,7 +2123,7 @@ public void SetSortByName_BothSortOptionsTrue_ExpectTrueOnlyForSortByName() var messageBox = new Mock(); var saveFileDialog = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var windowSettings = new WindowSettings @@ -2165,7 +2159,7 @@ public void SetSortByCodeOrder_NotAlreadySelectedInMenu_ExpectTrue() var components = project.MockVBComponents; var vbe = builder.AddProject(project.Build()).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var commands = new List { new AddStdModuleCommand(new AddComponentCommand(vbe.Object)) }; @@ -2173,7 +2167,7 @@ public void SetSortByCodeOrder_NotAlreadySelectedInMenu_ExpectTrue() var messageBox = new Mock(); var saveFileDialog = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var windowSettings = new WindowSettings @@ -2210,7 +2204,7 @@ public void SetSortByCodeOrder_AlreadySelectedInMenu_ExpectTrue() var components = project.MockVBComponents; var vbe = builder.AddProject(project.Build()).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var commands = new List { new AddStdModuleCommand(new AddComponentCommand(vbe.Object)) }; @@ -2218,7 +2212,7 @@ public void SetSortByCodeOrder_AlreadySelectedInMenu_ExpectTrue() var messageBox = new Mock(); var saveFileDialog = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var windowSettings = new WindowSettings @@ -2255,7 +2249,7 @@ public void SetSortByCodeOrder_BothSortOptionsFalse_ExpectCorrectSortPair() var components = project.MockVBComponents; var vbe = builder.AddProject(project.Build()).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var commands = new List { new AddStdModuleCommand(new AddComponentCommand(vbe.Object)) }; @@ -2263,7 +2257,7 @@ public void SetSortByCodeOrder_BothSortOptionsFalse_ExpectCorrectSortPair() var messageBox = new Mock(); var saveFileDialog = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var windowSettings = new WindowSettings @@ -2300,7 +2294,7 @@ public void SetSortByCodeOrder_BothSortOptionsTrue_ExpectCorrectSortPair() var components = project.MockVBComponents; var vbe = builder.AddProject(project.Build()).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var commands = new List { new AddStdModuleCommand(new AddComponentCommand(vbe.Object)) }; @@ -2308,7 +2302,7 @@ public void SetSortByCodeOrder_BothSortOptionsTrue_ExpectCorrectSortPair() var messageBox = new Mock(); var saveFileDialog = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var windowSettings = new WindowSettings @@ -2382,13 +2376,13 @@ public void CompareByType_ReturnsEventAboveConst() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var projectRepository = new ProjectsRepository(vbe.Object); var messageBox = new Mock(); var saveFileDialog = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var uiDispatcher = new Mock(); var removeCommand = new RemoveCommand(saveFileDialog.Object, messageBox.Object, state.ProjectsProvider); @@ -2414,13 +2408,13 @@ public void CompareByType_ReturnsConstAboveField() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var projectRepository = new ProjectsRepository(vbe.Object); var messageBox = new Mock(); var saveFileDialog = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var uiDispatcher = new Mock(); var removeCommand = new RemoveCommand(saveFileDialog.Object, messageBox.Object, state.ProjectsProvider); @@ -2449,13 +2443,13 @@ End Property IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var projectRepository = new ProjectsRepository(vbe.Object); var messageBox = new Mock(); var saveFileDialog = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var uiDispatcher = new Mock(); var removeCommand = new RemoveCommand(saveFileDialog.Object, messageBox.Object, state.ProjectsProvider); @@ -2485,13 +2479,13 @@ End Property IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var projectRepository = new ProjectsRepository(vbe.Object); var messageBox = new Mock(); var saveFileDialog = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var uiDispatcher = new Mock(); var removeCommand = new RemoveCommand(saveFileDialog.Object, messageBox.Object, state.ProjectsProvider); @@ -2521,13 +2515,13 @@ End Property IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var projectRepository = new ProjectsRepository(vbe.Object); var messageBox = new Mock(); var saveFileDialog = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var uiDispatcher = new Mock(); var removeCommand = new RemoveCommand(saveFileDialog.Object, messageBox.Object, state.ProjectsProvider); @@ -2557,13 +2551,13 @@ End Property IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var projectRepository = new ProjectsRepository(vbe.Object); var messageBox = new Mock(); var saveFileDialog = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var uiDispatcher = new Mock(); var removeCommand = new RemoveCommand(saveFileDialog.Object, messageBox.Object, state.ProjectsProvider); @@ -2593,13 +2587,13 @@ End Property IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var projectRepository = new ProjectsRepository(vbe.Object); var messageBox = new Mock(); var saveFileDialog = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var uiDispatcher = new Mock(); var removeCommand = new RemoveCommand(saveFileDialog.Object, messageBox.Object, state.ProjectsProvider); @@ -2629,13 +2623,13 @@ End Function IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var projectRepository = new ProjectsRepository(vbe.Object); var messageBox = new Mock(); var saveFileDialog = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var uiDispatcher = new Mock(); var removeCommand = new RemoveCommand(saveFileDialog.Object, messageBox.Object, state.ProjectsProvider); @@ -2665,13 +2659,13 @@ End Sub IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var projectRepository = new ProjectsRepository(vbe.Object); var messageBox = new Mock(); var saveFileDialog = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var uiDispatcher = new Mock(); var removeCommand = new RemoveCommand(saveFileDialog.Object, messageBox.Object, state.ProjectsProvider); @@ -2701,13 +2695,13 @@ End Sub IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var projectRepository = new ProjectsRepository(vbe.Object); var messageBox = new Mock(); var saveFileDialog = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var uiDispatcher = new Mock(); var removeCommand = new RemoveCommand(saveFileDialog.Object, messageBox.Object, state.ProjectsProvider); @@ -2734,13 +2728,13 @@ public void CompareByType_ReturnsClassModuleBelowDocument() var project = projectMock.Build(); var vbe = builder.AddProject(project).Build(); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var projectRepository = new ProjectsRepository(vbe.Object); var messageBox = new Mock(); var saveFileDialog = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var uiDispatcher = new Mock(); var removeCommand = new RemoveCommand(saveFileDialog.Object, messageBox.Object, state.ProjectsProvider); @@ -2774,13 +2768,13 @@ Sub Bar() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var projectRepository = new ProjectsRepository(vbe.Object); var messageBox = new Mock(); var saveFileDialog = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var uiDispatcher = new Mock(); var removeCommand = new RemoveCommand(saveFileDialog.Object, messageBox.Object, state.ProjectsProvider); @@ -2810,13 +2804,13 @@ Sub Bar() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var projectRepository = new ProjectsRepository(vbe.Object); var messageBox = new Mock(); var saveFileDialog = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var uiDispatcher = new Mock(); var removeCommand = new RemoveCommand(saveFileDialog.Object, messageBox.Object, state.ProjectsProvider); @@ -2846,13 +2840,13 @@ Sub Bar() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + var projectRepository = new ProjectsRepository(vbe.Object); var messageBox = new Mock(); var saveFileDialog = new Mock(); - using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object)) + using (var state = TestParserState(vbe, projectRepository)) { var uiDispatcher = new Mock(); var removeCommand = new RemoveCommand(saveFileDialog.Object, messageBox.Object, state.ProjectsProvider); @@ -2879,6 +2873,21 @@ public void CompareByNodeType_FoldersAreSortedByName() } #region Helpers + + private RubberduckParserState TestParserState(Mock vbe, IProjectsRepository projectsRepository) + { + var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); + + var codePaneSourceCodeHandler = new CodePaneSourceCodeHandler(projectsRepository); + //We use the same handler because to achieve consistency between the return values. + var attributesSourceCodeHandler = codePaneSourceCodeHandler; + var moduleRewriterFactory = new ModuleRewriterFactory( + codePaneSourceCodeHandler, + attributesSourceCodeHandler); + + return new RubberduckParserState(vbe.Object, projectsRepository, new DeclarationFinderFactory(), vbeEvents.Object, moduleRewriterFactory); + } + private Configuration GetDefaultUnitTestConfig() { var unitTestSettings = new UnitTestSettings(BindingMode.LateBinding, AssertMode.StrictAssert, true, true, false); diff --git a/RubberduckTests/Mocks/MockParser.cs b/RubberduckTests/Mocks/MockParser.cs index 779531698a..5080ca337d 100644 --- a/RubberduckTests/Mocks/MockParser.cs +++ b/RubberduckTests/Mocks/MockParser.cs @@ -48,7 +48,15 @@ public static (SynchronousParseCoordinator parser, IRewritingManager rewritingMa var vbeEvents = MockVbeEvents.CreateMockVbeEvents(new Moq.Mock()); var declarationFinderFactory = new DeclarationFinderFactory(); var projectRepository = new ProjectsRepository(vbe); - var state = new RubberduckParserState(vbe, projectRepository, declarationFinderFactory, vbeEvents.Object); + + var codePaneSourceCodeHandler = new CodePaneSourceCodeHandler(projectRepository); + //We use the same handler because to achieve consistency between the return values. + var attributesSourceCodeHandler = codePaneSourceCodeHandler; + var moduleRewriterFactory = new ModuleRewriterFactory( + codePaneSourceCodeHandler, + attributesSourceCodeHandler); + + var state = new RubberduckParserState(vbe, projectRepository, declarationFinderFactory, vbeEvents.Object, moduleRewriterFactory); return CreateWithRewriteManager(vbe, state, projectRepository, serializedComProjectsPath); } @@ -93,17 +101,14 @@ public static (SynchronousParseCoordinator parser, IRewritingManager rewritingMa new SpecialFormDeclarations(state), new FormEventDeclarations(state), new AliasDeclarations(state), - }); var codePaneSourceCodeHandler = new CodePaneSourceCodeHandler(projectRepository); + }); + var codePaneSourceCodeHandler = new CodePaneSourceCodeHandler(projectRepository); //We use the same handler because to achieve consistency between the return values. var attributesSourceCodeHandler = codePaneSourceCodeHandler; - var moduleRewriterFactory = new ModuleRewriterFactory( - codePaneSourceCodeHandler, - attributesSourceCodeHandler); var moduleParser = new ModuleParser( codePaneSourceCodeHandler, attributesSourceCodeHandler, - stringParser, - moduleRewriterFactory); + stringParser); var parseRunner = new SynchronousParseRunner( state, parserStateManager, @@ -132,6 +137,9 @@ public static (SynchronousParseCoordinator parser, IRewritingManager rewritingMa compilationsArgumentsCache ); var tokenStreamCache = new StateTokenStreamCache(state); + var moduleRewriterFactory = new ModuleRewriterFactory( + codePaneSourceCodeHandler, + attributesSourceCodeHandler); var rewriterProvider = new RewriterProvider(tokenStreamCache, moduleRewriterFactory); var rewriteSessionFactory = new RewriteSessionFactory(state, rewriterProvider); var rewritingManager = new RewritingManager(rewriteSessionFactory); diff --git a/RubberduckTests/QuickFixes/RemoveUnassignedIdentifierQuickFixTests.cs b/RubberduckTests/QuickFixes/RemoveUnassignedIdentifierQuickFixTests.cs index 824745fec6..30279f6190 100644 --- a/RubberduckTests/QuickFixes/RemoveUnassignedIdentifierQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/RemoveUnassignedIdentifierQuickFixTests.cs @@ -60,8 +60,8 @@ public void UnassignedVariable_MultipleVariablesOnSingleLine_QuickFixWorks() @"Sub Foo() Dim var1 As Integer End Sub"; - - var actualCode = ApplyQuickFixToFirstInspectionResult(inputCode, state => new VariableNotAssignedInspection(state)); + Func conditionToFix = s => s.Target.IdentifierName == "var2"; + var actualCode = ApplyQuickFixToFirstInspectionResultSatisfyingPredicate(inputCode, state => new VariableNotAssignedInspection(state), conditionToFix); Assert.AreEqual(expectedCode, actualCode); } From e28d67c0510ba5f4d1ac0e14e6b7c2f2aeeac0de Mon Sep 17 00:00:00 2001 From: Max Doerner Date: Fri, 2 Nov 2018 12:12:48 +0100 Subject: [PATCH 11/59] Rewire and streamline the ModuleRewriter tests With the new rewriting setup the source of IModuleRewriters changed. --- .../PostProcessing/ModuleRewriterTests.cs | 519 +++--------------- 1 file changed, 76 insertions(+), 443 deletions(-) diff --git a/RubberduckTests/PostProcessing/ModuleRewriterTests.cs b/RubberduckTests/PostProcessing/ModuleRewriterTests.cs index 3c43934c79..f5bfb3b672 100644 --- a/RubberduckTests/PostProcessing/ModuleRewriterTests.cs +++ b/RubberduckTests/PostProcessing/ModuleRewriterTests.cs @@ -1,7 +1,6 @@ using System; using System.Collections.Generic; using System.Linq; -using System.Threading; using Antlr4.Runtime; using NUnit.Framework; using Moq; @@ -68,18 +67,18 @@ public void RewriteDoesNotRewriteIfNotDirty() public void RewriterInsertsRewriterOutputAtLine1() { const string content = @"Option Explicit"; - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(content, out component).Object; - - using (var state = MockParser.CreateAndParse(vbe)) + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(content, out var component).Object; + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe); + using (state) { if (state.Status != ParserState.Ready) { Assert.Inconclusive("Parser isn't ready. Test cannot proceed."); } - var rewriter = state.GetRewriter(component); - rewriter.Rewrite(); + var rewriteSession = rewritingManager.CheckOutCodePaneSession(); + var rewriter = rewriteSession.CheckOutModuleRewriter(component.QualifiedModuleName); + rewriteSession.Rewrite(); Assert.AreEqual(content, rewriter.GetText()); } @@ -94,26 +93,9 @@ public void RemovesModuleVariableDeclarationStatement() const string content = @" Private foo As String "; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(content, out _).Object; - using (var state = MockParser.CreateAndParse(vbe)) - { - if (state.Status != ParserState.Ready) - { - Assert.Inconclusive("Parser isn't ready. Test cannot proceed."); - } - - var declarations = state.AllUserDeclarations; - var target = declarations.SingleOrDefault(d => d.DeclarationType == DeclarationType.Variable); - if (target == null) - { - Assert.Inconclusive("No variable was found in test code."); - } - - var rewriter = state.GetRewriter(target); - rewriter.Remove(target); - Assert.AreEqual(expected, rewriter.GetText()); - } + var actual = RewrittenForTargetRemovalCode(content, DeclarationType.Variable, target => true); + Assert.AreEqual(expected, actual); } [Test] @@ -125,26 +107,9 @@ public void RemovesModuleConstantDeclarationStatement() const string content = @" Private Const foo As String = ""Something"" "; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(content, out _).Object; - using (var state = MockParser.CreateAndParse(vbe)) - { - if (state.Status != ParserState.Ready) - { - Assert.Inconclusive("Parser isn't ready. Test cannot proceed."); - } - var declarations = state.AllUserDeclarations; - var target = declarations.SingleOrDefault(d => d.DeclarationType == DeclarationType.Constant); - if (target == null) - { - Assert.Inconclusive("No constant was found in test code."); - } - - var rewriter = state.GetRewriter(target); - rewriter.Remove(target); - - Assert.AreEqual(expected, rewriter.GetText()); - } + var actual = RewrittenForTargetRemovalCode(content, DeclarationType.Constant, target => true); + Assert.AreEqual(expected, actual); } [Test] @@ -160,26 +125,9 @@ Sub DoSomething() Dim foo As String End Sub "; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(content, out _).Object; - using (var state = MockParser.CreateAndParse(vbe)) - { - if (state.Status != ParserState.Ready) - { - Assert.Inconclusive("Parser isn't ready. Test cannot proceed."); - } - - var declarations = state.AllUserDeclarations; - var target = declarations.SingleOrDefault(d => d.DeclarationType == DeclarationType.Variable); - if (target == null) - { - Assert.Inconclusive("No variable was found in test code."); - } - - var rewriter = state.GetRewriter(target); - rewriter.Remove(target); - Assert.AreEqual(expected, rewriter.GetText()); - } + var actual = RewrittenForTargetRemovalCode(content, DeclarationType.Variable, target => true); + Assert.AreEqual(expected, actual); } [Test] @@ -195,27 +143,9 @@ Sub DoSomething() Const foo As String = ""Something"" End Sub "; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(content, out _).Object; - using (var state = MockParser.CreateAndParse(vbe)) - { - if (state.Status != ParserState.Ready) - { - Assert.Inconclusive("Parser isn't ready. Test cannot proceed."); - } - - var declarations = state.AllUserDeclarations; - var target = declarations.SingleOrDefault(d => d.DeclarationType == DeclarationType.Constant); - if (target == null) - { - Assert.Inconclusive("No constant was found in test code."); - } - - var rewriter = state.GetRewriter(target); - rewriter.Remove(target); - var rewrittenCode = rewriter.GetText(); - Assert.AreEqual(expected, rewrittenCode); - } + var actual = RewrittenForTargetRemovalCode(content, DeclarationType.Constant, target => true); + Assert.AreEqual(expected, actual); } [Test] @@ -230,26 +160,9 @@ End Sub Sub DoSomething(ByVal foo As Long) End Sub "; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(content, out _).Object; - using (var state = MockParser.CreateAndParse(vbe)) - { - if (state.Status != ParserState.Ready) - { - Assert.Inconclusive("Parser isn't ready. Test cannot proceed."); - } - var declarations = state.AllUserDeclarations; - var target = declarations.SingleOrDefault(d => d.DeclarationType == DeclarationType.Parameter); - if (target == null) - { - Assert.Inconclusive("No parameter was found in test code."); - } - - var rewriter = state.GetRewriter(target); - rewriter.Remove(target); - - Assert.AreEqual(expected, rewriter.GetText()); - } + var actual = RewrittenForTargetRemovalCode(content, DeclarationType.Parameter, target => true); + Assert.AreEqual(expected, actual); } [Test] @@ -262,26 +175,9 @@ Public Event SomeEvent() const string content = @" Public Event SomeEvent(ByVal foo As Long) "; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(content, out _).Object; - using (var state = MockParser.CreateAndParse(vbe)) - { - if (state.Status != ParserState.Ready) - { - Assert.Inconclusive("Parser isn't ready. Test cannot proceed."); - } - - var declarations = state.AllUserDeclarations; - var target = declarations.SingleOrDefault(d => d.DeclarationType == DeclarationType.Parameter); - if (target == null) - { - Assert.Inconclusive("No parameter was found in test code."); - } - - var rewriter = state.GetRewriter(target); - rewriter.Remove(target); - Assert.AreEqual(expected, rewriter.GetText()); - } + var actual = RewrittenForTargetRemovalCode(content, DeclarationType.Parameter, target => true); + Assert.AreEqual(expected, actual); } [Test] @@ -294,26 +190,9 @@ public void RemovesDeclareFunctionParameterDeclaration() const string content = @" Declare PtrSafe Function Foo Lib ""Z"" Alias ""Y"" (ByVal bar As Long) As Long "; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(content, out _).Object; - using (var state = MockParser.CreateAndParse(vbe)) - { - if (state.Status != ParserState.Ready) - { - Assert.Inconclusive("Parser isn't ready. Test cannot proceed."); - } - - var declarations = state.AllUserDeclarations; - var target = declarations.SingleOrDefault(d => d.DeclarationType == DeclarationType.Parameter); - if (target == null) - { - Assert.Inconclusive("No parameter was found in test code."); - } - - var rewriter = state.GetRewriter(target); - rewriter.Remove(target); - Assert.AreEqual(expected, rewriter.GetText()); - } + var actual = RewrittenForTargetRemovalCode(content, DeclarationType.Parameter, target => true); + Assert.AreEqual(expected, actual); } [Test] @@ -330,26 +209,9 @@ Sub DoSomething() Dim foo As String, bar As Integer End Sub "; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(content, out _).Object; - using (var state = MockParser.CreateAndParse(vbe)) - { - if (state.Status != ParserState.Ready) - { - Assert.Inconclusive("Parser isn't ready. Test cannot proceed."); - } - var declarations = state.AllUserDeclarations; - var target = declarations.SingleOrDefault(d => d.IdentifierName == "foo" && d.DeclarationType == DeclarationType.Variable); - if (target == null) - { - Assert.Inconclusive("No 'foo' variable was found in test code."); - } - - var rewriter = state.GetRewriter(target); - rewriter.Remove(target); - - Assert.AreEqual(expected, rewriter.GetText()); - } + var actual = RewrittenForTargetRemovalCode(content, DeclarationType.Variable, target => target.IdentifierName == "foo"); + Assert.AreEqual(expected, actual); } [Test] @@ -366,26 +228,9 @@ Sub DoSomething() Const foo As String = ""Something"", bar As Integer = 42 End Sub "; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(content, out _).Object; - using (var state = MockParser.CreateAndParse(vbe)) - { - if (state.Status != ParserState.Ready) - { - Assert.Inconclusive("Parser isn't ready. Test cannot proceed."); - } - - var declarations = state.AllUserDeclarations; - var target = declarations.SingleOrDefault(d => d.IdentifierName == "foo" && d.DeclarationType == DeclarationType.Constant); - if (target == null) - { - Assert.Inconclusive("No 'foo' constant was found in test code."); - } - - var rewriter = state.GetRewriter(target); - rewriter.Remove(target); - Assert.AreEqual(expected, rewriter.GetText()); - } + var actual = RewrittenForTargetRemovalCode(content, DeclarationType.Constant, target => target.IdentifierName == "foo"); + Assert.AreEqual(expected, actual); } [Test] @@ -400,26 +245,9 @@ End Sub Sub DoSomething(ByVal foo As Long, ByVal bar As Long) End Sub "; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(content, out _).Object; - using (var state = MockParser.CreateAndParse(vbe)) - { - if (state.Status != ParserState.Ready) - { - Assert.Inconclusive("Parser isn't ready. Test cannot proceed."); - } - - var declarations = state.AllUserDeclarations; - var target = declarations.SingleOrDefault(d => d.IdentifierName == "foo" && d.DeclarationType == DeclarationType.Parameter); - if (target == null) - { - Assert.Inconclusive("No 'foo' parameter was found in test code."); - } - - var rewriter = state.GetRewriter(target); - rewriter.Remove(target); - Assert.AreEqual(expected, rewriter.GetText()); - } + var actual = RewrittenForTargetRemovalCode(content, DeclarationType.Parameter, target => target.IdentifierName == "foo"); + Assert.AreEqual(expected, actual); } [Test] @@ -436,26 +264,9 @@ Sub DoSomething() Dim foo As String, bar As Integer End Sub "; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(content, out _).Object; - using (var state = MockParser.CreateAndParse(vbe)) - { - if (state.Status != ParserState.Ready) - { - Assert.Inconclusive("Parser isn't ready. Test cannot proceed."); - } - var declarations = state.AllUserDeclarations; - var target = declarations.SingleOrDefault(d => d.IdentifierName == "bar" && d.DeclarationType == DeclarationType.Variable); - if (target == null) - { - Assert.Inconclusive("No variable was found in test code."); - } - - var rewriter = state.GetRewriter(target); - rewriter.Remove(target); - - Assert.AreEqual(expected, rewriter.GetText()); - } + var actual = RewrittenForTargetRemovalCode(content, DeclarationType.Variable, target => target.IdentifierName == "bar"); + Assert.AreEqual(expected, actual); } [Test] @@ -470,26 +281,9 @@ End Sub Sub DoSomething(ByVal foo As Long, ByVal bar As Long) End Sub "; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(content, out _).Object; - using (var state = MockParser.CreateAndParse(vbe)) - { - if (state.Status != ParserState.Ready) - { - Assert.Inconclusive("Parser isn't ready. Test cannot proceed."); - } - - var declarations = state.AllUserDeclarations; - var target = declarations.SingleOrDefault(d => d.IdentifierName == "bar" && d.DeclarationType == DeclarationType.Parameter); - if (target == null) - { - Assert.Inconclusive("No parameter was found in test code."); - } - - var rewriter = state.GetRewriter(target); - rewriter.Remove(target); - Assert.AreEqual(expected, rewriter.GetText()); - } + var actual = RewrittenForTargetRemovalCode(content, DeclarationType.Parameter, target => target.IdentifierName == "bar"); + Assert.AreEqual(expected, actual); } [Test] @@ -506,26 +300,9 @@ Sub DoSomething() Const foo As String = ""Something"", bar As Integer = 42 End Sub "; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(content, out _).Object; - using (var state = MockParser.CreateAndParse(vbe)) - { - if (state.Status != ParserState.Ready) - { - Assert.Inconclusive("Parser isn't ready. Test cannot proceed."); - } - - var declarations = state.AllUserDeclarations; - var target = declarations.SingleOrDefault(d => d.IdentifierName == "bar" && d.DeclarationType == DeclarationType.Constant); - if (target == null) - { - Assert.Inconclusive("No 'bar' constant was found in test code."); - } - - var rewriter = state.GetRewriter(target); - rewriter.Remove(target); - Assert.AreEqual(expected, rewriter.GetText()); - } + var actual = RewrittenForTargetRemovalCode(content, DeclarationType.Constant, target => target.IdentifierName == "bar"); + Assert.AreEqual(expected, actual); } [Test] @@ -539,26 +316,9 @@ Private foo _ As _ String "; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(content, out _).Object; - using (var state = MockParser.CreateAndParse(vbe)) - { - if (state.Status != ParserState.Ready) - { - Assert.Inconclusive("Parser isn't ready. Test cannot proceed."); - } - var declarations = state.AllUserDeclarations; - var target = declarations.SingleOrDefault(d => d.DeclarationType == DeclarationType.Variable); - if (target == null) - { - Assert.Inconclusive("No variable was found in test code."); - } - - var rewriter = state.GetRewriter(target); - rewriter.Remove(target); - - Assert.AreEqual(expected, rewriter.GetText()); - } + var actual = RewrittenForTargetRemovalCode(content, DeclarationType.Variable, target => true); + Assert.AreEqual(expected, actual); } [Test] @@ -572,26 +332,9 @@ Private Const foo _ As String = _ ""Something"" "; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(content, out _).Object; - using (var state = MockParser.CreateAndParse(vbe)) - { - if (state.Status != ParserState.Ready) - { - Assert.Inconclusive("Parser isn't ready. Test cannot proceed."); - } - - var declarations = state.AllUserDeclarations; - var target = declarations.SingleOrDefault(d => d.DeclarationType == DeclarationType.Constant); - if (target == null) - { - Assert.Inconclusive("No constant was found in test code."); - } - - var rewriter = state.GetRewriter(target); - rewriter.Remove(target); - Assert.AreEqual(expected, rewriter.GetText()); - } + var actual = RewrittenForTargetRemovalCode(content, DeclarationType.Constant, target => true); + Assert.AreEqual(expected, actual); } [Test] @@ -604,26 +347,9 @@ public void RemovesFirstVariableInDeclarationList() const string expected = @" Private bar As Long "; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(content, out _).Object; - using (var state = MockParser.CreateAndParse(vbe)) - { - if (state.Status != ParserState.Ready) - { - Assert.Inconclusive("Parser isn't ready. Test cannot proceed."); - } - - var declarations = state.AllUserDeclarations; - var target = declarations.SingleOrDefault(d => d.IdentifierName == "foo" && d.DeclarationType == DeclarationType.Variable); - if (target == null) - { - Assert.Inconclusive("Target variable was not found in test code."); - } - - var rewriter = state.GetRewriter(target); - rewriter.Remove(target); - Assert.AreEqual(expected, rewriter.GetText()); - } + var actual = RewrittenForTargetRemovalCode(content, DeclarationType.Variable, target => target.IdentifierName == "foo"); + Assert.AreEqual(expected, actual); } [Test] @@ -636,26 +362,9 @@ public void RemovesFirstConstantInDeclarationList() const string expected = @" Private Const bar As Long = 42 "; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(content, out _).Object; - using (var state = MockParser.CreateAndParse(vbe)) - { - if (state.Status != ParserState.Ready) - { - Assert.Inconclusive("Parser isn't ready. Test cannot proceed."); - } - var declarations = state.AllUserDeclarations; - var target = declarations.SingleOrDefault(d => d.IdentifierName == "foo" && d.DeclarationType == DeclarationType.Constant); - if (target == null) - { - Assert.Inconclusive("Target constant was not found in test code."); - } - - var rewriter = state.GetRewriter(target); - rewriter.Remove(target); - - Assert.AreEqual(expected, rewriter.GetText()); - } + var actual = RewrittenForTargetRemovalCode(content, DeclarationType.Constant, target => target.IdentifierName == "foo"); + Assert.AreEqual(expected, actual); } [Test] @@ -668,26 +377,9 @@ public void RemovesLastVariableInDeclarationList() const string expected = @" Private foo As String "; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(content, out _).Object; - using (var state = MockParser.CreateAndParse(vbe)) - { - if (state.Status != ParserState.Ready) - { - Assert.Inconclusive("Parser isn't ready. Test cannot proceed."); - } - - var declarations = state.AllUserDeclarations; - var target = declarations.SingleOrDefault(d => d.IdentifierName == "bar" && d.DeclarationType == DeclarationType.Variable); - if (target == null) - { - Assert.Inconclusive("Target variable was not found in test code."); - } - - var rewriter = state.GetRewriter(target); - rewriter.Remove(target); - Assert.AreEqual(expected, rewriter.GetText()); - } + var actual = RewrittenForTargetRemovalCode(content, DeclarationType.Variable, target => target.IdentifierName == "bar"); + Assert.AreEqual(expected, actual); } [Test] @@ -700,26 +392,9 @@ public void RemovesLastConstantInDeclarationList() const string expected = @" Private Const foo As String = ""Something"" "; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(content, out _).Object; - using (var state = MockParser.CreateAndParse(vbe)) - { - if (state.Status != ParserState.Ready) - { - Assert.Inconclusive("Parser isn't ready. Test cannot proceed."); - } - - var declarations = state.AllUserDeclarations; - var target = declarations.SingleOrDefault(d => d.IdentifierName == "bar" && d.DeclarationType == DeclarationType.Constant); - if (target == null) - { - Assert.Inconclusive("Target constant was not found in test code."); - } - - var rewriter = state.GetRewriter(target); - rewriter.Remove(target); - Assert.AreEqual(expected, rewriter.GetText()); - } + var actual = RewrittenForTargetRemovalCode(content, DeclarationType.Constant, target => target.IdentifierName == "bar"); + Assert.AreEqual(expected, actual); } [Test] @@ -732,26 +407,9 @@ public void RemovesMiddleVariableInDeclarationList() const string expected = @" Private foo As String, buzz As Integer "; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(content, out _).Object; - using (var state = MockParser.CreateAndParse(vbe)) - { - if (state.Status != ParserState.Ready) - { - Assert.Inconclusive("Parser isn't ready. Test cannot proceed."); - } - var declarations = state.AllUserDeclarations; - var target = declarations.SingleOrDefault(d => d.IdentifierName == "bar" && d.DeclarationType == DeclarationType.Variable); - if (target == null) - { - Assert.Inconclusive("Target variable was not found in test code."); - } - - var rewriter = state.GetRewriter(target); - rewriter.Remove(target); - - Assert.AreEqual(expected, rewriter.GetText()); - } + var actual = RewrittenForTargetRemovalCode(content, DeclarationType.Variable, target => target.IdentifierName == "bar"); + Assert.AreEqual(expected, actual); } [Test] @@ -764,26 +422,9 @@ public void RemovesMiddleConstantInDeclarationList() const string expected = @" Private Const foo As String = ""Something"", buzz As Integer = 12 "; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(content, out _).Object; - using (var state = MockParser.CreateAndParse(vbe)) - { - if (state.Status != ParserState.Ready) - { - Assert.Inconclusive("Parser isn't ready. Test cannot proceed."); - } - - var declarations = state.AllUserDeclarations; - var target = declarations.SingleOrDefault(d => d.IdentifierName == "bar" && d.DeclarationType == DeclarationType.Constant); - if (target == null) - { - Assert.Inconclusive("Target constant was not found in test code."); - } - - var rewriter = state.GetRewriter(target); - rewriter.Remove(target); - Assert.AreEqual(expected, rewriter.GetText()); - } + var actual = RewrittenForTargetRemovalCode(content, DeclarationType.Constant, target => target.IdentifierName == "bar"); + Assert.AreEqual(expected, actual); } [Test] @@ -799,26 +440,9 @@ buzz As Integer Private foo As String, _ buzz As Integer "; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(content, out _).Object; - using (var state = MockParser.CreateAndParse(vbe)) - { - if (state.Status != ParserState.Ready) - { - Assert.Inconclusive("Parser isn't ready. Test cannot proceed."); - } - - var declarations = state.AllUserDeclarations; - var target = declarations.SingleOrDefault(d => d.IdentifierName == "bar" && d.DeclarationType == DeclarationType.Variable); - if (target == null) - { - Assert.Inconclusive("Target variable was found in test code."); - } - - var rewriter = state.GetRewriter(target); - rewriter.Remove(target); - Assert.AreEqual(expected, rewriter.GetText()); - } + var actual = RewrittenForTargetRemovalCode(content, DeclarationType.Variable, target => target.IdentifierName == "bar"); + Assert.AreEqual(expected, actual); } [Test] @@ -837,36 +461,45 @@ Private Const foo _ As String = ""Something"", _ buzz As Integer = 12 "; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(content, out _).Object; - using (var state = MockParser.CreateAndParse(vbe)) + + var actual = RewrittenForTargetRemovalCode(content, DeclarationType.Constant, target => target.IdentifierName == "bar"); + Assert.AreEqual(expected, actual); + } + + private static IProjectsProvider TestProvider(QualifiedModuleName module, ICodeModule testModule) + { + var component = new Mock(); + component.Setup(c => c.CodeModule).Returns(testModule); + var provider = new Mock(); + provider.Setup(p => p.Component(It.IsAny())) + .Returns(qmn => qmn.Equals(module) ? component.Object : null); + return provider.Object; + } + + private string RewrittenForTargetRemovalCode(string inputCode, DeclarationType targetType, Func targetCondition) + { + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _).Object; + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe); + using (state) { if (state.Status != ParserState.Ready) { Assert.Inconclusive("Parser isn't ready. Test cannot proceed."); } - var declarations = state.AllUserDeclarations; - var target = declarations.SingleOrDefault(d => d.IdentifierName == "bar" && d.DeclarationType == DeclarationType.Constant); + var target = state.DeclarationFinder.UserDeclarations(targetType).SingleOrDefault(targetCondition); if (target == null) { - Assert.Inconclusive("Target constant was found in test code."); + Assert.Inconclusive("No target was found in test code."); } - var rewriter = state.GetRewriter(target); + var rewriteSession = rewritingManager.CheckOutCodePaneSession(); + var rewriter = rewriteSession.CheckOutModuleRewriter(target.QualifiedModuleName); + rewriter.Remove(target); - Assert.AreEqual(expected, rewriter.GetText()); + return rewriter.GetText(); } } - - private IProjectsProvider TestProvider(QualifiedModuleName module, ICodeModule testModule) - { - var component = new Mock(); - component.Setup(c => c.CodeModule).Returns(testModule); - var provider = new Mock(); - provider.Setup(p => p.Component(It.IsAny())) - .Returns(qmn => qmn.Equals(module) ? component.Object : null); - return provider.Object; - } } } From a297eabfa64f2e6468e20238440b97f32eec407b Mon Sep 17 00:00:00 2001 From: Max Doerner Date: Fri, 2 Nov 2018 12:26:00 +0100 Subject: [PATCH 12/59] Remove _projectsProvider from ReorderParameter refactoring It was only ever needed because of a superfluous part of the execution. --- .../RefactorReorderParametersCommand.cs | 2 +- .../ReorderParametersRefactoring.cs | 19 ++--- .../Refactoring/ReorderParametersTests.cs | 69 +++++++++---------- 3 files changed, 41 insertions(+), 49 deletions(-) diff --git a/Rubberduck.Core/UI/Command/Refactorings/RefactorReorderParametersCommand.cs b/Rubberduck.Core/UI/Command/Refactorings/RefactorReorderParametersCommand.cs index 7d2c39cd63..0cec0484e8 100644 --- a/Rubberduck.Core/UI/Command/Refactorings/RefactorReorderParametersCommand.cs +++ b/Rubberduck.Core/UI/Command/Refactorings/RefactorReorderParametersCommand.cs @@ -75,7 +75,7 @@ protected override void OnExecute(object parameter) using (var view = new ReorderParametersDialog(new ReorderParametersViewModel(_state))) { var factory = new ReorderParametersPresenterFactory(Vbe, view, _state, _msgbox); - var refactoring = new ReorderParametersRefactoring(Vbe, factory, _msgbox, _state.ProjectsProvider); + var refactoring = new ReorderParametersRefactoring(Vbe, factory, _msgbox); refactoring.Refactor(selection.Value); } } diff --git a/Rubberduck.Refactorings/ReorderParameters/ReorderParametersRefactoring.cs b/Rubberduck.Refactorings/ReorderParameters/ReorderParametersRefactoring.cs index 54cfd1b896..a0ed7f03f7 100644 --- a/Rubberduck.Refactorings/ReorderParameters/ReorderParametersRefactoring.cs +++ b/Rubberduck.Refactorings/ReorderParameters/ReorderParametersRefactoring.cs @@ -3,10 +3,9 @@ using Rubberduck.Parsing; using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Symbols; - using Rubberduck.Resources; +using Rubberduck.Resources; using Rubberduck.VBEditor; using Rubberduck.Parsing.Rewriter; -using Rubberduck.VBEditor.ComManagement; using Rubberduck.VBEditor.SafeComWrappers.Abstract; using System; using System.Collections.Generic; @@ -21,14 +20,13 @@ public class ReorderParametersRefactoring : IRefactoring private ReorderParametersModel _model; private readonly IMessageBox _messageBox; private readonly HashSet _rewriters = new HashSet(); - private readonly IProjectsProvider _projectsProvider; - public ReorderParametersRefactoring(IVBE vbe, IRefactoringPresenterFactory factory, IMessageBox messageBox, IProjectsProvider projectsProvider) + public ReorderParametersRefactoring(IVBE vbe, IRefactoringPresenterFactory factory, + IMessageBox messageBox) { _vbe = vbe; _factory = factory; _messageBox = messageBox; - _projectsProvider = projectsProvider; } public void Refactor() @@ -153,17 +151,14 @@ private void AdjustReferences(IEnumerable references) continue; } - var component = _projectsProvider.Component(reference.QualifiedModuleName); - using (var module = component.CodeModule) - { - RewriteCall(argumentList, module); - } + var module = reference.QualifiedModuleName; + RewriteCall(argumentList, module); } } - private void RewriteCall(VBAParser.ArgumentListContext argList, ICodeModule module) + private void RewriteCall(VBAParser.ArgumentListContext argList, QualifiedModuleName module) { - var rewriter = _model.State.GetRewriter(module.Parent); + var rewriter = _model.State.GetRewriter(module); var args = argList.argument().Select((s, i) => new { Index = i, Text = s.GetText() }).ToList(); for (var i = 0; i < _model.Parameters.Count; i++) diff --git a/RubberduckTests/Refactoring/ReorderParametersTests.cs b/RubberduckTests/Refactoring/ReorderParametersTests.cs index 9ccf0b4939..0d0014a79d 100644 --- a/RubberduckTests/Refactoring/ReorderParametersTests.cs +++ b/RubberduckTests/Refactoring/ReorderParametersTests.cs @@ -1,12 +1,10 @@ using System; using System.Collections.Generic; using System.Linq; -using System.Windows.Forms; using NUnit.Framework; using Moq; using Rubberduck.Refactorings; using Rubberduck.Refactorings.ReorderParameters; -using Rubberduck.UI; using Rubberduck.VBEditor; using Rubberduck.VBEditor.SafeComWrappers; using Rubberduck.VBEditor.SafeComWrappers.Abstract; @@ -35,8 +33,7 @@ public void ReorderParams_SwapPositions() @"Private Sub Foo(ByVal arg2 As String, ByVal arg1 As Integer) End Sub"; - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component, selection); using (var state = MockParser.CreateAndParse(vbe.Object)) { @@ -48,7 +45,7 @@ public void ReorderParams_SwapPositions() var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, state.ProjectsProvider); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode, component.CodeModule.Content()); @@ -84,7 +81,7 @@ public void ReorderParams_SwapPositions_SignatureContainsParamName() var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, state.ProjectsProvider); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode, component.CodeModule.Content()); @@ -128,7 +125,7 @@ Sub Goo() var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, state.ProjectsProvider); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode, component.CodeModule.Content()); @@ -164,7 +161,7 @@ public void ReorderParams_RefactorDeclaration() var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, state.ProjectsProvider); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); refactoring.Refactor(model.TargetDeclaration); Assert.AreEqual(expectedCode, component.CodeModule.Content()); @@ -195,7 +192,7 @@ public void ReorderParams_RefactorDeclaration_FailsInvalidTarget() var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, state.ProjectsProvider); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); try { @@ -249,7 +246,7 @@ public void ReorderParams_WithOptionalParam() var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, state.ProjectsProvider); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode, component.CodeModule.Content()); @@ -295,7 +292,7 @@ End Sub var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, state.ProjectsProvider); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode, component.CodeModule.Content()); @@ -349,7 +346,7 @@ Private Function foo(ByVal b As Integer, ByRef a As Integer) As Integer var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, state.ProjectsProvider); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode, component.CodeModule.Content()); @@ -403,7 +400,7 @@ End Sub //SetupFactory var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, state.ProjectsProvider); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode, component.CodeModule.Content()); @@ -442,7 +439,7 @@ public void ReorderParametersRefactoring_ReorderNamedParams_Function() //SetupFactory var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, state.ProjectsProvider); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode, component.CodeModule.Content()); @@ -496,7 +493,7 @@ End Sub //SetupFactory var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, state.ProjectsProvider); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode, component.CodeModule.Content()); @@ -540,7 +537,7 @@ public void ReorderParametersRefactoring_ReorderGetter() //SetupFactory var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, state.ProjectsProvider); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode, component.CodeModule.Content()); @@ -577,7 +574,7 @@ public void ReorderParametersRefactoring_ReorderLetter() //SetupFactory var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, state.ProjectsProvider); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode, component.CodeModule.Content()); @@ -614,7 +611,7 @@ public void ReorderParametersRefactoring_ReorderSetter() //SetupFactory var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, state.ProjectsProvider); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode, component.CodeModule.Content()); @@ -703,7 +700,7 @@ public void ReorderParametersRefactoring_SignatureOnMultipleLines() //SetupFactory var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, state.ProjectsProvider); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode, component.CodeModule.Content()); @@ -758,7 +755,7 @@ End Sub //SetupFactory var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, state.ProjectsProvider); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode, component.CodeModule.Content()); @@ -803,7 +800,7 @@ End Sub var messageBox = new Mock(); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, messageBox.Object, state.ProjectsProvider); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, messageBox.Object); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(inputCode, component.CodeModule.Content()); @@ -873,7 +870,7 @@ End Sub var messageBox = new Mock(); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, messageBox.Object, state.ProjectsProvider); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, messageBox.Object); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode, component.CodeModule.Content()); @@ -957,7 +954,7 @@ End Sub var messageBox = new Mock(); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, messageBox.Object, state.ProjectsProvider); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, messageBox.Object); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode, component.CodeModule.Content()); @@ -997,7 +994,7 @@ public void ReorderParams_MoveOptionalParamBeforeNonOptionalParamFails() var messageBox = new Mock(); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, messageBox.Object, state.ProjectsProvider); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, messageBox.Object); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(inputCode, component.CodeModule.Content()); @@ -1050,7 +1047,7 @@ End Sub var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, state.ProjectsProvider); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode, component.CodeModule.Content()); @@ -1093,7 +1090,7 @@ Private Property Set Foo(ByVal arg2 As String, ByVal arg1 As Integer, ByVal arg3 //SetupFactory var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, state.ProjectsProvider); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode, component.CodeModule.Content()); @@ -1136,7 +1133,7 @@ Private Property Let Foo(ByVal arg2 As String, ByVal arg1 As Integer, ByVal arg3 //SetupFactory var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, state.ProjectsProvider); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode, component.CodeModule.Content()); @@ -1160,7 +1157,7 @@ public void ReorderParams_PresenterIsNull() var factory = new ReorderParametersPresenterFactory(vbe.Object, null, state, null); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory, null, state.ProjectsProvider); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory, null); refactoring.Refactor(); Assert.AreEqual(inputCode, component.CodeModule.Content()); @@ -1215,7 +1212,7 @@ Private Sub IClass1_DoSomething(ByVal b As String, ByVal a As Integer) //SetupFactory var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, state.ProjectsProvider); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode1, module1.Content()); @@ -1271,7 +1268,7 @@ Private Sub IClass1_DoSomething(ByVal v2 As String, ByVal v1 As Integer) //SetupFactory var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, state.ProjectsProvider); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode1, module1.Content()); @@ -1339,7 +1336,7 @@ Private Sub IClass1_DoSomething(ByVal s As String, ByVal i As Integer) //SetupFactory var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, state.ProjectsProvider); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode1, module1.Content()); @@ -1400,7 +1397,7 @@ Private Sub IClass1_DoSomething(ByVal b As String, ByVal a As Integer) //SetupFactory var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, state.ProjectsProvider); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode1, module1.Content()); @@ -1494,7 +1491,7 @@ Private Sub abc_Foo(ByVal arg2 As String, ByVal arg1 As Integer) //SetupFactory var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, state.ProjectsProvider); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode1, module1.Content()); @@ -1550,7 +1547,7 @@ Private Sub abc_Foo(ByVal arg2 As String, ByVal arg1 As Integer) //SetupFactory var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, state.ProjectsProvider); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode1, module1.Content()); @@ -1606,7 +1603,7 @@ Private Sub abc_Foo(ByVal s As String, ByVal i As Integer) //SetupFactory var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, state.ProjectsProvider); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode1, module1.Content()); @@ -1675,7 +1672,7 @@ Private Sub abc_Foo(ByVal v2 As String, ByVal v1 As Integer) //SetupFactory var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, state.ProjectsProvider); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode1, module1.Content()); From fa74ea361ebc4ffd32181f555d4d819b29ef4ade Mon Sep 17 00:00:00 2001 From: Max Doerner Date: Fri, 2 Nov 2018 12:47:37 +0100 Subject: [PATCH 13/59] Add some comment to quickfixes not using the IRewriteSession handed to them The quickfixes using a refactoring currently cannot pass on the IRewriteSession to the refactoring, which handles its own rewriting separately. Moreover, the AddIdentifierToWhitelistQuickfix does not need it because it is not changing code. --- .../QuickFixes/AddIdentifierToWhiteListQuickFix.cs | 1 + Rubberduck.CodeAnalysis/QuickFixes/EncapsulateFieldQuickFix.cs | 3 ++- .../QuickFixes/MoveFieldCloserToUsageQuickFix.cs | 3 ++- .../QuickFixes/RemoveUnusedParameterQuickFix.cs | 3 ++- .../QuickFixes/RenameDeclarationQuickFix.cs | 3 ++- 5 files changed, 9 insertions(+), 4 deletions(-) diff --git a/Rubberduck.CodeAnalysis/QuickFixes/AddIdentifierToWhiteListQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/AddIdentifierToWhiteListQuickFix.cs index a175c4c54d..83ed7f9c43 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/AddIdentifierToWhiteListQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/AddIdentifierToWhiteListQuickFix.cs @@ -18,6 +18,7 @@ public AddIdentifierToWhiteListQuickFix(IPersistanceService Date: Fri, 2 Nov 2018 13:40:12 +0100 Subject: [PATCH 14/59] Make the RenameRefactoring use a QualifiedSelection? to store the initial selection Previously, it used a tuple of ICodeModule and Selection, which was leaking SCWs. --- .../Rename/RenameRefactoring.cs | 27 ++++++++++++++----- 1 file changed, 21 insertions(+), 6 deletions(-) diff --git a/Rubberduck.Refactorings/Rename/RenameRefactoring.cs b/Rubberduck.Refactorings/Rename/RenameRefactoring.cs index a902caa18f..84b07f3dad 100644 --- a/Rubberduck.Refactorings/Rename/RenameRefactoring.cs +++ b/Rubberduck.Refactorings/Rename/RenameRefactoring.cs @@ -26,7 +26,7 @@ public class RenameRefactoring : IRefactoring private readonly IMessageBox _messageBox; private readonly RubberduckParserState _state; private RenameModel _model; - private Tuple _initialSelection; + private QualifiedSelection? _initialSelection; private readonly List _modulesToRewrite; private readonly Dictionary _renameActions; private readonly List _neverRenameIdentifiers; @@ -43,8 +43,10 @@ public RenameRefactoring(IVBE vbe, IRefactoringPresenterFactory(activeCodePane, activeCodePane.IsWrappingNullReference ? Selection.Empty : activeCodePane.Selection); + using (var activeCodePane = _vbe.ActiveCodePane) + { + _initialSelection = activeCodePane.GetQualifiedSelection(); + } _modulesToRewrite = new List(); _renameActions = new Dictionary { @@ -597,7 +599,7 @@ private void CacheInitialSelection(QualifiedSelection qSelection) { if (!codePane.IsWrappingNullReference) { - _initialSelection = new Tuple(codePane, codePane.Selection); + _initialSelection = codePane.GetQualifiedSelection(); } } } @@ -605,9 +607,22 @@ private void CacheInitialSelection(QualifiedSelection qSelection) private void RestoreInitialSelection() { - if (!_initialSelection.Item1.IsWrappingNullReference) + if (!_initialSelection.HasValue) + { + return; + } + + var qualifiedSelection = _initialSelection.Value; + var component = _state.ProjectsProvider.Component(qualifiedSelection.QualifiedName); + using (var codeModule = component.CodeModule) { - _initialSelection.Item1.Selection = _initialSelection.Item2; + using (var codePane = codeModule.CodePane) + { + if (!codePane.IsWrappingNullReference) + { + codePane.Selection = qualifiedSelection.Selection; + } + } } } From fa2dd3b1f882e154cfd76a20636ab18ff0d356a5 Mon Sep 17 00:00:00 2001 From: Max Doerner Date: Fri, 2 Nov 2018 14:54:44 +0100 Subject: [PATCH 15/59] Rewire the RenameRefactoring and its tests This includes a bug fix to the RewritingManager. --- .../QuickFixes/RenameDeclarationQuickFix.cs | 6 +- .../UI/CodeExplorer/Commands/RenameCommand.cs | 7 +- .../CodePaneRefactorRenameCommand.cs | 7 +- .../FormDesignerRefactorRenameCommand.cs | 7 +- .../ProjectExplorerRefactorRenameCommand.cs | 7 +- .../Rewriter/RewritingManager.cs | 4 +- .../Rename/RenameRefactoring.cs | 150 ++++++++---------- RubberduckTests/Refactoring/RenameTests.cs | 30 ++-- 8 files changed, 110 insertions(+), 108 deletions(-) diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RenameDeclarationQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RenameDeclarationQuickFix.cs index 0028c14c8d..d6a898d95c 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/RenameDeclarationQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/RenameDeclarationQuickFix.cs @@ -16,13 +16,15 @@ public sealed class RenameDeclarationQuickFix : QuickFixBase { private readonly IVBE _vbe; private readonly RubberduckParserState _state; + private readonly IRewritingManager _rewritingManager; private readonly IMessageBox _messageBox; - public RenameDeclarationQuickFix(IVBE vbe, RubberduckParserState state, IMessageBox messageBox) + public RenameDeclarationQuickFix(IVBE vbe, RubberduckParserState state, IMessageBox messageBox, IRewritingManager rewritingManager) : base(typeof(HungarianNotationInspection), typeof(UseMeaningfulNameInspection), typeof(DefaultProjectNameInspection)) { _vbe = vbe; _state = state; + _rewritingManager = rewritingManager; _messageBox = messageBox; } @@ -32,7 +34,7 @@ public override void Fix(IInspectionResult result, IRewriteSession rewriteSessio using (var view = new RenameDialog(new RenameViewModel(_state))) { var factory = new RenamePresenterFactory(_vbe, view, _state); - var refactoring = new RenameRefactoring(_vbe, factory, _messageBox, _state); + var refactoring = new RenameRefactoring(_vbe, factory, _messageBox, _state, _state.ProjectsProvider, _rewritingManager); refactoring.Refactor(result.Target); } } diff --git a/Rubberduck.Core/UI/CodeExplorer/Commands/RenameCommand.cs b/Rubberduck.Core/UI/CodeExplorer/Commands/RenameCommand.cs index 84c194b603..fdde7a567d 100644 --- a/Rubberduck.Core/UI/CodeExplorer/Commands/RenameCommand.cs +++ b/Rubberduck.Core/UI/CodeExplorer/Commands/RenameCommand.cs @@ -2,6 +2,7 @@ using NLog; using Rubberduck.Interaction; using Rubberduck.Navigation.CodeExplorer; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.VBA; using Rubberduck.Refactorings.Rename; using Rubberduck.UI.Command; @@ -15,13 +16,15 @@ public class RenameCommand : CommandBase, IDisposable { private readonly IVBE _vbe; private readonly RubberduckParserState _state; + private readonly IRewritingManager _rewritingManager; private readonly IRefactoringDialog _view; private readonly IMessageBox _msgBox; - public RenameCommand(IVBE vbe, IRefactoringDialog view, RubberduckParserState state, IMessageBox msgBox) : base(LogManager.GetCurrentClassLogger()) + public RenameCommand(IVBE vbe, IRefactoringDialog view, RubberduckParserState state, IMessageBox msgBox, IRewritingManager rewritingManager) : base(LogManager.GetCurrentClassLogger()) { _vbe = vbe; _state = state; + _rewritingManager = rewritingManager; _view = view; _msgBox = msgBox; } @@ -34,7 +37,7 @@ protected override bool EvaluateCanExecute(object parameter) protected override void OnExecute(object parameter) { var factory = new RenamePresenterFactory(_vbe, _view, _state); - var refactoring = new RenameRefactoring(_vbe, factory, _msgBox, _state); + var refactoring = new RenameRefactoring(_vbe, factory, _msgBox, _state, _state.ProjectsProvider, _rewritingManager); refactoring.Refactor(((ICodeExplorerDeclarationViewModel)parameter).Declaration); } diff --git a/Rubberduck.Core/UI/Command/Refactorings/CodePaneRefactorRenameCommand.cs b/Rubberduck.Core/UI/Command/Refactorings/CodePaneRefactorRenameCommand.cs index be5492999e..a2ee18bafa 100644 --- a/Rubberduck.Core/UI/Command/Refactorings/CodePaneRefactorRenameCommand.cs +++ b/Rubberduck.Core/UI/Command/Refactorings/CodePaneRefactorRenameCommand.cs @@ -1,5 +1,6 @@ using System.Runtime.InteropServices; using Rubberduck.Interaction; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.Symbols; using Rubberduck.Parsing.VBA; using Rubberduck.Refactorings.Rename; @@ -12,12 +13,14 @@ namespace Rubberduck.UI.Command.Refactorings public class CodePaneRefactorRenameCommand : RefactorCommandBase { private readonly RubberduckParserState _state; + private readonly IRewritingManager _rewritingManager; private readonly IMessageBox _messageBox; - public CodePaneRefactorRenameCommand(IVBE vbe, RubberduckParserState state, IMessageBox messageBox) + public CodePaneRefactorRenameCommand(IVBE vbe, RubberduckParserState state, IMessageBox messageBox, IRewritingManager rewritingManager) : base (vbe) { _state = state; + _rewritingManager = rewritingManager; _messageBox = messageBox; } @@ -68,7 +71,7 @@ protected override void OnExecute(object parameter) using (var view = new RenameDialog(new RenameViewModel(_state))) { var factory = new RenamePresenterFactory(Vbe, view, _state); - var refactoring = new RenameRefactoring(Vbe, factory, _messageBox, _state); + var refactoring = new RenameRefactoring(Vbe, factory, _messageBox, _state, _state.ProjectsProvider, _rewritingManager); refactoring.Refactor(target); } diff --git a/Rubberduck.Core/UI/Command/Refactorings/FormDesignerRefactorRenameCommand.cs b/Rubberduck.Core/UI/Command/Refactorings/FormDesignerRefactorRenameCommand.cs index 7c874ec5aa..dc3cb89f52 100644 --- a/Rubberduck.Core/UI/Command/Refactorings/FormDesignerRefactorRenameCommand.cs +++ b/Rubberduck.Core/UI/Command/Refactorings/FormDesignerRefactorRenameCommand.cs @@ -1,6 +1,7 @@ using System.Linq; using System.Runtime.InteropServices; using Rubberduck.Interaction; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.Symbols; using Rubberduck.Parsing.VBA; using Rubberduck.Refactorings.Rename; @@ -14,12 +15,14 @@ namespace Rubberduck.UI.Command.Refactorings public class FormDesignerRefactorRenameCommand : RefactorCommandBase { private readonly RubberduckParserState _state; + private readonly IRewritingManager _rewritingManager; private readonly IMessageBox _messageBox; - public FormDesignerRefactorRenameCommand(IVBE vbe, RubberduckParserState state, IMessageBox messageBox) + public FormDesignerRefactorRenameCommand(IVBE vbe, RubberduckParserState state, IMessageBox messageBox, IRewritingManager rewritingManager) : base (vbe) { _state = state; + _rewritingManager = rewritingManager; _messageBox = messageBox; } @@ -34,7 +37,7 @@ protected override void OnExecute(object parameter) using (var view = new RenameDialog(new RenameViewModel(_state))) { var factory = new RenamePresenterFactory(Vbe, view, _state); - var refactoring = new RenameRefactoring(Vbe, factory, _messageBox, _state); + var refactoring = new RenameRefactoring(Vbe, factory, _messageBox, _state, _state.ProjectsProvider, _rewritingManager); var target = GetTarget(); diff --git a/Rubberduck.Core/UI/Command/Refactorings/ProjectExplorerRefactorRenameCommand.cs b/Rubberduck.Core/UI/Command/Refactorings/ProjectExplorerRefactorRenameCommand.cs index a752a38052..a9e183a414 100644 --- a/Rubberduck.Core/UI/Command/Refactorings/ProjectExplorerRefactorRenameCommand.cs +++ b/Rubberduck.Core/UI/Command/Refactorings/ProjectExplorerRefactorRenameCommand.cs @@ -1,6 +1,7 @@ using System.Linq; using System.Runtime.InteropServices; using Rubberduck.Interaction; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.Symbols; using Rubberduck.Parsing.VBA; using Rubberduck.Refactorings.Rename; @@ -13,12 +14,14 @@ namespace Rubberduck.UI.Command.Refactorings public class ProjectExplorerRefactorRenameCommand : RefactorCommandBase { private readonly RubberduckParserState _state; + private readonly IRewritingManager _rewritingManager; private readonly IMessageBox _msgBox; - public ProjectExplorerRefactorRenameCommand(IVBE vbe, RubberduckParserState state, IMessageBox msgBox) + public ProjectExplorerRefactorRenameCommand(IVBE vbe, RubberduckParserState state, IMessageBox msgBox, IRewritingManager rewritingManager) : base (vbe) { _state = state; + _rewritingManager = rewritingManager; _msgBox = msgBox; } @@ -32,7 +35,7 @@ protected override void OnExecute(object parameter) using (var view = new RenameDialog(new RenameViewModel(_state))) { var factory = new RenamePresenterFactory(Vbe, view, _state); - var refactoring = new RenameRefactoring(Vbe, factory, _msgBox, _state); + var refactoring = new RenameRefactoring(Vbe, factory, _msgBox, _state, _state.ProjectsProvider, _rewritingManager); var target = GetTarget(); diff --git a/Rubberduck.Parsing/Rewriter/RewritingManager.cs b/Rubberduck.Parsing/Rewriter/RewritingManager.cs index d8c9e155dd..02b9a353e5 100644 --- a/Rubberduck.Parsing/Rewriter/RewritingManager.cs +++ b/Rubberduck.Parsing/Rewriter/RewritingManager.cs @@ -58,10 +58,10 @@ private bool IsCurrentlyActive(IRewriteSession rewriteSession) { switch (rewriteSession) { + case CodePaneRewriteSession codePaneSession: + return _activeCodePaneSessions.Contains(codePaneSession); case AttributesRewriteSession attributeSession: return _activeAttributesSessions.Contains(attributeSession); - case CodePaneRewriteSession codePaneSession: - return _activeAttributesSessions.Contains(codePaneSession); default: throw new NotSupportedException(nameof(rewriteSession)); } diff --git a/Rubberduck.Refactorings/Rename/RenameRefactoring.cs b/Rubberduck.Refactorings/Rename/RenameRefactoring.cs index 84b07f3dad..241d556dd5 100644 --- a/Rubberduck.Refactorings/Rename/RenameRefactoring.cs +++ b/Rubberduck.Refactorings/Rename/RenameRefactoring.cs @@ -12,6 +12,8 @@ using System.Runtime.InteropServices; using System.Collections.Generic; using Rubberduck.Parsing.Grammar; +using Rubberduck.Parsing.Rewriter; +using Rubberduck.VBEditor.ComManagement; using Rubberduck.VBEditor.SafeComWrappers; namespace Rubberduck.Refactorings.Rename @@ -24,31 +26,32 @@ public class RenameRefactoring : IRefactoring private readonly IVBE _vbe; private readonly IRefactoringPresenterFactory _factory; private readonly IMessageBox _messageBox; - private readonly RubberduckParserState _state; + private readonly IDeclarationFinderProvider _declarationFinderProvider; + private readonly IProjectsProvider _projectsProvider; + private readonly IRewritingManager _rewritingManager; private RenameModel _model; private QualifiedSelection? _initialSelection; - private readonly List _modulesToRewrite; - private readonly Dictionary _renameActions; + private readonly IDictionary> _renameActions; private readonly List _neverRenameIdentifiers; private bool IsInterfaceMemberRename { set; get; } private bool IsControlEventHandlerRename { set; get; } private bool IsUserEventHandlerRename { set; get; } - private bool RequestParseAfterRename { set; get; } - public RenameRefactoring(IVBE vbe, IRefactoringPresenterFactory factory, IMessageBox messageBox, RubberduckParserState state) + public RenameRefactoring(IVBE vbe, IRefactoringPresenterFactory factory, IMessageBox messageBox, IDeclarationFinderProvider declarationFinderProvider, IProjectsProvider projectsProvider, IRewritingManager rewritingManager) { _vbe = vbe; _factory = factory; _messageBox = messageBox; - _state = state; + _declarationFinderProvider = declarationFinderProvider; + _projectsProvider = projectsProvider; + _rewritingManager = rewritingManager; _model = null; using (var activeCodePane = _vbe.ActiveCodePane) { _initialSelection = activeCodePane.GetQualifiedSelection(); } - _modulesToRewrite = new List(); - _renameActions = new Dictionary + _renameActions = new Dictionary> { {DeclarationType.Member, RenameMember}, {DeclarationType.Parameter, RenameParameter}, @@ -58,7 +61,6 @@ public RenameRefactoring(IVBE vbe, IRefactoringPresenterFactory item.Name == target.IdentifierName)) @@ -229,7 +231,7 @@ private bool IsValidTarget(Declaration target) } else if (target.DeclarationType.HasFlag(DeclarationType.Module)) { - var component = _state.ProjectsProvider.Component(target.QualifiedName.QualifiedModuleName); + var component = _projectsProvider.Component(target.QualifiedName.QualifiedModuleName); using (var module = component.CodeModule) { if (module.IsWrappingNullReference) @@ -247,7 +249,7 @@ private bool TrySetNewName(IRenamePresenter presenter) var result = presenter.Show(_model.Target); if (result == null) { return false; } - var conflicts = _state.DeclarationFinder.FindNewDeclarationNameConflicts(_model.NewName, _model.Target); + var conflicts = _declarationFinderProvider.DeclarationFinder.FindNewDeclarationNameConflicts(_model.NewName, _model.Target); if (conflicts.Any()) { @@ -261,7 +263,7 @@ private bool TrySetNewName(IRenamePresenter presenter) private Declaration ResolveEventHandlerToControl(Declaration userTarget) { - var control = _state.DeclarationFinder.UserDeclarations(DeclarationType.Control) + var control = _declarationFinderProvider.DeclarationFinder.UserDeclarations(DeclarationType.Control) .FirstOrDefault(ctrl => userTarget.Scope.StartsWith($"{ctrl.ParentScope}.{ctrl.IdentifierName}_")); IsControlEventHandlerRename = control != null; @@ -271,7 +273,7 @@ private Declaration ResolveEventHandlerToControl(Declaration userTarget) private Declaration ResolveEventHandlerToUserEvent(Declaration userTarget) { - var withEventsDeclarations = _state.DeclarationFinder.UserDeclarations(DeclarationType.Variable) + var withEventsDeclarations = _declarationFinderProvider.DeclarationFinder.UserDeclarations(DeclarationType.Variable) .Where(varDec => varDec.IsWithEvents).ToList(); if (!withEventsDeclarations.Any()) { return null; } @@ -280,11 +282,11 @@ private Declaration ResolveEventHandlerToUserEvent(Declaration userTarget) { if (userTarget.IdentifierName.StartsWith($"{withEvent.IdentifierName}_")) { - if (_state.DeclarationFinder.FindHandlersForWithEventsField(withEvent).Contains(userTarget)) + if (_declarationFinderProvider.DeclarationFinder.FindHandlersForWithEventsField(withEvent).Contains(userTarget)) { var eventName = userTarget.IdentifierName.Remove(0, $"{withEvent.IdentifierName}_".Length); - var eventDeclaration = _state.DeclarationFinder.UserDeclarations(DeclarationType.Event).FirstOrDefault(ev => ev.IdentifierName.Equals(eventName) + var eventDeclaration = _declarationFinderProvider.DeclarationFinder.UserDeclarations(DeclarationType.Event).FirstOrDefault(ev => ev.IdentifierName.Equals(eventName) && withEvent.AsTypeName.Equals(ev.ParentDeclaration.IdentifierName)); IsUserEventHandlerRename = eventDeclaration != null; @@ -306,7 +308,7 @@ private Declaration ResolveRenameTargetIfInterfaceImplementationSelected(Declara return interfaceMember; } - private void Rename() + private void Rename(IRewriteSession rewriteSession) { Debug.Assert(!_model.NewName.Equals(_model.Target.IdentifierName, StringComparison.InvariantCultureIgnoreCase), $"input validation fail: New Name equals Original Name ({_model.Target.IdentifierName})"); @@ -315,31 +317,31 @@ private void Rename() if (actionKeys.Any()) { Debug.Assert(actionKeys.Count == 1, $"{actionKeys.Count} Rename Actions have flag '{_model.Target.DeclarationType.ToString()}'"); - _renameActions[actionKeys.FirstOrDefault()](); + _renameActions[actionKeys.FirstOrDefault()](rewriteSession); } else { - RenameStandardElements(_model.Target, _model.NewName); + RenameStandardElements(_model.Target, _model.NewName, rewriteSession); } } - private void RenameMember() + private void RenameMember(IRewriteSession rewriteSession) { if (_model.Target.DeclarationType.HasFlag(DeclarationType.Property)) { - var members = _state.DeclarationFinder.MatchName(_model.Target.IdentifierName) + var members = _declarationFinderProvider.DeclarationFinder.MatchName(_model.Target.IdentifierName) .Where(item => item.ProjectId == _model.Target.ProjectId && item.ComponentName == _model.Target.ComponentName && item.DeclarationType.HasFlag(DeclarationType.Property)); foreach (var member in members) { - RenameStandardElements(member, _model.NewName); + RenameStandardElements(member, _model.NewName, rewriteSession); } } else { - RenameStandardElements(_model.Target, _model.NewName); + RenameStandardElements(_model.Target, _model.NewName, rewriteSession); } if (!IsInterfaceMemberRename) @@ -347,18 +349,18 @@ private void RenameMember() return; } - var implementations = _state.DeclarationFinder.FindAllInterfaceImplementingMembers() + var implementations = _declarationFinderProvider.DeclarationFinder.FindAllInterfaceImplementingMembers() .Where(impl => ReferenceEquals(_model.Target.ParentDeclaration, impl.InterfaceImplemented) && impl.InterfaceMemberImplemented.IdentifierName.Equals(_model.Target.IdentifierName)); - RenameDefinedFormatMembers(implementations.ToList(), PrependUnderscoreFormat); + RenameDefinedFormatMembers(implementations.ToList(), PrependUnderscoreFormat, rewriteSession); } - private void RenameParameter() + private void RenameParameter(IRewriteSession rewriteSession) { if (_model.Target.ParentDeclaration.DeclarationType.HasFlag(DeclarationType.Property)) { - var parameters = _state.DeclarationFinder.MatchName(_model.Target.IdentifierName).Where(param => + var parameters = _declarationFinderProvider.DeclarationFinder.MatchName(_model.Target.IdentifierName).Where(param => param.ParentDeclaration.DeclarationType.HasFlag(DeclarationType.Property) && param.DeclarationType == DeclarationType.Parameter && param.ParentDeclaration.IdentifierName.Equals(_model.Target.ParentDeclaration.IdentifierName) @@ -366,38 +368,38 @@ private void RenameParameter() foreach (var param in parameters) { - RenameStandardElements(param, _model.NewName); + RenameStandardElements(param, _model.NewName, rewriteSession); } } else { - RenameStandardElements(_model.Target, _model.NewName); + RenameStandardElements(_model.Target, _model.NewName, rewriteSession); } } - private void RenameEvent() + private void RenameEvent(IRewriteSession rewriteSession) { - RenameStandardElements(_model.Target, _model.NewName); + RenameStandardElements(_model.Target, _model.NewName, rewriteSession); - var withEventsDeclarations = _state.DeclarationFinder.UserDeclarations(DeclarationType.Variable) + var withEventsDeclarations = _declarationFinderProvider.DeclarationFinder.UserDeclarations(DeclarationType.Variable) .Where(varDec => varDec.IsWithEvents && varDec.AsTypeName.Equals(_model.Target.ParentDeclaration.IdentifierName)); - var eventHandlers = withEventsDeclarations.SelectMany(we => _state.DeclarationFinder.FindHandlersForWithEventsField(we)); - RenameDefinedFormatMembers(eventHandlers.ToList(), PrependUnderscoreFormat); + var eventHandlers = withEventsDeclarations.SelectMany(we => _declarationFinderProvider.DeclarationFinder.FindHandlersForWithEventsField(we)); + RenameDefinedFormatMembers(eventHandlers.ToList(), PrependUnderscoreFormat, rewriteSession); } - private void RenameVariable() + private void RenameVariable(IRewriteSession rewriteSession) { if ((_model.Target.Accessibility == Accessibility.Public || _model.Target.Accessibility == Accessibility.Implicit) && _model.Target.ParentDeclaration is ClassModuleDeclaration classDeclaration && classDeclaration.Subtypes.Any()) { - RenameMember(); + RenameMember(rewriteSession); } else if (_model.Target.DeclarationType.HasFlag(DeclarationType.Control)) { - var component = _state.ProjectsProvider.Component(_model.Target.QualifiedName.QualifiedModuleName); + var component = _projectsProvider.Component(_model.Target.QualifiedName.QualifiedModuleName); using (var controls = component.Controls) { using (var control = controls.SingleOrDefault(item => item.Name == _model.Target.IdentifierName)) @@ -408,26 +410,24 @@ private void RenameVariable() control.Name = _model.NewName; } } - RenameReferences(_model.Target, _model.NewName); + RenameReferences(_model.Target, _model.NewName, rewriteSession); var controlEventHandlers = FindEventHandlersForControl(_model.Target); - RenameDefinedFormatMembers(controlEventHandlers.ToList(), AppendUnderscoreFormat); + RenameDefinedFormatMembers(controlEventHandlers.ToList(), AppendUnderscoreFormat, rewriteSession); } else { - RenameStandardElements(_model.Target, _model.NewName); + RenameStandardElements(_model.Target, _model.NewName, rewriteSession); if (_model.Target.IsWithEvents) { - var eventHandlers = _state.DeclarationFinder.FindHandlersForWithEventsField(_model.Target); - RenameDefinedFormatMembers(eventHandlers.ToList(), AppendUnderscoreFormat); + var eventHandlers = _declarationFinderProvider.DeclarationFinder.FindHandlersForWithEventsField(_model.Target); + RenameDefinedFormatMembers(eventHandlers.ToList(), AppendUnderscoreFormat, rewriteSession); } } } - private void RenameModule() + private void RenameModule(IRewriteSession rewriteSession) { - RequestParseAfterRename = false; - - RenameReferences(_model.Target, _model.NewName); + RenameReferences(_model.Target, _model.NewName, rewriteSession); if (_model.Target.DeclarationType.HasFlag(DeclarationType.ClassModule)) { @@ -436,12 +436,12 @@ private void RenameModule() var ctxt = reference.Context.GetAncestor(); if (ctxt != null) { - RenameDefinedFormatMembers(_state.DeclarationFinder.FindInterfaceMembersForImplementsContext(ctxt).ToList(), AppendUnderscoreFormat); + RenameDefinedFormatMembers(_declarationFinderProvider.DeclarationFinder.FindInterfaceMembersForImplementsContext(ctxt).ToList(), AppendUnderscoreFormat, rewriteSession); } } } - var component = _state.ProjectsProvider.Component(_model.Target.QualifiedName.QualifiedModuleName); + var component = _projectsProvider.Component(_model.Target.QualifiedName.QualifiedModuleName); switch (component.Type) { case ComponentType.Document: @@ -489,9 +489,9 @@ private void RenameModule() } } - private void RenameProject() + //The parameter is not used, but it is required for the _renameActions dictionary. + private void RenameProject(IRewriteSession rewriteSession) { - RequestParseAfterRename = false; var project = ProjectById(_vbe, _model.Target.ProjectId); if (project != null) @@ -517,7 +517,7 @@ private IVBProject ProjectById(IVBE vbe, string projectId) return null; } - private void RenameDefinedFormatMembers(IReadOnlyCollection members, string underscoreFormat) + private void RenameDefinedFormatMembers(IReadOnlyCollection members, string underscoreFormat, IRewriteSession rewriteSession) { if (!members.Any()) { return; } @@ -526,17 +526,17 @@ private void RenameDefinedFormatMembers(IReadOnlyCollection members foreach (var member in members) { var newMemberName = member.IdentifierName.Replace(targetFragment, replacementFragment); - RenameStandardElements(member, newMemberName); + RenameStandardElements(member, newMemberName, rewriteSession); } } - private void RenameStandardElements(Declaration target, string newName) + private void RenameStandardElements(Declaration target, string newName, IRewriteSession rewriteSession) { - RenameReferences(target, newName); - RenameDeclaration(target, newName); + RenameReferences(target, newName, rewriteSession); + RenameDeclaration(target, newName, rewriteSession); } - private void RenameReferences(Declaration target, string newName) + private void RenameReferences(Declaration target, string newName, IRewriteSession rewriteSession) { var modules = target.References .Where(reference => @@ -544,8 +544,7 @@ private void RenameReferences(Declaration target, string newName) foreach (var grouping in modules) { - _modulesToRewrite.Add(grouping.Key); - var rewriter = _state.GetRewriter(grouping.Key); + var rewriter = rewriteSession.CheckOutModuleRewriter(grouping.Key); foreach (var reference in grouping) { rewriter.Replace(reference.Context, newName); @@ -553,10 +552,9 @@ private void RenameReferences(Declaration target, string newName) } } - private void RenameDeclaration(Declaration target, string newName) + private void RenameDeclaration(Declaration target, string newName, IRewriteSession rewriteSession) { - _modulesToRewrite.Add(target.QualifiedName.QualifiedModuleName); - var rewriter = _state.GetRewriter(target.QualifiedName.QualifiedModuleName); + var rewriter = rewriteSession.CheckOutModuleRewriter(target.QualifiedName.QualifiedModuleName); if (target.Context is IIdentifierContext context) { @@ -564,27 +562,11 @@ private void RenameDeclaration(Declaration target, string newName) } } - private void Rewrite() - { - foreach (var module in _modulesToRewrite.Distinct()) - { - _state.GetRewriter(module).Rewrite(); - } - } - - private void Reparse() - { - if (RequestParseAfterRename) - { - _state.OnParseRequested(this); - } - } - private IEnumerable FindEventHandlersForControl(Declaration control) { if (control != null && control.DeclarationType.HasFlag(DeclarationType.Control)) { - return _state.DeclarationFinder.FindEventHandlers() + return _declarationFinderProvider.DeclarationFinder.FindEventHandlers() .Where(ev => ev.Scope.StartsWith($"{control.ParentScope}.{control.IdentifierName}_")); } return Enumerable.Empty(); @@ -592,7 +574,7 @@ private IEnumerable FindEventHandlersForControl(Declaration control private void CacheInitialSelection(QualifiedSelection qSelection) { - var component = _state.ProjectsProvider.Component(qSelection.QualifiedName); + var component = _projectsProvider.Component(qSelection.QualifiedName); using (var codeModule = component.CodeModule) { using (var codePane = codeModule.CodePane) @@ -613,7 +595,7 @@ private void RestoreInitialSelection() } var qualifiedSelection = _initialSelection.Value; - var component = _state.ProjectsProvider.Component(qualifiedSelection.QualifiedName); + var component = _projectsProvider.Component(qualifiedSelection.QualifiedName); using (var codeModule = component.CodeModule) { using (var codePane = codeModule.CodePane) @@ -639,7 +621,7 @@ private string BuildDefaultErrorMessage(Declaration target) private List NeverRenameList() { - return _state.DeclarationFinder.FindEventHandlers() + return _declarationFinderProvider.DeclarationFinder.FindEventHandlers() .Where(ev => ev.IdentifierName.StartsWith("Class_") || ev.IdentifierName.StartsWith("UserForm_") || ev.IdentifierName.StartsWith("auto_")) diff --git a/RubberduckTests/Refactoring/RenameTests.cs b/RubberduckTests/Refactoring/RenameTests.cs index ff2f4d283f..33fcb38858 100644 --- a/RubberduckTests/Refactoring/RenameTests.cs +++ b/RubberduckTests/Refactoring/RenameTests.cs @@ -14,6 +14,7 @@ using Rubberduck.UI.Refactorings.Rename; using Rubberduck.Interaction; using Rubberduck.Common; +using Rubberduck.Parsing.Rewriter; namespace RubberduckTests.Refactoring { @@ -1857,7 +1858,8 @@ public void RenameRefactoring_RenameCodeModule() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleModule(inputCode, "Class1", ComponentType.ClassModule, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -1871,7 +1873,7 @@ public void RenameRefactoring_RenameCodeModule() var factory = SetupFactory(model); - var refactoring = new RenameRefactoring(vbeWrapper, factory.Object, msgbox.Object, state); + var refactoring = new RenameRefactoring(vbeWrapper, factory.Object, msgbox.Object, state, state.ProjectsProvider, rewritingManager); refactoring.Refactor(model.Target); Assert.AreSame(newName, component.CodeModule.Name); @@ -1895,7 +1897,8 @@ public void RenameRefactoring_RenameProject() .AddProjectToVbeBuilder() .Build(); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var msgbox = new Mock(); @@ -1907,7 +1910,7 @@ public void RenameRefactoring_RenameProject() var factory = SetupFactory(model); - var refactoring = new RenameRefactoring(vbeWrapper, factory.Object, msgbox.Object, state); + var refactoring = new RenameRefactoring(vbeWrapper, factory.Object, msgbox.Object, state, state.ProjectsProvider, rewritingManager); refactoring.Refactor(model.Target); Assert.AreEqual(newName, vbe.Object.VBProjects[0].Name); @@ -2494,7 +2497,8 @@ public void Rename_PresenterIsNull() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var codePaneMock = new Mock(); @@ -2505,7 +2509,7 @@ public void Rename_PresenterIsNull() var vbeWrapper = vbe.Object; var factory = new RenamePresenterFactory(vbeWrapper, null, state); - var refactoring = new RenameRefactoring(vbeWrapper, factory, null, state); + var refactoring = new RenameRefactoring(vbeWrapper, factory, null, state, state.ProjectsProvider, rewritingManager); refactoring.Refactor(); var rewriter = state.GetRewriter(component); @@ -2641,7 +2645,8 @@ public void RenameRefactoring_RenameClassModule_DoesNotChangeMeReferences() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleModule(inputCode, "ClassModule1", ComponentType.ClassModule, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -2655,7 +2660,7 @@ public void RenameRefactoring_RenameClassModule_DoesNotChangeMeReferences() var factory = SetupFactory(model); - var refactoring = new RenameRefactoring(vbeWrapper, factory.Object, msgbox.Object, state); + var refactoring = new RenameRefactoring(vbeWrapper, factory.Object, msgbox.Object, state, state.ProjectsProvider, rewritingManager); refactoring.Refactor(model.Target); Assert.AreSame(newName, component.CodeModule.Name); @@ -2727,7 +2732,7 @@ private static void InitializeTestDataObject(RenameTestsDataObject tdo tdo.MsgBox.Setup(m => m.ConfirmYesNo(It.IsAny(), It.IsAny(), It.IsAny())).Returns(tdo.MsgBoxReturn == ConfirmationOutcome.Yes); tdo.VBE = tdo.VBE ?? BuildProject(tdo.ProjectName, tdo.ModuleTestSetupDefs); - tdo.ParserState = MockParser.CreateAndParse(tdo.VBE); + (tdo.ParserState, tdo.RewritingManager) = MockParser.CreateAndParseWithRewritingManager(tdo.VBE); CreateQualifiedSelectionForTestCase(tdo); tdo.RenameModel = new RenameModel(tdo.VBE, tdo.ParserState, tdo.QualifiedSelection) { NewName = tdo.NewName }; @@ -2736,7 +2741,7 @@ private static void InitializeTestDataObject(RenameTestsDataObject tdo var factory = SetupFactory(tdo.RenameModel); - tdo.RenameRefactoringUnderTest = new RenameRefactoring(tdo.VBE, factory.Object, tdo.MsgBox.Object, tdo.ParserState); + tdo.RenameRefactoringUnderTest = new RenameRefactoring(tdo.VBE, factory.Object, tdo.MsgBox.Object, tdo.ParserState, tdo.ParserState.ProjectsProvider, tdo.RewritingManager); } private static void AddTestModuleDefinition(RenameTestsDataObject tdo, RenameTestModuleDefinition inputOutput) @@ -2783,9 +2788,9 @@ private static void CheckRenameRefactorTestResults(RenameTestsDataObject tdo) { if (inputOutput.CheckExpectedEqualsActual) { - var rewriter = tdo.ParserState.GetRewriter(RetrieveComponent(tdo, inputOutput.ModuleName).CodeModule.Parent); + var codeModule = RetrieveComponent(tdo, inputOutput.ModuleName).CodeModule; var expected = inputOutput.Expected; - var actual = rewriter.GetText(); + var actual = codeModule.Content(); Assert.AreEqual(expected, actual); } } @@ -2925,6 +2930,7 @@ public RenameTestsDataObject(string selection, string newName) public IVBE VBE { get; set; } public RubberduckParserState ParserState { get; set; } + public IRewritingManager RewritingManager { get; set; } public string ProjectName { get; set; } public string NewName { get; set; } public string SelectionModuleName { get; set; } From 3d55d22b6590200ff3e4d8fd38674cb2b7aac77f Mon Sep 17 00:00:00 2001 From: Max Doerner Date: Fri, 2 Nov 2018 22:27:41 +0100 Subject: [PATCH 16/59] Rewire the ReorderParametersRefactoring and its tests The ReorderParametersCommand and its tests had to change, too. --- .../RefactorReorderParametersCommand.cs | 7 +- .../ReorderParametersRefactoring.cs | 58 ++--- .../Commands/RefactorCommandTests.cs | 224 +++++++++++------- .../Refactoring/ReorderParametersTests.cs | 181 ++++++++------ 4 files changed, 284 insertions(+), 186 deletions(-) diff --git a/Rubberduck.Core/UI/Command/Refactorings/RefactorReorderParametersCommand.cs b/Rubberduck.Core/UI/Command/Refactorings/RefactorReorderParametersCommand.cs index 0cec0484e8..d78f996956 100644 --- a/Rubberduck.Core/UI/Command/Refactorings/RefactorReorderParametersCommand.cs +++ b/Rubberduck.Core/UI/Command/Refactorings/RefactorReorderParametersCommand.cs @@ -2,6 +2,7 @@ using System.Runtime.InteropServices; using Rubberduck.Common; using Rubberduck.Interaction; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.Symbols; using Rubberduck.Parsing.VBA; using Rubberduck.Refactorings.ReorderParameters; @@ -14,12 +15,14 @@ namespace Rubberduck.UI.Command.Refactorings public class RefactorReorderParametersCommand : RefactorCommandBase { private readonly RubberduckParserState _state; + private readonly IRewritingManager _rewritingManager; private readonly IMessageBox _msgbox; - public RefactorReorderParametersCommand(IVBE vbe, RubberduckParserState state, IMessageBox msgbox) + public RefactorReorderParametersCommand(IVBE vbe, RubberduckParserState state, IMessageBox msgbox, IRewritingManager rewritingManager) : base (vbe) { _state = state; + _rewritingManager = rewritingManager; _msgbox = msgbox; } @@ -75,7 +78,7 @@ protected override void OnExecute(object parameter) using (var view = new ReorderParametersDialog(new ReorderParametersViewModel(_state))) { var factory = new ReorderParametersPresenterFactory(Vbe, view, _state, _msgbox); - var refactoring = new ReorderParametersRefactoring(Vbe, factory, _msgbox); + var refactoring = new ReorderParametersRefactoring(Vbe, factory, _msgbox, _rewritingManager); refactoring.Refactor(selection.Value); } } diff --git a/Rubberduck.Refactorings/ReorderParameters/ReorderParametersRefactoring.cs b/Rubberduck.Refactorings/ReorderParameters/ReorderParametersRefactoring.cs index a0ed7f03f7..d97435338d 100644 --- a/Rubberduck.Refactorings/ReorderParameters/ReorderParametersRefactoring.cs +++ b/Rubberduck.Refactorings/ReorderParameters/ReorderParametersRefactoring.cs @@ -19,14 +19,15 @@ public class ReorderParametersRefactoring : IRefactoring private readonly IRefactoringPresenterFactory _factory; private ReorderParametersModel _model; private readonly IMessageBox _messageBox; - private readonly HashSet _rewriters = new HashSet(); + private readonly IRewritingManager _rewritingManager; public ReorderParametersRefactoring(IVBE vbe, IRefactoringPresenterFactory factory, - IMessageBox messageBox) + IMessageBox messageBox, IRewritingManager rewritingManager) { _vbe = vbe; _factory = factory; _messageBox = messageBox; + _rewritingManager = rewritingManager; } public void Refactor() @@ -52,21 +53,16 @@ public void Refactor() var oldSelection = pane.GetQualifiedSelection(); - AdjustReferences(_model.TargetDeclaration.References); - AdjustSignatures(); + var rewriteSession = _rewritingManager.CheckOutCodePaneSession(); + AdjustReferences(_model.TargetDeclaration.References, rewriteSession); + AdjustSignatures(rewriteSession); + rewriteSession.Rewrite(); if (oldSelection.HasValue && !pane.IsWrappingNullReference) { pane.Selection = oldSelection.Value.Selection; } } - - foreach (var rewriter in _rewriters) - { - rewriter.Rewrite(); - } - - _model.State.OnParseRequested(this); } public void Refactor(QualifiedSelection target) @@ -126,7 +122,7 @@ private bool IsValidParamOrder() return false; } - private void AdjustReferences(IEnumerable references) + private void AdjustReferences(IEnumerable references, IRewriteSession rewriteSession) { foreach (var reference in references.Where(item => item.Context != _model.TargetDeclaration.Context)) { @@ -152,13 +148,13 @@ private void AdjustReferences(IEnumerable references) } var module = reference.QualifiedModuleName; - RewriteCall(argumentList, module); + RewriteCall(argumentList, module, rewriteSession); } } - private void RewriteCall(VBAParser.ArgumentListContext argList, QualifiedModuleName module) + private void RewriteCall(VBAParser.ArgumentListContext argList, QualifiedModuleName module, IRewriteSession rewriteSession) { - var rewriter = _model.State.GetRewriter(module); + var rewriter = rewriteSession.CheckOutModuleRewriter(module); var args = argList.argument().Select((s, i) => new { Index = i, Text = s.GetText() }).ToList(); for (var i = 0; i < _model.Parameters.Count; i++) @@ -171,11 +167,9 @@ private void RewriteCall(VBAParser.ArgumentListContext argList, QualifiedModuleN var arg = argList.argument()[i]; rewriter.Replace(arg, args.Single(s => s.Index == _model.Parameters[i].Index).Text); } - - _rewriters.Add(rewriter); } - private void AdjustSignatures() + private void AdjustSignatures(IRewriteSession rewriteSession) { var proc = (dynamic)_model.TargetDeclaration.Context; var paramList = (VBAParser.ArgListContext)proc.argList(); @@ -189,8 +183,8 @@ private void AdjustSignatures() if (setter != null) { - AdjustSignatures(setter); - AdjustReferences(setter.References); + AdjustSignatures(setter, rewriteSession); + AdjustReferences(setter.References, rewriteSession); } var letter = _model.Declarations.FirstOrDefault(item => item.ParentScope == _model.TargetDeclaration.ParentScope && @@ -199,19 +193,19 @@ private void AdjustSignatures() if (letter != null) { - AdjustSignatures(letter); - AdjustReferences(letter.References); + AdjustSignatures(letter, rewriteSession); + AdjustReferences(letter.References, rewriteSession); } } - RewriteSignature(_model.TargetDeclaration, paramList); + RewriteSignature(_model.TargetDeclaration, paramList, rewriteSession); foreach (var withEvents in _model.Declarations.Where(item => item.IsWithEvents && item.AsTypeName == _model.TargetDeclaration.ComponentName)) { foreach (var reference in _model.Declarations.FindEventProcedures(withEvents)) { - AdjustReferences(reference.References); - AdjustSignatures(reference); + AdjustReferences(reference.References, rewriteSession); + AdjustSignatures(reference, rewriteSession); } } @@ -228,12 +222,12 @@ private void AdjustSignatures() foreach (var interfaceImplentation in implementations) { - AdjustReferences(interfaceImplentation.References); - AdjustSignatures(interfaceImplentation); + AdjustReferences(interfaceImplentation.References, rewriteSession); + AdjustSignatures(interfaceImplentation, rewriteSession); } } - private void AdjustSignatures(Declaration declaration) + private void AdjustSignatures(Declaration declaration, IRewriteSession rewriteSession) { var proc = (dynamic) declaration.Context.Parent; VBAParser.ArgListContext paramList; @@ -248,12 +242,12 @@ private void AdjustSignatures(Declaration declaration) paramList = (VBAParser.ArgListContext) proc.subStmt().argList(); } - RewriteSignature(declaration, paramList); + RewriteSignature(declaration, paramList, rewriteSession); } - private void RewriteSignature(Declaration target, VBAParser.ArgListContext paramList) + private void RewriteSignature(Declaration target, VBAParser.ArgListContext paramList, IRewriteSession rewriteSession) { - var rewriter = _model.State.GetRewriter(target); + var rewriter = rewriteSession.CheckOutModuleRewriter(target.QualifiedModuleName); var parameters = paramList.arg().Select((s, i) => new { Index = i, Text = s.GetText() }).ToList(); for (var i = 0; i < _model.Parameters.Count; i++) @@ -261,8 +255,6 @@ private void RewriteSignature(Declaration target, VBAParser.ArgListContext param var param = paramList.arg()[i]; rewriter.Replace(param, parameters.SingleOrDefault(s => s.Index == _model.Parameters[i].Index)?.Text); } - - _rewriters.Add(rewriter); } } } diff --git a/RubberduckTests/Commands/RefactorCommandTests.cs b/RubberduckTests/Commands/RefactorCommandTests.cs index 81f77f5321..23471bbbe3 100644 --- a/RubberduckTests/Commands/RefactorCommandTests.cs +++ b/RubberduckTests/Commands/RefactorCommandTests.cs @@ -2,7 +2,6 @@ using NUnit.Framework; using Moq; using Rubberduck.Parsing.VBA; -using Rubberduck.UI; using Rubberduck.UI.Command.Refactorings; using Rubberduck.VBEditor; using Rubberduck.VBEditor.SafeComWrappers; @@ -23,7 +22,8 @@ public void EncapsulateField_CanExecute_NullActiveCodePane() var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out component); vbe.Setup(v => v.ActiveCodePane).Returns((ICodePane)null); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var encapsulateFieldCommand = new RefactorEncapsulateFieldCommand(vbe.Object, state, null); @@ -37,7 +37,8 @@ public void EncapsulateField_CanExecute_NonReadyState() { IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out component); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { state.SetStatusAndFireStateChanged(this, ParserState.ResolvedDeclarations, CancellationToken.None); @@ -57,7 +58,8 @@ Dim d As Boolean IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(2, 9, 2, 9)); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var encapsulateFieldCommand = new RefactorEncapsulateFieldCommand(vbe.Object, state, null); @@ -76,7 +78,8 @@ Sub Foo() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(2, 7, 2, 7)); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var encapsulateFieldCommand = new RefactorEncapsulateFieldCommand(vbe.Object, state, null); @@ -95,7 +98,8 @@ Sub Foo() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 5, 1, 5)); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var encapsulateFieldCommand = new RefactorEncapsulateFieldCommand(vbe.Object, state, null); @@ -111,7 +115,8 @@ public void ExtractInterface_CanExecute_NullActiveCodePane() var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out component); vbe.Setup(v => v.ActiveCodePane).Returns((ICodePane)null); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, state, null); @@ -126,7 +131,8 @@ public void ExtractInterface_CanExecute_NonReadyState() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleModule(string.Empty, ComponentType.ClassModule, out component, new Selection()); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { state.SetStatusAndFireStateChanged(this, ParserState.ResolvedDeclarations, CancellationToken.None); @@ -141,7 +147,8 @@ public void ExtractInterface_CanExecute_NoMembers() { IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleModule("Option Explicit", ComponentType.ClassModule, out component, new Selection()); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, state, null); Assert.IsFalse(extractInterfaceCommand.CanExecute(null)); @@ -158,7 +165,8 @@ public void ExtractInterface_CanExecute_Proc_StdModule() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, state, null); @@ -172,7 +180,8 @@ public void ExtractInterface_CanExecute_Field() { IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleModule("Dim d As Boolean", ComponentType.ClassModule, out component, Selection.Home); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, state, null); @@ -207,7 +216,8 @@ End Sub Assert.Inconclusive("The active code pane should be the one with the method stub."); } - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, state, null); Assert.IsTrue(extractInterfaceCommand.CanExecute(null)); @@ -233,7 +243,8 @@ public void ExtractInterface_CanExecute_ClassWithMembers_SameNameAsClassWithMemb vbe.Setup(s => s.ActiveCodePane).Returns(proj1.Object.VBComponents[0].CodeModule.CodePane); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, state, null); @@ -251,7 +262,8 @@ public void ExtractInterface_CanExecute_Proc() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleModule(input, ComponentType.ClassModule, out component, Selection.Home); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, state, null); @@ -270,7 +282,8 @@ public void ExtractInterface_CanExecute_Function() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleModule(input, ComponentType.ClassModule, out component, Selection.Home); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, state, null); @@ -288,7 +301,8 @@ public void ExtractInterface_CanExecute_PropertyGet() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleModule(input, ComponentType.ClassModule, out component, Selection.Home); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, state, null); @@ -306,7 +320,8 @@ public void ExtractInterface_CanExecute_PropertyLet() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleModule(input, ComponentType.ClassModule, out component, Selection.Home); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, state, null); @@ -324,7 +339,8 @@ public void ExtractInterface_CanExecute_PropertySet() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleModule(input, ComponentType.ClassModule, out component, Selection.Home); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, state, null); @@ -340,7 +356,8 @@ public void ImplementInterface_CanExecute_NullActiveCodePane() var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out component); vbe.Setup(v => v.ActiveCodePane).Returns((ICodePane)null); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var implementInterfaceCommand = new RefactorImplementInterfaceCommand(vbe.Object, state, null); @@ -355,7 +372,8 @@ public void ImplementInterface_CanExecute_NonReadyState() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out component); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { state.SetStatusAndFireStateChanged(this, ParserState.ResolvedDeclarations, CancellationToken.None); @@ -370,7 +388,8 @@ public void ImplementInterface_CanExecute_ImplementsInterfaceNotSelected() { IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleModule(string.Empty, ComponentType.ClassModule, out component, new Selection()); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var implementInterfaceCommand = new RefactorImplementInterfaceCommand(vbe.Object, state, null); @@ -389,7 +408,8 @@ public void ImplementInterface_CanExecute_ImplementsInterfaceSelected() .Build(); var vbe = builder.AddProject(project).Build(); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var implementInterfaceCommand = new RefactorImplementInterfaceCommand(vbe.Object, state, null); @@ -404,7 +424,8 @@ public void IntroduceField_CanExecute_NullActiveCodePane() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out component); vbe.Setup(v => v.ActiveCodePane).Returns((ICodePane)null); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var msgbox = new Mock(); @@ -420,7 +441,8 @@ public void IntroduceField_CanExecute_NonReadyState() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out component); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { state.SetStatusAndFireStateChanged(this, ParserState.ResolvedDeclarations, CancellationToken.None); @@ -436,7 +458,8 @@ public void IntroduceField_CanExecute_Field() { IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule("Dim d As Boolean", out component, Selection.Home); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var msgbox = new Mock(); @@ -456,7 +479,8 @@ Dim d As Boolean IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(2, 10, 2, 10)); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var msgbox = new Mock(); @@ -472,7 +496,8 @@ public void IntroduceParameter_CanExecute_NullActiveCodePane() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out component); vbe.Setup(v => v.ActiveCodePane).Returns((ICodePane)null); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var msgbox = new Mock(); @@ -488,7 +513,8 @@ public void IntroduceParameter_CanExecute_NonReadyState() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out component); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { state.SetStatusAndFireStateChanged(this, ParserState.ResolvedDeclarations, CancellationToken.None); @@ -504,7 +530,8 @@ public void IntroduceParameter_CanExecute_Field() { IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule("Dim d As Boolean", out component, Selection.Home); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var msgbox = new Mock(); @@ -524,7 +551,8 @@ Dim d As Boolean IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(2, 10, 2, 10)); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var msgbox = new Mock(); @@ -540,7 +568,8 @@ public void MoveCloserToUsage_CanExecute_NullActiveCodePane() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out component); vbe.Setup(v => v.ActiveCodePane).Returns((ICodePane)null); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var moveCloserToUsageCommand = new RefactorMoveCloserToUsageCommand(vbe.Object, state, null); @@ -555,7 +584,8 @@ public void MoveCloserToUsage_CanExecute_NonReadyState() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out component); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { state.SetStatusAndFireStateChanged(this, ParserState.ResolvedDeclarations, CancellationToken.None); @@ -570,7 +600,8 @@ public void MoveCloserToUsage_CanExecute_Field_NoReferences() { IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule("Dim d As Boolean", out component, Selection.Home); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var moveCloserToUsageCommand = new RefactorMoveCloserToUsageCommand(vbe.Object, state, null); @@ -589,7 +620,8 @@ Dim d As Boolean IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(2, 10, 2, 10)); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var moveCloserToUsageCommand = new RefactorMoveCloserToUsageCommand(vbe.Object, state, null); @@ -603,7 +635,8 @@ public void MoveCloserToUsage_CanExecute_Const_NoReferences() { IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule("Private Const const_abc = 0", out component, Selection.Home); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var moveCloserToUsageCommand = new RefactorMoveCloserToUsageCommand(vbe.Object, state, null); @@ -623,7 +656,8 @@ Sub Foo() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 5, 1, 5)); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var moveCloserToUsageCommand = new RefactorMoveCloserToUsageCommand(vbe.Object, state, null); @@ -643,7 +677,8 @@ Dim d As Boolean IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(2, 10, 2, 10)); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var moveCloserToUsageCommand = new RefactorMoveCloserToUsageCommand(vbe.Object, state, null); @@ -664,7 +699,8 @@ Dim d As Integer IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 17, 1, 17)); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var moveCloserToUsageCommand = new RefactorMoveCloserToUsageCommand(vbe.Object, state, null); @@ -679,7 +715,8 @@ public void RemoveParameters_CanExecute_NullActiveCodePane() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out component); vbe.Setup(v => v.ActiveCodePane).Returns((ICodePane)null); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, state, null); @@ -694,7 +731,8 @@ public void RemoveParameters_CanExecute_NonReadyState() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out component); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { state.SetStatusAndFireStateChanged(this, ParserState.ResolvedDeclarations, CancellationToken.None); @@ -712,7 +750,8 @@ public void RemoveParameters_CanExecute_Event_NoParams() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, state, null); @@ -730,7 +769,8 @@ public void RemoveParameters_CanExecute_Proc_NoParams() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 6, 1, 6)); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, state, null); @@ -748,7 +788,8 @@ public void RemoveParameters_CanExecute_Function_NoParams() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 11, 1, 11)); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, state, null); @@ -766,7 +807,8 @@ public void RemoveParameters_CanExecute_PropertyGet_NoParams() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, state, null); @@ -784,7 +826,8 @@ public void RemoveParameters_CanExecute_PropertyLet_OneParam() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, state, null); @@ -802,7 +845,8 @@ public void RemoveParameters_CanExecute_PropertySet_OneParam() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, state, null); @@ -819,7 +863,8 @@ public void RemoveParameters_CanExecute_Event_OneParam() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, state, null); @@ -837,7 +882,8 @@ public void RemoveParameters_CanExecute_Proc_OneParam() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 6, 1, 6)); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, state, null); @@ -855,7 +901,8 @@ public void RemoveParameters_CanExecute_Function_OneParam() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 11, 1, 11)); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, state, null); @@ -873,7 +920,8 @@ public void RemoveParameters_CanExecute_PropertyGet_OneParam() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, state, null); @@ -891,7 +939,8 @@ public void RemoveParameters_CanExecute_PropertyLet_TwoParams() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, state, null); @@ -909,7 +958,8 @@ public void RemoveParameters_CanExecute_PropertySet_TwoParams() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, state, null); @@ -924,10 +974,11 @@ public void ReorderParameters_CanExecute_NullActiveCodePane() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out component); vbe.Setup(v => v.ActiveCodePane).Returns((ICodePane)null); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { - var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, null); + var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, null, rewritingManager); Assert.IsFalse(reorderParametersCommand.CanExecute(null)); } } @@ -939,11 +990,12 @@ public void ReorderParameters_CanExecute_NonReadyState() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out component); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { state.SetStatusAndFireStateChanged(this, ParserState.ResolvedDeclarations, CancellationToken.None); - var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, null); + var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, null, rewritingManager); Assert.IsFalse(reorderParametersCommand.CanExecute(null)); } } @@ -957,10 +1009,11 @@ public void ReorderParameters_CanExecute_Event_OneParam() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { - var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, null); + var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, null, rewritingManager); Assert.IsFalse(reorderParametersCommand.CanExecute(null)); } } @@ -975,10 +1028,11 @@ public void ReorderParameters_CanExecute_Proc_OneParam() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 6, 1, 6)); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { - var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, null); + var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, null, rewritingManager); Assert.IsFalse(reorderParametersCommand.CanExecute(null)); } } @@ -993,10 +1047,11 @@ public void ReorderParameters_CanExecute_Function_OneParam() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 11, 1, 11)); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { - var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, null); + var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, null, rewritingManager); Assert.IsFalse(reorderParametersCommand.CanExecute(null)); } } @@ -1011,10 +1066,11 @@ public void ReorderParameters_CanExecute_PropertyGet_OneParam() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { - var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, null); + var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, null, rewritingManager); Assert.IsFalse(reorderParametersCommand.CanExecute(null)); } } @@ -1029,10 +1085,11 @@ public void ReorderParameters_CanExecute_PropertyLet_TwoParams() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { - var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, null); + var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, null, rewritingManager); Assert.IsFalse(reorderParametersCommand.CanExecute(null)); } } @@ -1047,10 +1104,11 @@ public void ReorderParameters_CanExecute_PropertySet_TwoParams() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { - var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, null); + var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, null, rewritingManager); Assert.IsFalse(reorderParametersCommand.CanExecute(null)); } } @@ -1064,10 +1122,11 @@ public void ReorderParameters_CanExecute_Event_TwoParams() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { - var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, null); + var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, null, rewritingManager); Assert.IsTrue(reorderParametersCommand.CanExecute(null)); } } @@ -1082,10 +1141,11 @@ public void ReorderParameters_CanExecute_Proc_TwoParams() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 6, 1, 6)); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { - var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, null); + var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, null, rewritingManager); Assert.IsTrue(reorderParametersCommand.CanExecute(null)); } } @@ -1100,10 +1160,11 @@ public void ReorderParameters_CanExecute_Function_TwoParams() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 11, 1, 11)); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { - var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, null); + var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, null, rewritingManager); Assert.IsTrue(reorderParametersCommand.CanExecute(null)); } } @@ -1118,10 +1179,11 @@ public void ReorderParameters_CanExecute_PropertyGet_TwoParams() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { - var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, null); + var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, null, rewritingManager); Assert.IsTrue(reorderParametersCommand.CanExecute(null)); } } @@ -1136,10 +1198,11 @@ public void ReorderParameters_CanExecute_PropertyLet_ThreeParams() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { - var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, null); + var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, null, rewritingManager); Assert.IsTrue(reorderParametersCommand.CanExecute(null)); } } @@ -1154,10 +1217,11 @@ public void ReorderParameters_CanExecute_PropertySet_ThreeParams() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { - var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, null); + var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, null, rewritingManager); Assert.IsTrue(reorderParametersCommand.CanExecute(null)); } } diff --git a/RubberduckTests/Refactoring/ReorderParametersTests.cs b/RubberduckTests/Refactoring/ReorderParametersTests.cs index 0d0014a79d..6dad0fe4eb 100644 --- a/RubberduckTests/Refactoring/ReorderParametersTests.cs +++ b/RubberduckTests/Refactoring/ReorderParametersTests.cs @@ -34,7 +34,8 @@ public void ReorderParams_SwapPositions() End Sub"; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -45,7 +46,7 @@ public void ReorderParams_SwapPositions() var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, rewritingManager); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode, component.CodeModule.Content()); @@ -70,7 +71,8 @@ public void ReorderParams_SwapPositions_SignatureContainsParamName() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -81,7 +83,7 @@ public void ReorderParams_SwapPositions_SignatureContainsParamName() var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, rewritingManager); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode, component.CodeModule.Content()); @@ -114,7 +116,8 @@ Sub Goo() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -125,7 +128,7 @@ Sub Goo() var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, rewritingManager); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode, component.CodeModule.Content()); @@ -150,7 +153,8 @@ public void ReorderParams_RefactorDeclaration() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -161,7 +165,7 @@ public void ReorderParams_RefactorDeclaration() var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, rewritingManager); refactoring.Refactor(model.TargetDeclaration); Assert.AreEqual(expectedCode, component.CodeModule.Content()); @@ -181,7 +185,8 @@ public void ReorderParams_RefactorDeclaration_FailsInvalidTarget() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -192,7 +197,7 @@ public void ReorderParams_RefactorDeclaration_FailsInvalidTarget() var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, rewritingManager); try { @@ -228,7 +233,8 @@ public void ReorderParams_WithOptionalParam() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -246,7 +252,7 @@ public void ReorderParams_WithOptionalParam() var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, rewritingManager); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode, component.CodeModule.Content()); @@ -281,7 +287,8 @@ End Sub IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -292,7 +299,7 @@ End Sub var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, rewritingManager); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode, component.CodeModule.Content()); @@ -335,7 +342,8 @@ Private Function foo(ByVal b As Integer, ByRef a As Integer) As Integer IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -346,7 +354,7 @@ Private Function foo(ByVal b As Integer, ByRef a As Integer) As Integer var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, rewritingManager); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode, component.CodeModule.Content()); @@ -381,7 +389,8 @@ End Sub IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -400,7 +409,7 @@ End Sub //SetupFactory var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, rewritingManager); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode, component.CodeModule.Content()); @@ -427,7 +436,8 @@ public void ReorderParametersRefactoring_ReorderNamedParams_Function() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -439,7 +449,7 @@ public void ReorderParametersRefactoring_ReorderNamedParams_Function() //SetupFactory var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, rewritingManager); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode, component.CodeModule.Content()); @@ -474,7 +484,8 @@ End Sub IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -493,7 +504,7 @@ End Sub //SetupFactory var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, rewritingManager); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode, component.CodeModule.Content()); @@ -518,7 +529,8 @@ public void ReorderParametersRefactoring_ReorderGetter() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -537,7 +549,7 @@ public void ReorderParametersRefactoring_ReorderGetter() //SetupFactory var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, rewritingManager); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode, component.CodeModule.Content()); @@ -562,7 +574,8 @@ public void ReorderParametersRefactoring_ReorderLetter() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -574,7 +587,7 @@ public void ReorderParametersRefactoring_ReorderLetter() //SetupFactory var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, rewritingManager); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode, component.CodeModule.Content()); @@ -599,7 +612,8 @@ public void ReorderParametersRefactoring_ReorderSetter() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -611,7 +625,7 @@ public void ReorderParametersRefactoring_ReorderSetter() //SetupFactory var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, rewritingManager); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode, component.CodeModule.Content()); @@ -631,7 +645,8 @@ public void ReorderParametersRefactoring_ReorderLastParamFromSetter_NotAllowed() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -655,7 +670,8 @@ public void ReorderParametersRefactoring_ReorderLastParamFromLetter_NotAllowed() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -688,7 +704,8 @@ public void ReorderParametersRefactoring_SignatureOnMultipleLines() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -700,7 +717,7 @@ public void ReorderParametersRefactoring_SignatureOnMultipleLines() //SetupFactory var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, rewritingManager); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode, component.CodeModule.Content()); @@ -743,7 +760,8 @@ End Sub IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -755,7 +773,7 @@ End Sub //SetupFactory var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, rewritingManager); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode, component.CodeModule.Content()); @@ -786,7 +804,8 @@ End Sub IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -800,7 +819,7 @@ End Sub var messageBox = new Mock(); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, messageBox.Object); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, messageBox.Object, rewritingManager); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(inputCode, component.CodeModule.Content()); @@ -849,7 +868,8 @@ End Sub IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -870,7 +890,7 @@ End Sub var messageBox = new Mock(); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, messageBox.Object); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, messageBox.Object, rewritingManager); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode, component.CodeModule.Content()); @@ -933,7 +953,8 @@ End Sub IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -954,7 +975,7 @@ End Sub var messageBox = new Mock(); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, messageBox.Object); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, messageBox.Object, rewritingManager); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode, component.CodeModule.Content()); @@ -974,7 +995,8 @@ public void ReorderParams_MoveOptionalParamBeforeNonOptionalParamFails() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -994,7 +1016,7 @@ public void ReorderParams_MoveOptionalParamBeforeNonOptionalParamFails() var messageBox = new Mock(); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, messageBox.Object); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, messageBox.Object, rewritingManager); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(inputCode, component.CodeModule.Content()); @@ -1029,7 +1051,8 @@ End Sub IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -1047,7 +1070,7 @@ End Sub var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, rewritingManager); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode, component.CodeModule.Content()); @@ -1078,7 +1101,8 @@ Private Property Set Foo(ByVal arg2 As String, ByVal arg1 As Integer, ByVal arg3 IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -1090,7 +1114,7 @@ Private Property Set Foo(ByVal arg2 As String, ByVal arg1 As Integer, ByVal arg3 //SetupFactory var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, rewritingManager); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode, component.CodeModule.Content()); @@ -1121,7 +1145,8 @@ Private Property Let Foo(ByVal arg2 As String, ByVal arg1 As Integer, ByVal arg3 IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -1133,7 +1158,7 @@ Private Property Let Foo(ByVal arg2 As String, ByVal arg1 As Integer, ByVal arg3 //SetupFactory var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, rewritingManager); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode, component.CodeModule.Content()); @@ -1152,12 +1177,13 @@ public void ReorderParams_PresenterIsNull() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var factory = new ReorderParametersPresenterFactory(vbe.Object, null, state, null); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory, null); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory, null, rewritingManager); refactoring.Refactor(); Assert.AreEqual(inputCode, component.CodeModule.Content()); @@ -1198,7 +1224,8 @@ Private Sub IClass1_DoSomething(ByVal b As String, ByVal a As Integer) .Build(); var vbe = builder.AddProject(project).Build(); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(project.Object.VBComponents[0]), selection); @@ -1212,7 +1239,7 @@ Private Sub IClass1_DoSomething(ByVal b As String, ByVal a As Integer) //SetupFactory var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, rewritingManager); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode1, module1.Content()); @@ -1254,7 +1281,8 @@ Private Sub IClass1_DoSomething(ByVal v2 As String, ByVal v1 As Integer) .Build(); var vbe = builder.AddProject(project).Build(); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(project.Object.VBComponents[0]), selection); @@ -1268,7 +1296,7 @@ Private Sub IClass1_DoSomething(ByVal v2 As String, ByVal v1 As Integer) //SetupFactory var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, rewritingManager); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode1, module1.Content()); @@ -1321,7 +1349,8 @@ Private Sub IClass1_DoSomething(ByVal s As String, ByVal i As Integer) .Build(); var vbe = builder.AddProject(project).Build(); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(project.Object.VBComponents[0]), selection); @@ -1336,7 +1365,7 @@ Private Sub IClass1_DoSomething(ByVal s As String, ByVal i As Integer) //SetupFactory var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, rewritingManager); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode1, module1.Content()); @@ -1380,7 +1409,8 @@ Private Sub IClass1_DoSomething(ByVal b As String, ByVal a As Integer) .Build(); var vbe = builder.AddProject(project).Build(); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(project.Object.VBComponents[0]), selection); @@ -1397,7 +1427,7 @@ Private Sub IClass1_DoSomething(ByVal b As String, ByVal a As Integer) //SetupFactory var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, rewritingManager); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode1, module1.Content()); @@ -1429,7 +1459,8 @@ Private Sub IClass1_DoSomething(ByVal a As Integer, ByVal b As String) .Build(); var vbe = builder.AddProject(project).Build(); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(project.Object.VBComponents[0]), selection); @@ -1477,7 +1508,8 @@ Private Sub abc_Foo(ByVal arg2 As String, ByVal arg1 As Integer) .Build(); var vbe = builder.AddProject(project).Build(); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(project.Object.VBComponents[0]), selection); @@ -1491,7 +1523,7 @@ Private Sub abc_Foo(ByVal arg2 As String, ByVal arg1 As Integer) //SetupFactory var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, rewritingManager); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode1, module1.Content()); @@ -1533,7 +1565,8 @@ Private Sub abc_Foo(ByVal arg2 As String, ByVal arg1 As Integer) .Build(); var vbe = builder.AddProject(project).Build(); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(project.Object.VBComponents[0]), selection); @@ -1547,7 +1580,7 @@ Private Sub abc_Foo(ByVal arg2 As String, ByVal arg1 As Integer) //SetupFactory var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, rewritingManager); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode1, module1.Content()); @@ -1589,7 +1622,8 @@ Private Sub abc_Foo(ByVal s As String, ByVal i As Integer) .Build(); var vbe = builder.AddProject(project).Build(); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(project.Object.VBComponents[0]), selection); @@ -1603,7 +1637,7 @@ Private Sub abc_Foo(ByVal s As String, ByVal i As Integer) //SetupFactory var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, rewritingManager); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode1, module1.Content()); @@ -1657,7 +1691,8 @@ Private Sub abc_Foo(ByVal v2 As String, ByVal v1 As Integer) .Build(); var vbe = builder.AddProject(project).Build(); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(project.Object.VBComponents[0]), selection); @@ -1672,7 +1707,7 @@ Private Sub abc_Foo(ByVal v2 As String, ByVal v1 As Integer) //SetupFactory var factory = SetupFactory(model); - var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null, rewritingManager); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode1, module1.Content()); @@ -1694,7 +1729,8 @@ public void Presenter_ParameterlessMemberCreatesNullModel() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var messageBox = new Mock(); @@ -1721,7 +1757,8 @@ public void Presenter_SingleParameterMemberCreatesNullModel() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var messageBox = new Mock(); @@ -1749,7 +1786,8 @@ Private Sub Foo(ByVal arg1 As Integer, ByVal arg2 As String) IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var factory = new ReorderParametersPresenterFactory(vbe.Object, null, state, null); @@ -1774,7 +1812,8 @@ public void Factory_NullSelectionCreatesNullPresenter() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { vbe.Setup(v => v.ActiveCodePane).Returns((ICodePane)null); From df916120ebe3080d3716d1dc7974d33ac9294262 Mon Sep 17 00:00:00 2001 From: Max Doerner Date: Fri, 2 Nov 2018 22:47:49 +0100 Subject: [PATCH 17/59] Rewire the MoveCloserToUsageRefactoring --- .../MoveFieldCloserToUsageQuickFix.cs | 12 +- .../RefactorMoveCloserToUsageCommand.cs | 7 +- .../MoveCloserToUsageRefactoring.cs | 47 ++-- .../Commands/RefactorCommandTests.cs | 16 +- .../MoveFieldCloserToUsageQuickFixTests.cs | 2 +- .../Refactoring/MoveCloserToUsageTests.cs | 249 ++++++++++-------- 6 files changed, 173 insertions(+), 160 deletions(-) diff --git a/Rubberduck.CodeAnalysis/QuickFixes/MoveFieldCloserToUsageQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/MoveFieldCloserToUsageQuickFix.cs index 773bf9ab6c..696287fea3 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/MoveFieldCloserToUsageQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/MoveFieldCloserToUsageQuickFix.cs @@ -14,20 +14,22 @@ public sealed class MoveFieldCloserToUsageQuickFix : QuickFixBase { private readonly IVBE _vbe; private readonly RubberduckParserState _state; + private readonly IRewritingManager _rewritingManager; private readonly IMessageBox _messageBox; - public MoveFieldCloserToUsageQuickFix(IVBE vbe, RubberduckParserState state, IMessageBox messageBox) + public MoveFieldCloserToUsageQuickFix(IVBE vbe, RubberduckParserState state, IMessageBox messageBox, IRewritingManager rewritingManager) : base(typeof(MoveFieldCloserToUsageInspection)) { _vbe = vbe; _state = state; + _rewritingManager = rewritingManager; _messageBox = messageBox; } //The rewriteSession is optional since it is not used in this particular quickfix because it is a refactoring quickfix. public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null) { - var refactoring = new MoveCloserToUsageRefactoring(_vbe, _state, _messageBox); + var refactoring = new MoveCloserToUsageRefactoring(_vbe, _state, _messageBox, _rewritingManager); refactoring.Refactor(result.Target); } @@ -36,8 +38,8 @@ public override string Description(IInspectionResult result) return string.Format(InspectionResults.MoveFieldCloserToUsageInspection, result.Target.IdentifierName); } - public override bool CanFixInProcedure => true; - public override bool CanFixInModule => true; - public override bool CanFixInProject => true; + public override bool CanFixInProcedure => false; + public override bool CanFixInModule => false; + public override bool CanFixInProject => false; } } \ No newline at end of file diff --git a/Rubberduck.Core/UI/Command/Refactorings/RefactorMoveCloserToUsageCommand.cs b/Rubberduck.Core/UI/Command/Refactorings/RefactorMoveCloserToUsageCommand.cs index 335d2be99a..05bf350ce7 100644 --- a/Rubberduck.Core/UI/Command/Refactorings/RefactorMoveCloserToUsageCommand.cs +++ b/Rubberduck.Core/UI/Command/Refactorings/RefactorMoveCloserToUsageCommand.cs @@ -1,5 +1,6 @@ using System.Linq; using Rubberduck.Interaction; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.Symbols; using Rubberduck.Parsing.VBA; using Rubberduck.Refactorings.MoveCloserToUsage; @@ -10,12 +11,14 @@ namespace Rubberduck.UI.Command.Refactorings public class RefactorMoveCloserToUsageCommand : RefactorCommandBase { private readonly RubberduckParserState _state; + private readonly IRewritingManager _rewritingManager; private readonly IMessageBox _msgbox; - public RefactorMoveCloserToUsageCommand(IVBE vbe, RubberduckParserState state, IMessageBox msgbox) + public RefactorMoveCloserToUsageCommand(IVBE vbe, RubberduckParserState state, IMessageBox msgbox, IRewritingManager rewritingManager) :base(vbe) { _state = state; + _rewritingManager = rewritingManager; _msgbox = msgbox; } @@ -43,7 +46,7 @@ protected override void OnExecute(object parameter) if (selection.HasValue) { - var refactoring = new MoveCloserToUsageRefactoring(Vbe, _state, _msgbox); + var refactoring = new MoveCloserToUsageRefactoring(Vbe, _state, _msgbox, _rewritingManager); refactoring.Refactor(selection.Value); } } diff --git a/Rubberduck.Refactorings/MoveCloserToUsage/MoveCloserToUsageRefactoring.cs b/Rubberduck.Refactorings/MoveCloserToUsage/MoveCloserToUsageRefactoring.cs index dd5ae4f942..8d5c5e878d 100644 --- a/Rubberduck.Refactorings/MoveCloserToUsage/MoveCloserToUsageRefactoring.cs +++ b/Rubberduck.Refactorings/MoveCloserToUsage/MoveCloserToUsageRefactoring.cs @@ -21,16 +21,17 @@ public class MoveCloserToUsageRefactoring : IRefactoring private readonly List _declarations; private readonly IVBE _vbe; private readonly RubberduckParserState _state; + private readonly IRewritingManager _rewritingManager; private readonly IMessageBox _messageBox; private Declaration _target; - - private readonly HashSet _rewriters = new HashSet(); - public MoveCloserToUsageRefactoring(IVBE vbe, RubberduckParserState state, IMessageBox messageBox) + public MoveCloserToUsageRefactoring(IVBE vbe, RubberduckParserState state, IMessageBox messageBox, IRewritingManager rewritingManager) { + //TODO: Use the DeclarationFinder instead and inject an IDeclarationFinderProvider instead of the RubberduckParserState. (Callers are not affected.) _declarations = state.AllUserDeclarations.ToList(); _vbe = vbe; _state = state; + _rewritingManager = rewritingManager; _messageBox = messageBox; } @@ -106,23 +107,20 @@ private void MoveCloserToUsage() oldSelection = pane.GetQualifiedSelection(); } - InsertNewDeclaration(); - RemoveOldDeclaration(); - UpdateOtherModules(); + var rewriteSession = _rewritingManager.CheckOutCodePaneSession(); + InsertNewDeclaration(rewriteSession); + RemoveOldDeclaration(rewriteSession); + UpdateOtherModules(rewriteSession); + rewriteSession.Rewrite(); if (oldSelection.HasValue && !pane.IsWrappingNullReference) { pane.Selection = oldSelection.Value.Selection; } } - foreach (var rewriter in _rewriters) - { - rewriter.Rewrite(); - } - Reparse(); } - private void UpdateOtherModules() + private void UpdateOtherModules(IRewriteSession rewriteSession) { QualifiedSelection? oldSelection = null; using (var pane = _vbe.ActiveCodePane) @@ -140,7 +138,7 @@ private void UpdateOtherModules() if (newTarget != null) { - UpdateCallsToOtherModule(newTarget.References.ToList()); + UpdateCallsToOtherModule(newTarget.References.ToList(), rewriteSession); } if (oldSelection.HasValue) @@ -150,7 +148,7 @@ private void UpdateOtherModules() } } - private void InsertNewDeclaration() + private void InsertNewDeclaration(IRewriteSession rewriteSession) { var newVariable = $"Dim {_target.IdentifierName} As {_target.AsTypeName}{Environment.NewLine}"; @@ -174,21 +172,17 @@ private void InsertNewDeclaration() } var padding = new string(' ', indentLength); - var rewriter = _state.GetRewriter(firstReference.QualifiedModuleName); + var rewriter = rewriteSession.CheckOutModuleRewriter(firstReference.QualifiedModuleName); rewriter.InsertBefore(insertionIndex, newVariable + padding); - - _rewriters.Add(rewriter); } - private void RemoveOldDeclaration() + private void RemoveOldDeclaration(IRewriteSession rewriteSession) { - var rewriter = _state.GetRewriter(_target); + var rewriter = rewriteSession.CheckOutModuleRewriter(_target.QualifiedModuleName); rewriter.Remove(_target); - - _rewriters.Add(rewriter); } - private void UpdateCallsToOtherModule(IEnumerable references) + private void UpdateCallsToOtherModule(IEnumerable references, IRewriteSession rewriteSession) { foreach (var reference in references.OrderByDescending(o => o.Selection.StartLine).ThenByDescending(t => t.Selection.StartColumn)) { @@ -212,17 +206,10 @@ private void UpdateCallsToOtherModule(IEnumerable reference continue; } - var rewriter = _state.GetRewriter(reference.QualifiedModuleName); + var rewriter = rewriteSession.CheckOutModuleRewriter(reference.QualifiedModuleName); var tokenInterval = Interval.Of(parent.SourceInterval.a, reference.Context.SourceInterval.b); rewriter.Replace(tokenInterval, reference.IdentifierName); - - _rewriters.Add(rewriter); } } - - private void Reparse() - { - _state.OnParseRequested(this); - } } } diff --git a/RubberduckTests/Commands/RefactorCommandTests.cs b/RubberduckTests/Commands/RefactorCommandTests.cs index 23471bbbe3..07a385145e 100644 --- a/RubberduckTests/Commands/RefactorCommandTests.cs +++ b/RubberduckTests/Commands/RefactorCommandTests.cs @@ -572,7 +572,7 @@ public void MoveCloserToUsage_CanExecute_NullActiveCodePane() using (state) { - var moveCloserToUsageCommand = new RefactorMoveCloserToUsageCommand(vbe.Object, state, null); + var moveCloserToUsageCommand = new RefactorMoveCloserToUsageCommand(vbe.Object, state, null, rewritingManager); Assert.IsFalse(moveCloserToUsageCommand.CanExecute(null)); } } @@ -589,7 +589,7 @@ public void MoveCloserToUsage_CanExecute_NonReadyState() { state.SetStatusAndFireStateChanged(this, ParserState.ResolvedDeclarations, CancellationToken.None); - var moveCloserToUsageCommand = new RefactorMoveCloserToUsageCommand(vbe.Object, state, null); + var moveCloserToUsageCommand = new RefactorMoveCloserToUsageCommand(vbe.Object, state, null, rewritingManager); Assert.IsFalse(moveCloserToUsageCommand.CanExecute(null)); } } @@ -604,7 +604,7 @@ public void MoveCloserToUsage_CanExecute_Field_NoReferences() using (state) { - var moveCloserToUsageCommand = new RefactorMoveCloserToUsageCommand(vbe.Object, state, null); + var moveCloserToUsageCommand = new RefactorMoveCloserToUsageCommand(vbe.Object, state, null, rewritingManager); Assert.IsFalse(moveCloserToUsageCommand.CanExecute(null)); } } @@ -624,7 +624,7 @@ Dim d As Boolean using (state) { - var moveCloserToUsageCommand = new RefactorMoveCloserToUsageCommand(vbe.Object, state, null); + var moveCloserToUsageCommand = new RefactorMoveCloserToUsageCommand(vbe.Object, state, null, rewritingManager); Assert.IsFalse(moveCloserToUsageCommand.CanExecute(null)); } } @@ -639,7 +639,7 @@ public void MoveCloserToUsage_CanExecute_Const_NoReferences() using (state) { - var moveCloserToUsageCommand = new RefactorMoveCloserToUsageCommand(vbe.Object, state, null); + var moveCloserToUsageCommand = new RefactorMoveCloserToUsageCommand(vbe.Object, state, null, rewritingManager); Assert.IsFalse(moveCloserToUsageCommand.CanExecute(null)); } } @@ -660,7 +660,7 @@ Sub Foo() using (state) { - var moveCloserToUsageCommand = new RefactorMoveCloserToUsageCommand(vbe.Object, state, null); + var moveCloserToUsageCommand = new RefactorMoveCloserToUsageCommand(vbe.Object, state, null, rewritingManager); Assert.IsTrue(moveCloserToUsageCommand.CanExecute(null)); } } @@ -681,7 +681,7 @@ Dim d As Boolean using (state) { - var moveCloserToUsageCommand = new RefactorMoveCloserToUsageCommand(vbe.Object, state, null); + var moveCloserToUsageCommand = new RefactorMoveCloserToUsageCommand(vbe.Object, state, null, rewritingManager); Assert.IsTrue(moveCloserToUsageCommand.CanExecute(null)); } } @@ -703,7 +703,7 @@ Dim d As Integer using (state) { - var moveCloserToUsageCommand = new RefactorMoveCloserToUsageCommand(vbe.Object, state, null); + var moveCloserToUsageCommand = new RefactorMoveCloserToUsageCommand(vbe.Object, state, null, rewritingManager); Assert.IsTrue(moveCloserToUsageCommand.CanExecute(null)); } } diff --git a/RubberduckTests/QuickFixes/MoveFieldCloserToUsageQuickFixTests.cs b/RubberduckTests/QuickFixes/MoveFieldCloserToUsageQuickFixTests.cs index 21dfce0cdb..0e8ded62e8 100644 --- a/RubberduckTests/QuickFixes/MoveFieldCloserToUsageQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/MoveFieldCloserToUsageQuickFixTests.cs @@ -122,7 +122,7 @@ private string ApplyQuickFixToFirstInspectionResult(string inputCode) var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); var resultToFix = inspectionResults.First(); var rewriteSession = rewritingManager.CheckOutCodePaneSession(); - var quickFix = new MoveFieldCloserToUsageQuickFix(vbe.Object, state, new Mock().Object); + var quickFix = new MoveFieldCloserToUsageQuickFix(vbe.Object, state, new Mock().Object, rewritingManager); quickFix.Fix(resultToFix, rewriteSession); diff --git a/RubberduckTests/Refactoring/MoveCloserToUsageTests.cs b/RubberduckTests/Refactoring/MoveCloserToUsageTests.cs index d44bae5550..be766dffcc 100644 --- a/RubberduckTests/Refactoring/MoveCloserToUsageTests.cs +++ b/RubberduckTests/Refactoring/MoveCloserToUsageTests.cs @@ -1,13 +1,10 @@ using System.Linq; -using System.Windows.Forms; using NUnit.Framework; using Moq; using Rubberduck.Parsing.Symbols; using Rubberduck.Refactorings.MoveCloserToUsage; -using Rubberduck.UI; using Rubberduck.VBEditor; using Rubberduck.VBEditor.SafeComWrappers; -using Rubberduck.VBEditor.SafeComWrappers.Abstract; using RubberduckTests.Mocks; using Rubberduck.Interaction; @@ -37,16 +34,17 @@ Dim bar As Boolean End Sub"; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); - var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, null); + var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -71,16 +69,17 @@ Dim bar As Boolean End Sub"; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); - var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, null); + var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -108,16 +107,17 @@ Dim bar As Boolean End Sub"; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); - var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, null); + var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -153,21 +153,22 @@ Dim bar As Boolean .Build(); var vbe = builder.AddProject(project).Build(); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(project.Object.VBComponents[0]), selection); var module1 = project.Object.VBComponents[0]; var module2 = project.Object.VBComponents[1]; - var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, null); + var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter1 = state.GetRewriter(module1); - Assert.AreEqual(expectedCode1, rewriter1.GetText()); + var actualCode1 = module1.CodeModule.Content(); + Assert.AreEqual(expectedCode1, actualCode1); - var rewriter2 = state.GetRewriter(module2); - Assert.AreEqual(expectedCode2, rewriter2.GetText()); + var actualCode2 = module2.CodeModule.Content(); + Assert.AreEqual(expectedCode2, actualCode2); } } @@ -194,16 +195,17 @@ Dim bar As Boolean End Sub"; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); - var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, null); + var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -231,16 +233,17 @@ Dim bar As Boolean End Sub"; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); - var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, null); + var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -270,16 +273,17 @@ Dim bar As Boolean End Sub"; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); - var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, null); + var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -310,16 +314,17 @@ Dim bat As Boolean End Sub"; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); - var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, null); + var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -350,16 +355,17 @@ Dim bar As Integer End Sub"; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using (state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); - var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, null); + var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -390,16 +396,17 @@ Dim bat As Boolean End Sub"; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); - var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, null); + var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -430,16 +437,17 @@ Dim bay As Date End Sub"; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); - var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, null); + var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -472,16 +480,17 @@ Dim bar As Integer End Sub"; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); - var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, null); + var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -514,16 +523,17 @@ Dim bat As Boolean End Sub"; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); - var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, null); + var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -556,16 +566,17 @@ Dim bay As Date End Sub"; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); - var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, null); + var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -582,20 +593,21 @@ Private Sub Foo() var selection = new Selection(1, 1); var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); var messageBox = new Mock(); - var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, messageBox.Object); + var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, messageBox.Object, rewritingManager); refactoring.Refactor(qualifiedSelection); messageBox.Verify(m => m.NotifyWarn(It.IsAny(), It.IsAny()), Times.Once()); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(inputCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(inputCode, actualCode); } } @@ -616,19 +628,20 @@ Private Sub Bar() var selection = new Selection(1, 1); var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); var messageBox = new Mock(); - var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, messageBox.Object); + var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, messageBox.Object, rewritingManager); refactoring.Refactor(qualifiedSelection); messageBox.Verify(m => m.NotifyWarn(It.IsAny(), It.IsAny()), Times.Once()); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(inputCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(inputCode, actualCode); } } @@ -652,16 +665,17 @@ Dim bar As Boolean var selection = new Selection(1, 1); var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); - var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, null); + var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -689,16 +703,17 @@ Sub Baz(ByVal bat As Boolean) var selection = new Selection(1, 1); var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); - var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, null); + var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -730,16 +745,17 @@ Sub Baz(ByVal bat As Boolean, ByVal bas As Boolean, ByVal bac As Boolean) var selection = new Selection(1, 1); var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); - var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, null); + var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -763,16 +779,17 @@ Private Sub Foo(): Baz True, True, bar: End Sub Private Sub Baz(ByVal bat As Boolean, ByVal bas As Boolean, ByVal bac As Boolean): End Sub"; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); - var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, null); + var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -808,16 +825,17 @@ Debug.Print someParam End Sub"; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); - var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, null); + var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -847,16 +865,17 @@ Debug.Print someParam End Sub"; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); - var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, null); + var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -873,15 +892,16 @@ Private Sub Foo() End Sub"; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var messageBox = new Mock(); - var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, messageBox.Object); + var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, messageBox.Object, rewritingManager); refactoring.Refactor(state.AllUserDeclarations.First(d => d.DeclarationType != DeclarationType.Variable)); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(inputCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(inputCode, actualCode); messageBox.Verify(m => m.NotifyWarn(It.IsAny(), It.IsAny()), Times.Once); } @@ -901,20 +921,21 @@ Private Sub Foo() var selection = new Selection(2, 15); var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var messageBox = new Mock(); var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); - var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, messageBox.Object); + var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, messageBox.Object, rewritingManager); refactoring.Refactor(qualifiedSelection); messageBox.Verify(m => m.NotifyWarn(It.IsAny(), It.IsAny()), Times.Once); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(inputCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(inputCode, actualCode); } } @@ -954,19 +975,19 @@ End With End Sub"; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = state.DeclarationFinder .UserDeclarations(DeclarationType.Variable) .Where(d => d.IdentifierName == "count") .Single().QualifiedSelection; - var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, null); + var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(component); - Assert.NotNull(rewriter); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -1013,7 +1034,7 @@ Public Sub Test() var selection = new Selection(1, 1); - const string expected = @" + const string expectedCode = @" Public Sub Test() Debug.Print ""Some statements between"" @@ -1031,17 +1052,17 @@ Dim foo As Class1 builder = builder.AddProject(project.Build()); var vbe = builder.Build(); - var testComponent = project.MockComponents.Find(mc => mc.Object.Name.Equals("Module1")); - var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(testComponent.Object), selection); + var component = project.MockComponents.Find(mc => mc.Object.Name.Equals("Module1")).Object; + var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var messageBox = new Mock(); - var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, messageBox.Object); + var refactoring = new MoveCloserToUsageRefactoring(vbe.Object, state, messageBox.Object, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(testComponent.Object); - var actual = rewriter.GetText(); - Assert.AreEqual(expected, actual); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } } From 245e0fc81e92d52f51d8b7e4d8e10506cedd184d Mon Sep 17 00:00:00 2001 From: Max Doerner Date: Fri, 2 Nov 2018 23:58:49 +0100 Subject: [PATCH 18/59] Rewire the EncapsulateFieldRefactoring Also contains one correction to a test for the RenameRefactoring --- .../QuickFixes/EncapsulateFieldQuickFix.cs | 6 +- .../RefactorEncapsulateFieldCommand.cs | 7 +- .../EncapsulateFieldRefactoring.cs | 40 ++--- .../Commands/RefactorCommandTests.cs | 10 +- .../Refactoring/EncapsulateFieldTests.cs | 162 ++++++++++-------- RubberduckTests/Refactoring/RenameTests.cs | 4 +- 6 files changed, 128 insertions(+), 101 deletions(-) diff --git a/Rubberduck.CodeAnalysis/QuickFixes/EncapsulateFieldQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/EncapsulateFieldQuickFix.cs index 4162521d5a..dcbe44b31a 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/EncapsulateFieldQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/EncapsulateFieldQuickFix.cs @@ -14,13 +14,15 @@ public sealed class EncapsulateFieldQuickFix : QuickFixBase { private readonly IVBE _vbe; private readonly RubberduckParserState _state; + private readonly IRewritingManager _rewritingManager; private readonly IIndenter _indenter; - public EncapsulateFieldQuickFix(IVBE vbe, RubberduckParserState state, IIndenter indenter) + public EncapsulateFieldQuickFix(IVBE vbe, RubberduckParserState state, IIndenter indenter, IRewritingManager rewritingManager) : base(typeof(EncapsulatePublicFieldInspection)) { _vbe = vbe; _state = state; + _rewritingManager = rewritingManager; _indenter = indenter; } @@ -30,7 +32,7 @@ public override void Fix(IInspectionResult result, IRewriteSession rewriteSessio using (var view = new EncapsulateFieldDialog(new EncapsulateFieldViewModel(_state, _indenter))) { var factory = new EncapsulateFieldPresenterFactory(_vbe, _state, view); - var refactoring = new EncapsulateFieldRefactoring(_vbe, _indenter, factory); + var refactoring = new EncapsulateFieldRefactoring(_vbe, _indenter, factory, _rewritingManager); refactoring.Refactor(result.Target); } } diff --git a/Rubberduck.Core/UI/Command/Refactorings/RefactorEncapsulateFieldCommand.cs b/Rubberduck.Core/UI/Command/Refactorings/RefactorEncapsulateFieldCommand.cs index 84c90016d5..a5bda2f06a 100644 --- a/Rubberduck.Core/UI/Command/Refactorings/RefactorEncapsulateFieldCommand.cs +++ b/Rubberduck.Core/UI/Command/Refactorings/RefactorEncapsulateFieldCommand.cs @@ -1,4 +1,5 @@ using System.Runtime.InteropServices; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.Symbols; using Rubberduck.Parsing.VBA; using Rubberduck.Refactorings.EncapsulateField; @@ -12,12 +13,14 @@ namespace Rubberduck.UI.Command.Refactorings public class RefactorEncapsulateFieldCommand : RefactorCommandBase { private readonly RubberduckParserState _state; + private readonly IRewritingManager _rewritingManager; private readonly Indenter _indenter; - public RefactorEncapsulateFieldCommand(IVBE vbe, RubberduckParserState state, Indenter indenter) + public RefactorEncapsulateFieldCommand(IVBE vbe, RubberduckParserState state, Indenter indenter, IRewritingManager rewritingManager) : base(vbe) { _state = state; + _rewritingManager = rewritingManager; _indenter = indenter; } @@ -52,7 +55,7 @@ protected override void OnExecute(object parameter) using (var view = new EncapsulateFieldDialog(new EncapsulateFieldViewModel(_state, _indenter))) { var factory = new EncapsulateFieldPresenterFactory(Vbe, _state, view); - var refactoring = new EncapsulateFieldRefactoring(Vbe, _indenter, factory); + var refactoring = new EncapsulateFieldRefactoring(Vbe, _indenter, factory, _rewritingManager); refactoring.Refactor(); } } diff --git a/Rubberduck.Refactorings/EncapsulateField/EncapsulateFieldRefactoring.cs b/Rubberduck.Refactorings/EncapsulateField/EncapsulateFieldRefactoring.cs index 49798c650d..c34e6fd775 100644 --- a/Rubberduck.Refactorings/EncapsulateField/EncapsulateFieldRefactoring.cs +++ b/Rubberduck.Refactorings/EncapsulateField/EncapsulateFieldRefactoring.cs @@ -13,35 +13,35 @@ public class EncapsulateFieldRefactoring : IRefactoring { private readonly IVBE _vbe; private readonly IIndenter _indenter; + private readonly IRewritingManager _rewritingManager; private readonly IRefactoringPresenterFactory _factory; private EncapsulateFieldModel _model; - private readonly HashSet _referenceRewriters = new HashSet(); - - public EncapsulateFieldRefactoring(IVBE vbe, IIndenter indenter, IRefactoringPresenterFactory factory) + public EncapsulateFieldRefactoring(IVBE vbe, IIndenter indenter, IRefactoringPresenterFactory factory, IRewritingManager rewritingManager) { _vbe = vbe; _indenter = indenter; _factory = factory; + _rewritingManager = rewritingManager; } public void Refactor() { var presenter = _factory.Create(); - if (presenter == null) { return; } + if (presenter == null) + { + return; + } _model = presenter.Show(); - if (_model == null) { return; } - - var target = _model.TargetDeclaration; - var rewriter = _model.State.GetRewriter(target); - AddProperty(rewriter); - - rewriter.Rewrite(); - foreach (var referenceRewriter in _referenceRewriters) + if (_model == null) { - referenceRewriter.Rewrite(); + return; } + + var rewriteSession = _rewritingManager.CheckOutCodePaneSession(); + AddProperty(rewriteSession); + rewriteSession.Rewrite(); } public void Refactor(QualifiedSelection target) @@ -71,9 +71,11 @@ public void Refactor(Declaration target) Refactor(); } - private void AddProperty(IExecutableModuleRewriter rewriter) + private void AddProperty(IRewriteSession rewriteSession) { - UpdateReferences(); + var rewriter = rewriteSession.CheckOutModuleRewriter(_model.TargetDeclaration.QualifiedModuleName); + + UpdateReferences(rewriteSession); SetFieldToPrivate(rewriter); var members = _model.State.DeclarationFinder @@ -109,18 +111,16 @@ private void AddProperty(IExecutableModuleRewriter rewriter) } } - private void UpdateReferences() + private void UpdateReferences(IRewriteSession rewriteSession) { foreach (var reference in _model.TargetDeclaration.References) { - var rewriter = _model.State.GetRewriter(reference.QualifiedModuleName); + var rewriter = rewriteSession.CheckOutModuleRewriter(reference.QualifiedModuleName); rewriter.Replace(reference.Context, _model.PropertyName); - - _referenceRewriters.Add(rewriter); } } - private void SetFieldToPrivate(IExecutableModuleRewriter rewriter) + private void SetFieldToPrivate(IModuleRewriter rewriter) { if (_model.TargetDeclaration.Accessibility != Accessibility.Private) { diff --git a/RubberduckTests/Commands/RefactorCommandTests.cs b/RubberduckTests/Commands/RefactorCommandTests.cs index 07a385145e..4d3e6d7223 100644 --- a/RubberduckTests/Commands/RefactorCommandTests.cs +++ b/RubberduckTests/Commands/RefactorCommandTests.cs @@ -26,7 +26,7 @@ public void EncapsulateField_CanExecute_NullActiveCodePane() using (state) { - var encapsulateFieldCommand = new RefactorEncapsulateFieldCommand(vbe.Object, state, null); + var encapsulateFieldCommand = new RefactorEncapsulateFieldCommand(vbe.Object, state, null, rewritingManager); Assert.IsFalse(encapsulateFieldCommand.CanExecute(null)); } } @@ -42,7 +42,7 @@ public void EncapsulateField_CanExecute_NonReadyState() { state.SetStatusAndFireStateChanged(this, ParserState.ResolvedDeclarations, CancellationToken.None); - var encapsulateFieldCommand = new RefactorEncapsulateFieldCommand(vbe.Object, state, null); + var encapsulateFieldCommand = new RefactorEncapsulateFieldCommand(vbe.Object, state, null, rewritingManager); Assert.IsFalse(encapsulateFieldCommand.CanExecute(null)); } } @@ -62,7 +62,7 @@ Dim d As Boolean using (state) { - var encapsulateFieldCommand = new RefactorEncapsulateFieldCommand(vbe.Object, state, null); + var encapsulateFieldCommand = new RefactorEncapsulateFieldCommand(vbe.Object, state, null, rewritingManager); Assert.IsFalse(encapsulateFieldCommand.CanExecute(null)); } } @@ -82,7 +82,7 @@ Sub Foo() using (state) { - var encapsulateFieldCommand = new RefactorEncapsulateFieldCommand(vbe.Object, state, null); + var encapsulateFieldCommand = new RefactorEncapsulateFieldCommand(vbe.Object, state, null, rewritingManager); Assert.IsFalse(encapsulateFieldCommand.CanExecute(null)); } } @@ -102,7 +102,7 @@ Sub Foo() using (state) { - var encapsulateFieldCommand = new RefactorEncapsulateFieldCommand(vbe.Object, state, null); + var encapsulateFieldCommand = new RefactorEncapsulateFieldCommand(vbe.Object, state, null, rewritingManager); Assert.IsTrue(encapsulateFieldCommand.CanExecute(null)); } } diff --git a/RubberduckTests/Refactoring/EncapsulateFieldTests.cs b/RubberduckTests/Refactoring/EncapsulateFieldTests.cs index 780ca0d686..112034ecfa 100644 --- a/RubberduckTests/Refactoring/EncapsulateFieldTests.cs +++ b/RubberduckTests/Refactoring/EncapsulateFieldTests.cs @@ -43,7 +43,8 @@ End Property IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -60,11 +61,12 @@ End Property //SetupFactory var factory = SetupFactory(model); - var refactoring = new EncapsulateFieldRefactoring(vbe.Object, CreateIndenter(vbe.Object), factory.Object); + var refactoring = new EncapsulateFieldRefactoring(vbe.Object, CreateIndenter(vbe.Object), factory.Object, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(model.TargetDeclaration); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var targetComponent = state.ProjectsProvider.Component(model.TargetDeclaration.QualifiedModuleName); + var actualCode = targetComponent.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -96,7 +98,8 @@ End Property IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -113,11 +116,12 @@ End Property //SetupFactory var factory = SetupFactory(model); - var refactoring = new EncapsulateFieldRefactoring(vbe.Object, CreateIndenter(vbe.Object), factory.Object); + var refactoring = new EncapsulateFieldRefactoring(vbe.Object, CreateIndenter(vbe.Object), factory.Object, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(model.TargetDeclaration); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var targetComponent = state.ProjectsProvider.Component(model.TargetDeclaration.QualifiedModuleName); + var actualCode = targetComponent.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -146,7 +150,8 @@ End Property IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -163,11 +168,12 @@ End Property //SetupFactory var factory = SetupFactory(model); - var refactoring = new EncapsulateFieldRefactoring(vbe.Object, CreateIndenter(vbe.Object), factory.Object); + var refactoring = new EncapsulateFieldRefactoring(vbe.Object, CreateIndenter(vbe.Object), factory.Object, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(model.TargetDeclaration); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var targetComponent = state.ProjectsProvider.Component(model.TargetDeclaration.QualifiedModuleName); + var actualCode = targetComponent.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -192,7 +198,8 @@ End Property IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -209,11 +216,12 @@ End Property //SetupFactory var factory = SetupFactory(model); - var refactoring = new EncapsulateFieldRefactoring(vbe.Object, CreateIndenter(vbe.Object), factory.Object); + var refactoring = new EncapsulateFieldRefactoring(vbe.Object, CreateIndenter(vbe.Object), factory.Object, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(model.TargetDeclaration); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var targetComponent = state.ProjectsProvider.Component(model.TargetDeclaration.QualifiedModuleName); + var actualCode = targetComponent.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -256,7 +264,8 @@ Function Bar() As Integer IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -273,11 +282,12 @@ Function Bar() As Integer //SetupFactory var factory = SetupFactory(model); - var refactoring = new EncapsulateFieldRefactoring(vbe.Object, CreateIndenter(vbe.Object), factory.Object); + var refactoring = new EncapsulateFieldRefactoring(vbe.Object, CreateIndenter(vbe.Object), factory.Object, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(model.TargetDeclaration); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var targetComponent = state.ProjectsProvider.Component(model.TargetDeclaration.QualifiedModuleName); + var actualCode = targetComponent.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -326,7 +336,8 @@ Property Set Foo(ByVal vall As Variant) IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -343,11 +354,12 @@ Property Set Foo(ByVal vall As Variant) //SetupFactory var factory = SetupFactory(model); - var refactoring = new EncapsulateFieldRefactoring(vbe.Object, CreateIndenter(vbe.Object), factory.Object); + var refactoring = new EncapsulateFieldRefactoring(vbe.Object, CreateIndenter(vbe.Object), factory.Object, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(model.TargetDeclaration); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var targetComponent = state.ProjectsProvider.Component(model.TargetDeclaration.QualifiedModuleName); + var actualCode = targetComponent.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -378,7 +390,8 @@ End Property IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -395,11 +408,12 @@ End Property //SetupFactory var factory = SetupFactory(model); - var refactoring = new EncapsulateFieldRefactoring(vbe.Object, CreateIndenter(vbe.Object), factory.Object); + var refactoring = new EncapsulateFieldRefactoring(vbe.Object, CreateIndenter(vbe.Object), factory.Object, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(model.TargetDeclaration); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var targetComponent = state.ProjectsProvider.Component(model.TargetDeclaration.QualifiedModuleName); + var actualCode = targetComponent.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -440,7 +454,8 @@ End Property IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -457,11 +472,12 @@ End Property //SetupFactory var factory = SetupFactory(model); - var refactoring = new EncapsulateFieldRefactoring(vbe.Object, CreateIndenter(vbe.Object), factory.Object); + var refactoring = new EncapsulateFieldRefactoring(vbe.Object, CreateIndenter(vbe.Object), factory.Object, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(model.TargetDeclaration); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var targetComponent = state.ProjectsProvider.Component(model.TargetDeclaration.QualifiedModuleName); + var actualCode = targetComponent.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -494,7 +510,8 @@ End Property IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -511,11 +528,12 @@ End Property //SetupFactory var factory = SetupFactory(model); - var refactoring = new EncapsulateFieldRefactoring(vbe.Object, CreateIndenter(vbe.Object), factory.Object); + var refactoring = new EncapsulateFieldRefactoring(vbe.Object, CreateIndenter(vbe.Object), factory.Object, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(model.TargetDeclaration); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var targetComponent = state.ProjectsProvider.Component(model.TargetDeclaration.QualifiedModuleName); + var actualCode = targetComponent.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -548,7 +566,8 @@ End Property IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -565,11 +584,12 @@ End Property //SetupFactory var factory = SetupFactory(model); - var refactoring = new EncapsulateFieldRefactoring(vbe.Object, CreateIndenter(vbe.Object), factory.Object); + var refactoring = new EncapsulateFieldRefactoring(vbe.Object, CreateIndenter(vbe.Object), factory.Object, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(model.TargetDeclaration); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var targetComponent = state.ProjectsProvider.Component(model.TargetDeclaration.QualifiedModuleName); + var actualCode = targetComponent.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -598,7 +618,8 @@ End Property IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -615,11 +636,12 @@ End Property //SetupFactory var factory = SetupFactory(model); - var refactoring = new EncapsulateFieldRefactoring(vbe.Object, CreateIndenter(vbe.Object), factory.Object); + var refactoring = new EncapsulateFieldRefactoring(vbe.Object, CreateIndenter(vbe.Object), factory.Object, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(model.TargetDeclaration); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var targetComponent = state.ProjectsProvider.Component(model.TargetDeclaration.QualifiedModuleName); + var actualCode = targetComponent.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -664,7 +686,8 @@ Sub Bar(ByVal name As Integer) IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -681,11 +704,12 @@ Sub Bar(ByVal name As Integer) //SetupFactory var factory = SetupFactory(model); - var refactoring = new EncapsulateFieldRefactoring(vbe.Object, CreateIndenter(vbe.Object), factory.Object); + var refactoring = new EncapsulateFieldRefactoring(vbe.Object, CreateIndenter(vbe.Object), factory.Object, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(model.TargetDeclaration); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var targetComponent = state.ProjectsProvider.Component(model.TargetDeclaration.QualifiedModuleName); + var actualCode = targetComponent.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -749,7 +773,8 @@ Sub Bar(ByVal v As Integer) var component = project.Object.VBComponents[0]; vbe.Setup(v => v.ActiveCodePane).Returns(component.CodeModule.CodePane); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -768,7 +793,7 @@ Sub Bar(ByVal v As Integer) //SetupFactory var factory = SetupFactory(model); - var refactoring = new EncapsulateFieldRefactoring(vbe.Object, CreateIndenter(vbe.Object), factory.Object); + var refactoring = new EncapsulateFieldRefactoring(vbe.Object, CreateIndenter(vbe.Object), factory.Object, rewritingManager); refactoring.Refactor(qualifiedSelection); var actualCode1 = module1.Content(); @@ -776,12 +801,6 @@ Sub Bar(ByVal v As Integer) Assert.AreEqual(expectedCode1, actualCode1); Assert.AreEqual(expectedCode2, actualCode2); - - var rewriter1 = state.GetRewriter(module1.Parent); - Assert.AreEqual(expectedCode1, rewriter1.GetText()); - - var rewriter2 = state.GetRewriter(module2.Parent); - Assert.AreEqual(expectedCode2, rewriter2.GetText()); } } @@ -810,7 +829,8 @@ End Property IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -827,11 +847,11 @@ End Property //SetupFactory var factory = SetupFactory(model); - var refactoring = new EncapsulateFieldRefactoring(vbe.Object, CreateIndenter(vbe.Object), factory.Object); + var refactoring = new EncapsulateFieldRefactoring(vbe.Object, CreateIndenter(vbe.Object), factory.Object, rewritingManager); refactoring.Refactor(state.AllUserDeclarations.FindVariable(qualifiedSelection)); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -846,17 +866,18 @@ public void EncapsulateField_PresenterIsNull() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var vbeWrapper = vbe.Object; var factory = new EncapsulateFieldPresenterFactory(vbeWrapper, state, null); - var refactoring = new EncapsulateFieldRefactoring(vbeWrapper, CreateIndenter(vbe.Object), factory); + var refactoring = new EncapsulateFieldRefactoring(vbeWrapper, CreateIndenter(vbe.Object), factory, rewritingManager); refactoring.Refactor(); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(inputCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(inputCode, actualCode); } } @@ -872,7 +893,8 @@ public void EncapsulateField_ModelIsNull() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -880,11 +902,11 @@ public void EncapsulateField_ModelIsNull() //SetupFactory var factory = SetupFactory(null); - var refactoring = new EncapsulateFieldRefactoring(vbe.Object, CreateIndenter(vbe.Object), factory.Object); + var refactoring = new EncapsulateFieldRefactoring(vbe.Object, CreateIndenter(vbe.Object), factory.Object, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(inputCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(inputCode, actualCode); } } @@ -899,7 +921,7 @@ public void GivenNullActiveCodePane_FactoryReturnsNullPresenter() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - using (var state = MockParser.CreateAndParse(vbe.Object)) + using(var state = MockParser.CreateAndParse(vbe.Object)) { vbe.Object.ActiveCodePane = null; @@ -1015,7 +1037,7 @@ public void Presenter_Reject_ReturnsNull() } } - //TODO: The tests below are commented out pending some sort of refactoring that enables them + //TODO: The tests below are ignored pending some sort of refactoring that enables them //to actually *test* something. Currently, all of the behavior the tests are looking for is //being mocked. // SEE: https://github.com/rubberduck-vba/Rubberduck/issues/3072 diff --git a/RubberduckTests/Refactoring/RenameTests.cs b/RubberduckTests/Refactoring/RenameTests.cs index 33fcb38858..1984f2d327 100644 --- a/RubberduckTests/Refactoring/RenameTests.cs +++ b/RubberduckTests/Refactoring/RenameTests.cs @@ -2512,8 +2512,8 @@ public void Rename_PresenterIsNull() var refactoring = new RenameRefactoring(vbeWrapper, factory, null, state, state.ProjectsProvider, rewritingManager); refactoring.Refactor(); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(inputCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(inputCode, actualCode); } } From 15a95306824dc10d149cc6f6619272f1bd706935 Mon Sep 17 00:00:00 2001 From: Max Doerner Date: Sat, 3 Nov 2018 12:24:39 +0100 Subject: [PATCH 19/59] Rewire the IntroduceParameterRefactoring --- .../RefactorIntroduceParameterCommand.cs | 7 +- .../IntroduceParameterRefactoring.cs | 45 ++-- .../Commands/RefactorCommandTests.cs | 8 +- .../Refactoring/IntroduceParameterTests.cs | 193 ++++++++++-------- 4 files changed, 137 insertions(+), 116 deletions(-) diff --git a/Rubberduck.Core/UI/Command/Refactorings/RefactorIntroduceParameterCommand.cs b/Rubberduck.Core/UI/Command/Refactorings/RefactorIntroduceParameterCommand.cs index 941caa49b3..c7a334a0a3 100644 --- a/Rubberduck.Core/UI/Command/Refactorings/RefactorIntroduceParameterCommand.cs +++ b/Rubberduck.Core/UI/Command/Refactorings/RefactorIntroduceParameterCommand.cs @@ -1,5 +1,6 @@ using Rubberduck.Common; using Rubberduck.Interaction; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.Symbols; using Rubberduck.Parsing.VBA; using Rubberduck.Refactorings.IntroduceParameter; @@ -10,12 +11,14 @@ namespace Rubberduck.UI.Command.Refactorings public class RefactorIntroduceParameterCommand : RefactorCommandBase { private readonly RubberduckParserState _state; + private readonly IRewritingManager _rewritingManager; private readonly IMessageBox _messageBox; - public RefactorIntroduceParameterCommand (IVBE vbe, RubberduckParserState state, IMessageBox messageBox) + public RefactorIntroduceParameterCommand (IVBE vbe, RubberduckParserState state, IMessageBox messageBox, IRewritingManager rewritingManager) :base(vbe) { _state = state; + _rewritingManager = rewritingManager; _messageBox = messageBox; } @@ -49,7 +52,7 @@ protected override void OnExecute(object parameter) return; } - var refactoring = new IntroduceParameterRefactoring(Vbe, _state, _messageBox); + var refactoring = new IntroduceParameterRefactoring(Vbe, _state, _messageBox, _rewritingManager); refactoring.Refactor(selection.Value); } } diff --git a/Rubberduck.Refactorings/IntroduceParameter/IntroduceParameterRefactoring.cs b/Rubberduck.Refactorings/IntroduceParameter/IntroduceParameterRefactoring.cs index 85e43dbe5e..56cbfd67c8 100644 --- a/Rubberduck.Refactorings/IntroduceParameter/IntroduceParameterRefactoring.cs +++ b/Rubberduck.Refactorings/IntroduceParameter/IntroduceParameterRefactoring.cs @@ -16,11 +16,10 @@ public class IntroduceParameterRefactoring : IRefactoring { private readonly IVBE _vbe; private readonly RubberduckParserState _state; + private readonly IRewritingManager _rewritingManager; private readonly IList _declarations; private readonly IMessageBox _messageBox; - private readonly HashSet _rewriters = new HashSet(); - private static readonly DeclarationType[] ValidDeclarationTypes = { DeclarationType.Function, @@ -30,10 +29,12 @@ public class IntroduceParameterRefactoring : IRefactoring DeclarationType.PropertySet }; - public IntroduceParameterRefactoring(IVBE vbe, RubberduckParserState state, IMessageBox messageBox) + public IntroduceParameterRefactoring(IVBE vbe, RubberduckParserState state, IMessageBox messageBox, IRewritingManager rewritingManager) { _vbe = vbe; _state = state; + _rewritingManager = rewritingManager; + //TODO: Make this use the DeclarationFinder and inject an IDeclarationFinderProvider instead of the RubberduckParserState. (Does not affect the callers.) _declarations = state.AllDeclarations.ToList(); _messageBox = messageBox; } @@ -89,9 +90,6 @@ private void PromoteVariable(Declaration target) return; } - var rewriter = _state.GetRewriter(target); - _rewriters.Add(rewriter); - using (var pane = _vbe.ActiveCodePane) { QualifiedSelection? oldSelection = null; @@ -100,19 +98,19 @@ private void PromoteVariable(Declaration target) oldSelection = pane.GetQualifiedSelection(); } - UpdateSignature(target); + var rewriteSession = _rewritingManager.CheckOutCodePaneSession(); + + var rewriter = rewriteSession.CheckOutModuleRewriter(target.QualifiedModuleName); + UpdateSignature(target, rewriteSession); rewriter.Remove(target); + rewriteSession.Rewrite(); + if (oldSelection.HasValue && !pane.IsWrappingNullReference) { pane.Selection = oldSelection.Value.Selection; } } - - foreach (var tokenRewriter in _rewriters) - { - tokenRewriter.Rewrite(); - } } private bool PromptIfMethodImplementsInterface(Declaration targetVariable) @@ -138,7 +136,7 @@ private bool PromptIfMethodImplementsInterface(Declaration targetVariable) return _messageBox.Question(message, RubberduckUI.IntroduceParameter_Caption); } - private void UpdateSignature(Declaration targetVariable) + private void UpdateSignature(Declaration targetVariable, IRewriteSession rewriteSession) { var functionDeclaration = (ModuleBodyElementDeclaration)_declarations.FindTarget(targetVariable.QualifiedSelection, ValidDeclarationTypes); @@ -147,11 +145,11 @@ private void UpdateSignature(Declaration targetVariable) if (functionDeclaration.DeclarationType.HasFlag(DeclarationType.Property)) { - UpdateProperties(functionDeclaration, targetVariable); + UpdateProperties(functionDeclaration, targetVariable, rewriteSession); } else { - AddParameter(functionDeclaration, targetVariable, paramList); + AddParameter(functionDeclaration, targetVariable, paramList, rewriteSession); } var interfaceImplementation = functionDeclaration.InterfaceMemberImplemented; @@ -161,28 +159,27 @@ private void UpdateSignature(Declaration targetVariable) return; } - UpdateSignature(interfaceImplementation, targetVariable); + UpdateSignature(interfaceImplementation, targetVariable, rewriteSession); var interfaceImplementations = _state.DeclarationFinder.FindInterfaceImplementationMembers(functionDeclaration.InterfaceMemberImplemented) .Where(member => !ReferenceEquals(member, functionDeclaration)); foreach (var implementation in interfaceImplementations) { - UpdateSignature(implementation, targetVariable); + UpdateSignature(implementation, targetVariable, rewriteSession); } } - private void UpdateSignature(Declaration targetMethod, Declaration targetVariable) + private void UpdateSignature(Declaration targetMethod, Declaration targetVariable, IRewriteSession rewriteSession) { var proc = (dynamic) targetMethod.Context; var paramList = (VBAParser.ArgListContext) proc.argList(); - AddParameter(targetMethod, targetVariable, paramList); + AddParameter(targetMethod, targetVariable, paramList, rewriteSession); } - private void AddParameter(Declaration targetMethod, Declaration targetVariable, VBAParser.ArgListContext paramList) + private void AddParameter(Declaration targetMethod, Declaration targetVariable, VBAParser.ArgListContext paramList, IRewriteSession rewriteSession) { - var rewriter = _state.GetRewriter(targetMethod); - _rewriters.Add(rewriter); + var rewriter = rewriteSession.CheckOutModuleRewriter(targetMethod.QualifiedModuleName); var argList = paramList.arg(); var newParameter = $"{Tokens.ByVal} {targetVariable.IdentifierName} {Tokens.As} {targetVariable.AsTypeName}"; @@ -203,7 +200,7 @@ private void AddParameter(Declaration targetMethod, Declaration targetVariable, } } - private void UpdateProperties(Declaration knownProperty, Declaration targetVariable) + private void UpdateProperties(Declaration knownProperty, Declaration targetVariable, IRewriteSession rewriteSession) { var propertyGet = _declarations.FirstOrDefault(d => d.DeclarationType == DeclarationType.PropertyGet && @@ -241,7 +238,7 @@ private void UpdateProperties(Declaration knownProperty, Declaration targetVaria properties.OrderByDescending(o => o.Selection.StartLine) .ThenByDescending(t => t.Selection.StartColumn)) { - UpdateSignature(property, targetVariable); + UpdateSignature(property, targetVariable, rewriteSession); } } } diff --git a/RubberduckTests/Commands/RefactorCommandTests.cs b/RubberduckTests/Commands/RefactorCommandTests.cs index 4d3e6d7223..5bd17cc313 100644 --- a/RubberduckTests/Commands/RefactorCommandTests.cs +++ b/RubberduckTests/Commands/RefactorCommandTests.cs @@ -501,7 +501,7 @@ public void IntroduceParameter_CanExecute_NullActiveCodePane() { var msgbox = new Mock(); - var introduceParameterCommand = new RefactorIntroduceParameterCommand(vbe.Object, state, msgbox.Object); + var introduceParameterCommand = new RefactorIntroduceParameterCommand(vbe.Object, state, msgbox.Object, rewritingManager); Assert.IsFalse(introduceParameterCommand.CanExecute(null)); } } @@ -519,7 +519,7 @@ public void IntroduceParameter_CanExecute_NonReadyState() state.SetStatusAndFireStateChanged(this, ParserState.ResolvedDeclarations, CancellationToken.None); var msgbox = new Mock(); - var introduceParameterCommand = new RefactorIntroduceParameterCommand(vbe.Object, state, msgbox.Object); + var introduceParameterCommand = new RefactorIntroduceParameterCommand(vbe.Object, state, msgbox.Object, rewritingManager); Assert.IsFalse(introduceParameterCommand.CanExecute(null)); } } @@ -535,7 +535,7 @@ public void IntroduceParameter_CanExecute_Field() { var msgbox = new Mock(); - var introduceParameterCommand = new RefactorIntroduceParameterCommand(vbe.Object, state, msgbox.Object); + var introduceParameterCommand = new RefactorIntroduceParameterCommand(vbe.Object, state, msgbox.Object, rewritingManager); Assert.IsFalse(introduceParameterCommand.CanExecute(null)); } } @@ -556,7 +556,7 @@ Dim d As Boolean { var msgbox = new Mock(); - var introduceParameterCommand = new RefactorIntroduceParameterCommand(vbe.Object, state, msgbox.Object); + var introduceParameterCommand = new RefactorIntroduceParameterCommand(vbe.Object, state, msgbox.Object, rewritingManager); Assert.IsTrue(introduceParameterCommand.CanExecute(null)); } } diff --git a/RubberduckTests/Refactoring/IntroduceParameterTests.cs b/RubberduckTests/Refactoring/IntroduceParameterTests.cs index defb837696..f32e6d4700 100644 --- a/RubberduckTests/Refactoring/IntroduceParameterTests.cs +++ b/RubberduckTests/Refactoring/IntroduceParameterTests.cs @@ -1,10 +1,8 @@ using System.Linq; -using System.Windows.Forms; using NUnit.Framework; using Moq; using Rubberduck.Parsing.Symbols; using Rubberduck.Refactorings.IntroduceParameter; -using Rubberduck.UI; using Rubberduck.VBEditor; using Rubberduck.VBEditor.SafeComWrappers; using Rubberduck.VBEditor.SafeComWrappers.Abstract; @@ -34,16 +32,17 @@ Dim bar As Boolean End Sub"; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out IVBComponent component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); - var refactoring = new IntroduceParameterRefactoring(vbe.Object, state, null); + var refactoring = new IntroduceParameterRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -67,16 +66,17 @@ Dim bar As Boolean End Function"; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out IVBComponent component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); - var refactoring = new IntroduceParameterRefactoring(vbe.Object, state, null); + var refactoring = new IntroduceParameterRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -98,16 +98,17 @@ Dim bar As Boolean End Sub"; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out IVBComponent component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); - var refactoring = new IntroduceParameterRefactoring(vbe.Object, state, null); + var refactoring = new IntroduceParameterRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -132,16 +133,17 @@ As _ End Sub"; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out IVBComponent component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); - var refactoring = new IntroduceParameterRefactoring(vbe.Object, state, null); + var refactoring = new IntroduceParameterRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -165,16 +167,17 @@ Dim bar As Boolean End Sub"; // note: the VBE removes extra spaces var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out IVBComponent component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); - var refactoring = new IntroduceParameterRefactoring(vbe.Object, state, null); + var refactoring = new IntroduceParameterRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -202,16 +205,17 @@ bap As Integer End Sub"; // note: the VBE removes extra spaces var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out IVBComponent component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); - var refactoring = new IntroduceParameterRefactoring(vbe.Object, state, null); + var refactoring = new IntroduceParameterRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -238,16 +242,17 @@ bap As Integer End Sub"; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out IVBComponent component); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var target = state.AllUserDeclarations.SingleOrDefault(e => e.IdentifierName == "bat"); - var refactoring = new IntroduceParameterRefactoring(vbe.Object, state, new Mock().Object); + var refactoring = new IntroduceParameterRefactoring(vbe.Object, state, new Mock().Object, rewritingManager); refactoring.Refactor(target); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -273,16 +278,17 @@ bat As Date End Sub"; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out IVBComponent component); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var target = state.AllUserDeclarations.SingleOrDefault(e => e.IdentifierName == "bap"); - var refactoring = new IntroduceParameterRefactoring(vbe.Object, state, null); + var refactoring = new IntroduceParameterRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(target); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -306,16 +312,17 @@ public void IntroduceParameterRefactoring_MultipleVariablesInStatement_OnOneLine End Sub"; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var target = state.AllUserDeclarations.SingleOrDefault(e => e.IdentifierName == "bar"); - var refactoring = new IntroduceParameterRefactoring(vbe.Object, state, null); + var refactoring = new IntroduceParameterRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(target); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -332,19 +339,22 @@ Private Sub Foo() End Sub"; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var messageBox = new Mock(); - var refactoring = new IntroduceParameterRefactoring(vbe.Object, state, messageBox.Object); + var refactoring = new IntroduceParameterRefactoring(vbe.Object, state, messageBox.Object, rewritingManager); var target = state.AllUserDeclarations.SingleOrDefault(e => e.IdentifierName == "fizz"); refactoring.Refactor(target); messageBox.Verify(m => m.NotifyWarn(It.IsAny(), It.IsAny()), Times.Once); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(inputCode, rewriter.GetText()); + + const string expectedCode = inputCode; + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -361,19 +371,22 @@ Private Sub Foo() End Sub"; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var messageBox = new Mock(); - var refactoring = new IntroduceParameterRefactoring(vbe.Object, state, messageBox.Object); + var refactoring = new IntroduceParameterRefactoring(vbe.Object, state, messageBox.Object, rewritingManager); var target = state.AllUserDeclarations.SingleOrDefault(e => e.IdentifierName == "fizz"); refactoring.Refactor(target); messageBox.Verify(m => m.NotifyWarn(It.IsAny(), It.IsAny()), Times.Once); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(inputCode, rewriter.GetText()); + + const string expectedCode = inputCode; + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -402,16 +415,16 @@ Property Let Foo(ByVal fizz As Boolean, ByVal bar As Integer, ByVal buzz As Bool End Property"; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { - var refactoring = new IntroduceParameterRefactoring(vbe.Object, state, null); + var refactoring = new IntroduceParameterRefactoring(vbe.Object, state, null, rewritingManager); var target = state.AllUserDeclarations.SingleOrDefault(e => e.IdentifierName == "bar"); refactoring.Refactor(target); - var rewriter = state.GetRewriter(component); - var actualCode = rewriter.GetText(); + var actualCode = component.CodeModule.Content(); Assert.AreEqual(expectedCode, actualCode); } } @@ -441,16 +454,17 @@ Property Set Foo(ByVal fizz As Boolean, ByVal bar As Integer, ByVal buzz As Vari End Property"; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out IVBComponent component); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { - var refactoring = new IntroduceParameterRefactoring(vbe.Object, state, null); + var refactoring = new IntroduceParameterRefactoring(vbe.Object, state, null, rewritingManager); var target = state.AllUserDeclarations.SingleOrDefault(e => e.IdentifierName == "bar"); refactoring.Refactor(target); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -487,28 +501,27 @@ Sub IClass1_fizz(ByVal boo As Boolean, ByVal fizz As Date) .AddComponent("Class1", ComponentType.ClassModule, inputCode2) .Build(); var vbe = builder.AddProject(project).Build(); - var component0 = project.Object.VBComponents[0]; - var component1 = project.Object.VBComponents[1]; + var component1 = project.Object.VBComponents[0]; + var component2 = project.Object.VBComponents[1]; vbe.Setup(v => v.ActiveCodePane).Returns(component1.CodeModule.CodePane); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var messageBox = new Mock(); messageBox.Setup(m => m.Question(It.IsAny(), It.IsAny())).Returns(true); - var refactoring = new IntroduceParameterRefactoring(vbe.Object, state, messageBox.Object); + var refactoring = new IntroduceParameterRefactoring(vbe.Object, state, messageBox.Object, rewritingManager); var target = state.AllUserDeclarations.SingleOrDefault(e => e.IdentifierName == "fizz" && e.DeclarationType == DeclarationType.Variable); refactoring.Refactor(target); - var rewriter1 = state.GetRewriter(component0); - var actual1 = rewriter1.GetText(); - Assert.AreEqual(expectedCode1, actual1); + var actualCode1 = component1.CodeModule.Content(); + Assert.AreEqual(expectedCode1, actualCode1); - var rewriter2 = state.GetRewriter(component1); - var actual2 = rewriter2.GetText(); - Assert.AreEqual(expectedCode2, actual2); + var actualCode2 = component2.CodeModule.Content(); + Assert.AreEqual(expectedCode2, actualCode2); messageBox.Verify(m => m.Question(It.IsAny(), It.IsAny()), Times.Once()); } @@ -566,25 +579,27 @@ Sub IClass1_fizz(ByVal boo As Boolean, ByVal fizz As Date) var component3 = project.Object.VBComponents[2]; vbe.Setup(v => v.ActiveCodePane).Returns(component2.CodeModule.CodePane); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var messageBox = new Mock(); messageBox.Setup(m => m.Question(It.IsAny(), It.IsAny())).Returns(true); - var refactoring = new IntroduceParameterRefactoring(vbe.Object, state, messageBox.Object); + var refactoring = new IntroduceParameterRefactoring(vbe.Object, state, messageBox.Object, rewritingManager); var target = state.AllUserDeclarations.SingleOrDefault(e => e.IdentifierName == "fizz" && e.DeclarationType == DeclarationType.Variable); refactoring.Refactor(target); - var rewriter1 = state.GetRewriter(component1); - Assert.AreEqual(expectedCode1, rewriter1.GetText()); + var actualCode1 = component1.CodeModule.Content(); + Assert.AreEqual(expectedCode1, actualCode1); + + var actualCode2 = component2.CodeModule.Content(); + Assert.AreEqual(expectedCode2, actualCode2); - var rewriter2 = state.GetRewriter(component2); - Assert.AreEqual(expectedCode2, rewriter2.GetText()); + var actualCode3 = component3.CodeModule.Content(); + Assert.AreEqual(expectedCode3, actualCode3); - var rewriter3 = state.GetRewriter(component3); - Assert.AreEqual(expectedCode3, rewriter3.GetText()); messageBox.Verify(m => m.Question(It.IsAny(), It.IsAny()), Times.Once()); } } @@ -616,22 +631,25 @@ Dim fizz As Date var component2 = project.Object.VBComponents[1]; vbe.Setup(v => v.ActiveCodePane).Returns(component2.CodeModule.CodePane); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var messageBox = new Mock(); messageBox.Setup(m => m.ConfirmYesNo(It.IsAny(), It.IsAny(), It.IsAny())).Returns(false); - var refactoring = new IntroduceParameterRefactoring(vbe.Object, state, messageBox.Object); + var refactoring = new IntroduceParameterRefactoring(vbe.Object, state, messageBox.Object, rewritingManager); var target = state.AllUserDeclarations.SingleOrDefault(e => e.IdentifierName == "fizz" && e.DeclarationType == DeclarationType.Variable); refactoring.Refactor(target); - var rewriter1 = state.GetRewriter(component1); - Assert.AreEqual(inputCode1, rewriter1.GetText()); + const string expectedCode1 = inputCode1; + var actualCode1 = component1.CodeModule.Content(); + Assert.AreEqual(expectedCode1, actualCode1); - var rewriter2 = state.GetRewriter(component2); - Assert.AreEqual(inputCode2, rewriter2.GetText()); + const string expectedCode2 = inputCode2; + var actualCode2 = component2.CodeModule.Content(); + Assert.AreEqual(expectedCode2, actualCode2); } } @@ -652,16 +670,17 @@ Dim bar As Boolean End Sub"; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out IVBComponent component); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { - var refactoring = new IntroduceParameterRefactoring(vbe.Object, state, null); + var refactoring = new IntroduceParameterRefactoring(vbe.Object, state, null, rewritingManager); var target = state.AllUserDeclarations.SingleOrDefault(e => e.IdentifierName == "bar" && e.DeclarationType == DeclarationType.Variable); refactoring.Refactor(target); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -677,18 +696,20 @@ Dim bar As Boolean End Sub"; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out IVBComponent component); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var messageBox = new Mock(); - var refactoring = new IntroduceParameterRefactoring(vbe.Object, state, messageBox.Object); + var refactoring = new IntroduceParameterRefactoring(vbe.Object, state, messageBox.Object, rewritingManager); refactoring.Refactor(state.AllUserDeclarations.First(d => d.DeclarationType != DeclarationType.Variable)); messageBox.Verify(m => m.NotifyWarn(It.IsAny(), It.IsAny()), Times.Once); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(inputCode, rewriter.GetText()); + const string expectedCode = inputCode; + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } } From 2ad16f68d605f6755ca40ae5eebac9c4743a0478 Mon Sep 17 00:00:00 2001 From: Max Doerner Date: Sat, 3 Nov 2018 12:41:12 +0100 Subject: [PATCH 20/59] Rewire the IntroduceFieldRefactoring --- .../RefactorIntroduceFieldCommand.cs | 7 +- .../IntroduceFieldRefactoring.cs | 22 ++-- .../Commands/RefactorCommandTests.cs | 8 +- .../Refactoring/IntroduceFieldTests.cs | 119 ++++++++++-------- 4 files changed, 88 insertions(+), 68 deletions(-) diff --git a/Rubberduck.Core/UI/Command/Refactorings/RefactorIntroduceFieldCommand.cs b/Rubberduck.Core/UI/Command/Refactorings/RefactorIntroduceFieldCommand.cs index 939ed3e429..a5dc9eacc0 100644 --- a/Rubberduck.Core/UI/Command/Refactorings/RefactorIntroduceFieldCommand.cs +++ b/Rubberduck.Core/UI/Command/Refactorings/RefactorIntroduceFieldCommand.cs @@ -1,5 +1,6 @@ using Rubberduck.Common; using Rubberduck.Interaction; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.Symbols; using Rubberduck.Parsing.VBA; using Rubberduck.Refactorings.IntroduceField; @@ -10,12 +11,14 @@ namespace Rubberduck.UI.Command.Refactorings public class RefactorIntroduceFieldCommand : RefactorCommandBase { private readonly RubberduckParserState _state; + private readonly IRewritingManager _rewritingManager; private readonly IMessageBox _messageBox; - public RefactorIntroduceFieldCommand (IVBE vbe, RubberduckParserState state, IMessageBox messageBox) + public RefactorIntroduceFieldCommand (IVBE vbe, RubberduckParserState state, IMessageBox messageBox, IRewritingManager rewritingManager) :base(vbe) { _state = state; + _rewritingManager = rewritingManager; _messageBox = messageBox; } @@ -49,7 +52,7 @@ protected override void OnExecute(object parameter) return; } - var refactoring = new IntroduceFieldRefactoring(Vbe, _state, _messageBox); + var refactoring = new IntroduceFieldRefactoring(Vbe, _state, _messageBox, _rewritingManager); refactoring.Refactor(selection.Value); } } diff --git a/Rubberduck.Refactorings/IntroduceField/IntroduceFieldRefactoring.cs b/Rubberduck.Refactorings/IntroduceField/IntroduceFieldRefactoring.cs index 80a5040ae8..f768fc32f7 100644 --- a/Rubberduck.Refactorings/IntroduceField/IntroduceFieldRefactoring.cs +++ b/Rubberduck.Refactorings/IntroduceField/IntroduceFieldRefactoring.cs @@ -7,7 +7,6 @@ using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.Symbols; using Rubberduck.Parsing.VBA; -using Rubberduck.UI; using Rubberduck.Resources; using Rubberduck.VBEditor; using Rubberduck.VBEditor.SafeComWrappers.Abstract; @@ -19,9 +18,10 @@ public class IntroduceFieldRefactoring : IRefactoring private readonly IList _declarations; private readonly IVBE _vbe; private readonly RubberduckParserState _state; + private readonly IRewritingManager _rewritingManager; private readonly IMessageBox _messageBox; - public IntroduceFieldRefactoring(IVBE vbe, RubberduckParserState state, IMessageBox messageBox) + public IntroduceFieldRefactoring(IVBE vbe, RubberduckParserState state, IMessageBox messageBox, IRewritingManager rewritingManager) { _declarations = state.AllUserDeclarations .Where(i => i.DeclarationType == DeclarationType.Variable) @@ -29,6 +29,7 @@ public IntroduceFieldRefactoring(IVBE vbe, RubberduckParserState state, IMessage _vbe = vbe; _state = state; + _rewritingManager = rewritingManager; _messageBox = messageBox; } @@ -55,8 +56,7 @@ public void Refactor(QualifiedSelection selection) return; } - var rewriter = _state.GetRewriter(target); - PromoteVariable(rewriter, target); + PromoteVariable(target); } public void Refactor(Declaration target) @@ -67,11 +67,10 @@ public void Refactor(Declaration target) throw new ArgumentException(@"Invalid declaration type", nameof(target)); } - var rewriter = _state.GetRewriter(target); - PromoteVariable(rewriter, target); + PromoteVariable(target); } - private void PromoteVariable(IExecutableModuleRewriter rewriter, Declaration target) + private void PromoteVariable(Declaration target) { if (new[] { DeclarationType.ClassModule, DeclarationType.ProceduralModule }.Contains(target.ParentDeclaration.DeclarationType)) { @@ -81,9 +80,14 @@ private void PromoteVariable(IExecutableModuleRewriter rewriter, Declaration tar var oldSelection = _vbe.GetActiveSelection(); + var rewriteSession = _rewritingManager.CheckOutCodePaneSession(); + var rewriter = rewriteSession.CheckOutModuleRewriter(target.QualifiedModuleName); + rewriter.Remove(target); AddField(rewriter, target); + rewriteSession.Rewrite(); + if (oldSelection.HasValue) { var component = _state.ProjectsProvider.Component(oldSelection.Value.QualifiedName); @@ -95,11 +99,9 @@ private void PromoteVariable(IExecutableModuleRewriter rewriter, Declaration tar } } } - - rewriter.Rewrite(); } - private void AddField(IExecutableModuleRewriter rewriter, Declaration target) + private void AddField(IModuleRewriter rewriter, Declaration target) { var content = $"{Tokens.Private} {target.IdentifierName} {Tokens.As} {target.AsTypeName}\r\n"; var members = _state.DeclarationFinder.Members(target.QualifiedName.QualifiedModuleName) diff --git a/RubberduckTests/Commands/RefactorCommandTests.cs b/RubberduckTests/Commands/RefactorCommandTests.cs index 5bd17cc313..2607a6e5ac 100644 --- a/RubberduckTests/Commands/RefactorCommandTests.cs +++ b/RubberduckTests/Commands/RefactorCommandTests.cs @@ -429,7 +429,7 @@ public void IntroduceField_CanExecute_NullActiveCodePane() { var msgbox = new Mock(); - var introduceFieldCommand = new RefactorIntroduceFieldCommand(vbe.Object, state, msgbox.Object); + var introduceFieldCommand = new RefactorIntroduceFieldCommand(vbe.Object, state, msgbox.Object, rewritingManager); Assert.IsFalse(introduceFieldCommand.CanExecute(null)); } } @@ -447,7 +447,7 @@ public void IntroduceField_CanExecute_NonReadyState() state.SetStatusAndFireStateChanged(this, ParserState.ResolvedDeclarations, CancellationToken.None); var msgbox = new Mock(); - var introduceFieldCommand = new RefactorIntroduceFieldCommand(vbe.Object, state, msgbox.Object); + var introduceFieldCommand = new RefactorIntroduceFieldCommand(vbe.Object, state, msgbox.Object, rewritingManager); Assert.IsFalse(introduceFieldCommand.CanExecute(null)); } } @@ -463,7 +463,7 @@ public void IntroduceField_CanExecute_Field() { var msgbox = new Mock(); - var introduceFieldCommand = new RefactorIntroduceFieldCommand(vbe.Object, state, msgbox.Object); + var introduceFieldCommand = new RefactorIntroduceFieldCommand(vbe.Object, state, msgbox.Object, rewritingManager); Assert.IsFalse(introduceFieldCommand.CanExecute(null)); } } @@ -484,7 +484,7 @@ Dim d As Boolean { var msgbox = new Mock(); - var introduceFieldCommand = new RefactorIntroduceFieldCommand(vbe.Object, state, msgbox.Object); + var introduceFieldCommand = new RefactorIntroduceFieldCommand(vbe.Object, state, msgbox.Object, rewritingManager); Assert.IsTrue(introduceFieldCommand.CanExecute(null)); } } diff --git a/RubberduckTests/Refactoring/IntroduceFieldTests.cs b/RubberduckTests/Refactoring/IntroduceFieldTests.cs index b4e8125408..985f9f1eb6 100644 --- a/RubberduckTests/Refactoring/IntroduceFieldTests.cs +++ b/RubberduckTests/Refactoring/IntroduceFieldTests.cs @@ -1,12 +1,10 @@ using System; using System.Linq; -using System.Windows.Forms; using NUnit.Framework; using Moq; using Rubberduck.Common; using Rubberduck.Parsing.Symbols; using Rubberduck.Refactorings.IntroduceField; -using Rubberduck.UI; using Rubberduck.VBEditor; using Rubberduck.VBEditor.SafeComWrappers.Abstract; using RubberduckTests.Mocks; @@ -37,16 +35,17 @@ Private Sub Foo() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); - var refactoring = new IntroduceFieldRefactoring(vbe.Object, state, null); + var refactoring = new IntroduceFieldRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var actual = state.GetRewriter(component).GetText(); - Assert.AreEqual(expectedCode, actual); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -72,16 +71,17 @@ Private Function Foo() As Boolean IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); - var refactoring = new IntroduceFieldRefactoring(vbe.Object, state, null); + var refactoring = new IntroduceFieldRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var actual = state.GetRewriter(component).GetText(); - Assert.AreEqual(expectedCode, actual); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -107,16 +107,17 @@ Private Sub Foo(ByVal buz As Integer) IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); - var refactoring = new IntroduceFieldRefactoring(vbe.Object, state, null); + var refactoring = new IntroduceFieldRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var actual = state.GetRewriter(component).GetText(); - Assert.AreEqual(expectedCode, actual); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -145,16 +146,17 @@ Private Sub Foo(ByVal buz As Integer) IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); - var refactoring = new IntroduceFieldRefactoring(vbe.Object, state, null); + var refactoring = new IntroduceFieldRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var actual = state.GetRewriter(component).GetText(); - Assert.AreEqual(expectedCode, actual); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -184,16 +186,17 @@ Private Sub Foo(ByVal buz As Integer, _ IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); - var refactoring = new IntroduceFieldRefactoring(vbe.Object, state, null); + var refactoring = new IntroduceFieldRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var actual = state.GetRewriter(component).GetText(); - Assert.AreEqual(expectedCode, actual); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -223,16 +226,17 @@ bap As Integer IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); - var refactoring = new IntroduceFieldRefactoring(vbe.Object, state, null); + var refactoring = new IntroduceFieldRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var actual = state.GetRewriter(component).GetText(); - Assert.AreEqual(expectedCode, actual); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -260,16 +264,17 @@ bap As Integer IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var target = state.AllUserDeclarations.SingleOrDefault(e => e.IdentifierName == "bat"); - var refactoring = new IntroduceFieldRefactoring(vbe.Object, state, new Mock().Object); + var refactoring = new IntroduceFieldRefactoring(vbe.Object, state, new Mock().Object, rewritingManager); refactoring.Refactor(target); - var actual = state.GetRewriter(component).GetText(); - Assert.AreEqual(expectedCode, actual); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -299,16 +304,17 @@ bat As Date IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); - var refactoring = new IntroduceFieldRefactoring(vbe.Object, state, null); + var refactoring = new IntroduceFieldRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var actual = state.GetRewriter(component).GetText(); - Assert.AreEqual(expectedCode, actual); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -335,16 +341,17 @@ Private Sub Foo(ByVal buz As Integer, _ IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); - var refactoring = new IntroduceFieldRefactoring(vbe.Object, state, null); + var refactoring = new IntroduceFieldRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var actual = state.GetRewriter(component).GetText(); - Assert.AreEqual(expectedCode, actual); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -363,18 +370,22 @@ Private Sub Foo() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); var messageBox = new Mock(); - var refactoring = new IntroduceFieldRefactoring(vbe.Object, state, messageBox.Object); + var refactoring = new IntroduceFieldRefactoring(vbe.Object, state, messageBox.Object, rewritingManager); refactoring.Refactor(qualifiedSelection); messageBox.Verify(m => m.NotifyWarn(It.IsAny(), It.IsAny()), Times.Once); - Assert.AreEqual(inputCode, component.CodeModule.Content()); + + const string expectedCode = inputCode; + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -393,20 +404,22 @@ Private Sub Foo() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); var messageBox = new Mock(); - var refactoring = new IntroduceFieldRefactoring(vbe.Object, state, messageBox.Object); + var refactoring = new IntroduceFieldRefactoring(vbe.Object, state, messageBox.Object, rewritingManager); refactoring.Refactor(qualifiedSelection); messageBox.Verify(m => m.NotifyWarn(It.IsAny(), It.IsAny()), Times.Once); - var actual = state.GetRewriter(component).GetText(); - Assert.AreEqual(inputCode, actual); + const string expectedCode = inputCode; + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -430,16 +443,17 @@ Private Sub Foo() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); - var refactoring = new IntroduceFieldRefactoring((vbe.Object), state, null); + var refactoring = new IntroduceFieldRefactoring((vbe.Object), state, null, rewritingManager); refactoring.Refactor(state.AllUserDeclarations.FindVariable(qualifiedSelection)); - var actual = state.GetRewriter(component).GetText(); - Assert.AreEqual(expectedCode, actual); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -456,12 +470,13 @@ Dim bar As Boolean IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var messageBox = new Mock(); - var refactoring = new IntroduceFieldRefactoring(vbe.Object, state, messageBox.Object); + var refactoring = new IntroduceFieldRefactoring(vbe.Object, state, messageBox.Object, rewritingManager); try { @@ -472,7 +487,7 @@ Dim bar As Boolean messageBox.Verify(m => m.NotifyWarn(It.IsAny(), It.IsAny()), Times.Once); Assert.AreEqual("target", e.ParamName); - var actual = state.GetRewriter(component).GetText(); + var actual = component.CodeModule.Content(); Assert.AreEqual(inputCode, actual); return; } From d3267cec06de46c5fc4ee4a5cf2f99c51bd5dc77 Mon Sep 17 00:00:00 2001 From: Max Doerner Date: Sat, 3 Nov 2018 13:40:00 +0100 Subject: [PATCH 21/59] Rewire the ImplementInterface- and ExtractInterfaceRefactoring --- .../RefactorExtractInterfaceCommand.cs | 7 +- .../RefactorImplementInterfaceCommand.cs | 7 +- .../ExtractInterfaceRefactoring.cs | 39 +++- .../ImplementInterfaceRefactoring.cs | 17 +- .../Commands/RefactorCommandTests.cs | 32 +-- .../Refactoring/ExtractInterfaceTests.cs | 35 ++-- .../Refactoring/ImplementInterfaceTests.cs | 182 ++++++++++-------- 7 files changed, 191 insertions(+), 128 deletions(-) diff --git a/Rubberduck.Core/UI/Command/Refactorings/RefactorExtractInterfaceCommand.cs b/Rubberduck.Core/UI/Command/Refactorings/RefactorExtractInterfaceCommand.cs index 7412073304..0ff6b12a9c 100644 --- a/Rubberduck.Core/UI/Command/Refactorings/RefactorExtractInterfaceCommand.cs +++ b/Rubberduck.Core/UI/Command/Refactorings/RefactorExtractInterfaceCommand.cs @@ -5,6 +5,7 @@ using Rubberduck.Interaction; using Rubberduck.Parsing; using Rubberduck.Parsing.Grammar; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.Symbols; using Rubberduck.Parsing.VBA; using Rubberduck.Refactorings.ExtractInterface; @@ -18,12 +19,14 @@ namespace Rubberduck.UI.Command.Refactorings public class RefactorExtractInterfaceCommand : RefactorCommandBase { private readonly RubberduckParserState _state; + private readonly IRewritingManager _rewritingManager; private readonly IMessageBox _messageBox; - public RefactorExtractInterfaceCommand(IVBE vbe, RubberduckParserState state, IMessageBox messageBox) + public RefactorExtractInterfaceCommand(IVBE vbe, RubberduckParserState state, IMessageBox messageBox, IRewritingManager rewritingManager) :base(vbe) { _state = state; + _rewritingManager = rewritingManager; _messageBox = messageBox; } @@ -85,7 +88,7 @@ protected override void OnExecute(object parameter) using (var view = new ExtractInterfaceDialog(new ExtractInterfaceViewModel())) { var factory = new ExtractInterfacePresenterFactory(Vbe, _state, view); - var refactoring = new ExtractInterfaceRefactoring(Vbe, _messageBox, factory); + var refactoring = new ExtractInterfaceRefactoring(Vbe, _messageBox, factory, _rewritingManager); refactoring.Refactor(); } } diff --git a/Rubberduck.Core/UI/Command/Refactorings/RefactorImplementInterfaceCommand.cs b/Rubberduck.Core/UI/Command/Refactorings/RefactorImplementInterfaceCommand.cs index 3f62d4dbdb..7afa78e1bb 100644 --- a/Rubberduck.Core/UI/Command/Refactorings/RefactorImplementInterfaceCommand.cs +++ b/Rubberduck.Core/UI/Command/Refactorings/RefactorImplementInterfaceCommand.cs @@ -1,6 +1,7 @@ using System.Linq; using System.Runtime.InteropServices; using Rubberduck.Interaction; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.Symbols; using Rubberduck.Parsing.VBA; using Rubberduck.Refactorings.ImplementInterface; @@ -12,12 +13,14 @@ namespace Rubberduck.UI.Command.Refactorings public class RefactorImplementInterfaceCommand : RefactorCommandBase { private readonly RubberduckParserState _state; + private readonly IRewritingManager _rewritingManager; private readonly IMessageBox _msgBox; - public RefactorImplementInterfaceCommand(IVBE vbe, RubberduckParserState state, IMessageBox msgBox) + public RefactorImplementInterfaceCommand(IVBE vbe, RubberduckParserState state, IMessageBox msgBox, IRewritingManager rewritingManager) : base(vbe) { _state = state; + _rewritingManager = rewritingManager; _msgBox = msgBox; } @@ -51,7 +54,7 @@ protected override void OnExecute(object parameter) return; } } - var refactoring = new ImplementInterfaceRefactoring(Vbe, _state, _msgBox); + var refactoring = new ImplementInterfaceRefactoring(Vbe, _state, _msgBox, _rewritingManager); refactoring.Refactor(); } } diff --git a/Rubberduck.Refactorings/ExtractInterface/ExtractInterfaceRefactoring.cs b/Rubberduck.Refactorings/ExtractInterface/ExtractInterfaceRefactoring.cs index 69997a2486..282d32e4d0 100644 --- a/Rubberduck.Refactorings/ExtractInterface/ExtractInterfaceRefactoring.cs +++ b/Rubberduck.Refactorings/ExtractInterface/ExtractInterfaceRefactoring.cs @@ -1,9 +1,12 @@ using System; +using System.Collections.Generic; using System.Linq; +using NLog; using Rubberduck.Interaction; using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.Symbols; +using Rubberduck.Parsing.VBA; using Rubberduck.Refactorings.ImplementInterface; using Rubberduck.VBEditor; using Rubberduck.VBEditor.SafeComWrappers; @@ -15,12 +18,16 @@ public class ExtractInterfaceRefactoring : IRefactoring { private readonly IVBE _vbe; private readonly IMessageBox _messageBox; + private readonly IRewritingManager _rewritingManager; private readonly IRefactoringPresenterFactory _factory; private ExtractInterfaceModel _model; - public ExtractInterfaceRefactoring(IVBE vbe, IMessageBox messageBox, IRefactoringPresenterFactory factory) + private readonly Logger _logger = LogManager.GetCurrentClassLogger(); + + public ExtractInterfaceRefactoring(IVBE vbe, IMessageBox messageBox, IRefactoringPresenterFactory factory, IRewritingManager rewritingManager) { _vbe = vbe; + _rewritingManager = rewritingManager; _messageBox = messageBox; _factory = factory; } @@ -86,6 +93,16 @@ public void Refactor(Declaration target) } private void AddInterface() + { + //We need to suspend here since addin the interface and rewriting will both trigger a reparse. + var suspendResult = _model.State.OnSuspendParser(this, new[] {ParserState.Ready}, AddInterfaceInternal); + if (suspendResult != SuspensionResult.Completed) + { + _logger.Warn("Extract interface failed."); + } + } + + private void AddInterfaceInternal() { var targetProject = _model.TargetDeclaration.Project; if (targetProject == null) @@ -93,7 +110,10 @@ private void AddInterface() return; //The target project is not available. } - var rewriter = _model.State.GetRewriter(_model.TargetDeclaration); + AddInterfaceClass(_model.TargetDeclaration, _model.InterfaceName, GetInterfaceModuleBody()); + + var rewriteSession = _rewritingManager.CheckOutCodePaneSession(); + var rewriter = rewriteSession.CheckOutModuleRewriter(_model.TargetDeclaration.QualifiedModuleName); var firstNonFieldMember = _model.State.DeclarationFinder.Members(_model.TargetDeclaration) .OrderBy(o => o.Selection) @@ -102,28 +122,35 @@ private void AddInterface() AddInterfaceMembersToClass(rewriter); + //We have to reparse here already, because + rewriteSession.Rewrite(); + } + + private void AddInterfaceClass(Declaration implementingClass, string interfaceName, string interfaceBody) + { + var targetProject = implementingClass.Project; using (var components = targetProject.VBComponents) { using (var interfaceComponent = components.Add(ComponentType.ClassModule)) { using (var interfaceModule = interfaceComponent.CodeModule) { - interfaceComponent.Name = _model.InterfaceName; + interfaceComponent.Name = interfaceName; var optionPresent = interfaceModule.CountOfLines > 1; if (!optionPresent) { interfaceModule.InsertLines(1, $"{Tokens.Option} {Tokens.Explicit}{Environment.NewLine}"); } - interfaceModule.InsertLines(3, GetInterfaceModuleBody()); + interfaceModule.InsertLines(3, interfaceBody); } } } } - private void AddInterfaceMembersToClass(IExecutableModuleRewriter rewriter) + private void AddInterfaceMembersToClass(IModuleRewriter rewriter) { - var implementInterfaceRefactoring = new ImplementInterfaceRefactoring(_vbe, _model.State, _messageBox); + var implementInterfaceRefactoring = new ImplementInterfaceRefactoring(_vbe, _model.State, _messageBox, _rewritingManager); implementInterfaceRefactoring.Refactor(_model.Members.Select(m => m.Member).ToList(), rewriter, _model.InterfaceName); } diff --git a/Rubberduck.Refactorings/ImplementInterface/ImplementInterfaceRefactoring.cs b/Rubberduck.Refactorings/ImplementInterface/ImplementInterfaceRefactoring.cs index f78f800f8c..46a78d6eed 100644 --- a/Rubberduck.Refactorings/ImplementInterface/ImplementInterfaceRefactoring.cs +++ b/Rubberduck.Refactorings/ImplementInterface/ImplementInterfaceRefactoring.cs @@ -16,6 +16,7 @@ public class ImplementInterfaceRefactoring : IRefactoring { private readonly IVBE _vbe; private readonly RubberduckParserState _state; + private readonly IRewritingManager _rewritingManager; private readonly IMessageBox _messageBox; private readonly List _declarations; @@ -24,10 +25,11 @@ public class ImplementInterfaceRefactoring : IRefactoring private const string MemberBody = " Err.Raise 5 'TODO implement interface member"; - public ImplementInterfaceRefactoring(IVBE vbe, RubberduckParserState state, IMessageBox messageBox) + public ImplementInterfaceRefactoring(IVBE vbe, RubberduckParserState state, IMessageBox messageBox, IRewritingManager rewritingManager) { _vbe = vbe; _state = state; + _rewritingManager = rewritingManager; _declarations = state.AllUserDeclarations.ToList(); _messageBox = messageBox; } @@ -77,7 +79,10 @@ public void Refactor(QualifiedSelection selection) var oldSelection = _vbe.GetActiveSelection(); - ImplementMissingMembers(_state.GetRewriter(_targetClass)); + var rewriteSession = _rewritingManager.CheckOutCodePaneSession(); + var rewriter = rewriteSession.CheckOutModuleRewriter(_targetClass.QualifiedModuleName); + ImplementMissingMembers(rewriter); + rewriteSession.Rewrite(); if (oldSelection.HasValue) { @@ -99,12 +104,12 @@ public void Refactor(Declaration target) throw new NotSupportedException(); } - internal void Refactor(List members, IExecutableModuleRewriter rewriter, string interfaceName) + internal void Refactor(List members, IModuleRewriter rewriter, string interfaceName) { AddItems(members, rewriter, interfaceName); } - private void ImplementMissingMembers(IExecutableModuleRewriter rewriter) + private void ImplementMissingMembers(IModuleRewriter rewriter) { var implemented = _targetClass.Members .Where(decl => decl is ModuleBodyElementDeclaration member && ReferenceEquals(member.InterfaceImplemented, _targetInterface)) @@ -119,14 +124,12 @@ private void ImplementMissingMembers(IExecutableModuleRewriter rewriter) AddItems(nonImplementedMembers, rewriter, _targetInterface.IdentifierName); } - private void AddItems(IEnumerable missingMembers, IExecutableModuleRewriter rewriter, string interfaceName) + private void AddItems(IEnumerable missingMembers, IModuleRewriter rewriter, string interfaceName) { var missingMembersText = missingMembers.Aggregate(string.Empty, (current, member) => current + Environment.NewLine + GetInterfaceMember(member, interfaceName)); rewriter.InsertAfter(rewriter.TokenStream.Size, Environment.NewLine + missingMembersText); - - rewriter.Rewrite(); } private string GetInterfaceMember(Declaration member, string interfaceName) diff --git a/RubberduckTests/Commands/RefactorCommandTests.cs b/RubberduckTests/Commands/RefactorCommandTests.cs index 2607a6e5ac..25484a9c1c 100644 --- a/RubberduckTests/Commands/RefactorCommandTests.cs +++ b/RubberduckTests/Commands/RefactorCommandTests.cs @@ -119,7 +119,7 @@ public void ExtractInterface_CanExecute_NullActiveCodePane() using (state) { - var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, state, null); + var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, state, null, rewritingManager); Assert.IsFalse(extractInterfaceCommand.CanExecute(null)); } } @@ -136,7 +136,7 @@ public void ExtractInterface_CanExecute_NonReadyState() { state.SetStatusAndFireStateChanged(this, ParserState.ResolvedDeclarations, CancellationToken.None); - var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, state, null); + var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, state, null, rewritingManager); Assert.IsFalse(extractInterfaceCommand.CanExecute(null)); } } @@ -150,7 +150,7 @@ public void ExtractInterface_CanExecute_NoMembers() var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { - var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, state, null); + var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, state, null, rewritingManager); Assert.IsFalse(extractInterfaceCommand.CanExecute(null)); } } @@ -169,7 +169,7 @@ public void ExtractInterface_CanExecute_Proc_StdModule() using (state) { - var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, state, null); + var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, state, null, rewritingManager); Assert.IsFalse(extractInterfaceCommand.CanExecute(null)); } } @@ -184,7 +184,7 @@ public void ExtractInterface_CanExecute_Field() using (state) { - var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, state, null); + var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, state, null, rewritingManager); Assert.IsFalse(extractInterfaceCommand.CanExecute(null)); } } @@ -219,7 +219,7 @@ End Sub var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { - var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, state, null); + var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, state, null, rewritingManager); Assert.IsTrue(extractInterfaceCommand.CanExecute(null)); } } @@ -247,7 +247,7 @@ public void ExtractInterface_CanExecute_ClassWithMembers_SameNameAsClassWithMemb using (state) { - var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, state, null); + var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, state, null, rewritingManager); Assert.IsTrue(extractInterfaceCommand.CanExecute(null)); } } @@ -266,7 +266,7 @@ public void ExtractInterface_CanExecute_Proc() using (state) { - var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, state, null); + var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, state, null, rewritingManager); var canExecute = extractInterfaceCommand.CanExecute(null); Assert.IsTrue(canExecute); } @@ -286,7 +286,7 @@ public void ExtractInterface_CanExecute_Function() using (state) { - var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, state, null); + var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, state, null, rewritingManager); Assert.IsTrue(extractInterfaceCommand.CanExecute(null)); } } @@ -305,7 +305,7 @@ public void ExtractInterface_CanExecute_PropertyGet() using (state) { - var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, state, null); + var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, state, null, rewritingManager); Assert.IsTrue(extractInterfaceCommand.CanExecute(null)); } } @@ -324,7 +324,7 @@ public void ExtractInterface_CanExecute_PropertyLet() using (state) { - var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, state, null); + var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, state, null, rewritingManager); Assert.IsTrue(extractInterfaceCommand.CanExecute(null)); } } @@ -343,7 +343,7 @@ public void ExtractInterface_CanExecute_PropertySet() using (state) { - var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, state, null); + var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, state, null, rewritingManager); Assert.IsTrue(extractInterfaceCommand.CanExecute(null)); } } @@ -360,7 +360,7 @@ public void ImplementInterface_CanExecute_NullActiveCodePane() using (state) { - var implementInterfaceCommand = new RefactorImplementInterfaceCommand(vbe.Object, state, null); + var implementInterfaceCommand = new RefactorImplementInterfaceCommand(vbe.Object, state, null, rewritingManager); Assert.IsFalse(implementInterfaceCommand.CanExecute(null)); } } @@ -377,7 +377,7 @@ public void ImplementInterface_CanExecute_NonReadyState() { state.SetStatusAndFireStateChanged(this, ParserState.ResolvedDeclarations, CancellationToken.None); - var implementInterfaceCommand = new RefactorImplementInterfaceCommand(vbe.Object, state, null); + var implementInterfaceCommand = new RefactorImplementInterfaceCommand(vbe.Object, state, null, rewritingManager); Assert.IsFalse(implementInterfaceCommand.CanExecute(null)); } } @@ -392,7 +392,7 @@ public void ImplementInterface_CanExecute_ImplementsInterfaceNotSelected() using (state) { - var implementInterfaceCommand = new RefactorImplementInterfaceCommand(vbe.Object, state, null); + var implementInterfaceCommand = new RefactorImplementInterfaceCommand(vbe.Object, state, null, rewritingManager); Assert.IsFalse(implementInterfaceCommand.CanExecute(null)); } } @@ -412,7 +412,7 @@ public void ImplementInterface_CanExecute_ImplementsInterfaceSelected() using (state) { - var implementInterfaceCommand = new RefactorImplementInterfaceCommand(vbe.Object, state, null); + var implementInterfaceCommand = new RefactorImplementInterfaceCommand(vbe.Object, state, null, rewritingManager); Assert.IsTrue(implementInterfaceCommand.CanExecute(null)); } } diff --git a/RubberduckTests/Refactoring/ExtractInterfaceTests.cs b/RubberduckTests/Refactoring/ExtractInterfaceTests.cs index d2dda92cf7..fb66b5b9b9 100644 --- a/RubberduckTests/Refactoring/ExtractInterfaceTests.cs +++ b/RubberduckTests/Refactoring/ExtractInterfaceTests.cs @@ -50,7 +50,8 @@ End Sub IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleModule(inputCode, ComponentType.ClassModule, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -61,7 +62,7 @@ End Sub //SetupFactory var factory = SetupFactory(model); - var refactoring = new ExtractInterfaceRefactoring(vbe.Object, null, factory.Object); + var refactoring = new ExtractInterfaceRefactoring(vbe.Object, null, factory.Object, rewritingManager); refactoring.Refactor(qualifiedSelection); var actualCode = component.CodeModule.Content(); @@ -156,7 +157,8 @@ End Property IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleModule(inputCode, ComponentType.ClassModule, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -167,7 +169,7 @@ End Property //SetupFactory var factory = SetupFactory(model); - var refactoring = new ExtractInterfaceRefactoring(vbe.Object, null, factory.Object); + var refactoring = new ExtractInterfaceRefactoring(vbe.Object, null, factory.Object, rewritingManager); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedInterfaceCode, component.Collection[1].CodeModule.Content()); @@ -240,7 +242,8 @@ End Function IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleModule(inputCode, ComponentType.ClassModule, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -252,7 +255,7 @@ End Function //SetupFactory var factory = SetupFactory(model); - var refactoring = new ExtractInterfaceRefactoring(vbe.Object, null, factory.Object); + var refactoring = new ExtractInterfaceRefactoring(vbe.Object, null, factory.Object, rewritingManager); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedInterfaceCode, component.Collection[1].CodeModule.Content()); @@ -273,7 +276,8 @@ public void ExtractInterfaceRefactoring_IgnoresField() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleModule(inputCode, ComponentType.ClassModule, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -297,7 +301,8 @@ public void ExtractInterfaceRefactoring_NullPresenter_NoChanges() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleModule(inputCode, ComponentType.ClassModule, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -309,7 +314,7 @@ public void ExtractInterfaceRefactoring_NullPresenter_NoChanges() var factory = SetupFactory(model); factory.Setup(f => f.Create()).Returns(value: null); - var refactoring = new ExtractInterfaceRefactoring(vbe.Object, null, factory.Object); + var refactoring = new ExtractInterfaceRefactoring(vbe.Object, null, factory.Object, rewritingManager); refactoring.Refactor(); Assert.AreEqual(1, vbe.Object.ActiveVBProject.VBComponents.Count()); @@ -330,7 +335,8 @@ public void ExtractInterfaceRefactoring_NullModel_NoChanges() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleModule(inputCode, ComponentType.ClassModule, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -345,7 +351,7 @@ public void ExtractInterfaceRefactoring_NullModel_NoChanges() var factory = SetupFactory(model); factory.Setup(f => f.Create()).Returns(presenter.Object); - var refactoring = new ExtractInterfaceRefactoring(vbe.Object, null, factory.Object); + var refactoring = new ExtractInterfaceRefactoring(vbe.Object, null, factory.Object, rewritingManager); refactoring.Refactor(); Assert.AreEqual(1, vbe.Object.ActiveVBProject.VBComponents.Count()); @@ -386,7 +392,8 @@ End Sub IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleModule(inputCode, ComponentType.ClassModule, out component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -398,7 +405,7 @@ End Sub //SetupFactory var factory = SetupFactory(model); - var refactoring = new ExtractInterfaceRefactoring(vbe.Object, null, factory.Object); + var refactoring = new ExtractInterfaceRefactoring(vbe.Object, null, factory.Object, rewritingManager); refactoring.Refactor(state.AllUserDeclarations.Single(s => s.DeclarationType == DeclarationType.ClassModule)); Assert.AreEqual(expectedInterfaceCode, component.Collection[1].CodeModule.Content()); @@ -501,7 +508,7 @@ public void Factory_NullSelectionNullReturnsNullPresenter() IVBComponent component; var vbe = MockVbeBuilder.BuildFromSingleModule(inputCode, ComponentType.ClassModule, out component); - using (var state = MockParser.CreateAndParse(vbe.Object)) + using(var state = MockParser.CreateAndParse(vbe.Object)) { vbe.Setup(v => v.ActiveCodePane).Returns((ICodePane)null); diff --git a/RubberduckTests/Refactoring/ImplementInterfaceTests.cs b/RubberduckTests/Refactoring/ImplementInterfaceTests.cs index f86525042a..e20ba70e4f 100644 --- a/RubberduckTests/Refactoring/ImplementInterfaceTests.cs +++ b/RubberduckTests/Refactoring/ImplementInterfaceTests.cs @@ -39,16 +39,17 @@ End Sub var vbe = builder.AddProject(project).Build(); var component = project.Object.VBComponents[1]; - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), Selection.Home); - var refactoring = new ImplementInterfaceRefactoring(vbe.Object, state, null); + var refactoring = new ImplementInterfaceRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -88,16 +89,17 @@ End Sub var vbe = builder.AddProject(project).Build(); var component = project.Object.VBComponents[1]; - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), Selection.Home); - var refactoring = new ImplementInterfaceRefactoring(vbe.Object, state, null); + var refactoring = new ImplementInterfaceRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -151,16 +153,16 @@ End Property var vbe = builder.AddProject(project).Build(); var component = project.Object.VBComponents[1]; - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), Selection.Home); - var refactoring = new ImplementInterfaceRefactoring(vbe.Object, state, null); + var refactoring = new ImplementInterfaceRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(component); - var actualCode = rewriter.GetText(); + var actualCode = component.CodeModule.Content(); Assert.AreEqual(expectedCode, actualCode); } } @@ -195,16 +197,17 @@ End Sub var vbe = builder.AddProject(project).Build(); var component = project.Object.VBComponents[1]; - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), Selection.Home); - var refactoring = new ImplementInterfaceRefactoring(vbe.Object, state, null); + var refactoring = new ImplementInterfaceRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -238,16 +241,17 @@ End Function var vbe = builder.AddProject(project).Build(); var component = project.Object.VBComponents[1]; - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), Selection.Home); - var refactoring = new ImplementInterfaceRefactoring(vbe.Object, state, null); + var refactoring = new ImplementInterfaceRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -281,16 +285,17 @@ End Function var vbe = builder.AddProject(project).Build(); var component = project.Object.VBComponents[1]; - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), Selection.Home); - var refactoring = new ImplementInterfaceRefactoring(vbe.Object, state, null); + var refactoring = new ImplementInterfaceRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -324,16 +329,17 @@ End Function var vbe = builder.AddProject(project).Build(); var component = project.Object.VBComponents[1]; - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), Selection.Home); - var refactoring = new ImplementInterfaceRefactoring(vbe.Object, state, null); + var refactoring = new ImplementInterfaceRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -367,16 +373,17 @@ End Property var vbe = builder.AddProject(project).Build(); var component = project.Object.VBComponents[1]; - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), Selection.Home); - var refactoring = new ImplementInterfaceRefactoring(vbe.Object, state, null); + var refactoring = new ImplementInterfaceRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -410,16 +417,17 @@ End Property var vbe = builder.AddProject(project).Build(); var component = project.Object.VBComponents[1]; - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), Selection.Home); - var refactoring = new ImplementInterfaceRefactoring(vbe.Object, state, null); + var refactoring = new ImplementInterfaceRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -453,16 +461,17 @@ End Property var vbe = builder.AddProject(project).Build(); var component = project.Object.VBComponents[1]; - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), Selection.Home); - var refactoring = new ImplementInterfaceRefactoring(vbe.Object, state, null); + var refactoring = new ImplementInterfaceRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -496,16 +505,17 @@ End Property var vbe = builder.AddProject(project).Build(); var component = project.Object.VBComponents[1]; - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), Selection.Home); - var refactoring = new ImplementInterfaceRefactoring(vbe.Object, state, null); + var refactoring = new ImplementInterfaceRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -539,16 +549,17 @@ End Property var vbe = builder.AddProject(project).Build(); var component = project.Object.VBComponents[1]; - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), Selection.Home); - var refactoring = new ImplementInterfaceRefactoring(vbe.Object, state, null); + var refactoring = new ImplementInterfaceRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -582,16 +593,17 @@ End Property var vbe = builder.AddProject(project).Build(); var component = project.Object.VBComponents[1]; - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), Selection.Home); - var refactoring = new ImplementInterfaceRefactoring(vbe.Object, state, null); + var refactoring = new ImplementInterfaceRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -625,16 +637,17 @@ End Property var vbe = builder.AddProject(project).Build(); var component = project.Object.VBComponents[1]; - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), Selection.Home); - var refactoring = new ImplementInterfaceRefactoring(vbe.Object, state, null); + var refactoring = new ImplementInterfaceRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -689,16 +702,17 @@ End Property var vbe = builder.AddProject(project).Build(); var component = project.Object.VBComponents[1]; - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), Selection.Home); - var refactoring = new ImplementInterfaceRefactoring(vbe.Object, state, null); + var refactoring = new ImplementInterfaceRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -760,16 +774,17 @@ End Property var vbe = builder.AddProject(project).Build(); var component = project.Object.VBComponents[1]; - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), Selection.Home); - var refactoring = new ImplementInterfaceRefactoring(vbe.Object, state, null); + var refactoring = new ImplementInterfaceRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -800,16 +815,17 @@ End Sub var project = vbe.Object.VBProjects[0]; var component = project.VBComponents["Sheet1"]; - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), Selection.Home); - var refactoring = new ImplementInterfaceRefactoring(vbe.Object, state, null); + var refactoring = new ImplementInterfaceRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -840,16 +856,17 @@ End Sub var project = vbe.Object.VBProjects[0]; var component = project.VBComponents["Form1"]; - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), Selection.Home); - var refactoring = new ImplementInterfaceRefactoring(vbe.Object, state, null); + var refactoring = new ImplementInterfaceRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var rewriter = state.GetRewriter(component); - Assert.AreEqual(expectedCode, rewriter.GetText()); + var actualCode = component.CodeModule.Content(); + Assert.AreEqual(expectedCode, actualCode); } } @@ -884,15 +901,16 @@ End Property var vbe = builder.AddProject(project).Build(); var component = project.Object.VBComponents[1]; - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), Selection.Home); - var refactoring = new ImplementInterfaceRefactoring(vbe.Object, state, null); + var refactoring = new ImplementInterfaceRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var actualCode = state.GetRewriter(component).GetText(); + var actualCode = component.CodeModule.Content(); Assert.AreEqual(expectedCode, actualCode); } } @@ -928,15 +946,16 @@ End Property var vbe = builder.AddProject(project).Build(); var component = project.Object.VBComponents[1]; - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), Selection.Home); - var refactoring = new ImplementInterfaceRefactoring(vbe.Object, state, null); + var refactoring = new ImplementInterfaceRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var actualCode = state.GetRewriter(component).GetText(); + var actualCode = component.CodeModule.Content(); Assert.AreEqual(expectedCode, actualCode); } } @@ -978,15 +997,16 @@ End Property var vbe = builder.AddProject(project).Build(); var component = project.Object.VBComponents[1]; - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), Selection.Home); - var refactoring = new ImplementInterfaceRefactoring(vbe.Object, state, null); + var refactoring = new ImplementInterfaceRefactoring(vbe.Object, state, null, rewritingManager); refactoring.Refactor(qualifiedSelection); - var actualCode = state.GetRewriter(component).GetText(); + var actualCode = component.CodeModule.Content(); Assert.AreEqual(expectedCode, actualCode); } } From 5f5ffe725cbfa7762c9d4788de742fa17c4cf9e1 Mon Sep 17 00:00:00 2001 From: Max Doerner Date: Sat, 3 Nov 2018 14:35:32 +0100 Subject: [PATCH 22/59] Rewire the RemoveParameterRefactoring --- .../RemoveUnusedParameterQuickFix.cs | 16 +- .../RefactorRemoveParametersCommand.cs | 7 +- .../RemoveParametersRefactoring.cs | 56 ++--- .../Commands/RefactorCommandTests.cs | 228 +++++++----------- .../RemoveUnusedParameterQuickFixTests.cs | 4 +- .../Refactoring/RemoveParametersTests.cs | 166 +++++++------ 6 files changed, 213 insertions(+), 264 deletions(-) diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RemoveUnusedParameterQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RemoveUnusedParameterQuickFix.cs index b56fe993fa..aa02c472ad 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/RemoveUnusedParameterQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/RemoveUnusedParameterQuickFix.cs @@ -14,13 +14,15 @@ public sealed class RemoveUnusedParameterQuickFix : QuickFixBase { private readonly IVBE _vbe; private readonly RubberduckParserState _state; + private readonly IRewritingManager _rewritingManager; private readonly IMessageBox _messageBox; - public RemoveUnusedParameterQuickFix(IVBE vbe, RubberduckParserState state, IMessageBox messageBox) + public RemoveUnusedParameterQuickFix(IVBE vbe, RubberduckParserState state, IMessageBox messageBox, IRewritingManager rewritingManager) : base(typeof(ParameterNotUsedInspection)) { _vbe = vbe; _state = state; + _rewritingManager = rewritingManager; _messageBox = messageBox; } @@ -29,8 +31,10 @@ public override void Fix(IInspectionResult result, IRewriteSession rewriteSessio { using (var dialog = new RemoveParametersDialog(new RemoveParametersViewModel(_state))) { - var refactoring = new RemoveParametersRefactoring(_vbe, - new RemoveParametersPresenterFactory(_vbe, dialog, _state, _messageBox)); + var refactoring = new RemoveParametersRefactoring( + _vbe, + new RemoveParametersPresenterFactory(_vbe, dialog, _state, _messageBox), + _rewritingManager); refactoring.QuickFix(_state, result.QualifiedSelection); } @@ -38,8 +42,8 @@ public override void Fix(IInspectionResult result, IRewriteSession rewriteSessio public override string Description(IInspectionResult result) => Resources.Inspections.QuickFixes.RemoveUnusedParameterQuickFix; - public override bool CanFixInProcedure => true; - public override bool CanFixInModule => true; - public override bool CanFixInProject => true; + public override bool CanFixInProcedure => false; + public override bool CanFixInModule => false; + public override bool CanFixInProject => false; } } \ No newline at end of file diff --git a/Rubberduck.Core/UI/Command/Refactorings/RefactorRemoveParametersCommand.cs b/Rubberduck.Core/UI/Command/Refactorings/RefactorRemoveParametersCommand.cs index 5fc79a8236..20322bdeac 100644 --- a/Rubberduck.Core/UI/Command/Refactorings/RefactorRemoveParametersCommand.cs +++ b/Rubberduck.Core/UI/Command/Refactorings/RefactorRemoveParametersCommand.cs @@ -2,6 +2,7 @@ using System.Runtime.InteropServices; using Rubberduck.Common; using Rubberduck.Interaction; +using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.Symbols; using Rubberduck.Parsing.VBA; using Rubberduck.Refactorings.RemoveParameters; @@ -16,12 +17,14 @@ public class RefactorRemoveParametersCommand : RefactorCommandBase { private readonly IMessageBox _msgbox; private readonly RubberduckParserState _state; + private readonly IRewritingManager _rewritingManager; - public RefactorRemoveParametersCommand(IVBE vbe, RubberduckParserState state, IMessageBox msgbox) + public RefactorRemoveParametersCommand(IVBE vbe, RubberduckParserState state, IMessageBox msgbox, IRewritingManager rewritingManager) : base (vbe) { _msgbox = msgbox; _state = state; + _rewritingManager = rewritingManager; } private static readonly DeclarationType[] ValidDeclarationTypes = @@ -75,7 +78,7 @@ protected override void OnExecute(object parameter) using (var view = new RemoveParametersDialog(new RemoveParametersViewModel(_state))) { var factory = new RemoveParametersPresenterFactory(Vbe, view, _state, _msgbox); - var refactoring = new RemoveParametersRefactoring(Vbe, factory); + var refactoring = new RemoveParametersRefactoring(Vbe, factory, _rewritingManager); refactoring.Refactor(selection.Value); } } diff --git a/Rubberduck.Refactorings/RemoveParameters/RemoveParametersRefactoring.cs b/Rubberduck.Refactorings/RemoveParameters/RemoveParametersRefactoring.cs index 0246b69023..72918de6c2 100644 --- a/Rubberduck.Refactorings/RemoveParameters/RemoveParametersRefactoring.cs +++ b/Rubberduck.Refactorings/RemoveParameters/RemoveParametersRefactoring.cs @@ -2,8 +2,6 @@ using System.Collections.Generic; using System.Diagnostics; using System.Linq; -using Antlr4.Runtime; -using Antlr4.Runtime.Tree; using Rubberduck.Common; using Rubberduck.Interaction; using Rubberduck.Parsing; @@ -20,12 +18,13 @@ public class RemoveParametersRefactoring : IRefactoring { private readonly IVBE _vbe; private readonly IRefactoringPresenterFactory _factory; + private readonly IRewritingManager _rewritingManager; private RemoveParametersModel _model; - private readonly HashSet _rewriters = new HashSet(); - public RemoveParametersRefactoring(IVBE vbe, IRefactoringPresenterFactory factory) + public RemoveParametersRefactoring(IVBE vbe, IRefactoringPresenterFactory factory, IRewritingManager rewritingManager) { _vbe = vbe; + _rewritingManager = rewritingManager; _factory = factory; } @@ -54,8 +53,6 @@ public void Refactor() pane.Selection = oldSelection.Value.Selection; } } - - _model.State.OnParseRequested(this); } public void Refactor(QualifiedSelection target) @@ -113,16 +110,15 @@ private void RemoveParameters() throw new NullReferenceException("Parameter is null"); } - AdjustReferences(_model.TargetDeclaration.References, _model.TargetDeclaration); - AdjustSignatures(); + var rewritingSession = _rewritingManager.CheckOutCodePaneSession(); - foreach (var rewriter in _rewriters) - { - rewriter.Rewrite(); - } + AdjustReferences(_model.TargetDeclaration.References, _model.TargetDeclaration, rewritingSession); + AdjustSignatures(rewritingSession); + + rewritingSession.Rewrite(); } - private void AdjustReferences(IEnumerable references, Declaration method) + private void AdjustReferences(IEnumerable references, Declaration method, IRewriteSession rewriteSession) { foreach (var reference in references.Where(item => item.Context != method.Context)) { @@ -158,14 +154,13 @@ private void AdjustReferences(IEnumerable references, Decla continue; } - RemoveCallArguments(argumentList, reference.QualifiedModuleName); + RemoveCallArguments(argumentList, reference.QualifiedModuleName, rewriteSession); } } - private void RemoveCallArguments(VBAParser.ArgumentListContext argList, QualifiedModuleName module) + private void RemoveCallArguments(VBAParser.ArgumentListContext argList, QualifiedModuleName module, IRewriteSession rewriteSession) { - var rewriter = _model.State.GetRewriter(module); - _rewriters.Add(rewriter); + var rewriter = rewriteSession.CheckOutModuleRewriter(module); var usesNamedArguments = false; var args = argList.children.OfType().ToList(); @@ -211,7 +206,7 @@ private void RemoveCallArguments(VBAParser.ArgumentListContext argList, Qualifie RemoveTrailingComma(rewriter, argList, usesNamedArguments); } - private void AdjustSignatures() + private void AdjustSignatures(IRewriteSession rewriteSession) { // if we are adjusting a property getter, check if we need to adjust the letter/setter too if (_model.TargetDeclaration.DeclarationType == DeclarationType.PropertyGet) @@ -219,19 +214,19 @@ private void AdjustSignatures() var setter = GetLetterOrSetter(_model.TargetDeclaration, DeclarationType.PropertySet); if (setter != null) { - RemoveSignatureParameters(setter); - AdjustReferences(setter.References, setter); + RemoveSignatureParameters(setter, rewriteSession); + AdjustReferences(setter.References, setter, rewriteSession); } var letter = GetLetterOrSetter(_model.TargetDeclaration, DeclarationType.PropertyLet); if (letter != null) { - RemoveSignatureParameters(letter); - AdjustReferences(letter.References, letter); + RemoveSignatureParameters(letter, rewriteSession); + AdjustReferences(letter.References, letter, rewriteSession); } } - RemoveSignatureParameters(_model.TargetDeclaration); + RemoveSignatureParameters(_model.TargetDeclaration, rewriteSession); var eventImplementations = _model.Declarations .Where(item => item.IsWithEvents && item.AsTypeName == _model.TargetDeclaration.ComponentName) @@ -239,8 +234,8 @@ private void AdjustSignatures() foreach (var eventImplementation in eventImplementations) { - AdjustReferences(eventImplementation.References, eventImplementation); - RemoveSignatureParameters(eventImplementation); + AdjustReferences(eventImplementation.References, eventImplementation, rewriteSession); + RemoveSignatureParameters(eventImplementation, rewriteSession); } var interfaceImplementations = _model.State.DeclarationFinder.FindAllInterfaceImplementingMembers().Where(item => @@ -250,8 +245,8 @@ private void AdjustSignatures() foreach (var interfaceImplentation in interfaceImplementations) { - AdjustReferences(interfaceImplentation.References, interfaceImplentation); - RemoveSignatureParameters(interfaceImplentation); + AdjustReferences(interfaceImplentation.References, interfaceImplentation, rewriteSession); + RemoveSignatureParameters(interfaceImplentation, rewriteSession); } } @@ -262,9 +257,9 @@ private Declaration GetLetterOrSetter(Declaration declaration, DeclarationType d && item.DeclarationType == declarationType); } - private void RemoveSignatureParameters(Declaration target) + private void RemoveSignatureParameters(Declaration target, IRewriteSession rewriteSession) { - var rewriter = _model.State.GetRewriter(target); + var rewriter = rewriteSession.CheckOutModuleRewriter(target.QualifiedModuleName); var parameters = ((IParameterizedDeclaration)target).Parameters.OrderBy(o => o.Selection).ToList(); @@ -274,13 +269,12 @@ private void RemoveSignatureParameters(Declaration target) } RemoveTrailingComma(rewriter); - _rewriters.Add(rewriter); } //Issue 4319. If there are 3 or more arguments and the user elects to remove 2 or more of //the last arguments, then we need to specifically remove the trailing comma from //the last 'kept' argument. - private void RemoveTrailingComma(IExecutableModuleRewriter rewriter, VBAParser.ArgumentListContext argList = null, bool usesNamedParams = false) + private void RemoveTrailingComma(IModuleRewriter rewriter, VBAParser.ArgumentListContext argList = null, bool usesNamedParams = false) { var commaLocator = RetrieveTrailingCommaInfo(_model.RemoveParameters, _model.Parameters); if (!commaLocator.RequiresTrailingCommaRemoval) diff --git a/RubberduckTests/Commands/RefactorCommandTests.cs b/RubberduckTests/Commands/RefactorCommandTests.cs index 25484a9c1c..1586c4b72d 100644 --- a/RubberduckTests/Commands/RefactorCommandTests.cs +++ b/RubberduckTests/Commands/RefactorCommandTests.cs @@ -18,8 +18,7 @@ public class RefactorCommandTests [Test] public void EncapsulateField_CanExecute_NullActiveCodePane() { - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out component); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out _); vbe.Setup(v => v.ActiveCodePane).Returns((ICodePane)null); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); @@ -35,8 +34,7 @@ public void EncapsulateField_CanExecute_NullActiveCodePane() [Test] public void EncapsulateField_CanExecute_NonReadyState() { - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out component); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out _); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { @@ -56,8 +54,7 @@ public void EncapsulateField_CanExecute_LocalVariable() Dim d As Boolean End Sub"; - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(2, 9, 2, 9)); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out _, new Selection(2, 9, 2, 9)); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { @@ -76,8 +73,7 @@ public void EncapsulateField_CanExecute_Proc() Sub Foo() End Sub"; - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(2, 7, 2, 7)); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out _, new Selection(2, 7, 2, 7)); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { @@ -96,8 +92,7 @@ public void EncapsulateField_CanExecute_Field() Sub Foo() End Sub"; - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 5, 1, 5)); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out _, new Selection(1, 5, 1, 5)); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { @@ -111,8 +106,7 @@ Sub Foo() [Test] public void ExtractInterface_CanExecute_NullActiveCodePane() { - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out component); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out _); vbe.Setup(v => v.ActiveCodePane).Returns((ICodePane)null); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); @@ -128,8 +122,7 @@ public void ExtractInterface_CanExecute_NullActiveCodePane() [Test] public void ExtractInterface_CanExecute_NonReadyState() { - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleModule(string.Empty, ComponentType.ClassModule, out component, new Selection()); + var vbe = MockVbeBuilder.BuildFromSingleModule(string.Empty, ComponentType.ClassModule, out _); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) @@ -145,8 +138,7 @@ public void ExtractInterface_CanExecute_NonReadyState() [Test] public void ExtractInterface_CanExecute_NoMembers() { - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleModule("Option Explicit", ComponentType.ClassModule, out component, new Selection()); + var vbe = MockVbeBuilder.BuildFromSingleModule("Option Explicit", ComponentType.ClassModule, out _); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { @@ -163,8 +155,7 @@ public void ExtractInterface_CanExecute_Proc_StdModule() @"Sub foo() End Sub"; - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out _); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { @@ -178,8 +169,7 @@ public void ExtractInterface_CanExecute_Proc_StdModule() [Test] public void ExtractInterface_CanExecute_Field() { - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleModule("Dim d As Boolean", ComponentType.ClassModule, out component, Selection.Home); + var vbe = MockVbeBuilder.BuildFromSingleModule("Dim d As Boolean", ComponentType.ClassModule, out _, Selection.Home); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { @@ -260,8 +250,7 @@ public void ExtractInterface_CanExecute_Proc() @"Sub foo() End Sub"; - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleModule(input, ComponentType.ClassModule, out component, Selection.Home); + var vbe = MockVbeBuilder.BuildFromSingleModule(input, ComponentType.ClassModule, out _, Selection.Home); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { @@ -280,8 +269,7 @@ public void ExtractInterface_CanExecute_Function() @"Function foo() As Integer End Function"; - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleModule(input, ComponentType.ClassModule, out component, Selection.Home); + var vbe = MockVbeBuilder.BuildFromSingleModule(input, ComponentType.ClassModule, out _, Selection.Home); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { @@ -299,8 +287,7 @@ public void ExtractInterface_CanExecute_PropertyGet() @"Property Get foo() As Boolean End Property"; - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleModule(input, ComponentType.ClassModule, out component, Selection.Home); + var vbe = MockVbeBuilder.BuildFromSingleModule(input, ComponentType.ClassModule, out _, Selection.Home); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { @@ -318,8 +305,7 @@ public void ExtractInterface_CanExecute_PropertyLet() @"Property Let foo(value) End Property"; - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleModule(input, ComponentType.ClassModule, out component, Selection.Home); + var vbe = MockVbeBuilder.BuildFromSingleModule(input, ComponentType.ClassModule, out _, Selection.Home); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { @@ -337,8 +323,7 @@ public void ExtractInterface_CanExecute_PropertySet() @"Property Set foo(value) End Property"; - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleModule(input, ComponentType.ClassModule, out component, Selection.Home); + var vbe = MockVbeBuilder.BuildFromSingleModule(input, ComponentType.ClassModule, out _, Selection.Home); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { @@ -352,8 +337,7 @@ public void ExtractInterface_CanExecute_PropertySet() [Test] public void ImplementInterface_CanExecute_NullActiveCodePane() { - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out component); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out _); vbe.Setup(v => v.ActiveCodePane).Returns((ICodePane)null); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); @@ -369,8 +353,7 @@ public void ImplementInterface_CanExecute_NullActiveCodePane() [Test] public void ImplementInterface_CanExecute_NonReadyState() { - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out component); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out _); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) @@ -386,8 +369,7 @@ public void ImplementInterface_CanExecute_NonReadyState() [Test] public void ImplementInterface_CanExecute_ImplementsInterfaceNotSelected() { - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleModule(string.Empty, ComponentType.ClassModule, out component, new Selection()); + var vbe = MockVbeBuilder.BuildFromSingleModule(string.Empty, ComponentType.ClassModule, out _); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { @@ -421,8 +403,7 @@ public void ImplementInterface_CanExecute_ImplementsInterfaceSelected() [Test] public void IntroduceField_CanExecute_NullActiveCodePane() { - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out component); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out _); vbe.Setup(v => v.ActiveCodePane).Returns((ICodePane)null); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) @@ -438,8 +419,7 @@ public void IntroduceField_CanExecute_NullActiveCodePane() [Test] public void IntroduceField_CanExecute_NonReadyState() { - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out component); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out _); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) @@ -456,8 +436,7 @@ public void IntroduceField_CanExecute_NonReadyState() [Test] public void IntroduceField_CanExecute_Field() { - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule("Dim d As Boolean", out component, Selection.Home); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule("Dim d As Boolean", out _, Selection.Home); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { @@ -477,8 +456,7 @@ public void IntroduceField_CanExecute_LocalVariable() Dim d As Boolean End Property"; - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(2, 10, 2, 10)); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out _, new Selection(2, 10, 2, 10)); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { @@ -493,8 +471,7 @@ Dim d As Boolean [Test] public void IntroduceParameter_CanExecute_NullActiveCodePane() { - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out component); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out _); vbe.Setup(v => v.ActiveCodePane).Returns((ICodePane)null); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) @@ -510,8 +487,7 @@ public void IntroduceParameter_CanExecute_NullActiveCodePane() [Test] public void IntroduceParameter_CanExecute_NonReadyState() { - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out component); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out _); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) @@ -528,8 +504,7 @@ public void IntroduceParameter_CanExecute_NonReadyState() [Test] public void IntroduceParameter_CanExecute_Field() { - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule("Dim d As Boolean", out component, Selection.Home); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule("Dim d As Boolean", out _, Selection.Home); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { @@ -549,8 +524,7 @@ public void IntroduceParameter_CanExecute_LocalVariable() Dim d As Boolean End Property"; - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(2, 10, 2, 10)); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out _, new Selection(2, 10, 2, 10)); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { @@ -565,14 +539,13 @@ Dim d As Boolean [Test] public void MoveCloserToUsage_CanExecute_NullActiveCodePane() { - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out component); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out _); vbe.Setup(v => v.ActiveCodePane).Returns((ICodePane)null); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { - var moveCloserToUsageCommand = new RefactorMoveCloserToUsageCommand(vbe.Object, state, null, rewritingManager); + var moveCloserToUsageCommand = new RefactorMoveCloserToUsageCommand(vbe.Object, state, null, rewritingManager); Assert.IsFalse(moveCloserToUsageCommand.CanExecute(null)); } } @@ -581,8 +554,7 @@ public void MoveCloserToUsage_CanExecute_NullActiveCodePane() [Test] public void MoveCloserToUsage_CanExecute_NonReadyState() { - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out component); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out _); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) @@ -598,13 +570,12 @@ public void MoveCloserToUsage_CanExecute_NonReadyState() [Test] public void MoveCloserToUsage_CanExecute_Field_NoReferences() { - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule("Dim d As Boolean", out component, Selection.Home); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule("Dim d As Boolean", out _, Selection.Home); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { - var moveCloserToUsageCommand = new RefactorMoveCloserToUsageCommand(vbe.Object, state, null, rewritingManager); + var moveCloserToUsageCommand = new RefactorMoveCloserToUsageCommand(vbe.Object, state, null, rewritingManager); Assert.IsFalse(moveCloserToUsageCommand.CanExecute(null)); } } @@ -618,13 +589,12 @@ public void MoveCloserToUsage_CanExecute_LocalVariable_NoReferences() Dim d As Boolean End Property"; - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(2, 10, 2, 10)); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out _, new Selection(2, 10, 2, 10)); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { - var moveCloserToUsageCommand = new RefactorMoveCloserToUsageCommand(vbe.Object, state, null, rewritingManager); + var moveCloserToUsageCommand = new RefactorMoveCloserToUsageCommand(vbe.Object, state, null, rewritingManager); Assert.IsFalse(moveCloserToUsageCommand.CanExecute(null)); } } @@ -633,13 +603,12 @@ Dim d As Boolean [Test] public void MoveCloserToUsage_CanExecute_Const_NoReferences() { - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule("Private Const const_abc = 0", out component, Selection.Home); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule("Private Const const_abc = 0", out _, Selection.Home); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { - var moveCloserToUsageCommand = new RefactorMoveCloserToUsageCommand(vbe.Object, state, null, rewritingManager); + var moveCloserToUsageCommand = new RefactorMoveCloserToUsageCommand(vbe.Object, state, null, rewritingManager); Assert.IsFalse(moveCloserToUsageCommand.CanExecute(null)); } } @@ -654,13 +623,12 @@ Sub Foo() d = True End Sub"; - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 5, 1, 5)); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out _, new Selection(1, 5, 1, 5)); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { - var moveCloserToUsageCommand = new RefactorMoveCloserToUsageCommand(vbe.Object, state, null, rewritingManager); + var moveCloserToUsageCommand = new RefactorMoveCloserToUsageCommand(vbe.Object, state, null, rewritingManager); Assert.IsTrue(moveCloserToUsageCommand.CanExecute(null)); } } @@ -675,13 +643,12 @@ Dim d As Boolean d = True End Property"; - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(2, 10, 2, 10)); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out _, new Selection(2, 10, 2, 10)); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { - var moveCloserToUsageCommand = new RefactorMoveCloserToUsageCommand(vbe.Object, state, null, rewritingManager); + var moveCloserToUsageCommand = new RefactorMoveCloserToUsageCommand(vbe.Object, state, null, rewritingManager); Assert.IsTrue(moveCloserToUsageCommand.CanExecute(null)); } } @@ -697,13 +664,12 @@ Dim d As Integer d = const_abc End Sub"; - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 17, 1, 17)); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out _, new Selection(1, 17, 1, 17)); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { - var moveCloserToUsageCommand = new RefactorMoveCloserToUsageCommand(vbe.Object, state, null, rewritingManager); + var moveCloserToUsageCommand = new RefactorMoveCloserToUsageCommand(vbe.Object, state, null, rewritingManager); Assert.IsTrue(moveCloserToUsageCommand.CanExecute(null)); } } @@ -712,14 +678,13 @@ Dim d As Integer [Test] public void RemoveParameters_CanExecute_NullActiveCodePane() { - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out component); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out _); vbe.Setup(v => v.ActiveCodePane).Returns((ICodePane)null); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { - var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, state, null); + var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, state, null, rewritingManager); Assert.IsFalse(removeParametersCommand.CanExecute(null)); } } @@ -728,15 +693,14 @@ public void RemoveParameters_CanExecute_NullActiveCodePane() [Test] public void RemoveParameters_CanExecute_NonReadyState() { - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out component); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out _); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { state.SetStatusAndFireStateChanged(this, ParserState.ResolvedDeclarations, CancellationToken.None); - var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, state, null); + var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, state, null, rewritingManager); Assert.IsFalse(removeParametersCommand.CanExecute(null)); } } @@ -748,13 +712,12 @@ public void RemoveParameters_CanExecute_Event_NoParams() const string input = @"Public Event Foo()"; - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out _, new Selection(1, 16, 1, 16)); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { - var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, state, null); + var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, state, null, rewritingManager); Assert.IsFalse(removeParametersCommand.CanExecute(null)); } } @@ -767,13 +730,12 @@ public void RemoveParameters_CanExecute_Proc_NoParams() @"Sub foo() End Sub"; - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 6, 1, 6)); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out _, new Selection(1, 6, 1, 6)); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { - var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, state, null); + var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, state, null, rewritingManager); Assert.IsFalse(removeParametersCommand.CanExecute(null)); } } @@ -786,13 +748,12 @@ public void RemoveParameters_CanExecute_Function_NoParams() @"Function foo() As Integer End Function"; - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 11, 1, 11)); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out _, new Selection(1, 11, 1, 11)); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { - var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, state, null); + var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, state, null, rewritingManager); Assert.IsFalse(removeParametersCommand.CanExecute(null)); } } @@ -805,13 +766,12 @@ public void RemoveParameters_CanExecute_PropertyGet_NoParams() @"Property Get foo() As Boolean End Property"; - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out _, new Selection(1, 16, 1, 16)); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { - var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, state, null); + var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, state, null, rewritingManager); Assert.IsFalse(removeParametersCommand.CanExecute(null)); } } @@ -824,13 +784,12 @@ public void RemoveParameters_CanExecute_PropertyLet_OneParam() @"Property Let foo(value) End Property"; - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out _, new Selection(1, 16, 1, 16)); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { - var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, state, null); + var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, state, null, rewritingManager); Assert.IsFalse(removeParametersCommand.CanExecute(null)); } } @@ -843,13 +802,12 @@ public void RemoveParameters_CanExecute_PropertySet_OneParam() @"Property Set foo(value) End Property"; - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out _, new Selection(1, 16, 1, 16)); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { - var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, state, null); + var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, state, null, rewritingManager); Assert.IsFalse(removeParametersCommand.CanExecute(null)); } } @@ -861,13 +819,12 @@ public void RemoveParameters_CanExecute_Event_OneParam() const string input = @"Public Event Foo(value)"; - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out _, new Selection(1, 16, 1, 16)); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { - var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, state, null); + var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, state, null, rewritingManager); Assert.IsTrue(removeParametersCommand.CanExecute(null)); } } @@ -880,13 +837,12 @@ public void RemoveParameters_CanExecute_Proc_OneParam() @"Sub foo(value) End Sub"; - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 6, 1, 6)); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out _, new Selection(1, 6, 1, 6)); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { - var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, state, null); + var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, state, null, rewritingManager); Assert.IsTrue(removeParametersCommand.CanExecute(null)); } } @@ -899,13 +855,12 @@ public void RemoveParameters_CanExecute_Function_OneParam() @"Function foo(value) As Integer End Function"; - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 11, 1, 11)); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out _, new Selection(1, 11, 1, 11)); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { - var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, state, null); + var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, state, null, rewritingManager); Assert.IsTrue(removeParametersCommand.CanExecute(null)); } } @@ -918,13 +873,12 @@ public void RemoveParameters_CanExecute_PropertyGet_OneParam() @"Property Get foo(value) As Boolean End Property"; - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out _, new Selection(1, 16, 1, 16)); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { - var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, state, null); + var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, state, null, rewritingManager); Assert.IsTrue(removeParametersCommand.CanExecute(null)); } } @@ -937,13 +891,12 @@ public void RemoveParameters_CanExecute_PropertyLet_TwoParams() @"Property Let foo(value1, value2) End Property"; - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out _, new Selection(1, 16, 1, 16)); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { - var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, state, null); + var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, state, null, rewritingManager); Assert.IsTrue(removeParametersCommand.CanExecute(null)); } } @@ -956,13 +909,12 @@ public void RemoveParameters_CanExecute_PropertySet_TwoParams() @"Property Set foo(value1, value2) End Property"; - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out _, new Selection(1, 16, 1, 16)); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { - var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, state, null); + var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, state, null, rewritingManager); Assert.IsTrue(removeParametersCommand.CanExecute(null)); } } @@ -971,8 +923,7 @@ public void RemoveParameters_CanExecute_PropertySet_TwoParams() [Test] public void ReorderParameters_CanExecute_NullActiveCodePane() { - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out component); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out _); vbe.Setup(v => v.ActiveCodePane).Returns((ICodePane)null); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) @@ -987,8 +938,7 @@ public void ReorderParameters_CanExecute_NullActiveCodePane() [Test] public void ReorderParameters_CanExecute_NonReadyState() { - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out component); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out _); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) @@ -1007,8 +957,7 @@ public void ReorderParameters_CanExecute_Event_OneParam() const string input = @"Public Event Foo(value)"; - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out _, new Selection(1, 16, 1, 16)); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { @@ -1026,8 +975,7 @@ public void ReorderParameters_CanExecute_Proc_OneParam() @"Sub foo(value) End Sub"; - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 6, 1, 6)); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out _, new Selection(1, 6, 1, 6)); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { @@ -1045,8 +993,7 @@ public void ReorderParameters_CanExecute_Function_OneParam() @"Function foo(value) As Integer End Function"; - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 11, 1, 11)); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out _, new Selection(1, 11, 1, 11)); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { @@ -1064,8 +1011,7 @@ public void ReorderParameters_CanExecute_PropertyGet_OneParam() @"Property Get foo(value) As Boolean End Property"; - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out _, new Selection(1, 16, 1, 16)); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { @@ -1083,8 +1029,7 @@ public void ReorderParameters_CanExecute_PropertyLet_TwoParams() @"Property Let foo(value1, value2) End Property"; - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out _, new Selection(1, 16, 1, 16)); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { @@ -1102,8 +1047,7 @@ public void ReorderParameters_CanExecute_PropertySet_TwoParams() @"Property Set foo(value1, value2) End Property"; - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out _, new Selection(1, 16, 1, 16)); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { @@ -1120,8 +1064,7 @@ public void ReorderParameters_CanExecute_Event_TwoParams() const string input = @"Public Event Foo(value1, value2)"; - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out _, new Selection(1, 16, 1, 16)); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { @@ -1139,8 +1082,7 @@ public void ReorderParameters_CanExecute_Proc_TwoParams() @"Sub foo(value1, value2) End Sub"; - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 6, 1, 6)); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out _, new Selection(1, 6, 1, 6)); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { @@ -1158,8 +1100,7 @@ public void ReorderParameters_CanExecute_Function_TwoParams() @"Function foo(value1, value2) As Integer End Function"; - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 11, 1, 11)); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out _, new Selection(1, 11, 1, 11)); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { @@ -1177,8 +1118,7 @@ public void ReorderParameters_CanExecute_PropertyGet_TwoParams() @"Property Get foo(value1, value2) As Boolean End Property"; - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out _, new Selection(1, 16, 1, 16)); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { @@ -1196,8 +1136,7 @@ public void ReorderParameters_CanExecute_PropertyLet_ThreeParams() @"Property Let foo(value1, value2, value3) End Property"; - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out _, new Selection(1, 16, 1, 16)); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { @@ -1215,8 +1154,7 @@ public void ReorderParameters_CanExecute_PropertySet_ThreeParams() @"Property Set foo(value1, value2, value3) End Property"; - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out _, new Selection(1, 16, 1, 16)); var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); using (state) { diff --git a/RubberduckTests/QuickFixes/RemoveUnusedParameterQuickFixTests.cs b/RubberduckTests/QuickFixes/RemoveUnusedParameterQuickFixTests.cs index 3440580bbd..d2d618d14d 100644 --- a/RubberduckTests/QuickFixes/RemoveUnusedParameterQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/RemoveUnusedParameterQuickFixTests.cs @@ -34,8 +34,8 @@ Private Sub Foo() var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); var rewriteSession = rewritingManager.CheckOutCodePaneSession(); - new RemoveUnusedParameterQuickFix(vbe.Object, state, new Mock().Object).Fix( - inspectionResults.First(), rewriteSession); + new RemoveUnusedParameterQuickFix(vbe.Object, state, new Mock().Object, rewritingManager) + .Fix(inspectionResults.First(), rewriteSession); Assert.AreEqual(expectedCode, component.CodeModule.Content()); } diff --git a/RubberduckTests/Refactoring/RemoveParametersTests.cs b/RubberduckTests/Refactoring/RemoveParametersTests.cs index 3c7780195b..4536d7b923 100644 --- a/RubberduckTests/Refactoring/RemoveParametersTests.cs +++ b/RubberduckTests/Refactoring/RemoveParametersTests.cs @@ -75,11 +75,11 @@ public void RemoveParametersRefactoring_SignatureParamRemoval(int numParams, str expect = expect.Equals(preamble) ? expect : expect.Remove(expect.Length - 2); expect = expect + ")"; - string inputCode = + var inputCode = $@"{input} End Sub"; - string expectedCode = + var expectedCode = $@"{expect} End Sub"; var actual = RemoveParams(inputCode, paramIndices: userParamRemovalChoices); @@ -100,8 +100,8 @@ public void RemoveParametersRefactoring_SignatureParamRemoval(int numParams, str [Category("Remove Parameters")] public void RemoveParametersRefactoring_SignatureAndReferenceParamRemoval(int numParams, string paramsToRemove) { - var preamble = "Private Sub Foo("; - var refPreamble = "Foo "; + const string preamble = "Private Sub Foo("; + const string refPreamble = "Foo "; var input = preamble; var refInput = refPreamble; for (var argNum = 1; argNum <= numParams; argNum++) @@ -135,7 +135,7 @@ public void RemoveParametersRefactoring_SignatureAndReferenceParamRemoval(int nu expect = expect + ")"; refExpect = refExpect.Equals(refPreamble) ? refExpect : refExpect.Remove(refExpect.Length - 1); - string inputCode = + var inputCode = $@"{input} End Sub @@ -147,7 +147,7 @@ Private Sub AnotherBar() {refInput} End Sub"; - string expectedCode = + var expectedCode = $@"{expect} End Sub @@ -184,7 +184,7 @@ Public Sub Goo() End Sub "; - var userParamRemovalChoices = new int[] { 1, 2, 3 }; + var userParamRemovalChoices = new[] { 1, 2, 3 }; var actual = RemoveParams(inputCode, paramIndices: userParamRemovalChoices); Assert.AreEqual(expectedCode, actual); @@ -212,7 +212,7 @@ Public Sub Goo() End Sub "; - var userParamRemovalChoices = new int[] { 1, 2 }; + var userParamRemovalChoices = new[] { 1, 2 }; var actual = RemoveParams(inputCode, paramIndices: userParamRemovalChoices); Assert.AreEqual(expectedCode, actual); @@ -240,7 +240,7 @@ Public Sub Goo() End Sub "; - var userParamRemovalChoices = new int[] { 2 }; + var userParamRemovalChoices = new[] { 2 }; var actual = RemoveParams(inputCode, paramIndices: userParamRemovalChoices); Assert.AreEqual(expectedCode, actual); @@ -267,7 +267,7 @@ Sub goo() foo asd, sdf End Sub"; - var userParamRemovalChoices = new int[] { 2 }; + var userParamRemovalChoices = new[] { 2 }; var actual = RemoveParams(inputCode, paramIndices: userParamRemovalChoices); Assert.AreEqual(expectedCode, actual); @@ -286,7 +286,7 @@ public void RemoveParametersRefactoring_RemoveLastFromFunction() @"Private Function Foo(ByVal arg1 As Integer) As Boolean End Function"; - var userParamRemovalChoices = new int[] { 1 }; + var userParamRemovalChoices = new[] { 1 }; var actual = RemoveParams(inputCode, paramIndices: userParamRemovalChoices); Assert.AreEqual(expectedCode, actual); @@ -315,7 +315,7 @@ public void RemoveParametersRefactoring_RemoveAllFromFunction() [Category("Remove Parameters")] public void RemoveParametersRefactoring_RemoveAllFromFunction_UpdateCallReferences(string input, string expected) { - string inputCode = + var inputCode = $@"Private Function Foo(ByVal ar|g1 As Integer, ByVal arg2 As String) As Boolean End Function @@ -325,7 +325,7 @@ Dim test As Boolean End Sub "; - string expectedCode = + var expectedCode = $@"Private Function Foo() As Boolean End Function @@ -362,7 +362,7 @@ Foo arg1 End Sub "; - var userParamRemovalChoices = new int[] { 1,2 }; + var userParamRemovalChoices = new[] { 1,2 }; var actual = RemoveParams(inputCode, paramIndices: userParamRemovalChoices); Assert.AreEqual(expectedCode, actual); @@ -389,7 +389,7 @@ Private Sub goo() foo 1, 2, 5, 7 End Sub"; - var userParamRemovalChoices = new int[] {2,3,5}; + var userParamRemovalChoices = new[] {2,3,5}; var actual = RemoveParams(inputCode, paramIndices: userParamRemovalChoices); Assert.AreEqual(expectedCode, actual); @@ -433,7 +433,7 @@ Private Property Get Foo(ByVal arg1 As Integer, arg2 As Integer, arg3 As Integer Private Property Get Foo(ByVal arg1 As Integer, arg3 As Integer) As Integer End Property"; - var userParamRemovalChoices = new int[] { 1 }; + var userParamRemovalChoices = new[] { 1 }; var actual = RemoveParams(inputCode, paramIndices: userParamRemovalChoices); Assert.AreEqual(expectedCode, actual); @@ -452,8 +452,9 @@ Private Property Set Foo(ByVal arg1 As Integer, ByVal arg2 As String) Private Property Set Foo(ByVal arg2 As String) End Property"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out IVBComponent component); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var parameter = state.AllUserDeclarations.SingleOrDefault(p => @@ -468,7 +469,7 @@ Private Property Set Foo(ByVal arg2 As String) //SetupFactory var factory = SetupFactory(model); - var refactoring = new RemoveParametersRefactoring(vbe.Object, factory.Object); + var refactoring = new RemoveParametersRefactoring(vbe.Object, factory.Object, rewritingManager); refactoring.QuickFix(state, qualifiedSelection); Assert.AreEqual(expectedCode, component.CodeModule.Content()); @@ -488,7 +489,7 @@ public void RemoveParametersRefactoring_RemoveFirstParamFromSetter() @"Private Property Set Foo(ByVal arg2 As String) End Property"; - var userParamRemovalChoices = new int[] { 0 }; + var userParamRemovalChoices = new[] { 0 }; var actual = RemoveParams(inputCode, paramIndices: userParamRemovalChoices); Assert.AreEqual(expectedCode, actual); @@ -517,7 +518,7 @@ Private Sub Bar() End Sub "; - var userParamRemovalChoices = new int[] { 0 }; + var userParamRemovalChoices = new[] { 0 }; var actual = RemoveParams(inputCode, paramIndices: userParamRemovalChoices); Assert.AreEqual(expectedCode, actual); @@ -550,7 +551,7 @@ Dim x As Variant End Sub "; - var userParamRemovalChoices = new int[] { 0 }; + var userParamRemovalChoices = new[] { 0 }; var actual = RemoveParams(inputCode, paramIndices: userParamRemovalChoices); Assert.AreEqual(expectedCode, actual); @@ -586,7 +587,7 @@ Private Function foo(ByVal b As Integer) As Integer foo = a + b End Function"; - var userParamRemovalChoices = new int[] { 0 }; + var userParamRemovalChoices = new[] { 0 }; var actual = RemoveParams(inputCode, paramIndices: userParamRemovalChoices); Assert.AreEqual(expectedCode, actual); @@ -615,7 +616,7 @@ Foo 10 End Sub "; - var userParamRemovalChoices = new int[] { 1 }; + var userParamRemovalChoices = new[] { 1 }; var actual = RemoveParams(inputCode, paramIndices: userParamRemovalChoices); Assert.AreEqual(expectedCode, actual); @@ -654,7 +655,8 @@ End Sub var declaringComponent = projectBuilder.MockComponents[0].Object; var callingComponent = projectBuilder.MockComponents[1].Object; - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(declaringComponent), selection); @@ -666,7 +668,7 @@ End Sub //SetupFactory var factory = SetupFactory(model); - var refactoring = new RemoveParametersRefactoring(vbe.Object, factory.Object); + var refactoring = new RemoveParametersRefactoring(vbe.Object, factory.Object, rewritingManager); refactoring.Refactor(qualifiedSelection); var resultCallingCode = callingComponent.CodeModule.Content(); @@ -709,7 +711,7 @@ Public Sub Goo(ByVal arg1 As Integer, _ End Sub "; - var userParamRemovalChoices = new int[] { 1 }; + var userParamRemovalChoices = new[] { 1 }; var actual = RemoveParams(inputCode, paramIndices: userParamRemovalChoices); Assert.AreEqual(expectedCode, actual); @@ -750,7 +752,7 @@ Public Sub Goo(ByVal arg1 As Integer, _ End Sub "; - var userParamRemovalChoices = new int[] { 1,2 }; + var userParamRemovalChoices = new[] { 1,2 }; var actual = RemoveParams(inputCode, paramIndices: userParamRemovalChoices); Assert.AreEqual(expectedCode, actual); @@ -767,7 +769,7 @@ public void RemoveParametersRefactoring_RemoveLastParamFromSetter_NotAllowed() End Property"; var selection = new Selection(1, 23, 1, 27); - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out IVBComponent component, selection); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component, selection); using (var state = MockParser.CreateAndParse(vbe.Object)) { @@ -790,7 +792,7 @@ public void RemoveParametersRefactoring_RemoveLastParamFromLetter_NotAllowed() End Property"; var selection = new Selection(1, 23, 1, 27); - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out IVBComponent component, selection); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component, selection); using (var state = MockParser.CreateAndParse(vbe.Object)) { @@ -821,7 +823,7 @@ End Property Private Property Set Foo(ByVal arg2 As String) End Property"; - var userParamRemovalChoices = new int[] { 0 }; + var userParamRemovalChoices = new[] { 0 }; var actual = RemoveParams(inputCode, paramIndices: userParamRemovalChoices); Assert.AreEqual(expectedCode, actual); @@ -846,7 +848,7 @@ End Property Private Property Let Foo(ByVal arg2 As String) End Property"; - var userParamRemovalChoices = new int[] { 0 }; + var userParamRemovalChoices = new[] { 0 }; var actual = RemoveParams(inputCode, paramIndices: userParamRemovalChoices); Assert.AreEqual(expectedCode, actual); @@ -873,7 +875,7 @@ Private Sub Goo(ByVal arg1 As Integer) Foo End Sub"; - var userParamRemovalChoices = new int[] { 0 }; + var userParamRemovalChoices = new[] { 0 }; var actual = RemoveParams(inputCode, paramIndices: userParamRemovalChoices); Assert.AreEqual(expectedCode, actual); @@ -902,7 +904,7 @@ Foo arg1 Foo 1 End Sub"; - var userParamRemovalChoices = new int[] { 1 }; + var userParamRemovalChoices = new[] { 1 }; var actual = RemoveParams(inputCode, paramIndices: userParamRemovalChoices); Assert.AreEqual(expectedCode, actual); @@ -933,7 +935,7 @@ Private Sub Goo(ByVal arg1 As Integer) Foo ""test"" End Sub"; - var userParamRemovalChoices = new int[] { 0 }; + var userParamRemovalChoices = new[] { 0 }; var actual = RemoveParams(inputCode, paramIndices: userParamRemovalChoices); Assert.AreEqual(expectedCode, actual); @@ -972,7 +974,7 @@ Foo 1 Foo ,3 End Sub"; - var userParamRemovalChoices = new int[] { 1 }; + var userParamRemovalChoices = new[] { 1 }; var actual = RemoveParams(inputCode, paramIndices: userParamRemovalChoices); Assert.AreEqual(expectedCode, actual); @@ -994,7 +996,7 @@ public void RemoveParametersRefactoring_SignatureOnMultipleLines() ByVal arg3 As Date) End Sub"; // note: VBE removes excess spaces - var userParamRemovalChoices = new int[] { 0 }; + var userParamRemovalChoices = new[] { 0 }; var actual = RemoveParams(inputCode, paramIndices: userParamRemovalChoices); Assert.AreEqual(expectedCode, actual); @@ -1016,7 +1018,7 @@ public void RemoveParametersRefactoring_SignatureOnMultipleLines_RemoveSecond() ByVal arg3 As Date) End Sub"; // note: VBE removes excess spaces - var userParamRemovalChoices = new int[] { 1 }; + var userParamRemovalChoices = new[] { 1 }; var actual = RemoveParams(inputCode, paramIndices: userParamRemovalChoices); Assert.AreEqual(expectedCode, actual); @@ -1039,7 +1041,7 @@ public void RemoveParametersRefactoring_SignatureOnMultipleLines_RemoveLast() ByVal arg2 As String) End Sub"; // note: VBE removes excess spaces - var userParamRemovalChoices = new int[] { 2 }; + var userParamRemovalChoices = new[] { 2 }; var actual = RemoveParams(inputCode, paramIndices: userParamRemovalChoices); Assert.AreEqual(expectedCode, actual); @@ -1061,7 +1063,7 @@ public void RemoveParametersRefactoring_PassTargetIn() ByVal arg3 As Date) End Sub"; // note: VBE removes excess spaces - var userParamRemovalChoices = new int[] { 0 }; + var userParamRemovalChoices = new[] { 0 }; var actual = RemoveParams(inputCode, paramIndices: userParamRemovalChoices); Assert.AreEqual(expectedCode, actual); @@ -1097,7 +1099,7 @@ Private Sub Goo(ByVal arg1 as Integer, ByVal arg2 As String, ByVal arg3 As Date) End Sub "; // note: IDE removes excess spaces - var userParamRemovalChoices = new int[] { 0 }; + var userParamRemovalChoices = new[] { 0 }; var actual = RemoveParams(inputCode, paramIndices: userParamRemovalChoices); Assert.AreEqual(expectedCode, actual); @@ -1137,7 +1139,8 @@ Private Sub IClass1_DoSomething(ByVal a As Integer) .Build(); var vbe = builder.AddProject(project).Build(); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(project.Object.VBComponents[0]), selection); @@ -1151,7 +1154,7 @@ Private Sub IClass1_DoSomething(ByVal a As Integer) //SetupFactory var factory = SetupFactory(model); - var refactoring = new RemoveParametersRefactoring(vbe.Object, factory.Object); + var refactoring = new RemoveParametersRefactoring(vbe.Object, factory.Object, rewritingManager); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode1, module1.Content()); @@ -1193,7 +1196,8 @@ Private Sub IClass1_DoSomething(ByVal v1 As Integer) .Build(); var vbe = builder.AddProject(project).Build(); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(project.Object.VBComponents[0]), selection); @@ -1207,7 +1211,7 @@ Private Sub IClass1_DoSomething(ByVal v1 As Integer) //SetupFactory var factory = SetupFactory(model); - var refactoring = new RemoveParametersRefactoring(vbe.Object, factory.Object); + var refactoring = new RemoveParametersRefactoring(vbe.Object, factory.Object, rewritingManager); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode1, module1.Content()); @@ -1260,7 +1264,8 @@ Private Sub IClass1_DoSomething(ByVal i As Integer) .Build(); var vbe = builder.AddProject(project).Build(); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(project.Object.VBComponents[0]), selection); @@ -1275,7 +1280,7 @@ Private Sub IClass1_DoSomething(ByVal i As Integer) //SetupFactory var factory = SetupFactory(model); - var refactoring = new RemoveParametersRefactoring(vbe.Object, factory.Object); + var refactoring = new RemoveParametersRefactoring(vbe.Object, factory.Object, rewritingManager); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode1, module1.Content()); @@ -1318,7 +1323,8 @@ Private Sub abc_Foo(ByVal arg1 As Integer) .Build(); var vbe = builder.AddProject(project).Build(); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(project.Object.VBComponents[0]), selection); @@ -1332,7 +1338,7 @@ Private Sub abc_Foo(ByVal arg1 As Integer) //SetupFactory var factory = SetupFactory(model); - var refactoring = new RemoveParametersRefactoring(vbe.Object, factory.Object); + var refactoring = new RemoveParametersRefactoring(vbe.Object, factory.Object, rewritingManager); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode1, module1.Content()); @@ -1374,7 +1380,8 @@ Private Sub abc_Foo(ByVal arg1 As Integer) .Build(); var vbe = builder.AddProject(project).Build(); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(project.Object.VBComponents[0]), selection); @@ -1388,7 +1395,7 @@ Private Sub abc_Foo(ByVal arg1 As Integer) //SetupFactory var factory = SetupFactory(model); - var refactoring = new RemoveParametersRefactoring(vbe.Object, factory.Object); + var refactoring = new RemoveParametersRefactoring(vbe.Object, factory.Object, rewritingManager); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode1, module1.Content()); @@ -1430,7 +1437,8 @@ Private Sub abc_Foo(ByVal i As Integer) .Build(); var vbe = builder.AddProject(project).Build(); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(project.Object.VBComponents[0]), selection); @@ -1444,7 +1452,7 @@ Private Sub abc_Foo(ByVal i As Integer) //SetupFactory var factory = SetupFactory(model); - var refactoring = new RemoveParametersRefactoring(vbe.Object, factory.Object); + var refactoring = new RemoveParametersRefactoring(vbe.Object, factory.Object, rewritingManager); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode1, module1.Content()); @@ -1497,7 +1505,8 @@ Private Sub abc_Foo(ByVal v1 As Integer) .Build(); var vbe = builder.AddProject(project).Build(); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(project.Object.VBComponents[0]), selection); @@ -1512,7 +1521,7 @@ Private Sub abc_Foo(ByVal v1 As Integer) //SetupFactory var factory = SetupFactory(model); - var refactoring = new RemoveParametersRefactoring(vbe.Object, factory.Object); + var refactoring = new RemoveParametersRefactoring(vbe.Object, factory.Object, rewritingManager); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode1, module1.Content()); @@ -1556,7 +1565,8 @@ Private Sub IClass1_DoSomething(ByVal a As Integer) .Build(); var vbe = builder.AddProject(project).Build(); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(project.Object.VBComponents[0]), selection); @@ -1573,7 +1583,7 @@ Private Sub IClass1_DoSomething(ByVal a As Integer) //SetupFactory var factory = SetupFactory(model); - var refactoring = new RemoveParametersRefactoring(vbe.Object, factory.Object); + var refactoring = new RemoveParametersRefactoring(vbe.Object, factory.Object, rewritingManager); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(expectedCode1, module1.Content()); @@ -1629,9 +1639,10 @@ public void RemoveParams_RefactorDeclaration_FailsInvalidTarget() End Sub"; var selection = new Selection(1, 23, 1, 27); - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out IVBComponent component, selection); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -1640,7 +1651,7 @@ public void RemoveParams_RefactorDeclaration_FailsInvalidTarget() var factory = SetupFactory(model); - var refactoring = new RemoveParametersRefactoring(vbe.Object, factory.Object); + var refactoring = new RemoveParametersRefactoring(vbe.Object, factory.Object, rewritingManager); try { @@ -1668,13 +1679,14 @@ public void RemoveParams_PresenterIsNull() @"Private Sub Foo() End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out IVBComponent component); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var factory = new RemoveParametersPresenterFactory(vbe.Object, null, state, null); - var refactoring = new RemoveParametersRefactoring(vbe.Object, factory); + var refactoring = new RemoveParametersRefactoring(vbe.Object, factory, rewritingManager); refactoring.Refactor(); Assert.AreEqual(inputCode, component.CodeModule.Content()); @@ -1692,9 +1704,10 @@ public void RemoveParams_ModelIsNull() End Sub"; var selection = new Selection(1, 23, 1, 27); - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out IVBComponent component, selection); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -1704,7 +1717,7 @@ public void RemoveParams_ModelIsNull() //SetupFactory var factory = SetupFactory(model); - var refactoring = new RemoveParametersRefactoring(vbe.Object, factory.Object); + var refactoring = new RemoveParametersRefactoring(vbe.Object, factory.Object, rewritingManager); refactoring.Refactor(qualifiedSelection); Assert.AreEqual(inputCode, component.CodeModule.Content()); @@ -1722,9 +1735,9 @@ public void Presenter_Accept_AutoMarksSingleParamAsRemoved() End Sub"; var selection = new Selection(1, 15, 1, 15); - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out IVBComponent component, selection); + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component, selection); - using (var state = MockParser.CreateAndParse(vbe.Object)) + using(var state = MockParser.CreateAndParse(vbe.Object)) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); @@ -1793,23 +1806,20 @@ public void Factory_NullSelectionNullReturnsNullPresenter() } } - private string RemoveParams(string inputCode, bool passInTarget = false, Selection? selection = null, IEnumerable paramIndices = null) + private static string RemoveParams(string inputCode, bool passInTarget = false, Selection? selection = null, IEnumerable paramIndices = null) { var codeString = inputCode.ToCodeString(); if (!selection.HasValue) { - Selection? derivedSelect = codeString.CaretPosition.ToOneBased(); + var derivedSelect = codeString.CaretPosition.ToOneBased(); - if (!derivedSelect.HasValue) - { - Assert.Fail($"Unable to derive user selection for test"); - } selection = derivedSelect; } - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(codeString.Code, out IVBComponent component, selection.Value); - var result = string.Empty; - using (var state = MockParser.CreateAndParse(vbe.Object)) + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(codeString.Code, out var component, selection.Value); + string result; + var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object); + using(state) { var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection.Value); @@ -1832,7 +1842,7 @@ private string RemoveParams(string inputCode, bool passInTarget = false, Selecti //SetupFactory var factory = SetupFactory(model); - var refactoring = new RemoveParametersRefactoring(vbe.Object, factory.Object); + var refactoring = new RemoveParametersRefactoring(vbe.Object, factory.Object, rewritingManager); if (passInTarget) { refactoring.Refactor(model.TargetDeclaration); From f22b5cc25790e910e296cde98c72bc0fded8d27a Mon Sep 17 00:00:00 2001 From: Max Doerner Date: Sat, 3 Nov 2018 14:58:43 +0100 Subject: [PATCH 23/59] Remove the rewriters from the ModuleStates and RubberduckParserState All interaction with rewriters is to go through an IRewriteSession in the future, which is acquired from an IRewritingManager. --- Rubberduck.API/VBA/Parser.cs | 15 ++------ Rubberduck.Parsing/VBA/ModuleState.cs | 15 -------- .../VBA/RubberduckParserState.cs | 37 +------------------ .../CodeExplorer/CodeExplorerTests.cs | 10 +---- RubberduckTests/Mocks/MockParser.cs | 12 +----- .../ArgumentRewriterInfoFinderTests.cs | 32 +++++++++------- .../ConstantRewriterInfoFinderTests.cs | 16 ++++---- .../ParameterRewriterInfoFinderTests.cs | 16 ++++---- .../VariableRewriterInfoFinderTests.cs | 16 ++++---- 9 files changed, 54 insertions(+), 115 deletions(-) diff --git a/Rubberduck.API/VBA/Parser.cs b/Rubberduck.API/VBA/Parser.cs index 9c6f52ec1e..7b24f41100 100644 --- a/Rubberduck.API/VBA/Parser.cs +++ b/Rubberduck.API/VBA/Parser.cs @@ -94,17 +94,8 @@ internal Parser(object vbe) : this() _vbeEvents = VBEEvents.Initialize(_vbe); var declarationFinderFactory = new ConcurrentlyConstructedDeclarationFinderFactory(); var projectRepository = new ProjectsRepository(_vbe); - - var codePaneSourceCodeHandler = new CodePaneSourceCodeHandler(projectRepository); - var sourceFileHandler = _vbe.TempSourceFileHandler; - var attributesSourceCodeHandler = new SourceFileHandlerSourceCodeHandlerAdapter(sourceFileHandler, projectRepository); - var moduleRewriterFactory = new ModuleRewriterFactory( - codePaneSourceCodeHandler, - attributesSourceCodeHandler); - - _state = new RubberduckParserState(_vbe, projectRepository, declarationFinderFactory, _vbeEvents, moduleRewriterFactory); + _state = new RubberduckParserState(_vbe, projectRepository, declarationFinderFactory, _vbeEvents); _state.StateChanged += _state_StateChanged; - var vbeVersion = double.Parse(_vbe.Version, CultureInfo.InvariantCulture); var predefinedCompilationConstants = new VBAPredefinedCompilationConstants(vbeVersion); var typeLibProvider = new TypeLibWrapperProvider(projectRepository); @@ -136,7 +127,9 @@ internal Parser(object vbe) : this() //new RubberduckApiDeclarations(_state) } ); - + var codePaneSourceCodeHandler = new CodePaneSourceCodeHandler(projectRepository); + var sourceFileHandler = _vbe.TempSourceFileHandler; + var attributesSourceCodeHandler = new SourceFileHandlerSourceCodeHandlerAdapter(sourceFileHandler, projectRepository); var moduleParser = new ModuleParser( codePaneSourceCodeHandler, attributesSourceCodeHandler, diff --git a/Rubberduck.Parsing/VBA/ModuleState.cs b/Rubberduck.Parsing/VBA/ModuleState.cs index 3762f665bf..27eedbcfe1 100644 --- a/Rubberduck.Parsing/VBA/ModuleState.cs +++ b/Rubberduck.Parsing/VBA/ModuleState.cs @@ -4,7 +4,6 @@ using Antlr4.Runtime; using Antlr4.Runtime.Tree; using Rubberduck.Parsing.Annotations; -using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.Symbols; using Rubberduck.Parsing.VBA.Parsing; using Rubberduck.Parsing.VBA.Parsing.ParsingExceptions; @@ -17,8 +16,6 @@ public class ModuleState public ConcurrentDictionary UnresolvedMemberDeclarations { get; private set; } public ITokenStream CodePaneTokenStream { get; private set; } public ITokenStream AttributesTokenStream { get; private set; } - public IExecutableModuleRewriter CodePaneRewriter { get; private set; } - public IExecutableModuleRewriter AttributesRewriter { get; private set; } public IParseTree ParseTree { get; private set; } public IParseTree AttributesPassParseTree { get; private set; } public ParserState State { get; private set; } @@ -86,12 +83,6 @@ public ModuleState SetCodePaneTokenStream(ITokenStream codePaneTokenStream) return this; } - public ModuleState SetCodePaneRewriter(IExecutableModuleRewriter codePaneRewriter) - { - CodePaneRewriter = codePaneRewriter; - return this; - } - public ModuleState SetParseTree(IParseTree parseTree, CodeKind codeKind) { switch (codeKind) @@ -157,12 +148,6 @@ public ModuleState SetAttributesTokenStream(ITokenStream attributesTokenStream) return this; } - public ModuleState SetAttributesRewriter(IExecutableModuleRewriter attributesRewriter) - { - AttributesRewriter = attributesRewriter; - return this; - } - private bool _isDisposed; public void Dispose() diff --git a/Rubberduck.Parsing/VBA/RubberduckParserState.cs b/Rubberduck.Parsing/VBA/RubberduckParserState.cs index 7457b85d12..3426bb5ad4 100644 --- a/Rubberduck.Parsing/VBA/RubberduckParserState.cs +++ b/Rubberduck.Parsing/VBA/RubberduckParserState.cs @@ -144,12 +144,10 @@ public sealed class RubberduckParserState : IDisposable, IDeclarationFinderProvi private readonly IVBEEvents _vbeEvents; private readonly IHostApplication _hostApp; private readonly IDeclarationFinderFactory _declarationFinderFactory; - //TODO: Remove this again in a later PR when all rewriters get acquired via IRewriteSessions. - private readonly IModuleRewriterFactory _moduleRewriterFactory; /// Provides event handling from the VBE. Static method must be already called prior to constructing the method. [SuppressMessage("ReSharper", "JoinNullCheckWithUsage")] - public RubberduckParserState(IVBE vbe, IProjectsRepository projectRepository, IDeclarationFinderFactory declarationFinderFactory, IVBEEvents vbeEvents, IModuleRewriterFactory moduleRewriterFactory) + public RubberduckParserState(IVBE vbe, IProjectsRepository projectRepository, IDeclarationFinderFactory declarationFinderFactory, IVBEEvents vbeEvents) { if (vbe == null) { @@ -171,15 +169,9 @@ public RubberduckParserState(IVBE vbe, IProjectsRepository projectRepository, ID throw new ArgumentNullException(nameof(vbeEvents)); } - if (moduleRewriterFactory == null) - { - throw new ArgumentNullException(nameof(moduleRewriterFactory)); - } - _vbe = vbe; _projectRepository = projectRepository; _declarationFinderFactory = declarationFinderFactory; - _moduleRewriterFactory = moduleRewriterFactory; _vbeEvents = vbeEvents; var values = Enum.GetValues(typeof(ParserState)); @@ -854,9 +846,6 @@ private bool RemoveKeysFromCollections(IEnumerable keys) public void SetCodePaneTokenStream(QualifiedModuleName module, ITokenStream codePaneTokenStream) { _moduleStates[module].SetCodePaneTokenStream(codePaneTokenStream); - - var rewriter = _moduleRewriterFactory.CodePaneRewriter(module, codePaneTokenStream); - _moduleStates[module].SetCodePaneRewriter(rewriter); } public void SaveContentHash(QualifiedModuleName module) @@ -939,27 +928,6 @@ public bool IsDirty() return false; } - public IExecutableModuleRewriter GetRewriter(IVBComponent component) - { - return GetRewriter(component.QualifiedModuleName); - } - - public IExecutableModuleRewriter GetRewriter(QualifiedModuleName qualifiedModuleName) - { - return _moduleStates[qualifiedModuleName].CodePaneRewriter; - } - - public IExecutableModuleRewriter GetRewriter(Declaration declaration) - { - var qualifiedModuleName = declaration.QualifiedSelection.QualifiedName; - return GetRewriter(qualifiedModuleName); - } - - public IExecutableModuleRewriter GetAttributeRewriter(QualifiedModuleName qualifiedModuleName) - { - return _moduleStates[qualifiedModuleName].AttributesRewriter; - } - public ITokenStream GetCodePaneTokenStream(QualifiedModuleName qualifiedModuleName) { return _moduleStates[qualifiedModuleName].CodePaneTokenStream; @@ -1080,9 +1048,6 @@ private void ClearAsTypeDeclarationPointingToReference(QualifiedModuleName refer public void SetAttributesTokenStream(QualifiedModuleName module, ITokenStream attributesTokenStream) { _moduleStates[module].SetAttributesTokenStream(attributesTokenStream); - - var rewriter = _moduleRewriterFactory.AttributesRewriter(module, attributesTokenStream); - _moduleStates[module].SetAttributesRewriter(rewriter); } //todo: Remove this again in favor of injection of the IRewritingManager into the callers. diff --git a/RubberduckTests/CodeExplorer/CodeExplorerTests.cs b/RubberduckTests/CodeExplorer/CodeExplorerTests.cs index 16b82c6378..b26917025b 100644 --- a/RubberduckTests/CodeExplorer/CodeExplorerTests.cs +++ b/RubberduckTests/CodeExplorer/CodeExplorerTests.cs @@ -2877,15 +2877,7 @@ public void CompareByNodeType_FoldersAreSortedByName() private RubberduckParserState TestParserState(Mock vbe, IProjectsRepository projectsRepository) { var vbeEvents = MockVbeEvents.CreateMockVbeEvents(vbe); - - var codePaneSourceCodeHandler = new CodePaneSourceCodeHandler(projectsRepository); - //We use the same handler because to achieve consistency between the return values. - var attributesSourceCodeHandler = codePaneSourceCodeHandler; - var moduleRewriterFactory = new ModuleRewriterFactory( - codePaneSourceCodeHandler, - attributesSourceCodeHandler); - - return new RubberduckParserState(vbe.Object, projectsRepository, new DeclarationFinderFactory(), vbeEvents.Object, moduleRewriterFactory); + return new RubberduckParserState(vbe.Object, projectsRepository, new DeclarationFinderFactory(), vbeEvents.Object); } private Configuration GetDefaultUnitTestConfig() diff --git a/RubberduckTests/Mocks/MockParser.cs b/RubberduckTests/Mocks/MockParser.cs index 5080ca337d..cd9c494867 100644 --- a/RubberduckTests/Mocks/MockParser.cs +++ b/RubberduckTests/Mocks/MockParser.cs @@ -45,18 +45,10 @@ public static RubberduckParserState ParseString(string inputCode, out QualifiedM public static (SynchronousParseCoordinator parser, IRewritingManager rewritingManager) CreateWithRewriteManager(IVBE vbe, string serializedComProjectsPath = null) { - var vbeEvents = MockVbeEvents.CreateMockVbeEvents(new Moq.Mock()); + var vbeEvents = MockVbeEvents.CreateMockVbeEvents(new Mock()); var declarationFinderFactory = new DeclarationFinderFactory(); var projectRepository = new ProjectsRepository(vbe); - - var codePaneSourceCodeHandler = new CodePaneSourceCodeHandler(projectRepository); - //We use the same handler because to achieve consistency between the return values. - var attributesSourceCodeHandler = codePaneSourceCodeHandler; - var moduleRewriterFactory = new ModuleRewriterFactory( - codePaneSourceCodeHandler, - attributesSourceCodeHandler); - - var state = new RubberduckParserState(vbe, projectRepository, declarationFinderFactory, vbeEvents.Object, moduleRewriterFactory); + var state = new RubberduckParserState(vbe, projectRepository, declarationFinderFactory, vbeEvents.Object); return CreateWithRewriteManager(vbe, state, projectRepository, serializedComProjectsPath); } diff --git a/RubberduckTests/Rewriter/ArgumentRewriterInfoFinderTests.cs b/RubberduckTests/Rewriter/ArgumentRewriterInfoFinderTests.cs index 26931df3ae..627685d8c3 100644 --- a/RubberduckTests/Rewriter/ArgumentRewriterInfoFinderTests.cs +++ b/RubberduckTests/Rewriter/ArgumentRewriterInfoFinderTests.cs @@ -108,19 +108,25 @@ Public Sub Baz() private void TestEnclosedCode(string inputCode, string enclosingModuleBodyElementName, int argumentPosition, string expectedEnclosedCode) { var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - var state = MockParser.CreateAndParse(vbe.Object); - - var enclosingModuleBodyElementDeclarationContext = state.DeclarationFinder.MatchName(enclosingModuleBodyElementName).First().Context; - var enclosingModuleBodyElementContext = enclosingModuleBodyElementDeclarationContext.GetAncestor(); - var enclosingModuleBodyElementBodyContext = enclosingModuleBodyElementContext.GetDescendent(); - var argumentListContext = enclosingModuleBodyElementBodyContext.GetDescendent(); - var argumentContext = argumentListContext.argument(argumentPosition-1); - - var infoFinder = new ArgumentRewriterInfoFinder(); - var info = infoFinder.GetRewriterInfo(argumentContext); - - var actualEnclosedCode = state.GetRewriter(component).TokenStream.GetText(info.StartTokenIndex, info.StopTokenIndex); - Assert.AreEqual(expectedEnclosedCode, actualEnclosedCode); + using (var state = MockParser.CreateAndParse(vbe.Object)) + { + var enclosingModuleBodyElementDeclarationContext = state.DeclarationFinder + .MatchName(enclosingModuleBodyElementName).First().Context; + var enclosingModuleBodyElementContext = enclosingModuleBodyElementDeclarationContext + .GetAncestor(); + var enclosingModuleBodyElementBodyContext = + enclosingModuleBodyElementContext.GetDescendent(); + var argumentListContext = + enclosingModuleBodyElementBodyContext.GetDescendent(); + var argumentContext = argumentListContext.argument(argumentPosition - 1); + + var infoFinder = new ArgumentRewriterInfoFinder(); + var info = infoFinder.GetRewriterInfo(argumentContext); + + var actualEnclosedCode = state.GetCodePaneTokenStream(component.QualifiedModuleName) + .GetText(info.StartTokenIndex, info.StopTokenIndex); + Assert.AreEqual(expectedEnclosedCode, actualEnclosedCode); + } } } } \ No newline at end of file diff --git a/RubberduckTests/Rewriter/ConstantRewriterInfoFinderTests.cs b/RubberduckTests/Rewriter/ConstantRewriterInfoFinderTests.cs index 0ce7e6e095..b2a7dcd4da 100644 --- a/RubberduckTests/Rewriter/ConstantRewriterInfoFinderTests.cs +++ b/RubberduckTests/Rewriter/ConstantRewriterInfoFinderTests.cs @@ -409,15 +409,17 @@ Private Sub Whatever(brr As Integer) private void TestEnclosedCode(string inputCode, string constantName, string expectedEnclosedCode) { var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - var state = MockParser.CreateAndParse(vbe.Object); + using (var state = MockParser.CreateAndParse(vbe.Object)) + { + var constantSubStmtContext = state.DeclarationFinder.MatchName(constantName).First().Context; - var constantSubStmtContext = state.DeclarationFinder.MatchName(constantName).First().Context; + var infoFinder = new ConstantRewriterInfoFinder(); + var info = infoFinder.GetRewriterInfo(constantSubStmtContext); - var infoFinder = new ConstantRewriterInfoFinder(); - var info = infoFinder.GetRewriterInfo(constantSubStmtContext); - - var actualEnclosedCode = state.GetRewriter(component).TokenStream.GetText(info.StartTokenIndex, info.StopTokenIndex); - Assert.AreEqual(expectedEnclosedCode, actualEnclosedCode); + var actualEnclosedCode = state.GetCodePaneTokenStream(component.QualifiedModuleName) + .GetText(info.StartTokenIndex, info.StopTokenIndex); + Assert.AreEqual(expectedEnclosedCode, actualEnclosedCode); + } } } } diff --git a/RubberduckTests/Rewriter/ParameterRewriterInfoFinderTests.cs b/RubberduckTests/Rewriter/ParameterRewriterInfoFinderTests.cs index acb6ca3a12..7f1e2339cc 100644 --- a/RubberduckTests/Rewriter/ParameterRewriterInfoFinderTests.cs +++ b/RubberduckTests/Rewriter/ParameterRewriterInfoFinderTests.cs @@ -82,15 +82,17 @@ public void TestParameterRewriterInfoFinder_Last() private void TestEnclosedCode(string inputCode, string parameterName, string expectedEnclosedCode) { var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - var state = MockParser.CreateAndParse(vbe.Object); + using (var state = MockParser.CreateAndParse(vbe.Object)) + { + var argContext = state.DeclarationFinder.MatchName(parameterName).First().Context; - var argContext = state.DeclarationFinder.MatchName(parameterName).First().Context; + var infoFinder = new ParameterRewriterInfoFinder(); + var info = infoFinder.GetRewriterInfo(argContext); - var infoFinder = new ParameterRewriterInfoFinder(); - var info = infoFinder.GetRewriterInfo(argContext); - - var actualEnclosedCode = state.GetRewriter(component).TokenStream.GetText(info.StartTokenIndex, info.StopTokenIndex); - Assert.AreEqual(expectedEnclosedCode, actualEnclosedCode); + var actualEnclosedCode = state.GetCodePaneTokenStream(component.QualifiedModuleName) + .GetText(info.StartTokenIndex, info.StopTokenIndex); + Assert.AreEqual(expectedEnclosedCode, actualEnclosedCode); + } } } } diff --git a/RubberduckTests/Rewriter/VariableRewriterInfoFinderTests.cs b/RubberduckTests/Rewriter/VariableRewriterInfoFinderTests.cs index 5cc12196b0..e88b797a07 100644 --- a/RubberduckTests/Rewriter/VariableRewriterInfoFinderTests.cs +++ b/RubberduckTests/Rewriter/VariableRewriterInfoFinderTests.cs @@ -409,15 +409,17 @@ Private Sub Whatever(brr As Integer) private void TestEnclosedCode(string inputCode, string variableName, string expectedEnclosedCode) { var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); - var state = MockParser.CreateAndParse(vbe.Object); + using (var state = MockParser.CreateAndParse(vbe.Object)) + { + var variableSubStmtContext = state.DeclarationFinder.MatchName(variableName).First().Context; - var variableSubStmtContext = state.DeclarationFinder.MatchName(variableName).First().Context; + var infoFinder = new VariableRewriterInfoFinder(); + var info = infoFinder.GetRewriterInfo(variableSubStmtContext); - var infoFinder = new VariableRewriterInfoFinder(); - var info = infoFinder.GetRewriterInfo(variableSubStmtContext); - - var actualEnclosedCode = state.GetRewriter(component).TokenStream.GetText(info.StartTokenIndex, info.StopTokenIndex); - Assert.AreEqual(expectedEnclosedCode, actualEnclosedCode); + var actualEnclosedCode = state.GetCodePaneTokenStream(component.QualifiedModuleName) + .GetText(info.StartTokenIndex, info.StopTokenIndex); + Assert.AreEqual(expectedEnclosedCode, actualEnclosedCode); + } } } } From 7a81d8fea236083d98378821d30da1953cc5ab47 Mon Sep 17 00:00:00 2001 From: Max Doerner Date: Sat, 3 Nov 2018 15:03:21 +0100 Subject: [PATCH 24/59] Remove the RewriteManager from the RubberDuckParserState All users have been rewired. So, it does not have to be property injected anymore. --- Rubberduck.Parsing/VBA/ParseCoordinator.cs | 4 ---- Rubberduck.Parsing/VBA/RubberduckParserState.cs | 4 ---- 2 files changed, 8 deletions(-) diff --git a/Rubberduck.Parsing/VBA/ParseCoordinator.cs b/Rubberduck.Parsing/VBA/ParseCoordinator.cs index a8a1490cf1..eec03d5602 100644 --- a/Rubberduck.Parsing/VBA/ParseCoordinator.cs +++ b/Rubberduck.Parsing/VBA/ParseCoordinator.cs @@ -72,10 +72,6 @@ public ParseCoordinator( state.SuspendRequest += SuspendRequested; _requestorStack = new ConcurrentStack(); - - //todo: Remove this again in favor of injection of the IRewritingManager into the callers RubberduckParserState.RewritingManager. - //This gets property injected here because the construction of the rewritingManager ultimately depend on the RubberduckParserState. - state.RewritingManager = rewritingManager; } // In production, the cancellation token should be accessed inside the CancellationSyncObject diff --git a/Rubberduck.Parsing/VBA/RubberduckParserState.cs b/Rubberduck.Parsing/VBA/RubberduckParserState.cs index 3426bb5ad4..5287882971 100644 --- a/Rubberduck.Parsing/VBA/RubberduckParserState.cs +++ b/Rubberduck.Parsing/VBA/RubberduckParserState.cs @@ -1050,10 +1050,6 @@ public void SetAttributesTokenStream(QualifiedModuleName module, ITokenStream at _moduleStates[module].SetAttributesTokenStream(attributesTokenStream); } - //todo: Remove this again in favor of injection of the IRewritingManager into the callers. - public IRewritingManager RewritingManager { get; internal set; } - - private bool _isDisposed; public void Dispose() { From 0b93e503e275ab27fb77569192cd371c7f6099cd Mon Sep 17 00:00:00 2001 From: comintern Date: Sat, 3 Nov 2018 16:36:23 -0500 Subject: [PATCH 25/59] Add new inspection for Excel UDFs hidden by cells. --- ...elUdfNameIsValidCellReferenceInspection.cs | 49 ++++++ .../QuickFixes/RenameDeclarationQuickFix.cs | 6 +- Rubberduck.Core/Properties/Settings.settings | 27 +-- Rubberduck.Core/app.config | 28 +--- .../Inspections/InspectionInfo.Designer.cs | 9 + .../Inspections/InspectionInfo.resx | 3 + .../Inspections/InspectionNames.Designer.cs | 9 + .../Inspections/InspectionNames.resx | 3 + .../Inspections/InspectionResults.Designer.cs | 9 + .../Inspections/InspectionResults.resx | 4 + .../Rubberduck.Resources.csproj | 16 +- .../Settings/AutoCompletesPage.Designer.cs | 158 ++++-------------- .../Settings/SettingsUI.Designer.cs | 9 - ...NameIsValidCellReferenceInspectionTests.cs | 128 ++++++++++++++ 14 files changed, 279 insertions(+), 179 deletions(-) create mode 100644 Rubberduck.CodeAnalysis/Inspections/Concrete/ExcelUdfNameIsValidCellReferenceInspection.cs create mode 100644 RubberduckTests/Inspections/ExcelUdfNameIsValidCellReferenceInspectionTests.cs diff --git a/Rubberduck.CodeAnalysis/Inspections/Concrete/ExcelUdfNameIsValidCellReferenceInspection.cs b/Rubberduck.CodeAnalysis/Inspections/Concrete/ExcelUdfNameIsValidCellReferenceInspection.cs new file mode 100644 index 0000000000..f23b890678 --- /dev/null +++ b/Rubberduck.CodeAnalysis/Inspections/Concrete/ExcelUdfNameIsValidCellReferenceInspection.cs @@ -0,0 +1,49 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text.RegularExpressions; +using Rubberduck.Inspections.Abstract; +using Rubberduck.Inspections.Results; +using Rubberduck.Parsing.Inspections; +using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.Symbols; +using Rubberduck.Parsing.VBA; +using Rubberduck.Resources.Inspections; + +namespace Rubberduck.Inspections.Inspections.Concrete +{ + [RequiredLibrary("Excel")] + public class ExcelUdfNameIsValidCellReferenceInspection : InspectionBase + { + public ExcelUdfNameIsValidCellReferenceInspection(RubberduckParserState state) : base(state) { } + + private static readonly Regex ValidCellIdRegex = + new Regex(@"^([a-z]|[a-z]{2}|[a-w][a-z]{2}|x([a-e][a-z]|f[a-d]))(?\d+)$", + RegexOptions.Compiled | RegexOptions.IgnoreCase | RegexOptions.ExplicitCapture); + + private static readonly HashSet VisibleAsUdf = new HashSet { Accessibility.Public, Accessibility.Implicit }; + + private const uint MaximumExcelRows = 1048576; + + protected override IEnumerable DoGetInspectionResults() + { + var excel = State.DeclarationFinder.Projects.SingleOrDefault(item => !item.IsUserDefined && item.IdentifierName == "Excel"); + if (excel == null) + { + return Enumerable.Empty(); + } + + var candidates = UserDeclarations.OfType().Where(decl => + decl.ParentScopeDeclaration.DeclarationType == DeclarationType.ProceduralModule && + VisibleAsUdf.Contains(decl.Accessibility)); + + return (from function in candidates.Where(decl => ValidCellIdRegex.IsMatch(decl.IdentifierName)) + let row = Convert.ToUInt32(ValidCellIdRegex.Matches(function.IdentifierName)[0].Groups["Row"].Value) + where row > 0 && row <= MaximumExcelRows && !IsIgnoringInspectionResultFor(function, AnnotationName) + select new DeclarationInspectionResult(this, + string.Format(InspectionResults.ExcelUdfNameIsValidCellReferenceInspection, function.IdentifierName), + function)) + .Cast().ToList(); + } + } +} diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RenameDeclarationQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RenameDeclarationQuickFix.cs index ab6c2817a8..e7a308d5af 100644 --- a/Rubberduck.CodeAnalysis/QuickFixes/RenameDeclarationQuickFix.cs +++ b/Rubberduck.CodeAnalysis/QuickFixes/RenameDeclarationQuickFix.cs @@ -1,6 +1,7 @@ using System.Globalization; using Rubberduck.Inspections.Abstract; using Rubberduck.Inspections.Concrete; +using Rubberduck.Inspections.Inspections.Concrete; using Rubberduck.Interaction; using Rubberduck.Parsing.Inspections.Abstract; using Rubberduck.Parsing.VBA; @@ -18,7 +19,10 @@ public sealed class RenameDeclarationQuickFix : QuickFixBase private readonly IMessageBox _messageBox; public RenameDeclarationQuickFix(IVBE vbe, RubberduckParserState state, IMessageBox messageBox) - : base(typeof(HungarianNotationInspection), typeof(UseMeaningfulNameInspection), typeof(DefaultProjectNameInspection)) + : base(typeof(HungarianNotationInspection), + typeof(UseMeaningfulNameInspection), + typeof(DefaultProjectNameInspection), + typeof(ExcelUdfNameIsValidCellReferenceInspection)) { _vbe = vbe; _state = state; diff --git a/Rubberduck.Core/Properties/Settings.settings b/Rubberduck.Core/Properties/Settings.settings index 65cc1ca0f3..1962a7e622 100644 --- a/Rubberduck.Core/Properties/Settings.settings +++ b/Rubberduck.Core/Properties/Settings.settings @@ -268,26 +268,13 @@ <?xml version="1.0" encoding="utf-16"?> -<AutoCompleteSettings xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" IsEnabled="false" CompleteBlockOnTab="true" CompleteBlockOnEnter="true" EnableSmartConcat="true"> - <AutoCompletes> - <AutoComplete Key="AutoCompleteClosingBrace" IsEnabled="true" /> - <AutoComplete Key="AutoCompleteClosingBracket" IsEnabled="true" /> - <AutoComplete Key="AutoCompleteClosingParenthese" IsEnabled="true" /> - <AutoComplete Key="AutoCompleteClosingString" IsEnabled="true" /> - <AutoComplete Key="AutoCompleteDoBlock" IsEnabled="true" /> - <AutoComplete Key="AutoCompleteEnumBlock" IsEnabled="true" /> - <AutoComplete Key="AutoCompleteForBlock" IsEnabled="true" /> - <AutoComplete Key="AutoCompleteFunctionBlock" IsEnabled="true" /> - <AutoComplete Key="AutoCompleteIfBlock" IsEnabled="true" /> - <AutoComplete Key="AutoCompleteOnErrorResumeNextBlock" IsEnabled="true" /> - <AutoComplete Key="AutoCompletePrecompilerIfBlock" IsEnabled="true" /> - <AutoComplete Key="AutoCompletePropertyBlock" IsEnabled="true" /> - <AutoComplete Key="AutoCompleteSelectBlock" IsEnabled="true" /> - <AutoComplete Key="AutoCompleteSubBlock" IsEnabled="true" /> - <AutoComplete Key="AutoCompleteTypeBlock" IsEnabled="true" /> - <AutoComplete Key="AutoCompleteWhileBlock" IsEnabled="true" /> - <AutoComplete Key="AutoCompleteWithBlock" IsEnabled="true" /> - </AutoCompletes> +<AutoCompleteSettings xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" IsEnabled="false"> + <SmartConcat> + <IsEnabled>false</IsEnabled> + <ConcatVbNewLineModifier>None</ConcatVbNewLineModifier> + </SmartConcat> + <SelfClosingPairs IsEnabled="false" /> + <BlockCompletion IsEnabled="false" CompleteOnEnter="false" CompleteOnTab="false" /> </AutoCompleteSettings> diff --git a/Rubberduck.Core/app.config b/Rubberduck.Core/app.config index 3aef405463..11c717c6c1 100644 --- a/Rubberduck.Core/app.config +++ b/Rubberduck.Core/app.config @@ -395,27 +395,13 @@ - - - - - - - - - - - - - - - - - - - + xmlns:xsd="http://www.w3.org/2001/XMLSchema" IsEnabled="false"> + + false + None + + + diff --git a/Rubberduck.Resources/Inspections/InspectionInfo.Designer.cs b/Rubberduck.Resources/Inspections/InspectionInfo.Designer.cs index e399928601..e98d337132 100644 --- a/Rubberduck.Resources/Inspections/InspectionInfo.Designer.cs +++ b/Rubberduck.Resources/Inspections/InspectionInfo.Designer.cs @@ -222,6 +222,15 @@ public static string EncapsulatePublicFieldInspection { } } + /// + /// Looks up a localized string similar to Functions that are visible to Excel as User-Defined Functions will return a '#REF' error when used on a Worksheet if they match the name of a valid cell reference. If the function is intended to be used as a UDF, it must be renamed. If the function is not intended to be used as a UDF, it should be scoped as 'Private' or moved out of a standard Module.. + /// + public static string ExcelUdfNameIsValidCellReferenceInspection { + get { + return ResourceManager.GetString("ExcelUdfNameIsValidCellReferenceInspection", resourceCulture); + } + } + /// /// Looks up a localized string similar to A member is written as a function, but used as a procedure. Unless the function is recursive, consider converting the 'Function' into a 'Sub'. If the function is recursive, none of its external callers are using the returned value.. /// diff --git a/Rubberduck.Resources/Inspections/InspectionInfo.resx b/Rubberduck.Resources/Inspections/InspectionInfo.resx index b06e89193b..58c4817d84 100644 --- a/Rubberduck.Resources/Inspections/InspectionInfo.resx +++ b/Rubberduck.Resources/Inspections/InspectionInfo.resx @@ -349,4 +349,7 @@ If the parameter can be null, ignore this inspection result; passing a null valu An assignment is immediately overridden by another assignment or is never referenced. + + Functions that are visible to Excel as User-Defined Functions will return a '#REF' error when used on a Worksheet if they match the name of a valid cell reference. If the function is intended to be used as a UDF, it must be renamed. If the function is not intended to be used as a UDF, it should be scoped as 'Private' or moved out of a standard Module. + \ No newline at end of file diff --git a/Rubberduck.Resources/Inspections/InspectionNames.Designer.cs b/Rubberduck.Resources/Inspections/InspectionNames.Designer.cs index f13cc181ab..def9778047 100644 --- a/Rubberduck.Resources/Inspections/InspectionNames.Designer.cs +++ b/Rubberduck.Resources/Inspections/InspectionNames.Designer.cs @@ -222,6 +222,15 @@ public static string EncapsulatePublicFieldInspection { } } + /// + /// Looks up a localized string similar to Function is hidden by Excel cell reference. + /// + public static string ExcelUdfNameIsValidCellReferenceInspection { + get { + return ResourceManager.GetString("ExcelUdfNameIsValidCellReferenceInspection", resourceCulture); + } + } + /// /// Looks up a localized string similar to Function return value is never used. /// diff --git a/Rubberduck.Resources/Inspections/InspectionNames.resx b/Rubberduck.Resources/Inspections/InspectionNames.resx index 619f5ddbb9..cf1ef9d7d4 100644 --- a/Rubberduck.Resources/Inspections/InspectionNames.resx +++ b/Rubberduck.Resources/Inspections/InspectionNames.resx @@ -348,4 +348,7 @@ Assignment is not used + + Function is hidden by Excel cell reference + \ No newline at end of file diff --git a/Rubberduck.Resources/Inspections/InspectionResults.Designer.cs b/Rubberduck.Resources/Inspections/InspectionResults.Designer.cs index 02946f951a..7403434027 100644 --- a/Rubberduck.Resources/Inspections/InspectionResults.Designer.cs +++ b/Rubberduck.Resources/Inspections/InspectionResults.Designer.cs @@ -222,6 +222,15 @@ public static string EncapsulatePublicFieldInspection { } } + /// + /// Looks up a localized string similar to '{0}' is hidden by a valid Excel cell reference.. + /// + public static string ExcelUdfNameIsValidCellReferenceInspection { + get { + return ResourceManager.GetString("ExcelUdfNameIsValidCellReferenceInspection", resourceCulture); + } + } + /// /// Looks up a localized string similar to Return value of function '{0}' is never used.. /// diff --git a/Rubberduck.Resources/Inspections/InspectionResults.resx b/Rubberduck.Resources/Inspections/InspectionResults.resx index 36ac7d58cb..4074833183 100644 --- a/Rubberduck.Resources/Inspections/InspectionResults.resx +++ b/Rubberduck.Resources/Inspections/InspectionResults.resx @@ -378,4 +378,8 @@ An assignment is immediately overridden by another assignment or is never referenced. + + '{0}' is hidden by a valid Excel cell reference. + {0} Function name + \ No newline at end of file diff --git a/Rubberduck.Resources/Rubberduck.Resources.csproj b/Rubberduck.Resources/Rubberduck.Resources.csproj index 88e5eb41a0..7205ec5764 100644 --- a/Rubberduck.Resources/Rubberduck.Resources.csproj +++ b/Rubberduck.Resources/Rubberduck.Resources.csproj @@ -12,12 +12,20 @@ - - PublicResXFileCodeGenerator - $([System.String]::Copy('%(FileName)')).Designer.cs - + + + + True + True $([System.String]::Copy('%(Filename)').Replace('.Designer', '')).resx + + + + PublicResXFileCodeGenerator + $([System.String]::Copy('%(FileName)')).Designer.cs + + \ No newline at end of file diff --git a/Rubberduck.Resources/Settings/AutoCompletesPage.Designer.cs b/Rubberduck.Resources/Settings/AutoCompletesPage.Designer.cs index e71b292377..18a7c254a2 100644 --- a/Rubberduck.Resources/Settings/AutoCompletesPage.Designer.cs +++ b/Rubberduck.Resources/Settings/AutoCompletesPage.Designer.cs @@ -61,160 +61,70 @@ internal AutoCompletesPage() { } /// - /// Looks up a localized string similar to Close curly braces '{'. + /// Looks up a localized string similar to Block Completion. /// - public static string AutoCompleteClosingBraceDescription { + public static string BlockCompletion { get { - return ResourceManager.GetString("AutoCompleteClosingBraceDescription", resourceCulture); + return ResourceManager.GetString("BlockCompletion", resourceCulture); } } /// - /// Looks up a localized string similar to Close square brackets '['. - /// - public static string AutoCompleteClosingBracketDescription { - get { - return ResourceManager.GetString("AutoCompleteClosingBracketDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Close parentheses '('. - /// - public static string AutoCompleteClosingParentheseDescription { - get { - return ResourceManager.GetString("AutoCompleteClosingParentheseDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Close string literals '"'. - /// - public static string AutoCompleteClosingStringDescription { - get { - return ResourceManager.GetString("AutoCompleteClosingStringDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Close 'Do [Until|While]...Loop' loop blocks. - /// - public static string AutoCompleteDoBlockDescription { - get { - return ResourceManager.GetString("AutoCompleteDoBlockDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Close 'Enum' blocks. - /// - public static string AutoCompleteEnumBlockDescription { - get { - return ResourceManager.GetString("AutoCompleteEnumBlockDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Close 'For [Each]...Next' loop blocks. - /// - public static string AutoCompleteForBlockDescription { - get { - return ResourceManager.GetString("AutoCompleteForBlockDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Override 'Function' member block completion. - /// - public static string AutoCompleteFunctionBlockDescription { - get { - return ResourceManager.GetString("AutoCompleteFunctionBlockDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Close 'If' blocks. - /// - public static string AutoCompleteIfBlockDescription { - get { - return ResourceManager.GetString("AutoCompleteIfBlockDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Treat 'On Error Resume Next...GoTo 0' as a block. - /// - public static string AutoCompleteOnErrorResumeNextBlockDescription { - get { - return ResourceManager.GetString("AutoCompleteOnErrorResumeNextBlockDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Close precompiler '#If' blocks. - /// - public static string AutoCompletePrecompilerIfBlockDescription { - get { - return ResourceManager.GetString("AutoCompletePrecompilerIfBlockDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Override 'Property' member block completion. + /// Looks up a localized string similar to Autocomplete blocks on ENTER. /// - public static string AutoCompletePropertyBlockDescription { + public static string CompleteBlockOnEnter { get { - return ResourceManager.GetString("AutoCompletePropertyBlockDescription", resourceCulture); + return ResourceManager.GetString("CompleteBlockOnEnter", resourceCulture); } } /// - /// Looks up a localized string similar to Close 'Select' blocks. + /// Looks up a localized string similar to Autocomplete blocks on TAB. /// - public static string AutoCompleteSelectBlockDescription { + public static string CompleteBlockOnTab { get { - return ResourceManager.GetString("AutoCompleteSelectBlockDescription", resourceCulture); + return ResourceManager.GetString("CompleteBlockOnTab", resourceCulture); } } /// - /// Looks up a localized string similar to Override 'Sub' member block completion. + /// Looks up a localized string similar to Concatenate 'vbNewLine' on Ctrl+Enter. /// - public static string AutoCompleteSubBlockDescription { + public static string ConcatVbNewLine { get { - return ResourceManager.GetString("AutoCompleteSubBlockDescription", resourceCulture); + return ResourceManager.GetString("ConcatVbNewLine", resourceCulture); } } /// - /// Looks up a localized string similar to Close 'Type' blocks. + /// Looks up a localized string similar to Enable autocompletion features. /// - public static string AutoCompleteTypeBlockDescription { + public static string EnableAutocompleteLabel { get { - return ResourceManager.GetString("AutoCompleteTypeBlockDescription", resourceCulture); + return ResourceManager.GetString("EnableAutocompleteLabel", resourceCulture); } } /// - /// Looks up a localized string similar to Close 'While...Wend' loop blocks. + /// Looks up a localized string similar to Enable block completion. /// - public static string AutoCompleteWhileBlockDescription { + public static string EnableBlockCompletion { get { - return ResourceManager.GetString("AutoCompleteWhileBlockDescription", resourceCulture); + return ResourceManager.GetString("EnableBlockCompletion", resourceCulture); } } /// - /// Looks up a localized string similar to Close 'With' blocks. + /// Looks up a localized string similar to Enable self-closing pairs. /// - public static string AutoCompleteWithBlockDescription { + public static string EnableSelfClosingPairs { get { - return ResourceManager.GetString("AutoCompleteWithBlockDescription", resourceCulture); + return ResourceManager.GetString("EnableSelfClosingPairs", resourceCulture); } } /// - /// Looks up a localized string similar to Enable smart concatenation. + /// Looks up a localized string similar to Enable smart-concatenation. /// public static string EnableSmartConcat { get { @@ -223,38 +133,38 @@ public static string EnableSmartConcat { } /// - /// Looks up a localized string similar to Autocomplete blocks on ENTER. + /// Looks up a localized string similar to Autocompletion Settings. /// - public static string HandleEnterKey { + public static string PageHeader { get { - return ResourceManager.GetString("HandleEnterKey", resourceCulture); + return ResourceManager.GetString("PageHeader", resourceCulture); } } /// - /// Looks up a localized string similar to Autocomplete blocks on TAB. + /// Looks up a localized string similar to Configure which Rubberduck autocompletions are enabled.. /// - public static string HandleTabKey { + public static string PageInstructions { get { - return ResourceManager.GetString("HandleTabKey", resourceCulture); + return ResourceManager.GetString("PageInstructions", resourceCulture); } } /// - /// Looks up a localized string similar to Autocompletion Settings. + /// Looks up a localized string similar to Self-Closing Pairs. /// - public static string PageHeader { + public static string SelfClosingPairs { get { - return ResourceManager.GetString("PageHeader", resourceCulture); + return ResourceManager.GetString("SelfClosingPairs", resourceCulture); } } /// - /// Looks up a localized string similar to Configure which Rubberduck autocompletions are enabled.. + /// Looks up a localized string similar to Smart-Concatenation. /// - public static string PageInstructions { + public static string SmartConcat { get { - return ResourceManager.GetString("PageInstructions", resourceCulture); + return ResourceManager.GetString("SmartConcat", resourceCulture); } } } diff --git a/Rubberduck.Resources/Settings/SettingsUI.Designer.cs b/Rubberduck.Resources/Settings/SettingsUI.Designer.cs index e37a412e19..cb5cd64526 100644 --- a/Rubberduck.Resources/Settings/SettingsUI.Designer.cs +++ b/Rubberduck.Resources/Settings/SettingsUI.Designer.cs @@ -69,15 +69,6 @@ public static string ConfirmResetSettings { } } - /// - /// Looks up a localized string similar to Enable autocompletion. Feature isn't fully completed and may behave in unintended ways.. - /// - public static string EnableAutocompleteLabel { - get { - return ResourceManager.GetString("EnableAutocompleteLabel", resourceCulture); - } - } - /// /// Looks up a localized string similar to Export. /// diff --git a/RubberduckTests/Inspections/ExcelUdfNameIsValidCellReferenceInspectionTests.cs b/RubberduckTests/Inspections/ExcelUdfNameIsValidCellReferenceInspectionTests.cs new file mode 100644 index 0000000000..334b4e4c64 --- /dev/null +++ b/RubberduckTests/Inspections/ExcelUdfNameIsValidCellReferenceInspectionTests.cs @@ -0,0 +1,128 @@ +using System.Linq; +using System.Threading; +using NUnit.Framework; +using Rubberduck.Inspections.Inspections.Concrete; +using Rubberduck.VBEditor.SafeComWrappers; +using RubberduckTests.Mocks; + +namespace RubberduckTests.Inspections +{ + [TestFixture] + public class ExcelUdfNameIsValidCellReferenceInspectionTests + { + [TestCase("a1")] + [TestCase("A1")] + [TestCase("AA1")] + [TestCase("ZZ1")] + [TestCase("XFD1")] + [TestCase("XEZ1")] + [TestCase("WZZ1")] + [TestCase("Foo42")] + [TestCase("XFD1048576")] + [Category("Inspections")] + public void ExcelUdfNameIsValidCellReferenceInspection_ReturnsResult_ValidCells(string identifier) + { + const string codeTemplate = +@"Public Function {0}() As Long + {0} = 42 +End Function +"; + + Assert.AreEqual(1, InspectionResultCount(string.Format(codeTemplate, identifier), ComponentType.StandardModule)); + } + + [TestCase("Foo")] + [TestCase("XXX69")] + [TestCase("XKCD42")] + [TestCase("AAA1234567")] + [Category("Inspections")] + public void ExcelUdfNameIsValidCellReferenceInspection_ReturnsNoResult_InvalidAsCell(string identifier) + { + const string codeTemplate = +@"Public Function {0}() As Long + {0} = 42 +End Function +"; + + Assert.AreEqual(0, InspectionResultCount(string.Format(codeTemplate, identifier), ComponentType.StandardModule)); + } + + [TestCase(ComponentType.ClassModule)] + [TestCase(ComponentType.UserForm)] + [TestCase(ComponentType.DocObject)] + [Category("Inspections")] + public void ExcelUdfNameIsValidCellReferenceInspection_ReturnsNoResult_NonStandardModule(ComponentType moduleType) + { + const string code = +@"Public Function A1() As Long + A1 = 42 +End Function +"; + + Assert.AreEqual(0, InspectionResultCount(code, moduleType)); + } + + [Test] + [Category("Inspections")] + public void ExcelUdfNameIsValidCellReferenceInspection_ReturnsNoResult_Ignored() + { + const string code = +@"'@Ignore ExcelUdfNameIsValidCellReference +Public Function A1() As Long + A1 = 42 +End Function +"; + + Assert.AreEqual(0, InspectionResultCount(code, ComponentType.StandardModule)); + } + + [Test] + [Category("Inspections")] + public void ExcelUdfNameIsValidCellReferenceInspection_ReturnsNoResult_PrivateFunction() + { + const string code = +@"Private Function A1() As Long + A1 = 42 +End Function +"; + + Assert.AreEqual(0, InspectionResultCount(code, ComponentType.StandardModule)); + } + + [TestCase("Sub A1()", "Sub")] + [TestCase("Property Get A1() As Long", "Property")] + [TestCase("Property Let A1(foo As Long)", "Property")] + [TestCase("Property Set A1(foo As Variant)", "Property")] + [Category("Inspections")] + public void ExcelUdfNameIsValidCellReferenceInspection_ReturnsNoResult_NonFunction(string signature, string ending) + { + const string codeTemplate = +@"{0} + A1 = 42 +End {1} +"; + + Assert.AreEqual(0, InspectionResultCount(string.Format(codeTemplate, signature, ending), ComponentType.StandardModule)); + } + + private static int InspectionResultCount(string inputCode, ComponentType moduleType) + { + var builder = new MockVbeBuilder(); + var project = builder.ProjectBuilder("VBAProject", ProjectProtection.Unprotected) + .AddComponent("UnderTest", moduleType, inputCode) + .AddReference("Excel", MockVbeBuilder.LibraryPathMsExcel, 1, 8, true) + .Build(); + + var vbe = builder.AddProject(project).Build(); + + using (var state = MockParser.CreateAndParse(vbe.Object)) + { + + var inspection = new ExcelUdfNameIsValidCellReferenceInspection(state); + var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); + + return inspectionResults.Count(); + } + } + } +} From 62dfc3517bae8d599928b70055e3071d854d7393 Mon Sep 17 00:00:00 2001 From: comintern Date: Sun, 4 Nov 2018 16:00:06 -0600 Subject: [PATCH 26/59] Add inspection defaults to Settings.settings --- Rubberduck.Core/Properties/Settings.settings | 489 ++++++++++--------- Rubberduck.Core/Rubberduck.Core.csproj | 15 +- Rubberduck.Core/app.config | 2 + 3 files changed, 265 insertions(+), 241 deletions(-) diff --git a/Rubberduck.Core/Properties/Settings.settings b/Rubberduck.Core/Properties/Settings.settings index 1962a7e622..d061c65c55 100644 --- a/Rubberduck.Core/Properties/Settings.settings +++ b/Rubberduck.Core/Properties/Settings.settings @@ -3,279 +3,298 @@ - <?xml version="1.0" encoding="utf-16"?> -<HotkeySetting xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> - <Key1>R</Key1> - <IsEnabled>true</IsEnabled> - <HasShiftModifier>true</HasShiftModifier> - <HasAltModifier>false</HasAltModifier> - <HasCtrlModifier>true</HasCtrlModifier> - <CommandTypeName>CodePaneRefactorRenameCommand</CommandTypeName> -</HotkeySetting> + + <HotkeySetting xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> + <Key1>R</Key1> + <IsEnabled>true</IsEnabled> + <HasShiftModifier>true</HasShiftModifier> + <HasAltModifier>false</HasAltModifier> + <HasCtrlModifier>true</HasCtrlModifier> + <CommandTypeName>CodePaneRefactorRenameCommand</CommandTypeName> + </HotkeySetting> + - <?xml version="1.0" encoding="utf-16"?> -<HotkeySetting xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> - <Key1>F</Key1> - <IsEnabled>true</IsEnabled> - <HasShiftModifier>true</HasShiftModifier> - <HasAltModifier>false</HasAltModifier> - <HasCtrlModifier>true</HasCtrlModifier> - <CommandTypeName>RefactorEncapsulateFieldCommand</CommandTypeName> -</HotkeySetting> + + <HotkeySetting xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> + <Key1>F</Key1> + <IsEnabled>true</IsEnabled> + <HasShiftModifier>true</HasShiftModifier> + <HasAltModifier>false</HasAltModifier> + <HasCtrlModifier>true</HasCtrlModifier> + <CommandTypeName>RefactorEncapsulateFieldCommand</CommandTypeName> + </HotkeySetting> + - <?xml version="1.0" encoding="utf-16"?> -<HotkeySetting xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> - <Key1>M</Key1> - <IsEnabled>true</IsEnabled> - <HasShiftModifier>true</HasShiftModifier> - <HasAltModifier>false</HasAltModifier> - <HasCtrlModifier>true</HasCtrlModifier> - <CommandTypeName>RefactorExtractMethodCommand</CommandTypeName> -</HotkeySetting> + + <HotkeySetting xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> + <Key1>M</Key1> + <IsEnabled>true</IsEnabled> + <HasShiftModifier>true</HasShiftModifier> + <HasAltModifier>false</HasAltModifier> + <HasCtrlModifier>true</HasCtrlModifier> + <CommandTypeName>RefactorExtractMethodCommand</CommandTypeName> + </HotkeySetting> + - <?xml version="1.0" encoding="utf-16"?> -<HotkeySetting xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> - <Key1>C</Key1> - <IsEnabled>true</IsEnabled> - <HasShiftModifier>true</HasShiftModifier> - <HasAltModifier>false</HasAltModifier> - <HasCtrlModifier>true</HasCtrlModifier> - <CommandTypeName>RefactorMoveCloserToUsageCommand</CommandTypeName> -</HotkeySetting> + + <HotkeySetting xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> + <Key1>C</Key1> + <IsEnabled>true</IsEnabled> + <HasShiftModifier>true</HasShiftModifier> + <HasAltModifier>false</HasAltModifier> + <HasCtrlModifier>true</HasCtrlModifier> + <CommandTypeName>RefactorMoveCloserToUsageCommand</CommandTypeName> + </HotkeySetting> + - <?xml version="1.0" encoding="utf-16"?> -<HotkeySetting xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> - <Key1>R</Key1> - <IsEnabled>true</IsEnabled> - <HasShiftModifier>false</HasShiftModifier> - <HasAltModifier>false</HasAltModifier> - <HasCtrlModifier>true</HasCtrlModifier> - <CommandTypeName>CodeExplorerCommand</CommandTypeName> -</HotkeySetting> + + <HotkeySetting xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> + <Key1>R</Key1> + <IsEnabled>true</IsEnabled> + <HasShiftModifier>false</HasShiftModifier> + <HasAltModifier>false</HasAltModifier> + <HasCtrlModifier>true</HasCtrlModifier> + <CommandTypeName>CodeExplorerCommand</CommandTypeName> + </HotkeySetting> + - <?xml version="1.0" encoding="utf-16"?> -<HotkeySetting xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> - <Key1>E</Key1> - <IsEnabled>true</IsEnabled> - <HasShiftModifier>true</HasShiftModifier> - <HasAltModifier>false</HasAltModifier> - <HasCtrlModifier>true</HasCtrlModifier> - <CommandTypeName>ExportAllCommand</CommandTypeName> -</HotkeySetting> + + <HotkeySetting xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> + <Key1>E</Key1> + <IsEnabled>true</IsEnabled> + <HasShiftModifier>true</HasShiftModifier> + <HasAltModifier>false</HasAltModifier> + <HasCtrlModifier>true</HasCtrlModifier> + <CommandTypeName>ExportAllCommand</CommandTypeName> + </HotkeySetting> + - <?xml version="1.0" encoding="utf-16"?> -<HotkeySetting xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> - <Key1>T</Key1> - <IsEnabled>true</IsEnabled> - <HasShiftModifier>false</HasShiftModifier> - <HasAltModifier>false</HasAltModifier> - <HasCtrlModifier>true</HasCtrlModifier> - <CommandTypeName>FindSymbolCommand</CommandTypeName> -</HotkeySetting> + + <HotkeySetting xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> + <Key1>T</Key1> + <IsEnabled>true</IsEnabled> + <HasShiftModifier>false</HasShiftModifier> + <HasAltModifier>false</HasAltModifier> + <HasCtrlModifier>true</HasCtrlModifier> + <CommandTypeName>FindSymbolCommand</CommandTypeName> + </HotkeySetting> + - <?xml version="1.0" encoding="utf-16"?> -<HotkeySetting xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> - <Key1>M</Key1> - <IsEnabled>true</IsEnabled> - <HasShiftModifier>false</HasShiftModifier> - <HasAltModifier>false</HasAltModifier> - <HasCtrlModifier>true</HasCtrlModifier> - <CommandTypeName>IndentCurrentModuleCommand</CommandTypeName> -</HotkeySetting> + + <HotkeySetting xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> + <Key1>M</Key1> + <IsEnabled>true</IsEnabled> + <HasShiftModifier>false</HasShiftModifier> + <HasAltModifier>false</HasAltModifier> + <HasCtrlModifier>true</HasCtrlModifier> + <CommandTypeName>IndentCurrentModuleCommand</CommandTypeName> + </HotkeySetting> + - <?xml version="1.0" encoding="utf-16"?> -<HotkeySetting xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> - <Key1>P</Key1> - <IsEnabled>true</IsEnabled> - <HasShiftModifier>false</HasShiftModifier> - <HasAltModifier>false</HasAltModifier> - <HasCtrlModifier>true</HasCtrlModifier> - <CommandTypeName>IndentCurrentProcedureCommand</CommandTypeName> -</HotkeySetting> + + <HotkeySetting xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> + <Key1>P</Key1> + <IsEnabled>true</IsEnabled> + <HasShiftModifier>false</HasShiftModifier> + <HasAltModifier>false</HasAltModifier> + <HasCtrlModifier>true</HasCtrlModifier> + <CommandTypeName>IndentCurrentProcedureCommand</CommandTypeName> + </HotkeySetting> + - <?xml version="1.0" encoding="utf-16"?> -<HotkeySetting xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> - <Key1>I</Key1> - <IsEnabled>true</IsEnabled> - <HasShiftModifier>true</HasShiftModifier> - <HasAltModifier>false</HasAltModifier> - <HasCtrlModifier>true</HasCtrlModifier> - <CommandTypeName>InspectionResultsCommand</CommandTypeName> -</HotkeySetting> + + <HotkeySetting xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> + <Key1>I</Key1> + <IsEnabled>true</IsEnabled> + <HasShiftModifier>true</HasShiftModifier> + <HasAltModifier>false</HasAltModifier> + <HasCtrlModifier>true</HasCtrlModifier> + <CommandTypeName>InspectionResultsCommand</CommandTypeName> + </HotkeySetting> + - <?xml version="1.0" encoding="utf-16"?> -<HotkeySetting xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> - <Key1>`</Key1> - <IsEnabled>true</IsEnabled> - <HasShiftModifier>false</HasShiftModifier> - <HasAltModifier>false</HasAltModifier> - <HasCtrlModifier>true</HasCtrlModifier> - <CommandTypeName>ReparseCommand</CommandTypeName> -</HotkeySetting> + + <HotkeySetting xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> + <Key1>`</Key1> + <IsEnabled>true</IsEnabled> + <HasShiftModifier>false</HasShiftModifier> + <HasAltModifier>false</HasAltModifier> + <HasCtrlModifier>true</HasCtrlModifier> + <CommandTypeName>ReparseCommand</CommandTypeName> + </HotkeySetting> + - <?xml version="1.0" encoding="utf-16"?> -<HotkeySetting xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> - <Key1>T</Key1> - <IsEnabled>true</IsEnabled> - <HasShiftModifier>true</HasShiftModifier> - <HasAltModifier>false</HasAltModifier> - <HasCtrlModifier>true</HasCtrlModifier> - <CommandTypeName>TestExplorerCommand</CommandTypeName> -</HotkeySetting> + + <HotkeySetting xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> + <Key1>T</Key1> + <IsEnabled>true</IsEnabled> + <HasShiftModifier>true</HasShiftModifier> + <HasAltModifier>false</HasAltModifier> + <HasCtrlModifier>true</HasCtrlModifier> + <CommandTypeName>TestExplorerCommand</CommandTypeName> + </HotkeySetting> + - <?xml version="1.0" encoding="utf-16"?> -<ToDoMarker xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" Text="TODO" /> + + <ToDoMarker xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" Text="TODO" /> + - <?xml version="1.0" encoding="utf-16"?> -<ToDoMarker xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" Text="NOTE" /> + + <ToDoMarker xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" Text="NOTE" /> + - <?xml version="1.0" encoding="utf-16"?> -<ToDoMarker xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" Text="BUG" /> + + <ToDoMarker xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" Text="BUG" /> + - <?xml version="1.0" encoding="utf-16"?> -<WindowSettings xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> - <CodeExplorerVisibleOnStartup>false</CodeExplorerVisibleOnStartup> - <CodeInspectionsVisibleOnStartup>false</CodeInspectionsVisibleOnStartup> - <TestExplorerVisibleOnStartup>false</TestExplorerVisibleOnStartup> - <TodoExplorerVisibleOnStartup>false</TodoExplorerVisibleOnStartup> - <CodeExplorer_SortByName>true</CodeExplorer_SortByName> - <CodeExplorer_SortByCodeOrder>false</CodeExplorer_SortByCodeOrder> - <CodeExplorer_GroupByType>false</CodeExplorer_GroupByType> -</WindowSettings> + + <WindowSettings xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> + <CodeExplorerVisibleOnStartup>false</CodeExplorerVisibleOnStartup> + <CodeInspectionsVisibleOnStartup>false</CodeInspectionsVisibleOnStartup> + <TestExplorerVisibleOnStartup>false</TestExplorerVisibleOnStartup> + <TodoExplorerVisibleOnStartup>false</TodoExplorerVisibleOnStartup> + <CodeExplorer_SortByName>true</CodeExplorer_SortByName> + <CodeExplorer_SortByCodeOrder>false</CodeExplorer_SortByCodeOrder> + <CodeExplorer_GroupByType>false</CodeExplorer_GroupByType> + </WindowSettings> + - <?xml version="1.0" encoding="utf-16"?> -<UnitTestSettings xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> - <BindingMode>LateBinding</BindingMode> - <AssertMode>StrictAssert</AssertMode> - <ModuleInit>true</ModuleInit> - <MethodInit>true</MethodInit> - <DefaultTestStubInNewModule>false</DefaultTestStubInNewModule> -</UnitTestSettings> + + <UnitTestSettings xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> + <BindingMode>LateBinding</BindingMode> + <AssertMode>StrictAssert</AssertMode> + <ModuleInit>true</ModuleInit> + <MethodInit>true</MethodInit> + <DefaultTestStubInNewModule>false</DefaultTestStubInNewModule> + </UnitTestSettings> + - <?xml version="1.0" encoding="utf-16"?> -<GeneralSettings xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> - <Language Code="en-US" /> - <CanShowSplash>true</CanShowSplash> - <CanCheckVersion>true</CanCheckVersion> - <CompileBeforeParse>true</CompileBeforeParse> - <IsSmartIndenterPrompted>false</IsSmartIndenterPrompted> - <IsAutoSaveEnabled>false</IsAutoSaveEnabled> - <AutoSavePeriod>10</AutoSavePeriod> - <UserEditedLogLevel>false</UserEditedLogLevel> - <MinimumLogLevel>0</MinimumLogLevel> - <EnableExperimentalFeatures /> -</GeneralSettings> + + <GeneralSettings xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> + <Language Code="en-US" /> + <CanShowSplash>true</CanShowSplash> + <CanCheckVersion>true</CanCheckVersion> + <CompileBeforeParse>true</CompileBeforeParse> + <IsSmartIndenterPrompted>false</IsSmartIndenterPrompted> + <IsAutoSaveEnabled>false</IsAutoSaveEnabled> + <AutoSavePeriod>10</AutoSavePeriod> + <UserEditedLogLevel>false</UserEditedLogLevel> + <MinimumLogLevel>0</MinimumLogLevel> + <EnableExperimentalFeatures /> + </GeneralSettings> + - <?xml version="1.0" encoding="utf-16"?> -<CodeInspectionSettings xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> - <CodeInspections> - <CodeInspection Name="BooleanAssignedInIfElseInspection" Severity="Warning" InspectionType="MaintainabilityAndReadabilityIssues" /> - <CodeInspection Name="ObsoleteErrorSyntaxInspection" Severity="Suggestion" InspectionType="LanguageOpportunities" /> - <CodeInspection Name="StopKeywordInspection" Severity="Suggestion" InspectionType="CodeQualityIssues" /> - <CodeInspection Name="UnhandledOnErrorResumeNextInspection" Severity="Warning" InspectionType="CodeQualityIssues" /> - <CodeInspection Name="EmptyStringLiteralInspection" Severity="Warning" InspectionType="LanguageOpportunities" /> - <CodeInspection Name="ImplicitByRefModifierInspection" Severity="Hint" InspectionType="CodeQualityIssues" /> - <CodeInspection Name="MissingAttributeInspection" Severity="Warning" InspectionType="RubberduckOpportunities" /> - <CodeInspection Name="FunctionReturnValueNotUsedInspection" Severity="Warning" InspectionType="CodeQualityIssues" /> - <CodeInspection Name="IllegalAnnotationInspection" Severity="Error" InspectionType="RubberduckOpportunities" /> - <CodeInspection Name="RedundantByRefModifierInspection" Severity="DoNotShow" InspectionType="CodeQualityIssues" /> - <CodeInspection Name="MissingAnnotationArgumentInspection" Severity="Error" InspectionType="CodeQualityIssues" /> - <CodeInspection Name="ModuleScopeDimKeywordInspection" Severity="Suggestion" InspectionType="LanguageOpportunities" /> - <CodeInspection Name="MultilineParameterInspection" Severity="Suggestion" InspectionType="MaintainabilityAndReadabilityIssues" /> - <CodeInspection Name="MultipleDeclarationsInspection" Severity="Warning" InspectionType="MaintainabilityAndReadabilityIssues" /> - <CodeInspection Name="ObsoleteCallStatementInspection" Severity="Suggestion" InspectionType="LanguageOpportunities" /> - <CodeInspection Name="ObsoleteCommentSyntaxInspection" Severity="Suggestion" InspectionType="LanguageOpportunities" /> - <CodeInspection Name="ObsoleteLetStatementInspection" Severity="Suggestion" InspectionType="LanguageOpportunities" /> - <CodeInspection Name="OptionBaseInspection" Severity="Hint" InspectionType="MaintainabilityAndReadabilityIssues" /> - <CodeInspection Name="RedundantOptionInspection" Severity="Hint" InspectionType="LanguageOpportunities" /> - <CodeInspection Name="OptionExplicitInspection" Severity="Error" InspectionType="CodeQualityIssues" /> - <CodeInspection Name="ProcedureCanBeWrittenAsFunctionInspection" Severity="Suggestion" InspectionType="LanguageOpportunities" /> - <CodeInspection Name="ApplicationWorksheetFunctionInspection" Severity="Suggestion" InspectionType="CodeQualityIssues" /> - <CodeInspection Name="AssignedByValParameterInspection" Severity="Warning" InspectionType="CodeQualityIssues" /> - <CodeInspection Name="EmptyModuleInspection" Severity="Hint" InspectionType="MaintainabilityAndReadabilityIssues" /> - <CodeInspection Name="LineLabelNotUsedInspection" Severity="Warning" InspectionType="CodeQualityIssues" /> - <CodeInspection Name="IntegerDataTypeInspection" Severity="Hint" InspectionType="CodeQualityIssues" /> - <CodeInspection Name="ShadowedDeclarationInspection" Severity="DoNotShow" InspectionType="CodeQualityIssues" /> - <CodeInspection Name="ConstantNotUsedInspection" Severity="Warning" InspectionType="CodeQualityIssues" /> - <CodeInspection Name="DefaultProjectNameInspection" Severity="Suggestion" InspectionType="MaintainabilityAndReadabilityIssues" /> - <CodeInspection Name="EmptyCaseBlockInspection" Severity="Warning" InspectionType="MaintainabilityAndReadabilityIssues" /> - <CodeInspection Name="EmptyDoWhileBlockInspection" Severity="Suggestion" InspectionType="MaintainabilityAndReadabilityIssues" /> - <CodeInspection Name="EmptyElseBlockInspection" Severity="Warning" InspectionType="MaintainabilityAndReadabilityIssues" /> - <CodeInspection Name="EmptyForEachBlockInspection" Severity="Warning" InspectionType="MaintainabilityAndReadabilityIssues" /> - <CodeInspection Name="EmptyForLoopBlockInspection" Severity="Warning" InspectionType="MaintainabilityAndReadabilityIssues" /> - <CodeInspection Name="EmptyIfBlockInspection" Severity="Warning" InspectionType="MaintainabilityAndReadabilityIssues" /> - <CodeInspection Name="EmptyWhileWendBlockInspection" Severity="Warning" InspectionType="MaintainabilityAndReadabilityIssues" /> - <CodeInspection Name="EncapsulatePublicFieldInspection" Severity="Suggestion" InspectionType="MaintainabilityAndReadabilityIssues" /> - <CodeInspection Name="HostSpecificExpressionInspection" Severity="Warning" InspectionType="LanguageOpportunities" /> - <CodeInspection Name="HungarianNotationInspection" Severity="Suggestion" InspectionType="MaintainabilityAndReadabilityIssues" /> - <CodeInspection Name="ImplicitActiveSheetReferenceInspection" Severity="Warning" InspectionType="LanguageOpportunities" /> - <CodeInspection Name="ImplicitActiveWorkbookReferenceInspection" Severity="Warning" InspectionType="LanguageOpportunities" /> - <CodeInspection Name="ImplicitDefaultMemberAssignmentInspection" Severity="Suggestion" InspectionType="LanguageOpportunities" /> - <CodeInspection Name="ImplicitPublicMemberInspection" Severity="Hint" InspectionType="LanguageOpportunities" /> - <CodeInspection Name="ImplicitVariantReturnTypeInspection" Severity="Hint" InspectionType="LanguageOpportunities" /> - <CodeInspection Name="MemberNotOnInterfaceInspection" Severity="Warning" InspectionType="CodeQualityIssues" /> - <CodeInspection Name="MoveFieldCloserToUsageInspection" Severity="Hint" InspectionType="MaintainabilityAndReadabilityIssues" /> - <CodeInspection Name="NonReturningFunctionInspection" Severity="Error" InspectionType="CodeQualityIssues" /> - <CodeInspection Name="ObjectVariableNotSetInspection" Severity="Error" InspectionType="CodeQualityIssues" /> - <CodeInspection Name="ObsoleteGlobalInspection" Severity="Suggestion" InspectionType="LanguageOpportunities" /> - <CodeInspection Name="ObsoleteTypeHintInspection" Severity="Suggestion" InspectionType="LanguageOpportunities" /> - <CodeInspection Name="ParameterCanBeByValInspection" Severity="Suggestion" InspectionType="MaintainabilityAndReadabilityIssues" /> - <CodeInspection Name="ParameterNotUsedInspection" Severity="Warning" InspectionType="CodeQualityIssues" /> - <CodeInspection Name="ProcedureNotUsedInspection" Severity="Warning" InspectionType="CodeQualityIssues" /> - <CodeInspection Name="SelfAssignedDeclarationInspection" Severity="Suggestion" InspectionType="CodeQualityIssues" /> - <CodeInspection Name="UnassignedVariableUsageInspection" Severity="Error" InspectionType="CodeQualityIssues" /> - <CodeInspection Name="UndeclaredVariableInspection" Severity="Error" InspectionType="CodeQualityIssues" /> - <CodeInspection Name="UntypedFunctionUsageInspection" Severity="Hint" InspectionType="LanguageOpportunities" /> - <CodeInspection Name="UseMeaningfulNameInspection" Severity="Suggestion" InspectionType="MaintainabilityAndReadabilityIssues" /> - <CodeInspection Name="VariableNotAssignedInspection" Severity="Warning" InspectionType="CodeQualityIssues" /> - <CodeInspection Name="VariableNotUsedInspection" Severity="Warning" InspectionType="CodeQualityIssues" /> - <CodeInspection Name="VariableTypeNotDeclaredInspection" Severity="Warning" InspectionType="LanguageOpportunities" /> - <CodeInspection Name="WriteOnlyPropertyInspection" Severity="Suggestion" InspectionType="CodeQualityIssues" /> - <CodeInspection Name="DefTypeStatementInspection" Severity="Suggestion" InspectionType="LanguageOpportunities" /> - <CodeInspection Name="StepIsNotSpecifiedInspection" Severity="DoNotShow" InspectionType="LanguageOpportunities" /> - <CodeInspection Name="StepOneIsRedundantInspection" Severity="Hint" InspectionType="LanguageOpportunities" /> - <CodeInspection Name="SheetAccessedUsingStringInspection" Severity="Suggestion" InspectionType="LanguageOpportunities" /> - <CodeInspection Name="ObsoleteMemberUsageInspection" Severity="Warning" InspectionType="MaintainabilityAndReadabilityIssues" /> - <CodeInspection Name="ObsoleteCallingConventionInspection" Severity="Warning" InspectionType="CodeQualityIssues" /> - <CodeInspection Name="DuplicatedAnnotationInspection" Severity="Error" InspectionType="RubberduckOpportunities" /> - <CodeInspection Name="ModuleWithoutFolderInspection" Severity="Suggestion" InspectionType="RubberduckOpportunities" /> - <CodeInspection Name="OnLocalErrorInspection" Severity="Suggestion" InspectionType="LanguageOpportunities" /> - <CodeInspection Name="IsMissingOnInappropriateArgumentInspection" Severity="Warning" InspectionType="CodeQualityIssues" /> - <CodeInspection Name="IsMissingWithNonArgumentParameterInspection" Severity="Warning" InspectionType="CodeQualityIssues" /> - <CodeInspection Name="AssignmentNotUsedInspection" Severity="Suggestion" InspectionType="CodeQualityIssues" /> - </CodeInspections> - <WhitelistedIdentifiers /> - <RunInspectionsOnSuccessfulParse>true</RunInspectionsOnSuccessfulParse> -</CodeInspectionSettings> + <CodeInspectionSettings xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> + <CodeInspections> + <CodeInspection Name="BooleanAssignedInIfElseInspection" Severity="Warning" InspectionType="MaintainabilityAndReadabilityIssues" /> + <CodeInspection Name="ObsoleteErrorSyntaxInspection" Severity="Suggestion" InspectionType="LanguageOpportunities" /> + <CodeInspection Name="StopKeywordInspection" Severity="Suggestion" InspectionType="CodeQualityIssues" /> + <CodeInspection Name="UnhandledOnErrorResumeNextInspection" Severity="Warning" InspectionType="CodeQualityIssues" /> + <CodeInspection Name="EmptyStringLiteralInspection" Severity="Warning" InspectionType="LanguageOpportunities" /> + <CodeInspection Name="ImplicitByRefModifierInspection" Severity="Hint" InspectionType="CodeQualityIssues" /> + <CodeInspection Name="MissingAttributeInspection" Severity="Warning" InspectionType="RubberduckOpportunities" /> + <CodeInspection Name="FunctionReturnValueNotUsedInspection" Severity="Warning" InspectionType="CodeQualityIssues" /> + <CodeInspection Name="IllegalAnnotationInspection" Severity="Error" InspectionType="RubberduckOpportunities" /> + <CodeInspection Name="RedundantByRefModifierInspection" Severity="DoNotShow" InspectionType="CodeQualityIssues" /> + <CodeInspection Name="MissingAnnotationArgumentInspection" Severity="Error" InspectionType="CodeQualityIssues" /> + <CodeInspection Name="ModuleScopeDimKeywordInspection" Severity="Suggestion" InspectionType="LanguageOpportunities" /> + <CodeInspection Name="MultilineParameterInspection" Severity="Suggestion" InspectionType="MaintainabilityAndReadabilityIssues" /> + <CodeInspection Name="MultipleDeclarationsInspection" Severity="Warning" InspectionType="MaintainabilityAndReadabilityIssues" /> + <CodeInspection Name="ObsoleteCallStatementInspection" Severity="Suggestion" InspectionType="LanguageOpportunities" /> + <CodeInspection Name="ObsoleteCommentSyntaxInspection" Severity="Suggestion" InspectionType="LanguageOpportunities" /> + <CodeInspection Name="ObsoleteLetStatementInspection" Severity="Suggestion" InspectionType="LanguageOpportunities" /> + <CodeInspection Name="OptionBaseInspection" Severity="Hint" InspectionType="MaintainabilityAndReadabilityIssues" /> + <CodeInspection Name="RedundantOptionInspection" Severity="Hint" InspectionType="LanguageOpportunities" /> + <CodeInspection Name="OptionExplicitInspection" Severity="Error" InspectionType="CodeQualityIssues" /> + <CodeInspection Name="ProcedureCanBeWrittenAsFunctionInspection" Severity="Suggestion" InspectionType="LanguageOpportunities" /> + <CodeInspection Name="ApplicationWorksheetFunctionInspection" Severity="Suggestion" InspectionType="CodeQualityIssues" /> + <CodeInspection Name="AssignedByValParameterInspection" Severity="Warning" InspectionType="CodeQualityIssues" /> + <CodeInspection Name="EmptyModuleInspection" Severity="Hint" InspectionType="MaintainabilityAndReadabilityIssues" /> + <CodeInspection Name="LineLabelNotUsedInspection" Severity="Warning" InspectionType="CodeQualityIssues" /> + <CodeInspection Name="IntegerDataTypeInspection" Severity="Hint" InspectionType="CodeQualityIssues" /> + <CodeInspection Name="ShadowedDeclarationInspection" Severity="DoNotShow" InspectionType="CodeQualityIssues" /> + <CodeInspection Name="ConstantNotUsedInspection" Severity="Warning" InspectionType="CodeQualityIssues" /> + <CodeInspection Name="DefaultProjectNameInspection" Severity="Suggestion" InspectionType="MaintainabilityAndReadabilityIssues" /> + <CodeInspection Name="EmptyCaseBlockInspection" Severity="Warning" InspectionType="MaintainabilityAndReadabilityIssues" /> + <CodeInspection Name="EmptyDoWhileBlockInspection" Severity="Suggestion" InspectionType="MaintainabilityAndReadabilityIssues" /> + <CodeInspection Name="EmptyElseBlockInspection" Severity="Warning" InspectionType="MaintainabilityAndReadabilityIssues" /> + <CodeInspection Name="EmptyForEachBlockInspection" Severity="Warning" InspectionType="MaintainabilityAndReadabilityIssues" /> + <CodeInspection Name="EmptyForLoopBlockInspection" Severity="Warning" InspectionType="MaintainabilityAndReadabilityIssues" /> + <CodeInspection Name="EmptyIfBlockInspection" Severity="Warning" InspectionType="MaintainabilityAndReadabilityIssues" /> + <CodeInspection Name="EmptyWhileWendBlockInspection" Severity="Warning" InspectionType="MaintainabilityAndReadabilityIssues" /> + <CodeInspection Name="EncapsulatePublicFieldInspection" Severity="Suggestion" InspectionType="MaintainabilityAndReadabilityIssues" /> + <CodeInspection Name="HostSpecificExpressionInspection" Severity="Warning" InspectionType="LanguageOpportunities" /> + <CodeInspection Name="HungarianNotationInspection" Severity="Suggestion" InspectionType="MaintainabilityAndReadabilityIssues" /> + <CodeInspection Name="ImplicitActiveSheetReferenceInspection" Severity="Warning" InspectionType="LanguageOpportunities" /> + <CodeInspection Name="ImplicitActiveWorkbookReferenceInspection" Severity="Warning" InspectionType="LanguageOpportunities" /> + <CodeInspection Name="ImplicitDefaultMemberAssignmentInspection" Severity="Suggestion" InspectionType="LanguageOpportunities" /> + <CodeInspection Name="ImplicitPublicMemberInspection" Severity="Hint" InspectionType="LanguageOpportunities" /> + <CodeInspection Name="ImplicitVariantReturnTypeInspection" Severity="Hint" InspectionType="LanguageOpportunities" /> + <CodeInspection Name="MemberNotOnInterfaceInspection" Severity="Warning" InspectionType="CodeQualityIssues" /> + <CodeInspection Name="MoveFieldCloserToUsageInspection" Severity="Hint" InspectionType="MaintainabilityAndReadabilityIssues" /> + <CodeInspection Name="NonReturningFunctionInspection" Severity="Error" InspectionType="CodeQualityIssues" /> + <CodeInspection Name="ObjectVariableNotSetInspection" Severity="Error" InspectionType="CodeQualityIssues" /> + <CodeInspection Name="ObsoleteGlobalInspection" Severity="Suggestion" InspectionType="LanguageOpportunities" /> + <CodeInspection Name="ObsoleteTypeHintInspection" Severity="Suggestion" InspectionType="LanguageOpportunities" /> + <CodeInspection Name="ParameterCanBeByValInspection" Severity="Suggestion" InspectionType="MaintainabilityAndReadabilityIssues" /> + <CodeInspection Name="ParameterNotUsedInspection" Severity="Warning" InspectionType="CodeQualityIssues" /> + <CodeInspection Name="ProcedureNotUsedInspection" Severity="Warning" InspectionType="CodeQualityIssues" /> + <CodeInspection Name="SelfAssignedDeclarationInspection" Severity="Suggestion" InspectionType="CodeQualityIssues" /> + <CodeInspection Name="UnassignedVariableUsageInspection" Severity="Error" InspectionType="CodeQualityIssues" /> + <CodeInspection Name="UndeclaredVariableInspection" Severity="Error" InspectionType="CodeQualityIssues" /> + <CodeInspection Name="UntypedFunctionUsageInspection" Severity="Hint" InspectionType="LanguageOpportunities" /> + <CodeInspection Name="UseMeaningfulNameInspection" Severity="Suggestion" InspectionType="MaintainabilityAndReadabilityIssues" /> + <CodeInspection Name="VariableNotAssignedInspection" Severity="Warning" InspectionType="CodeQualityIssues" /> + <CodeInspection Name="VariableNotUsedInspection" Severity="Warning" InspectionType="CodeQualityIssues" /> + <CodeInspection Name="VariableTypeNotDeclaredInspection" Severity="Warning" InspectionType="LanguageOpportunities" /> + <CodeInspection Name="WriteOnlyPropertyInspection" Severity="Suggestion" InspectionType="CodeQualityIssues" /> + <CodeInspection Name="DefTypeStatementInspection" Severity="Suggestion" InspectionType="LanguageOpportunities" /> + <CodeInspection Name="StepIsNotSpecifiedInspection" Severity="DoNotShow" InspectionType="LanguageOpportunities" /> + <CodeInspection Name="StepOneIsRedundantInspection" Severity="Hint" InspectionType="LanguageOpportunities" /> + <CodeInspection Name="SheetAccessedUsingStringInspection" Severity="Suggestion" InspectionType="LanguageOpportunities" /> + <CodeInspection Name="ObsoleteMemberUsageInspection" Severity="Warning" InspectionType="MaintainabilityAndReadabilityIssues" /> + <CodeInspection Name="ObsoleteCallingConventionInspection" Severity="Warning" InspectionType="CodeQualityIssues" /> + <CodeInspection Name="DuplicatedAnnotationInspection" Severity="Error" InspectionType="RubberduckOpportunities" /> + <CodeInspection Name="ModuleWithoutFolderInspection" Severity="Suggestion" InspectionType="RubberduckOpportunities" /> + <CodeInspection Name="OnLocalErrorInspection" Severity="Suggestion" InspectionType="LanguageOpportunities" /> + <CodeInspection Name="IsMissingOnInappropriateArgumentInspection" Severity="Warning" InspectionType="CodeQualityIssues" /> + <CodeInspection Name="IsMissingWithNonArgumentParameterInspection" Severity="Warning" InspectionType="CodeQualityIssues" /> + <CodeInspection Name="AssignmentNotUsedInspection" Severity="Suggestion" InspectionType="CodeQualityIssues" /> + <CodeInspection Name="ExcelUdfNameIsValidCellReferenceInspection" Severity="Warning" InspectionType="CodeQualityIssues" /> + </CodeInspections> + <WhitelistedIdentifiers /> + <RunInspectionsOnSuccessfulParse>true</RunInspectionsOnSuccessfulParse> + </CodeInspectionSettings> - <?xml version="1.0" encoding="utf-16"?> -<AutoCompleteSettings xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" IsEnabled="false"> - <SmartConcat> - <IsEnabled>false</IsEnabled> - <ConcatVbNewLineModifier>None</ConcatVbNewLineModifier> - </SmartConcat> - <SelfClosingPairs IsEnabled="false" /> - <BlockCompletion IsEnabled="false" CompleteOnEnter="false" CompleteOnTab="false" /> -</AutoCompleteSettings> + + <AutoCompleteSettings xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" IsEnabled="false"> + <SmartConcat> + <IsEnabled>false</IsEnabled> + <ConcatVbNewLineModifier>None</ConcatVbNewLineModifier> + </SmartConcat> + <SelfClosingPairs IsEnabled="false" /> + <BlockCompletion IsEnabled="false" CompleteOnEnter="false" CompleteOnTab="false" /> + </AutoCompleteSettings> + \ No newline at end of file diff --git a/Rubberduck.Core/Rubberduck.Core.csproj b/Rubberduck.Core/Rubberduck.Core.csproj index aa0e0bf1a2..987baa2cbf 100644 --- a/Rubberduck.Core/Rubberduck.Core.csproj +++ b/Rubberduck.Core/Rubberduck.Core.csproj @@ -108,27 +108,30 @@ Code %(Filename) - + + + Resources.resx true true - - Resources.Designer.cs - ResXFileCodeGenerator - - True True Settings.settings True + + SettingsSingleFileGenerator Settings.Designer.cs + + Resources.Designer.cs + ResXFileCodeGenerator + diff --git a/Rubberduck.Core/app.config b/Rubberduck.Core/app.config index 11c717c6c1..0df00ce776 100644 --- a/Rubberduck.Core/app.config +++ b/Rubberduck.Core/app.config @@ -386,6 +386,8 @@ Severity="Warning" InspectionType="CodeQualityIssues" /> + true From 0ded26bd5ba153a84d6cba515803881d33ae3e44 Mon Sep 17 00:00:00 2001 From: Max Doerner Date: Tue, 6 Nov 2018 00:46:11 +0100 Subject: [PATCH 27/59] Add tests for IRewriteSession implementations Contains extraction of a partial interface from the RubberduckParserState (IParseManager) in order to allow mocking the corresponding functionality. --- Rubberduck.Core/UI/Command/ReparseCommand.cs | 2 - .../Root/RubberduckIoCInstaller.cs | 2 +- .../Rewriter/AttributesRewriteSession.cs | 10 +- .../Rewriter/CodePaneRewriteSession.cs | 8 +- Rubberduck.Parsing/VBA/IParseManager.cs | 14 ++ .../VBA/RubberduckParserState.cs | 3 +- .../Rewriter/AttributesRewriteSessionTests.cs | 71 ++++++ .../Rewriter/CodePaneRewriteSessionTests.cs | 102 +++++++++ .../Rewriter/RewriteSessionTestBase.cs | 216 ++++++++++++++++++ 9 files changed, 414 insertions(+), 14 deletions(-) create mode 100644 Rubberduck.Parsing/VBA/IParseManager.cs create mode 100644 RubberduckTests/Rewriter/AttributesRewriteSessionTests.cs create mode 100644 RubberduckTests/Rewriter/CodePaneRewriteSessionTests.cs create mode 100644 RubberduckTests/Rewriter/RewriteSessionTestBase.cs diff --git a/Rubberduck.Core/UI/Command/ReparseCommand.cs b/Rubberduck.Core/UI/Command/ReparseCommand.cs index dc1244ecfe..fee6998e88 100644 --- a/Rubberduck.Core/UI/Command/ReparseCommand.cs +++ b/Rubberduck.Core/UI/Command/ReparseCommand.cs @@ -2,14 +2,12 @@ using System.Collections.Generic; using System.Linq; using System.Runtime.InteropServices; -using System.Windows.Forms; using NLog; using Rubberduck.Interaction; using Rubberduck.Parsing.VBA; using Rubberduck.Settings; using Rubberduck.SettingsProvider; using Rubberduck.Resources; -using Rubberduck.UI.CodeExplorer.Commands; using Rubberduck.VBEditor.ComManagement.TypeLibsAPI; using Rubberduck.VBEditor.SafeComWrappers; using Rubberduck.VBEditor.SafeComWrappers.Abstract; diff --git a/Rubberduck.Main/Root/RubberduckIoCInstaller.cs b/Rubberduck.Main/Root/RubberduckIoCInstaller.cs index b11031b66a..cf2b0905fa 100644 --- a/Rubberduck.Main/Root/RubberduckIoCInstaller.cs +++ b/Rubberduck.Main/Root/RubberduckIoCInstaller.cs @@ -93,7 +93,7 @@ public void Install(IWindsorContainer container, IConfigurationStore store) container.Register(Component.For() .ImplementedBy() .LifestyleSingleton()); - container.Register(Component.For() + container.Register(Component.For() .ImplementedBy() .LifestyleSingleton()); container.Register(Component.For() diff --git a/Rubberduck.Parsing/Rewriter/AttributesRewriteSession.cs b/Rubberduck.Parsing/Rewriter/AttributesRewriteSession.cs index de94ed5b72..8d84bfe427 100644 --- a/Rubberduck.Parsing/Rewriter/AttributesRewriteSession.cs +++ b/Rubberduck.Parsing/Rewriter/AttributesRewriteSession.cs @@ -6,24 +6,24 @@ namespace Rubberduck.Parsing.Rewriter { public class AttributesRewriteSession : RewriteSessionBase { - private readonly RubberduckParserState _state; + private readonly IParseManager _parseManager; - public AttributesRewriteSession(RubberduckParserState state, IRewriterProvider rewriterProvider, + public AttributesRewriteSession(IParseManager parseManager, IRewriterProvider rewriterProvider, Func rewritingAllowed) : base(rewriterProvider, rewritingAllowed) { - _state = state; + _parseManager = parseManager; } protected override IExecutableModuleRewriter ModuleRewriter(QualifiedModuleName module) { - return RewriterProvider.CodePaneModuleRewriter(module); + return RewriterProvider.AttributesModuleRewriter(module); } protected override void RewriteInternal() { //The suspension ensures that only one parse gets executed instead of two for each rewritten module. - var result = _state.OnSuspendParser(this, new[] {ParserState.Ready}, ExecuteAllRewriters); + var result = _parseManager.OnSuspendParser(this, new[] {ParserState.Ready}, ExecuteAllRewriters); if(result != SuspensionResult.Completed) { Logger.Warn($"Rewriting attribute modules did not succeed. suspension result = {result}"); diff --git a/Rubberduck.Parsing/Rewriter/CodePaneRewriteSession.cs b/Rubberduck.Parsing/Rewriter/CodePaneRewriteSession.cs index 4b731d7bc7..a76d6b91f9 100644 --- a/Rubberduck.Parsing/Rewriter/CodePaneRewriteSession.cs +++ b/Rubberduck.Parsing/Rewriter/CodePaneRewriteSession.cs @@ -6,13 +6,13 @@ namespace Rubberduck.Parsing.Rewriter { public class CodePaneRewriteSession : RewriteSessionBase { - private readonly RubberduckParserState _state; + private readonly IParseManager _parseManager; - public CodePaneRewriteSession(RubberduckParserState state, IRewriterProvider rewriterProvider, + public CodePaneRewriteSession(IParseManager parseManager, IRewriterProvider rewriterProvider, Func rewritingAllowed) : base(rewriterProvider, rewritingAllowed) { - _state = state; + _parseManager = parseManager; } @@ -27,7 +27,7 @@ protected override void RewriteInternal() { rewriter.Rewrite(); } - _state.OnParseRequested(this); + _parseManager.OnParseRequested(this); } } } \ No newline at end of file diff --git a/Rubberduck.Parsing/VBA/IParseManager.cs b/Rubberduck.Parsing/VBA/IParseManager.cs new file mode 100644 index 0000000000..fc9bda0947 --- /dev/null +++ b/Rubberduck.Parsing/VBA/IParseManager.cs @@ -0,0 +1,14 @@ +using System; +using System.Collections.Generic; + +namespace Rubberduck.Parsing.VBA +{ + public interface IParseManager + { + event EventHandler StateChanged; + event EventHandler ModuleStateChanged; + + void OnParseRequested(object requestor); + SuspensionResult OnSuspendParser(object requestor, IEnumerable allowedRunStates, Action busyAction, int millisecondsTimeout = -1); + } +} \ No newline at end of file diff --git a/Rubberduck.Parsing/VBA/RubberduckParserState.cs b/Rubberduck.Parsing/VBA/RubberduckParserState.cs index e4e6ad6c76..a72c870928 100644 --- a/Rubberduck.Parsing/VBA/RubberduckParserState.cs +++ b/Rubberduck.Parsing/VBA/RubberduckParserState.cs @@ -12,7 +12,6 @@ using Rubberduck.VBEditor; using Rubberduck.Parsing.Annotations; using NLog; -using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.VBA.Parsing; using Rubberduck.VBEditor.ComManagement; using Rubberduck.VBEditor.Events; @@ -120,7 +119,7 @@ public RubberduckStatusMessageEventArgs(string message) public string Message { get; } } - public sealed class RubberduckParserState : IDisposable, IDeclarationFinderProvider, IParseTreeProvider + public sealed class RubberduckParserState : IDisposable, IDeclarationFinderProvider, IParseTreeProvider, IParseManager { public const int NoTimeout = -1; diff --git a/RubberduckTests/Rewriter/AttributesRewriteSessionTests.cs b/RubberduckTests/Rewriter/AttributesRewriteSessionTests.cs new file mode 100644 index 0000000000..21ca2513f2 --- /dev/null +++ b/RubberduckTests/Rewriter/AttributesRewriteSessionTests.cs @@ -0,0 +1,71 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using Moq; +using NUnit.Framework; +using Rubberduck.Parsing.Rewriter; +using Rubberduck.Parsing.VBA; +using Rubberduck.Parsing.VBA.Parsing; +using Rubberduck.VBEditor; + +namespace RubberduckTests.Rewriter +{ + [TestFixture] + public class AttributesRewriteSessionTests : RewriteSessionTestBase + { + [Test] + [Category("Rewriter")] + public void UsesASuspendActionToRewrite() + { + var mockParseManager = new Mock(); + mockParseManager.Setup(m => m.OnSuspendParser(It.IsAny(), It.IsAny>(), It.IsAny(), It.IsAny())) + .Callback((object requestor, IEnumerable allowedStates, Action suspendAction, int timeout) => suspendAction()) + .Returns((object requestor, IEnumerable allowedStates, Action suspendAction, int timeout) => SuspensionResult.Completed); + + var rewriteSession = RewriteSession(mockParseManager.Object, session => true, out _); + var module = new QualifiedModuleName("TestProject", string.Empty, "TestModule"); + rewriteSession.CheckOutModuleRewriter(module); + + rewriteSession.Rewrite(); + + mockParseManager.Verify(m => m.OnSuspendParser(It.IsAny(), It.IsAny>(), It.IsAny(), It.IsAny()), Times.Once); + } + + [Test] + [Category("Rewriter")] + public void DoesNotCallRewriteOutsideTheSuspendAction() + { + var mockParseManager = new Mock(); + mockParseManager.Setup(m => m.OnSuspendParser(It.IsAny(), It.IsAny>(), It.IsAny(), It.IsAny())) + .Returns((object requestor, IEnumerable allowedStates, Action suspendAction, int timeout) => SuspensionResult.Completed); + + var rewriteSession = RewriteSession(mockParseManager.Object, session => true, out var mockRewriterProvider); + var module = new QualifiedModuleName("TestProject", string.Empty, "TestModule"); + rewriteSession.CheckOutModuleRewriter(module); + var (qmn, codeKind, mockRewriter) = mockRewriterProvider.RequestedRewriters().Single(); + + rewriteSession.Rewrite(); + + mockRewriter.Verify(m => m.Rewrite(), Times.Never); + } + + [Test] + [Category("Rewriter")] + public void ChecksOutAttributesRewriters() + { + var rewriteSession = RewriteSession(session => true, out var mockRewriterProvider); + var module = new QualifiedModuleName("TestProject", string.Empty, "TestModule"); + + rewriteSession.CheckOutModuleRewriter(module); + + var (qmn, codeKind, mockRewriter) = mockRewriterProvider.RequestedRewriters().Single(); + Assert.AreEqual(CodeKind.AttributesCode, codeKind); + } + + protected override IRewriteSession RewriteSession(IParseManager parseManager, Func rewritingAllowed, out MockRewriterProvider mockProvider) + { + mockProvider = new MockRewriterProvider(); + return new AttributesRewriteSession(parseManager, mockProvider, rewritingAllowed); + } + } +} \ No newline at end of file diff --git a/RubberduckTests/Rewriter/CodePaneRewriteSessionTests.cs b/RubberduckTests/Rewriter/CodePaneRewriteSessionTests.cs new file mode 100644 index 0000000000..efeb565a10 --- /dev/null +++ b/RubberduckTests/Rewriter/CodePaneRewriteSessionTests.cs @@ -0,0 +1,102 @@ +using System; +using System.Linq; +using Moq; +using NUnit.Framework; +using Rubberduck.Parsing.Rewriter; +using Rubberduck.Parsing.VBA; +using Rubberduck.Parsing.VBA.Parsing; +using Rubberduck.VBEditor; + +namespace RubberduckTests.Rewriter +{ + [TestFixture] + public class CodePaneRewriteSessionTests : RewriteSessionTestBase + { + [Test] + [Category("Rewriter")] + public void RequestsParseAfterRewriteIfNotInvalidatedAndParsingAllowed() + { + var mockParseManager = new Mock(); + mockParseManager.Setup(m => m.OnParseRequested(It.IsAny())); + + var rewriteSession = RewriteSession(mockParseManager.Object, session => true, out _); + var module = new QualifiedModuleName("TestProject", string.Empty, "TestModule"); + var otherModule = new QualifiedModuleName("TestProject", string.Empty, "OtherTestModule"); + rewriteSession.CheckOutModuleRewriter(module); + rewriteSession.CheckOutModuleRewriter(otherModule); + + rewriteSession.Rewrite(); + + mockParseManager.Verify(m => m.OnParseRequested(It.IsAny()), Times.Once); + } + + [Test] + [Category("Rewriter")] + public void DoesNotCallRequestsParseAfterRewriteIfInvalidated() + { + var mockParseManager = new Mock(); + mockParseManager.Setup(m => m.OnParseRequested(It.IsAny())); + + var rewriteSession = RewriteSession(mockParseManager.Object, session => true, out _); + var module = new QualifiedModuleName("TestProject", string.Empty, "TestModule"); + var otherModule = new QualifiedModuleName("TestProject", string.Empty, "OtherTestModule"); + rewriteSession.CheckOutModuleRewriter(module); + rewriteSession.Invalidate(); + rewriteSession.CheckOutModuleRewriter(otherModule); + + rewriteSession.Rewrite(); + + mockParseManager.Verify(m => m.OnParseRequested(It.IsAny()), Times.Never); + } + + [Test] + [Category("Rewriter")] + public void DoesNotRequestsParseAfterRewriteIfNotParsingAllowed() + { + var mockParseManager = new Mock(); + mockParseManager.Setup(m => m.OnParseRequested(It.IsAny())); + + var rewriteSession = RewriteSession(mockParseManager.Object, session => false, out _); + var module = new QualifiedModuleName("TestProject", string.Empty, "TestModule"); + var otherModule = new QualifiedModuleName("TestProject", string.Empty, "OtherTestModule"); + rewriteSession.CheckOutModuleRewriter(module); + rewriteSession.CheckOutModuleRewriter(otherModule); + + rewriteSession.Rewrite(); + + mockParseManager.Verify(m => m.OnParseRequested(It.IsAny()), Times.Never); + } + + [Test] + [Category("Rewriter")] + public void DoesNotRequestParseIfNoRewritersAreCheckedOut() + { + var mockParseManager = new Mock(); + mockParseManager.Setup(m => m.OnParseRequested(It.IsAny())); + var rewriteSession = RewriteSession(mockParseManager.Object, session => true, out _); + + rewriteSession.Rewrite(); + + mockParseManager.Verify(m => m.OnParseRequested(It.IsAny()), Times.Never); + } + + [Test] + [Category("Rewriter")] + public void ChecksOutCodePaneRewriters() + { + var rewriteSession = RewriteSession(session => true, out var mockRewriterProvider); + var module = new QualifiedModuleName("TestProject", string.Empty, "TestModule"); + + rewriteSession.CheckOutModuleRewriter(module); + + var (qmn, codeKind, mockRewriter) = mockRewriterProvider.RequestedRewriters().Single(); + Assert.AreEqual(CodeKind.CodePaneCode, codeKind); + } + + protected override IRewriteSession RewriteSession(IParseManager parseManager, Func rewritingAllowed, out MockRewriterProvider mockProvider) + { + mockProvider = new MockRewriterProvider(); + return new CodePaneRewriteSession(parseManager, mockProvider, rewritingAllowed); + } + } +} \ No newline at end of file diff --git a/RubberduckTests/Rewriter/RewriteSessionTestBase.cs b/RubberduckTests/Rewriter/RewriteSessionTestBase.cs new file mode 100644 index 0000000000..727814dc2d --- /dev/null +++ b/RubberduckTests/Rewriter/RewriteSessionTestBase.cs @@ -0,0 +1,216 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using Moq; +using NUnit.Framework; +using Rubberduck.Parsing.Rewriter; +using Rubberduck.Parsing.VBA; +using Rubberduck.Parsing.VBA.Parsing; +using Rubberduck.VBEditor; + +namespace RubberduckTests.Rewriter +{ + [TestFixture] + public abstract class RewriteSessionTestBase + { + [Test] + [Category("Rewriter")] + public void IsNotInvalidatedAtStart() + { + var rewriteSession = RewriteSession(session => true, out _); + Assert.IsFalse(rewriteSession.IsInvalidated); + } + + [Test] + [Category("Rewriter")] + public void IsInvalidatedAfterCallingInvalidate() + { + var rewriteSession = RewriteSession(session => true, out _); + rewriteSession.Invalidate(); + Assert.IsTrue(rewriteSession.IsInvalidated); + } + + [Test] + [Category("Rewriter")] + public void CallsRewritingAllowedOnRewriteIfNotInvalidatedAndRewritersHaveBeenCheckedOut() + { + var isCalled = false; + var rewriteSession = RewriteSession(session => + { + isCalled = true; + return true; + }, out _); + var module = new QualifiedModuleName("TestProject", string.Empty, "TestModule"); + rewriteSession.CheckOutModuleRewriter(module); + rewriteSession.Rewrite(); + Assert.IsTrue(isCalled); + } + + [Test] + [Category("Rewriter")] + public void DoesNotCallRewritingAllowedOnRewriteIfNoRewritersHaveBeenCheckedOut() + { + var isCalled = false; + var rewriteSession = RewriteSession(session => + { + isCalled = true; + return true; + }, out _); + rewriteSession.Rewrite(); + Assert.IsFalse(isCalled); + } + + [Test] + [Category("Rewriter")] + public void DoesNotCallRewritingAllowedOnRewriteIfInvalidated() + { + var isCalled = false; + var rewriteSession = RewriteSession(session => + { + isCalled = true; + return true; + }, out _); + var module = new QualifiedModuleName("TestProject", string.Empty, "TestModule"); + var otherModule = new QualifiedModuleName("TestProject", string.Empty, "OtherTestModule"); + rewriteSession.CheckOutModuleRewriter(module); + rewriteSession.Invalidate(); + rewriteSession.CheckOutModuleRewriter(otherModule); + + rewriteSession.Rewrite(); + Assert.IsFalse(isCalled); + } + + [Test] + [Category("Rewriter")] + public void CallsRewriteOnAllCheckedOutRewritersIfNotInvalidatedAndParsingAllowed() + { + var rewriteSession = RewriteSession(session => true, out var mockRewriterProvider); + var module = new QualifiedModuleName("TestProject", string.Empty,"TestModule"); + var otherModule = new QualifiedModuleName("TestProject", string.Empty, "OtherTestModule"); + rewriteSession.CheckOutModuleRewriter(module); + rewriteSession.CheckOutModuleRewriter(otherModule); + + var requestedRewriters = mockRewriterProvider.RequestedRewriters(); + + rewriteSession.Rewrite(); + + foreach (var (qmn, codeKind, mockRewriter) in requestedRewriters) + { + mockRewriter.Verify(m => m.Rewrite(), Times.Once); + } + } + + [Test] + [Category("Rewriter")] + public void DoesNotCallRewriteOnAnyCheckedOutRewriterIfInvalidated() + { + var rewriteSession = RewriteSession(session => true, out var mockRewriterProvider); + var module = new QualifiedModuleName("TestProject", string.Empty, "TestModule"); + var otherModule = new QualifiedModuleName("TestProject", string.Empty, "OtherTestModule"); + rewriteSession.CheckOutModuleRewriter(module); + rewriteSession.Invalidate(); + rewriteSession.CheckOutModuleRewriter(otherModule); + + var requestedRewriters = mockRewriterProvider.RequestedRewriters(); + + rewriteSession.Rewrite(); + + foreach (var (qmn, codeKind, mockRewriter) in requestedRewriters) + { + mockRewriter.Verify(m => m.Rewrite(), Times.Never); + } + } + + [Test] + [Category("Rewriter")] + public void DoesNotCallRewriteOnAnCheckedOutRewriterIfNotParsingAllowed() + { + var rewriteSession = RewriteSession(session => false, out var mockRewriterProvider); + var module = new QualifiedModuleName("TestProject", string.Empty, "TestModule"); + var otherModule = new QualifiedModuleName("TestProject", string.Empty, "OtherTestModule"); + rewriteSession.CheckOutModuleRewriter(module); + rewriteSession.CheckOutModuleRewriter(otherModule); + + var requestedRewriters = mockRewriterProvider.RequestedRewriters(); + + rewriteSession.Rewrite(); + + foreach (var (qmn, codeKind, mockRewriter) in requestedRewriters) + { + mockRewriter.Verify(m => m.Rewrite(), Times.Never); + } + } + + [Test] + [Category("Rewriter")] + public void ReturnsTheSameRewriterOnMultipleCheckoutsForTheSameModule() + { + var rewriteSession = RewriteSession(session => true, out _); + var module = new QualifiedModuleName("TestProject", string.Empty, "TestModule"); + var initialRewriter = rewriteSession.CheckOutModuleRewriter(module); + var nextRewriter = rewriteSession.CheckOutModuleRewriter(module); + + Assert.AreEqual(initialRewriter, nextRewriter); + } + + [Test] + [Category("Rewriter")] + public void CallsRewriteOnlyOnceForRewritersCheckedOutMultipleTimes() + { + var rewriteSession = RewriteSession(session => true, out var mockRewriterProvider); + var module = new QualifiedModuleName("TestProject", string.Empty, "TestModule"); + rewriteSession.CheckOutModuleRewriter(module); + rewriteSession.CheckOutModuleRewriter(module); + var (qmn, codeKind, mockRewriter) = mockRewriterProvider.RequestedRewriters().Single(); + + rewriteSession.Rewrite(); + + mockRewriter.Verify(m => m.Rewrite(), Times.Once); + } + + protected IRewriteSession RewriteSession(Func rewritingAllowed, + out MockRewriterProvider mockProvider) + { + var parseManager = new Mock(); + parseManager.Setup(m => m.OnSuspendParser(It.IsAny(), It.IsAny>(), It.IsAny(), It.IsAny())) + .Callback((object requestor, IEnumerable allowedStates, Action suspendAction, int timeout) => suspendAction()) + .Returns((object requestor, IEnumerable allowedStates, Action suspendAction, int timeout) => SuspensionResult.Completed); + return RewriteSession(parseManager.Object, rewritingAllowed, out mockProvider); + } + + protected abstract IRewriteSession RewriteSession(IParseManager parseManager, Func rewritingAllowed, out MockRewriterProvider mockProvider); + } + + + public class MockRewriterProvider: IRewriterProvider + { + private readonly List<(QualifiedModuleName module, CodeKind codeKind, Mock moduleRewriter)> _requestedRewriters = new List<(QualifiedModuleName module, CodeKind codeKind, Mock moduleRewriter)>(); + + public IExecutableModuleRewriter CodePaneModuleRewriter(QualifiedModuleName module) + { + var rewriter = CreateMockModuleRewriter(); + _requestedRewriters.Add((module, CodeKind.CodePaneCode, rewriter)); + return rewriter.Object; + } + + private static Mock CreateMockModuleRewriter() + { + var mock = new Mock(); + mock.Setup(m => m.Rewrite()); + + return mock; + } + + public IExecutableModuleRewriter AttributesModuleRewriter(QualifiedModuleName module) + { + var rewriter = CreateMockModuleRewriter(); + _requestedRewriters.Add((module, CodeKind.AttributesCode, rewriter)); + return rewriter.Object; + } + + public IEnumerable<(QualifiedModuleName module, CodeKind codeKind, Mock moduleRewriter)> RequestedRewriters() + { + return _requestedRewriters; + } + } +} \ No newline at end of file From 16a560769b71c981709c49fe9a5629ed35058cdd Mon Sep 17 00:00:00 2001 From: Max Doerner Date: Tue, 6 Nov 2018 22:11:08 +0100 Subject: [PATCH 28/59] Add tests for the RewritingManager Also makes the IRewriteSession expose the target code kind in order to make the RewritingManager testable. --- .../Rewriter/AttributesRewriteSession.cs | 3 + .../Rewriter/CodePaneRewriteSession.cs | 2 + .../Rewriter/IRewriteSession.cs | 4 +- .../Rewriter/RewriteSessionBase.cs | 2 + .../Rewriter/RewritingManager.cs | 11 +- .../Rewriter/AttributesRewriteSessionTests.cs | 11 +- .../Rewriter/CodePaneRewriteSessionTests.cs | 11 +- .../Rewriter/RewriteManagerTests.cs | 228 ++++++++++++++++++ .../Rewriter/RewriteSessionTestBase.cs | 14 ++ 9 files changed, 264 insertions(+), 22 deletions(-) create mode 100644 RubberduckTests/Rewriter/RewriteManagerTests.cs diff --git a/Rubberduck.Parsing/Rewriter/AttributesRewriteSession.cs b/Rubberduck.Parsing/Rewriter/AttributesRewriteSession.cs index 8d84bfe427..fb8000c4c8 100644 --- a/Rubberduck.Parsing/Rewriter/AttributesRewriteSession.cs +++ b/Rubberduck.Parsing/Rewriter/AttributesRewriteSession.cs @@ -1,5 +1,6 @@ using System; using Rubberduck.Parsing.VBA; +using Rubberduck.Parsing.VBA.Parsing; using Rubberduck.VBEditor; namespace Rubberduck.Parsing.Rewriter @@ -15,6 +16,8 @@ public AttributesRewriteSession(IParseManager parseManager, IRewriterProvider re _parseManager = parseManager; } + public override CodeKind TargetCodeKind => CodeKind.AttributesCode; + protected override IExecutableModuleRewriter ModuleRewriter(QualifiedModuleName module) { return RewriterProvider.AttributesModuleRewriter(module); diff --git a/Rubberduck.Parsing/Rewriter/CodePaneRewriteSession.cs b/Rubberduck.Parsing/Rewriter/CodePaneRewriteSession.cs index a76d6b91f9..78c3204297 100644 --- a/Rubberduck.Parsing/Rewriter/CodePaneRewriteSession.cs +++ b/Rubberduck.Parsing/Rewriter/CodePaneRewriteSession.cs @@ -1,5 +1,6 @@ using System; using Rubberduck.Parsing.VBA; +using Rubberduck.Parsing.VBA.Parsing; using Rubberduck.VBEditor; namespace Rubberduck.Parsing.Rewriter @@ -15,6 +16,7 @@ public CodePaneRewriteSession(IParseManager parseManager, IRewriterProvider rewr _parseManager = parseManager; } + public override CodeKind TargetCodeKind => CodeKind.CodePaneCode; protected override IExecutableModuleRewriter ModuleRewriter(QualifiedModuleName module) { diff --git a/Rubberduck.Parsing/Rewriter/IRewriteSession.cs b/Rubberduck.Parsing/Rewriter/IRewriteSession.cs index b4488592a4..6d20e3e366 100644 --- a/Rubberduck.Parsing/Rewriter/IRewriteSession.cs +++ b/Rubberduck.Parsing/Rewriter/IRewriteSession.cs @@ -1,4 +1,5 @@ -using Rubberduck.VBEditor; +using Rubberduck.Parsing.VBA.Parsing; +using Rubberduck.VBEditor; namespace Rubberduck.Parsing.Rewriter { @@ -8,5 +9,6 @@ public interface IRewriteSession void Rewrite(); bool IsInvalidated { get; } void Invalidate(); + CodeKind TargetCodeKind { get; } } } \ No newline at end of file diff --git a/Rubberduck.Parsing/Rewriter/RewriteSessionBase.cs b/Rubberduck.Parsing/Rewriter/RewriteSessionBase.cs index 9256d35c22..da2040c49f 100644 --- a/Rubberduck.Parsing/Rewriter/RewriteSessionBase.cs +++ b/Rubberduck.Parsing/Rewriter/RewriteSessionBase.cs @@ -2,6 +2,7 @@ using System.Collections.Generic; using System.Linq; using NLog; +using Rubberduck.Parsing.VBA.Parsing; using Rubberduck.VBEditor; namespace Rubberduck.Parsing.Rewriter @@ -16,6 +17,7 @@ public abstract class RewriteSessionBase : IRewriteSession protected readonly Logger Logger = LogManager.GetCurrentClassLogger(); private readonly object _invalidationLockObject = new object(); + public abstract CodeKind TargetCodeKind { get; } protected RewriteSessionBase(IRewriterProvider rewriterProvider, Func rewritingAllowed) { diff --git a/Rubberduck.Parsing/Rewriter/RewritingManager.cs b/Rubberduck.Parsing/Rewriter/RewritingManager.cs index 02b9a353e5..60af3da64e 100644 --- a/Rubberduck.Parsing/Rewriter/RewritingManager.cs +++ b/Rubberduck.Parsing/Rewriter/RewritingManager.cs @@ -1,5 +1,6 @@ using System; using System.Collections.Generic; +using Rubberduck.Parsing.VBA.Parsing; namespace Rubberduck.Parsing.Rewriter { @@ -56,12 +57,12 @@ private bool TryAllowExclusiveRewrite(IRewriteSession rewriteSession) private bool IsCurrentlyActive(IRewriteSession rewriteSession) { - switch (rewriteSession) + switch (rewriteSession.TargetCodeKind) { - case CodePaneRewriteSession codePaneSession: - return _activeCodePaneSessions.Contains(codePaneSession); - case AttributesRewriteSession attributeSession: - return _activeAttributesSessions.Contains(attributeSession); + case CodeKind.CodePaneCode: + return _activeCodePaneSessions.Contains(rewriteSession); + case CodeKind.AttributesCode: + return _activeAttributesSessions.Contains(rewriteSession); default: throw new NotSupportedException(nameof(rewriteSession)); } diff --git a/RubberduckTests/Rewriter/AttributesRewriteSessionTests.cs b/RubberduckTests/Rewriter/AttributesRewriteSessionTests.cs index 21ca2513f2..94e0c78cbe 100644 --- a/RubberduckTests/Rewriter/AttributesRewriteSessionTests.cs +++ b/RubberduckTests/Rewriter/AttributesRewriteSessionTests.cs @@ -51,15 +51,10 @@ public void DoesNotCallRewriteOutsideTheSuspendAction() [Test] [Category("Rewriter")] - public void ChecksOutAttributesRewriters() + public void TargetsAttributesCode() { - var rewriteSession = RewriteSession(session => true, out var mockRewriterProvider); - var module = new QualifiedModuleName("TestProject", string.Empty, "TestModule"); - - rewriteSession.CheckOutModuleRewriter(module); - - var (qmn, codeKind, mockRewriter) = mockRewriterProvider.RequestedRewriters().Single(); - Assert.AreEqual(CodeKind.AttributesCode, codeKind); + var rewriteSession = RewriteSession(session => true, out _); + Assert.AreEqual(CodeKind.AttributesCode, rewriteSession.TargetCodeKind); } protected override IRewriteSession RewriteSession(IParseManager parseManager, Func rewritingAllowed, out MockRewriterProvider mockProvider) diff --git a/RubberduckTests/Rewriter/CodePaneRewriteSessionTests.cs b/RubberduckTests/Rewriter/CodePaneRewriteSessionTests.cs index efeb565a10..ca2376a9b9 100644 --- a/RubberduckTests/Rewriter/CodePaneRewriteSessionTests.cs +++ b/RubberduckTests/Rewriter/CodePaneRewriteSessionTests.cs @@ -82,15 +82,10 @@ public void DoesNotRequestParseIfNoRewritersAreCheckedOut() [Test] [Category("Rewriter")] - public void ChecksOutCodePaneRewriters() + public void TargetsCodePaneCode() { - var rewriteSession = RewriteSession(session => true, out var mockRewriterProvider); - var module = new QualifiedModuleName("TestProject", string.Empty, "TestModule"); - - rewriteSession.CheckOutModuleRewriter(module); - - var (qmn, codeKind, mockRewriter) = mockRewriterProvider.RequestedRewriters().Single(); - Assert.AreEqual(CodeKind.CodePaneCode, codeKind); + var rewriteSession = RewriteSession(session => true, out _); + Assert.AreEqual(CodeKind.CodePaneCode, rewriteSession.TargetCodeKind); } protected override IRewriteSession RewriteSession(IParseManager parseManager, Func rewritingAllowed, out MockRewriterProvider mockProvider) diff --git a/RubberduckTests/Rewriter/RewriteManagerTests.cs b/RubberduckTests/Rewriter/RewriteManagerTests.cs new file mode 100644 index 0000000000..3de06d6c8e --- /dev/null +++ b/RubberduckTests/Rewriter/RewriteManagerTests.cs @@ -0,0 +1,228 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using Moq; +using NUnit.Framework; +using Rubberduck.Parsing.Rewriter; +using Rubberduck.Parsing.VBA.Parsing; + +namespace RubberduckTests.Rewriter +{ + [TestFixture] + public class RewriteManagerTests + { + [Test] + [Category("Rewriter")] + public void ReturnsValidCodePaneSessions() + { + var rewritingManager = RewritingManager(out _); + var codePaneSession = rewritingManager.CheckOutCodePaneSession(); + Assert.IsFalse(codePaneSession.IsInvalidated); + } + + + [Test] + [Category("Rewriter")] + public void ReturnsValidAttributesSessions() + { + var rewritingManager = RewritingManager(out _); + var attributesSession = rewritingManager.CheckOutAttributesSession(); + Assert.IsFalse(attributesSession.IsInvalidated); + } + + + [Test] + [Category("Rewriter")] + public void InvalidateAllSessionsCallsInvalidateOnAllActiveSessions() + { + var rewritingManager = RewritingManager(out var mockFactory); + rewritingManager.CheckOutCodePaneSession(); + rewritingManager.CheckOutAttributesSession(); + rewritingManager.CheckOutCodePaneSession(); + rewritingManager.CheckOutAttributesSession(); + + rewritingManager.InvalidateAllSessions(); + + foreach (var mockSession in mockFactory.RequestedCodePaneSessions().Concat(mockFactory.RequestedAttributesSessions())) + { + mockSession.Verify(m => m.Invalidate(), Times.Once); + } + } + + [Test] + [Category("Rewriter")] + public void CallingTheRewritingAllowedCallbackFromAnActiveCodePaneSessionCallsInvalidateOnAllActiveSessions() + { + var rewritingManager = RewritingManager(out var mockFactory); + var codePaneSession = rewritingManager.CheckOutCodePaneSession(); + rewritingManager.CheckOutAttributesSession(); + rewritingManager.CheckOutCodePaneSession(); + rewritingManager.CheckOutAttributesSession(); + + codePaneSession.Rewrite(); + + foreach (var mockSession in mockFactory.RequestedCodePaneSessions().Concat(mockFactory.RequestedAttributesSessions())) + { + mockSession.Verify(m => m.Invalidate(), Times.Once); + } + } + + [Test] + [Category("Rewriter")] + public void CallingTheRewritingAllowedCallbackFromAnActiveAttributesSessionCallsInvalidateOnAllActiveSessions() + { + var rewritingManager = RewritingManager(out var mockFactory); + rewritingManager.CheckOutCodePaneSession(); + var attributesSession = rewritingManager.CheckOutAttributesSession(); + rewritingManager.CheckOutCodePaneSession(); + rewritingManager.CheckOutAttributesSession(); + + attributesSession.Rewrite(); + + foreach (var mockSession in mockFactory.RequestedCodePaneSessions().Concat(mockFactory.RequestedAttributesSessions())) + { + mockSession.Verify(m => m.Invalidate(), Times.Once); + } + } + + [Test] + [Category("Rewriter")] + public void CallingTheRewritingAllowedCallbackFromANoLongerActiveCodePaneSessionDoesNotCallInvalidateOnAnyActiveSession_InactiveDueToRewrite() + { + var rewritingManager = RewritingManager(out var mockFactory); + var codePaneSession = rewritingManager.CheckOutCodePaneSession(); + var attributesSession = rewritingManager.CheckOutAttributesSession(); + + rewritingManager.InvalidateAllSessions(); + + rewritingManager.CheckOutCodePaneSession(); + rewritingManager.CheckOutAttributesSession(); + + codePaneSession.Rewrite(); + + foreach (var mockSession in mockFactory.RequestedCodePaneSessions() + .Concat(mockFactory.RequestedAttributesSessions()) + .Where(session => session.Object != codePaneSession && session.Object != attributesSession)) + { + mockSession.Verify(m => m.Invalidate(), Times.Never); + } + } + + [Test] + [Category("Rewriter")] + public void CallingTheRewritingAllowedCallbackFromANoLongerActiveAttributesSessionDoesNotCallInvalidateOnAnyActiveSession_InactiveDueToRewrite() + { + var rewritingManager = RewritingManager(out var mockFactory); + var codePaneSession = rewritingManager.CheckOutCodePaneSession(); + var attributesSession = rewritingManager.CheckOutAttributesSession(); + + rewritingManager.InvalidateAllSessions(); + + rewritingManager.CheckOutCodePaneSession(); + rewritingManager.CheckOutAttributesSession(); + + codePaneSession.Rewrite(); + + foreach (var mockSession in mockFactory.RequestedCodePaneSessions() + .Concat(mockFactory.RequestedAttributesSessions()) + .Where(session => session.Object != codePaneSession && session.Object != attributesSession)) + { + mockSession.Verify(m => m.Invalidate(), Times.Never); + } + } + + [Test] + [Category("Rewriter")] + public void CallingTheRewritingAllowedCallbackFromANoLongerActiveCodePaneSessionDoesNotCallInvalidateOnAnyActiveSession_InactiveDueToInvalidateAll() + { + var rewritingManager = RewritingManager(out var mockFactory); + var codePaneSession = rewritingManager.CheckOutCodePaneSession(); + var attributesSession = rewritingManager.CheckOutAttributesSession(); + + attributesSession.Rewrite(); + + rewritingManager.CheckOutCodePaneSession(); + rewritingManager.CheckOutAttributesSession(); + + codePaneSession.Rewrite(); + + foreach (var mockSession in mockFactory.RequestedCodePaneSessions() + .Concat(mockFactory.RequestedAttributesSessions()) + .Where(session => session.Object != codePaneSession && session.Object != attributesSession)) + { + mockSession.Verify(m => m.Invalidate(), Times.Never); + } + } + + [Test] + [Category("Rewriter")] + public void CallingTheRewritingAllowedCallbackFromANoLongerActiveAttributesSessionDoesNotCallInvalidateOnAnyActiveSession_InactiveDueToInvalidateAll() + { + var rewritingManager = RewritingManager(out var mockFactory); + var codePaneSession = rewritingManager.CheckOutCodePaneSession(); + var attributesSession = rewritingManager.CheckOutAttributesSession(); + + codePaneSession.Rewrite(); + + rewritingManager.CheckOutCodePaneSession(); + rewritingManager.CheckOutAttributesSession(); + + attributesSession.Rewrite(); + + foreach (var mockSession in mockFactory.RequestedCodePaneSessions() + .Concat(mockFactory.RequestedAttributesSessions()) + .Where( session => session.Object != codePaneSession && session.Object != attributesSession)) + { + mockSession.Verify(m => m.Invalidate(), Times.Never); + } + } + + private IRewritingManager RewritingManager(out MockRewriteSessionFactory mockFactory) + { + mockFactory = new MockRewriteSessionFactory(); + return new RewritingManager(mockFactory); + } + } + + public class MockRewriteSessionFactory : IRewriteSessionFactory + { + private readonly List> _requestedCodePaneSessions = new List>(); + private readonly List> _requestedAttributesSessions = new List>(); + + public IEnumerable> RequestedCodePaneSessions() + { + return _requestedCodePaneSessions; + } + + public IEnumerable> RequestedAttributesSessions() + { + return _requestedAttributesSessions; + } + + public IRewriteSession CodePaneSession(Func rewritingAllowed) + { + var mockSession = MockSession(rewritingAllowed, CodeKind.CodePaneCode); + _requestedCodePaneSessions.Add(mockSession); + return mockSession.Object; + } + + private Mock MockSession(Func rewritingAllowed, CodeKind targetCodeKind) + { + var mockSession = new Mock(); + mockSession.Setup(m => m.Rewrite()).Callback(() => rewritingAllowed.Invoke(mockSession.Object)); + var isInvalidated = false; + mockSession.Setup(m => m.IsInvalidated).Returns(() => isInvalidated); + mockSession.Setup(m => m.Invalidate()).Callback(() => isInvalidated = true); + mockSession.Setup(m => m.TargetCodeKind).Returns(targetCodeKind); + + return mockSession; + } + + public IRewriteSession AttributesSession(Func rewritingAllowed) + { + var mockSession = MockSession(rewritingAllowed, CodeKind.AttributesCode); + _requestedAttributesSessions.Add(mockSession); + return mockSession.Object; + } + } +} \ No newline at end of file diff --git a/RubberduckTests/Rewriter/RewriteSessionTestBase.cs b/RubberduckTests/Rewriter/RewriteSessionTestBase.cs index 727814dc2d..dcea529eff 100644 --- a/RubberduckTests/Rewriter/RewriteSessionTestBase.cs +++ b/RubberduckTests/Rewriter/RewriteSessionTestBase.cs @@ -168,6 +168,20 @@ public void CallsRewriteOnlyOnceForRewritersCheckedOutMultipleTimes() mockRewriter.Verify(m => m.Rewrite(), Times.Once); } + [Test] + [Category("Rewriter")] + public void ChecksOutRewritersForTheTargetCodeKind() + { + var rewriteSession = RewriteSession(session => true, out var mockRewriterProvider); + var module = new QualifiedModuleName("TestProject", string.Empty, "TestModule"); + + rewriteSession.CheckOutModuleRewriter(module); + + var expectedCodeKind = rewriteSession.TargetCodeKind; + var (qmn, actualCodeKind, mockRewriter) = mockRewriterProvider.RequestedRewriters().Single(); + Assert.AreEqual(expectedCodeKind, actualCodeKind); + } + protected IRewriteSession RewriteSession(Func rewritingAllowed, out MockRewriterProvider mockProvider) { From d73230d3c9777ca44b54463e4274546b731f7705 Mon Sep 17 00:00:00 2001 From: comintern Date: Tue, 6 Nov 2018 19:52:23 -0600 Subject: [PATCH 29/59] Use Sunburst SDK for build. --- Rubberduck.API/Rubberduck.API.csproj | 2 +- .../Rubberduck.CodeAnalysis.csproj | 2 +- .../Properties/Settings.Designer.cs | 7 +-- Rubberduck.Core/Rubberduck.Core.csproj | 53 +------------------ Rubberduck.Core/UI/About/AboutControl.xaml | 2 +- .../Rubberduck.Deployment.csproj | 2 +- .../Rubberduck.Interaction.csproj | 2 +- Rubberduck.Main/Rubberduck.Main.csproj | 2 +- Rubberduck.Parsing/Rubberduck.Parsing.csproj | 2 +- .../Rubberduck.Refactorings.csproj | 2 +- .../Rubberduck.RegexAssistant.csproj | 2 +- .../Rubberduck.Resources.csproj | 9 +--- .../Rubberduck.SettingsProvider.csproj | 2 +- .../Rubberduck.SmartIndenter.csproj | 2 +- .../Rubberduck.UnitTesting.csproj | 2 +- .../Rubberduck.VBEditor.csproj | 2 +- .../Rubberduck.VBEditor.VB6.csproj | 2 +- .../Rubberduck.VBEditor.VBA.csproj | 2 +- RubberduckBaseProject.csproj | 2 +- .../RubberduckCodeAnalysis.csproj | 2 +- RubberduckTests/RubberduckTests.csproj | 2 +- .../RubberduckTestsCodeAnalysis.csproj | 2 +- 22 files changed, 25 insertions(+), 82 deletions(-) diff --git a/Rubberduck.API/Rubberduck.API.csproj b/Rubberduck.API/Rubberduck.API.csproj index 2aad7d3e2f..1019700262 100644 --- a/Rubberduck.API/Rubberduck.API.csproj +++ b/Rubberduck.API/Rubberduck.API.csproj @@ -1,5 +1,5 @@  - + Rubberduck.API Rubberduck Reflection API diff --git a/Rubberduck.CodeAnalysis/Rubberduck.CodeAnalysis.csproj b/Rubberduck.CodeAnalysis/Rubberduck.CodeAnalysis.csproj index 710227885b..08f91a0755 100644 --- a/Rubberduck.CodeAnalysis/Rubberduck.CodeAnalysis.csproj +++ b/Rubberduck.CodeAnalysis/Rubberduck.CodeAnalysis.csproj @@ -1,5 +1,5 @@  - + Rubberduck.CodeAnalysis Assembly Containing the Code Analysis features exposed by Rubberduck diff --git a/Rubberduck.Core/Properties/Settings.Designer.cs b/Rubberduck.Core/Properties/Settings.Designer.cs index b91735e4f8..9c9c23a4ea 100644 --- a/Rubberduck.Core/Properties/Settings.Designer.cs +++ b/Rubberduck.Core/Properties/Settings.Designer.cs @@ -305,7 +305,8 @@ public static Settings Default { false false 10 - 6 + false + 0 ")] public global::Rubberduck.Settings.GeneralSettings GeneralSettings { @@ -464,7 +465,7 @@ public static Settings Default { public global::Rubberduck.Settings.AutoCompleteSettings AutoCompleteSettings { get { return ((global::Rubberduck.Settings.AutoCompleteSettings)(this["AutoCompleteSettings"])); - } -} + } + } } } diff --git a/Rubberduck.Core/Rubberduck.Core.csproj b/Rubberduck.Core/Rubberduck.Core.csproj index aa0e0bf1a2..46ea79c2e7 100644 --- a/Rubberduck.Core/Rubberduck.Core.csproj +++ b/Rubberduck.Core/Rubberduck.Core.csproj @@ -1,5 +1,5 @@  - + Rubberduck Rubberduck.Core @@ -81,55 +81,4 @@ 2.0.20525 - - - - - - - - - - $([System.String]::Copy('%(Filename)').Replace('.Designer', '')).cs - - - %(Filename).cs - - - - - - - - Designer - MSBuild:Compile - - - Code - %(Filename) - - - - Resources.resx - true - true - - - Resources.Designer.cs - ResXFileCodeGenerator - - - - True - True - Settings.settings - True - - - SettingsSingleFileGenerator - Settings.Designer.cs - - - - \ No newline at end of file diff --git a/Rubberduck.Core/UI/About/AboutControl.xaml b/Rubberduck.Core/UI/About/AboutControl.xaml index f420fff7a9..63996c942c 100644 --- a/Rubberduck.Core/UI/About/AboutControl.xaml +++ b/Rubberduck.Core/UI/About/AboutControl.xaml @@ -185,7 +185,7 @@ Brian Zenger Bruno Costa Carlos J. Quintero (MZ-Tools) Clemens Lieb -@Comintern +@Comintern, esq. Christopher McClellan @daFreeMan @Duga SE chat bot diff --git a/Rubberduck.Deployment/Rubberduck.Deployment.csproj b/Rubberduck.Deployment/Rubberduck.Deployment.csproj index a10dbe493d..7d93535d35 100644 --- a/Rubberduck.Deployment/Rubberduck.Deployment.csproj +++ b/Rubberduck.Deployment/Rubberduck.Deployment.csproj @@ -1,5 +1,5 @@  - + Rubberduck.Deployment Copyright © 2018 diff --git a/Rubberduck.Interaction/Rubberduck.Interaction.csproj b/Rubberduck.Interaction/Rubberduck.Interaction.csproj index 2b09548001..ca639854aa 100644 --- a/Rubberduck.Interaction/Rubberduck.Interaction.csproj +++ b/Rubberduck.Interaction/Rubberduck.Interaction.csproj @@ -1,5 +1,5 @@  - + Copyright © 2018 Rubberduck.Interaction diff --git a/Rubberduck.Main/Rubberduck.Main.csproj b/Rubberduck.Main/Rubberduck.Main.csproj index 0d8eb19ecf..80d1356f85 100644 --- a/Rubberduck.Main/Rubberduck.Main.csproj +++ b/Rubberduck.Main/Rubberduck.Main.csproj @@ -1,5 +1,5 @@  - + Rubberduck Rubberduck diff --git a/Rubberduck.Parsing/Rubberduck.Parsing.csproj b/Rubberduck.Parsing/Rubberduck.Parsing.csproj index 39112bf542..fff21b23a8 100644 --- a/Rubberduck.Parsing/Rubberduck.Parsing.csproj +++ b/Rubberduck.Parsing/Rubberduck.Parsing.csproj @@ -1,5 +1,5 @@  - + Rubberduck.Parsing Rubberduck.Parsing diff --git a/Rubberduck.Refactorings/Rubberduck.Refactorings.csproj b/Rubberduck.Refactorings/Rubberduck.Refactorings.csproj index 88660ec695..3010a01373 100644 --- a/Rubberduck.Refactorings/Rubberduck.Refactorings.csproj +++ b/Rubberduck.Refactorings/Rubberduck.Refactorings.csproj @@ -1,5 +1,5 @@  - + {D4B6A510-14E1-420A-A8D5-6A09890FD7D8} Rubberduck.Refactorings diff --git a/Rubberduck.RegexAssistant/Rubberduck.RegexAssistant.csproj b/Rubberduck.RegexAssistant/Rubberduck.RegexAssistant.csproj index d9a1436d37..5ebd3b9d27 100644 --- a/Rubberduck.RegexAssistant/Rubberduck.RegexAssistant.csproj +++ b/Rubberduck.RegexAssistant/Rubberduck.RegexAssistant.csproj @@ -1,5 +1,5 @@  - + Rubberduck.RegexAssistant Rubberduck.RegexAssistant diff --git a/Rubberduck.Resources/Rubberduck.Resources.csproj b/Rubberduck.Resources/Rubberduck.Resources.csproj index 88e5eb41a0..4e624ac7ca 100644 --- a/Rubberduck.Resources/Rubberduck.Resources.csproj +++ b/Rubberduck.Resources/Rubberduck.Resources.csproj @@ -1,5 +1,5 @@  - + Rubberduck.Resources Rubberduck.Resources @@ -12,12 +12,5 @@ - - PublicResXFileCodeGenerator - $([System.String]::Copy('%(FileName)')).Designer.cs - - - $([System.String]::Copy('%(Filename)').Replace('.Designer', '')).resx - \ No newline at end of file diff --git a/Rubberduck.SettingsProvider/Rubberduck.SettingsProvider.csproj b/Rubberduck.SettingsProvider/Rubberduck.SettingsProvider.csproj index e9d2c6a45f..e47f248f5b 100644 --- a/Rubberduck.SettingsProvider/Rubberduck.SettingsProvider.csproj +++ b/Rubberduck.SettingsProvider/Rubberduck.SettingsProvider.csproj @@ -1,5 +1,5 @@  - + Rubberduck.SettingsProvider Rubberduck.SettingsProvider diff --git a/Rubberduck.SmartIndenter/Rubberduck.SmartIndenter.csproj b/Rubberduck.SmartIndenter/Rubberduck.SmartIndenter.csproj index 60b66a4d56..199499db54 100644 --- a/Rubberduck.SmartIndenter/Rubberduck.SmartIndenter.csproj +++ b/Rubberduck.SmartIndenter/Rubberduck.SmartIndenter.csproj @@ -1,5 +1,5 @@  - + Rubberduck.SmartIndenter Rubberduck.SmartIndenter diff --git a/Rubberduck.UnitTesting/Rubberduck.UnitTesting.csproj b/Rubberduck.UnitTesting/Rubberduck.UnitTesting.csproj index 7b7487682e..1c2d602c06 100644 --- a/Rubberduck.UnitTesting/Rubberduck.UnitTesting.csproj +++ b/Rubberduck.UnitTesting/Rubberduck.UnitTesting.csproj @@ -1,5 +1,5 @@  - + Rubberduck.UnitTesting Rubberduck.UnitTesting diff --git a/Rubberduck.VBEEditor/Rubberduck.VBEditor.csproj b/Rubberduck.VBEEditor/Rubberduck.VBEditor.csproj index 0c61c2dbd3..4b83744329 100644 --- a/Rubberduck.VBEEditor/Rubberduck.VBEditor.csproj +++ b/Rubberduck.VBEEditor/Rubberduck.VBEditor.csproj @@ -1,5 +1,5 @@  - + Rubberduck.VBEditor Rubberduck.VBEditor diff --git a/Rubberduck.VBEditor.VB6/Rubberduck.VBEditor.VB6.csproj b/Rubberduck.VBEditor.VB6/Rubberduck.VBEditor.VB6.csproj index 9b371d17e1..b677268cc7 100644 --- a/Rubberduck.VBEditor.VB6/Rubberduck.VBEditor.VB6.csproj +++ b/Rubberduck.VBEditor.VB6/Rubberduck.VBEditor.VB6.csproj @@ -1,5 +1,5 @@  - + Rubberduck.VBEditor.VB6 Rubberduck.VBEditor.VB6 diff --git a/Rubberduck.VBEditor.VBA/Rubberduck.VBEditor.VBA.csproj b/Rubberduck.VBEditor.VBA/Rubberduck.VBEditor.VBA.csproj index b73cfd5a9e..ba9cd1de44 100644 --- a/Rubberduck.VBEditor.VBA/Rubberduck.VBEditor.VBA.csproj +++ b/Rubberduck.VBEditor.VBA/Rubberduck.VBEditor.VBA.csproj @@ -1,5 +1,5 @@  - + Rubberduck.VBEditor.VBA Rubberduck.VBEditor.VBA diff --git a/RubberduckBaseProject.csproj b/RubberduckBaseProject.csproj index 6d8f658ad9..aae613ee2a 100644 --- a/RubberduckBaseProject.csproj +++ b/RubberduckBaseProject.csproj @@ -1,4 +1,4 @@ - + Library diff --git a/RubberduckCodeAnalysis/RubberduckCodeAnalysis.csproj b/RubberduckCodeAnalysis/RubberduckCodeAnalysis.csproj index 067eb14cc7..e2e561062d 100644 --- a/RubberduckCodeAnalysis/RubberduckCodeAnalysis.csproj +++ b/RubberduckCodeAnalysis/RubberduckCodeAnalysis.csproj @@ -1,5 +1,5 @@  - + Rubberduck Code Analysis Internal Analyzer to enforce standards for Rubberduck solution's codebase diff --git a/RubberduckTests/RubberduckTests.csproj b/RubberduckTests/RubberduckTests.csproj index abd512bf3c..5ba260dd6a 100644 --- a/RubberduckTests/RubberduckTests.csproj +++ b/RubberduckTests/RubberduckTests.csproj @@ -1,5 +1,5 @@  - + RubberduckTests RubberduckTests diff --git a/RubberduckTestsCodeAnalysis/RubberduckTestsCodeAnalysis.csproj b/RubberduckTestsCodeAnalysis/RubberduckTestsCodeAnalysis.csproj index 0b465f1979..cc977e60cb 100644 --- a/RubberduckTestsCodeAnalysis/RubberduckTestsCodeAnalysis.csproj +++ b/RubberduckTestsCodeAnalysis/RubberduckTestsCodeAnalysis.csproj @@ -1,5 +1,5 @@  - + RubberduckTestsCodeAnalysis RubberduckTestsCodeAnalysis From f3f990f9218ad05be45616aca862c410ecd4cfe9 Mon Sep 17 00:00:00 2001 From: comintern Date: Tue, 6 Nov 2018 19:55:45 -0600 Subject: [PATCH 30/59] Forgot to disbar comintern. --- Rubberduck.Core/UI/About/AboutControl.xaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Rubberduck.Core/UI/About/AboutControl.xaml b/Rubberduck.Core/UI/About/AboutControl.xaml index 63996c942c..f420fff7a9 100644 --- a/Rubberduck.Core/UI/About/AboutControl.xaml +++ b/Rubberduck.Core/UI/About/AboutControl.xaml @@ -185,7 +185,7 @@ Brian Zenger Bruno Costa Carlos J. Quintero (MZ-Tools) Clemens Lieb -@Comintern, esq. +@Comintern Christopher McClellan @daFreeMan @Duga SE chat bot From 09ac9cbcfae4e98f8e0f0ac41e26d3acaf12f9b7 Mon Sep 17 00:00:00 2001 From: comintern Date: Tue, 6 Nov 2018 20:38:06 -0600 Subject: [PATCH 31/59] Remove extra whitespace. --- Rubberduck.Resources/Rubberduck.Resources.csproj | 1 - 1 file changed, 1 deletion(-) diff --git a/Rubberduck.Resources/Rubberduck.Resources.csproj b/Rubberduck.Resources/Rubberduck.Resources.csproj index 4e624ac7ca..1881eb1be9 100644 --- a/Rubberduck.Resources/Rubberduck.Resources.csproj +++ b/Rubberduck.Resources/Rubberduck.Resources.csproj @@ -7,7 +7,6 @@ {1B84B387-F7C4-4876-9BDF-C644C365359A} - From 4494b8d431af3379fa8eefb6394166925d49494f Mon Sep 17 00:00:00 2001 From: Max Doerner Date: Wed, 7 Nov 2018 23:00:59 +0100 Subject: [PATCH 32/59] Change Rewrite to TryRewrite This change on the IRewriteSession allows the user to see whether the rewrite actually happened successfully. --- .../QuickFixes/QuickFixProvider.cs | 10 +-- .../Rewriter/AttributesRewriteSession.cs | 5 +- .../Rewriter/CodePaneRewriteSession.cs | 4 +- .../Rewriter/IRewriteSession.cs | 2 +- .../Rewriter/RewriteSessionBase.cs | 14 ++-- .../EncapsulateFieldRefactoring.cs | 2 +- .../ExtractInterfaceRefactoring.cs | 2 +- .../ImplementInterfaceRefactoring.cs | 2 +- .../IntroduceFieldRefactoring.cs | 2 +- .../IntroduceParameterRefactoring.cs | 2 +- .../MoveCloserToUsageRefactoring.cs | 2 +- .../RemoveParametersRefactoring.cs | 2 +- .../Rename/RenameRefactoring.cs | 2 +- .../ReorderParametersRefactoring.cs | 2 +- .../PostProcessing/ModuleRewriterTests.cs | 2 +- .../Rewriter/AttributesRewriteSessionTests.cs | 36 +++++++++- .../Rewriter/CodePaneRewriteSessionTests.cs | 19 +++-- .../Rewriter/RewriteManagerTests.cs | 18 ++--- .../Rewriter/RewriteSessionTestBase.cs | 72 +++++++++++++------ 19 files changed, 140 insertions(+), 60 deletions(-) diff --git a/Rubberduck.CodeAnalysis/QuickFixes/QuickFixProvider.cs b/Rubberduck.CodeAnalysis/QuickFixes/QuickFixProvider.cs index 8f9bd99fee..4429adf703 100644 --- 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 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 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 results) @@ -181,7 +181,7 @@ public void FixAll(IQuickFix fix, Type inspectionType, IEnumerable references, Declaration method, IRewriteSession rewriteSession) diff --git a/Rubberduck.Refactorings/Rename/RenameRefactoring.cs b/Rubberduck.Refactorings/Rename/RenameRefactoring.cs index 241d556dd5..0abb562820 100644 --- 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 index d97435338d..1f5bfaf4dc 100644 --- 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 index f5bfb3b672..2b3eeb9fac 100644 --- 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 index 94e0c78cbe..2677956788 100644 --- 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(), It.IsAny>(), It.IsAny(), It.IsAny()), 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(); + parseManager.Setup(m => m.OnSuspendParser(It.IsAny(), It.IsAny>(), It.IsAny(), It.IsAny())) + .Callback((object requestor, IEnumerable allowedStates, Action suspendAction, int timeout) => suspendAction()) + .Returns((object requestor, IEnumerable 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(); + parseManager.Setup(m => m.OnSuspendParser(It.IsAny(), It.IsAny>(), It.IsAny(), It.IsAny())) + .Callback((object requestor, IEnumerable allowedStates, Action suspendAction, int timeout) => suspendAction()) + .Returns((object requestor, IEnumerable 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 index ca2376a9b9..a9bcab5304 100644 --- 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()), 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()), 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()), Times.Never); } @@ -75,11 +75,22 @@ public void DoesNotRequestParseIfNoRewritersAreCheckedOut() mockParseManager.Setup(m => m.OnParseRequested(It.IsAny())); var rewriteSession = RewriteSession(mockParseManager.Object, session => true, out _); - rewriteSession.Rewrite(); + rewriteSession.TryRewrite(); mockParseManager.Verify(m => m.OnParseRequested(It.IsAny()), 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 index 3de06d6c8e..08954f817a 100644 --- a/RubberduckTests/Rewriter/RewriteManagerTests.cs +++ b/RubberduckTests/Rewriter/RewriteManagerTests.cs @@ -59,7 +59,7 @@ public void CallingTheRewritingAllowedCallbackFromAnActiveCodePaneSessionCallsIn rewritingManager.CheckOutCodePaneSession(); rewritingManager.CheckOutAttributesSession(); - codePaneSession.Rewrite(); + codePaneSession.TryRewrite(); foreach (var mockSession in mockFactory.RequestedCodePaneSessions().Concat(mockFactory.RequestedAttributesSessions())) { @@ -77,7 +77,7 @@ public void CallingTheRewritingAllowedCallbackFromAnActiveAttributesSessionCalls rewritingManager.CheckOutCodePaneSession(); rewritingManager.CheckOutAttributesSession(); - attributesSession.Rewrite(); + attributesSession.TryRewrite(); foreach (var mockSession in mockFactory.RequestedCodePaneSessions().Concat(mockFactory.RequestedAttributesSessions())) { @@ -98,7 +98,7 @@ public void CallingTheRewritingAllowedCallbackFromANoLongerActiveCodePaneSession rewritingManager.CheckOutCodePaneSession(); rewritingManager.CheckOutAttributesSession(); - codePaneSession.Rewrite(); + codePaneSession.TryRewrite(); foreach (var mockSession in mockFactory.RequestedCodePaneSessions() .Concat(mockFactory.RequestedAttributesSessions()) @@ -121,7 +121,7 @@ public void CallingTheRewritingAllowedCallbackFromANoLongerActiveAttributesSessi rewritingManager.CheckOutCodePaneSession(); rewritingManager.CheckOutAttributesSession(); - codePaneSession.Rewrite(); + codePaneSession.TryRewrite(); foreach (var mockSession in mockFactory.RequestedCodePaneSessions() .Concat(mockFactory.RequestedAttributesSessions()) @@ -139,12 +139,12 @@ public void CallingTheRewritingAllowedCallbackFromANoLongerActiveCodePaneSession var codePaneSession = rewritingManager.CheckOutCodePaneSession(); var attributesSession = rewritingManager.CheckOutAttributesSession(); - attributesSession.Rewrite(); + attributesSession.TryRewrite(); rewritingManager.CheckOutCodePaneSession(); rewritingManager.CheckOutAttributesSession(); - codePaneSession.Rewrite(); + codePaneSession.TryRewrite(); foreach (var mockSession in mockFactory.RequestedCodePaneSessions() .Concat(mockFactory.RequestedAttributesSessions()) @@ -162,12 +162,12 @@ public void CallingTheRewritingAllowedCallbackFromANoLongerActiveAttributesSessi var codePaneSession = rewritingManager.CheckOutCodePaneSession(); var attributesSession = rewritingManager.CheckOutAttributesSession(); - codePaneSession.Rewrite(); + codePaneSession.TryRewrite(); rewritingManager.CheckOutCodePaneSession(); rewritingManager.CheckOutAttributesSession(); - attributesSession.Rewrite(); + attributesSession.TryRewrite(); foreach (var mockSession in mockFactory.RequestedCodePaneSessions() .Concat(mockFactory.RequestedAttributesSessions()) @@ -209,7 +209,7 @@ public IRewriteSession CodePaneSession(Func rewritingAllo private Mock MockSession(Func rewritingAllowed, CodeKind targetCodeKind) { var mockSession = new Mock(); - mockSession.Setup(m => m.Rewrite()).Callback(() => rewritingAllowed.Invoke(mockSession.Object)); + mockSession.Setup(m => m.TryRewrite()).Callback(() => rewritingAllowed.Invoke(mockSession.Object)); var isInvalidated = false; mockSession.Setup(m => m.IsInvalidated).Returns(() => isInvalidated); mockSession.Setup(m => m.Invalidate()).Callback(() => isInvalidated = true); diff --git a/RubberduckTests/Rewriter/RewriteSessionTestBase.cs b/RubberduckTests/Rewriter/RewriteSessionTestBase.cs index dcea529eff..5a38100261 100644 --- a/RubberduckTests/Rewriter/RewriteSessionTestBase.cs +++ b/RubberduckTests/Rewriter/RewriteSessionTestBase.cs @@ -30,6 +30,29 @@ public void IsInvalidatedAfterCallingInvalidate() Assert.IsTrue(rewriteSession.IsInvalidated); } + [Test] + [Category("Rewriter")] + public void DoesNotCallRewritingAllowedOnRewriteIfNoRewritersHaveBeenCheckedOut() + { + var isCalled = false; + var rewriteSession = RewriteSession(session => + { + isCalled = true; + return true; + }, out _); + rewriteSession.TryRewrite(); + Assert.IsFalse(isCalled); + } + + [Test] + [Category("Rewriter")] + public void TryRewriteReturnsFalseIfNoRewritersHaveBeenCheckedOut() + { + var rewriteSession = RewriteSession(session => true, out _); + var actual = rewriteSession.TryRewrite(); + Assert.IsFalse(actual); + } + [Test] [Category("Rewriter")] public void CallsRewritingAllowedOnRewriteIfNotInvalidatedAndRewritersHaveBeenCheckedOut() @@ -42,24 +65,10 @@ public void CallsRewritingAllowedOnRewriteIfNotInvalidatedAndRewritersHaveBeenCh }, out _); var module = new QualifiedModuleName("TestProject", string.Empty, "TestModule"); rewriteSession.CheckOutModuleRewriter(module); - rewriteSession.Rewrite(); + rewriteSession.TryRewrite(); Assert.IsTrue(isCalled); } - [Test] - [Category("Rewriter")] - public void DoesNotCallRewritingAllowedOnRewriteIfNoRewritersHaveBeenCheckedOut() - { - var isCalled = false; - var rewriteSession = RewriteSession(session => - { - isCalled = true; - return true; - }, out _); - rewriteSession.Rewrite(); - Assert.IsFalse(isCalled); - } - [Test] [Category("Rewriter")] public void DoesNotCallRewritingAllowedOnRewriteIfInvalidated() @@ -76,7 +85,7 @@ public void DoesNotCallRewritingAllowedOnRewriteIfInvalidated() rewriteSession.Invalidate(); rewriteSession.CheckOutModuleRewriter(otherModule); - rewriteSession.Rewrite(); + rewriteSession.TryRewrite(); Assert.IsFalse(isCalled); } @@ -92,7 +101,7 @@ public void CallsRewriteOnAllCheckedOutRewritersIfNotInvalidatedAndParsingAllowe var requestedRewriters = mockRewriterProvider.RequestedRewriters(); - rewriteSession.Rewrite(); + rewriteSession.TryRewrite(); foreach (var (qmn, codeKind, mockRewriter) in requestedRewriters) { @@ -100,6 +109,18 @@ public void CallsRewriteOnAllCheckedOutRewritersIfNotInvalidatedAndParsingAllowe } } + [Test] + [Category("Rewriter")] + public void TryRewriteReturnsFalseIfInvalidated() + { + var rewriteSession = RewriteSession(session => true, out _); + var module = new QualifiedModuleName("TestProject", string.Empty, "TestModule"); + rewriteSession.CheckOutModuleRewriter(module); + rewriteSession.Invalidate(); + var actual = rewriteSession.TryRewrite(); + Assert.IsFalse(actual); + } + [Test] [Category("Rewriter")] public void DoesNotCallRewriteOnAnyCheckedOutRewriterIfInvalidated() @@ -113,7 +134,7 @@ public void DoesNotCallRewriteOnAnyCheckedOutRewriterIfInvalidated() var requestedRewriters = mockRewriterProvider.RequestedRewriters(); - rewriteSession.Rewrite(); + rewriteSession.TryRewrite(); foreach (var (qmn, codeKind, mockRewriter) in requestedRewriters) { @@ -121,6 +142,17 @@ public void DoesNotCallRewriteOnAnyCheckedOutRewriterIfInvalidated() } } + [Test] + [Category("Rewriter")] + public void TryRewriteReturnsFalseIfNotParsingAllowed() + { + var rewriteSession = RewriteSession(session => false, out _); + var module = new QualifiedModuleName("TestProject", string.Empty, "TestModule"); + rewriteSession.CheckOutModuleRewriter(module); + var actual = rewriteSession.TryRewrite(); + Assert.IsFalse(actual); + } + [Test] [Category("Rewriter")] public void DoesNotCallRewriteOnAnCheckedOutRewriterIfNotParsingAllowed() @@ -133,7 +165,7 @@ public void DoesNotCallRewriteOnAnCheckedOutRewriterIfNotParsingAllowed() var requestedRewriters = mockRewriterProvider.RequestedRewriters(); - rewriteSession.Rewrite(); + rewriteSession.TryRewrite(); foreach (var (qmn, codeKind, mockRewriter) in requestedRewriters) { @@ -163,7 +195,7 @@ public void CallsRewriteOnlyOnceForRewritersCheckedOutMultipleTimes() rewriteSession.CheckOutModuleRewriter(module); var (qmn, codeKind, mockRewriter) = mockRewriterProvider.RequestedRewriters().Single(); - rewriteSession.Rewrite(); + rewriteSession.TryRewrite(); mockRewriter.Verify(m => m.Rewrite(), Times.Once); } From bd9c9c20c266b98335e3477c7f6eb3cc7a0bdb7e Mon Sep 17 00:00:00 2001 From: Max Doerner Date: Wed, 7 Nov 2018 23:17:13 +0100 Subject: [PATCH 33/59] Amend doc-comments in IModuleRewriter The Rewrite member is no longer on the interface. --- .../Rewriter/IModuleRewriter.cs | 28 +++++++++---------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/Rubberduck.Parsing/Rewriter/IModuleRewriter.cs b/Rubberduck.Parsing/Rewriter/IModuleRewriter.cs index ed8da6744c..4f2a1857e8 100644 --- a/Rubberduck.Parsing/Rewriter/IModuleRewriter.cs +++ b/Rubberduck.Parsing/Rewriter/IModuleRewriter.cs @@ -10,91 +10,91 @@ public interface IModuleRewriter bool IsDirty { get; } /// - /// Removes all tokens for specified . Use method to apply changes. + /// Removes all tokens for specified . Use to get the changed module code. /// /// The to remove. /// Removes a line that would be left empty by the removal of the declaration. void Remove(Declaration target); /// - /// Removes all tokens in specified context. Use method to apply changes. + /// Removes all tokens in specified context. Use to get the changed module code. /// /// The to remove. /// Removes a line that would be left empty by the removal of the identifier reference token. void Remove(ParserRuleContext target); /// - /// Removes all tokens for specified . Use method to apply changes. + /// Removes all tokens for specified . Use to get the changed module code. /// /// The to remove. /// Removes a line that would be left empty by the removal of the identifier reference token. void Remove(IToken target); /// - /// Removes all tokens for specified . Use method to apply changes. + /// Removes all tokens for specified . Use to get the changed module code. /// /// The to remove. /// Removes a line that would be left empty by the removal of the identifier reference token. void Remove(ITerminalNode target); /// - /// Removes all tokens for specified . Use method to apply changes. + /// Removes all tokens for specified . Use to get the changed module code. /// /// The to remove. /// Removes a line that would be left empty by the removal of the identifier reference token. void Remove(IParseTree target); /// - /// Removes all tokens from the start of the first node to the end of the second node. + /// Removes all tokens from the start of the first node to the end of the second node. Use to get the changed module code. /// /// The start index to remove. /// The end index to remove. void RemoveRange(int start, int stop); /// - /// Replaces all tokens for specified with specified content. Use method to apply changes. + /// Replaces all tokens for specified with specified content. Use to get the changed module code. /// /// The to replace. /// The literal replacement for the declaration. /// Useful for adding/removing e.g. access modifiers. void Replace(Declaration target, string content); /// - /// Replaces all tokens for specified with specified content. Use method to apply changes. + /// Replaces all tokens for specified with specified content. Use to get the changed module code. /// /// The to replace. /// The literal replacement for the expression. void Replace(ParserRuleContext target, string content); /// - /// Replaces specified token with specified content. Use method to apply changes. + /// Replaces specified token with specified content. Use to get the changed module code. /// /// The to replace. /// The literal replacement for the expression. void Replace(IToken token, string content); /// - /// Replaces specified token with specified content. Use method to apply changes. + /// Replaces specified token with specified content. Use to get the changed module code. /// /// The to replace. /// The literal replacement for the expression. void Replace(ITerminalNode target, string content); /// - /// Replaces specified token with specified content. Use method to apply changes. + /// Replaces specified token with specified content. Use to get the changed module code. /// /// The to replace. /// The literal replacement for the expression. void Replace(IParseTree target, string content); /// - /// Replaces specified interval with specified content. Use method to apply changes. + /// Replaces specified interval with specified content. Use to get the changed module code. /// /// The to replace. /// The literal replacement for the expression. void Replace(Interval tokenInterval, string content); /// - /// Inserts specified content before the specified token index in the module. Use method to apply changes. + /// Inserts specified content before the specified token index in the module. Use to get the changed module code. /// /// The index of the insertion point in the module's lexer token stream. /// The literal content to insert. void InsertBefore(int tokenIndex, string content); /// - /// Inserts specified content after the specified token index in the module. Use method to apply changes. + /// Inserts specified content after the specified token index in the module. Use to get the changed module code. /// /// The index of the insertion point in the module's lexer token stream. /// The literal content to insert. From bbb9d72f8c26d59ca7b502052a8fde5ba1b1a741 Mon Sep 17 00:00:00 2001 From: Mathieu Guindon Date: Mon, 12 Nov 2018 21:03:45 -0500 Subject: [PATCH 34/59] fixes #4486 --- .../Concrete/AssignmentNotUsedInspection.cs | 7 +- .../AssignmentNotUsedInspectionTests.cs | 187 +++++++++--------- 2 files changed, 96 insertions(+), 98 deletions(-) diff --git a/Rubberduck.CodeAnalysis/Inspections/Concrete/AssignmentNotUsedInspection.cs b/Rubberduck.CodeAnalysis/Inspections/Concrete/AssignmentNotUsedInspection.cs index d3e42e68fd..1075dc9c1d 100644 --- a/Rubberduck.CodeAnalysis/Inspections/Concrete/AssignmentNotUsedInspection.cs +++ b/Rubberduck.CodeAnalysis/Inspections/Concrete/AssignmentNotUsedInspection.cs @@ -7,6 +7,8 @@ using Rubberduck.Inspections.CodePathAnalysis.Extensions; using System.Linq; using Rubberduck.Inspections.Results; +using Rubberduck.Parsing; +using Rubberduck.Parsing.Grammar; namespace Rubberduck.Inspections.Concrete { @@ -21,7 +23,9 @@ public AssignmentNotUsedInspection(RubberduckParserState state, Walker walker) protected override IEnumerable DoGetInspectionResults() { - var variables = State.DeclarationFinder.UserDeclarations(DeclarationType.Variable); + var variables = State.DeclarationFinder + .UserDeclarations(DeclarationType.Variable) + .Where(d => !d.IsArray); var nodes = new List(); foreach (var variable in variables) @@ -32,6 +36,7 @@ protected override IEnumerable DoGetInspectionResults() } return nodes + //.Where(n => !n.Context.TryGetChildContext(out var lhs) || !lhs.TryGetChildContext(out _)) .Select(issue => new IdentifierReferenceInspectionResult(this, Description, State, issue)) .ToList(); } diff --git a/RubberduckTests/Inspections/AssignmentNotUsedInspectionTests.cs b/RubberduckTests/Inspections/AssignmentNotUsedInspectionTests.cs index 75f71fb779..949fe4b8d9 100644 --- a/RubberduckTests/Inspections/AssignmentNotUsedInspectionTests.cs +++ b/RubberduckTests/Inspections/AssignmentNotUsedInspectionTests.cs @@ -1,21 +1,78 @@ -using NUnit.Framework; +using System.Collections.Generic; +using NUnit.Framework; using Rubberduck.Inspections.CodePathAnalysis; using Rubberduck.Inspections.Concrete; using RubberduckTests.Mocks; using System.Linq; using System.Threading; +using Rubberduck.Parsing.Inspections.Abstract; namespace RubberduckTests.Inspections { [TestFixture] public class AssignmentNotUsedInspectionTests { + private IEnumerable GetInspectionResults(string code) + { + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(code, out _); + using (var state = MockParser.CreateAndParse(vbe.Object)) + { + + var inspection = new AssignmentNotUsedInspection(state, new Walker()); + var inspector = InspectionsHelper.GetInspector(inspection); + return inspector.FindIssuesAsync(state, CancellationToken.None).Result; + } + } + + [Test] + [Category("Inspections")] + public void IgnoresExplicitArrays() + { + const string code = @" +Sub Foo() + Dim bar(1 To 10) As String + bar(1) = 42 +End Sub +"; + var results = GetInspectionResults(code); + Assert.AreEqual(0, results.Count()); + } + + [Test] + [Category("Inspections")] + public void IgnoresImplicitArrays() + { + const string code = @" +Sub Foo() + Dim bar As Variant + bar(1) = ""Z"" +End Sub +"; + var results = GetInspectionResults(code); + Assert.AreEqual(0, results.Count()); + } + + [Test] + [Category("Inspections")] + public void IgnoresImplicitReDimmedArray() + { + const string code = @" +Sub test() + Dim foo As Variant + ReDim foo(1 To 10) + foo(1) = 42 +End Sub +"; + var results = GetInspectionResults(code); + Assert.AreEqual(0, results.Count()); + } + [Test] [Category("Inspections")] public void MarksSequentialAssignments() { - const string inputcode = - @"Sub Foo() + const string code = @" +Sub Foo() Dim i As Integer i = 9 i = 8 @@ -24,37 +81,21 @@ End Sub Sub Bar(ByVal i As Integer) End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputcode, out _); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new AssignmentNotUsedInspection(state, new Walker()); - var inspector = InspectionsHelper.GetInspector(inspection); - var results = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - Assert.AreEqual(1, results.Count()); - } + var results = GetInspectionResults(code); + Assert.AreEqual(1, results.Count()); } [Test] [Category("Inspections")] public void MarksLastAssignmentInDeclarationBlock() { - const string inputcode = - @"Sub Foo() + const string code = @" +Sub Foo() Dim i As Integer i = 9 End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputcode, out _); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new AssignmentNotUsedInspection(state, new Walker()); - var inspector = InspectionsHelper.GetInspector(inspection); - var results = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - Assert.AreEqual(1, results.Count()); - } + var results = GetInspectionResults(code); + Assert.AreEqual(1, results.Count()); } [Test] @@ -63,8 +104,8 @@ Dim i As Integer // I just want feedback before I start mucking around that deep. public void DoesNotMarkLastAssignmentInNonDeclarationBlock() { - const string inputcode = - @"Sub Foo() + const string code = @" +Sub Foo() Dim i As Integer i = 0 If i = 9 Then @@ -73,24 +114,16 @@ Dim i As Integer i = 8 End If End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputcode, out _); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new AssignmentNotUsedInspection(state, new Walker()); - var inspector = InspectionsHelper.GetInspector(inspection); - var results = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - Assert.AreEqual(0, results.Count()); - } + var results = GetInspectionResults(code); + Assert.AreEqual(0, results.Count()); } [Test] [Category("Inspections")] public void DoesNotMarkAssignmentWithReferenceAfter() { - const string inputcode = - @"Sub Foo() + const string code = @" +Sub Foo() Dim i As Integer i = 9 Bar i @@ -98,47 +131,31 @@ End Sub Sub Bar(ByVal i As Integer) End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputcode, out _); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new AssignmentNotUsedInspection(state, new Walker()); - var inspector = InspectionsHelper.GetInspector(inspection); - var results = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - Assert.AreEqual(0, results.Count()); - } + var results = GetInspectionResults(code); + Assert.AreEqual(0, results.Count()); } [Test] [Category("Inspections")] public void DoesNotMarkAssignment_UsedInForNext() { - const string inputcode = - @"Sub foo() + const string code = @" +Sub foo() Dim i As Integer i = 1 For counter = i To 2 Next End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputcode, out _); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new AssignmentNotUsedInspection(state, new Walker()); - var inspector = InspectionsHelper.GetInspector(inspection); - var results = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - Assert.AreEqual(0, results.Count()); - } + var results = GetInspectionResults(code); + Assert.AreEqual(0, results.Count()); } [Test] [Category("Inspections")] public void DoesNotMarkAssignment_UsedInWhileWend() { - const string inputcode = - @"Sub foo() + const string code = @" +Sub foo() Dim i As Integer i = 0 @@ -146,47 +163,31 @@ While i < 10 i = i + 1 Wend End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputcode, out _); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new AssignmentNotUsedInspection(state, new Walker()); - var inspector = InspectionsHelper.GetInspector(inspection); - var results = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - Assert.AreEqual(0, results.Count()); - } + var results = GetInspectionResults(code); + Assert.AreEqual(0, results.Count()); } [Test] [Category("Inspections")] public void DoesNotMarkAssignment_UsedInDoWhile() { - const string inputcode = - @"Sub foo() + const string code = @" +Sub foo() Dim i As Integer i = 0 Do While i < 10 Loop End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputcode, out _); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new AssignmentNotUsedInspection(state, new Walker()); - var inspector = InspectionsHelper.GetInspector(inspection); - var results = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - Assert.AreEqual(0, results.Count()); - } + var results = GetInspectionResults(code); + Assert.AreEqual(0, results.Count()); } [Test] [Category("Inspections")] public void DoesNotMarkAssignment_UsedInSelectCase() { - const string inputcode = - @"Sub foo() + const string code = @" +Sub foo() Dim i As Integer i = 0 Select Case i @@ -200,16 +201,8 @@ Case Else i = -1 End Select End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputcode, out _); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new AssignmentNotUsedInspection(state, new Walker()); - var inspector = InspectionsHelper.GetInspector(inspection); - var results = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - Assert.AreEqual(0, results.Count()); - } + var results = GetInspectionResults(code); + Assert.AreEqual(0, results.Count()); } } } From 15671d8d4e906a5e50a66af4a584a491854ff10d Mon Sep 17 00:00:00 2001 From: comintern Date: Mon, 12 Nov 2018 20:19:14 -0600 Subject: [PATCH 35/59] Fix bindings. --- .../UI/Controls/NumberPicker.xaml.cs | 28 +++++++++++++++++-- 1 file changed, 26 insertions(+), 2 deletions(-) diff --git a/Rubberduck.Core/UI/Controls/NumberPicker.xaml.cs b/Rubberduck.Core/UI/Controls/NumberPicker.xaml.cs index 081d681d83..f8c33fe2b0 100644 --- a/Rubberduck.Core/UI/Controls/NumberPicker.xaml.cs +++ b/Rubberduck.Core/UI/Controls/NumberPicker.xaml.cs @@ -11,6 +11,10 @@ public partial class NumberPicker : IDataErrorInfo { public static readonly DependencyProperty NumValueProperty = DependencyProperty.Register("NumValue", typeof(int), typeof(NumberPicker), new UIPropertyMetadata(null)); + public static readonly DependencyProperty MinNumberProperty = + DependencyProperty.Register("MinNumber", typeof(int), typeof(NumberPicker), new UIPropertyMetadata(null)); + public static readonly DependencyProperty MaxNumberProperty = + DependencyProperty.Register("MaxNumber", typeof(int), typeof(NumberPicker), new UIPropertyMetadata(null)); public int NumValue { @@ -22,9 +26,29 @@ public int NumValue } } - public int MinNumber { get; set; } = int.MinValue; - public int MaxNumber { get; set; } = int.MaxValue; + public int MinNumber + { + get => (int)GetValue(MinNumberProperty); + set + { + SetValue(MinNumberProperty, value); + OnPropertyChanged(new DependencyPropertyChangedEventArgs(MinNumberProperty, NumValue - 1, NumValue)); + } + } + + public int MaxNumber + { + get => (int)GetValue(MaxNumberProperty); + set + { + SetValue(MaxNumberProperty, value); + OnPropertyChanged(new DependencyPropertyChangedEventArgs(MaxNumberProperty, NumValue - 1, NumValue)); + } + } + //public int MinNumber { get; set; } = int.MinValue; + + //public int MaxNumber { get; set; } = int.MaxValue; public NumberPicker() { From 479f27ec87bf00ead3c50fa015ac8012834a5cb3 Mon Sep 17 00:00:00 2001 From: comintern Date: Mon, 12 Nov 2018 20:23:16 -0600 Subject: [PATCH 36/59] Removed commented code. --- Rubberduck.Core/UI/Controls/NumberPicker.xaml.cs | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/Rubberduck.Core/UI/Controls/NumberPicker.xaml.cs b/Rubberduck.Core/UI/Controls/NumberPicker.xaml.cs index f8c33fe2b0..73a6be6898 100644 --- a/Rubberduck.Core/UI/Controls/NumberPicker.xaml.cs +++ b/Rubberduck.Core/UI/Controls/NumberPicker.xaml.cs @@ -1,4 +1,5 @@ -using System.ComponentModel; +using System; +using System.ComponentModel; using System.Windows; // credit to http://stackoverflow.com/a/2752538 @@ -46,9 +47,6 @@ public int MaxNumber OnPropertyChanged(new DependencyPropertyChangedEventArgs(MaxNumberProperty, NumValue - 1, NumValue)); } } - //public int MinNumber { get; set; } = int.MinValue; - - //public int MaxNumber { get; set; } = int.MaxValue; public NumberPicker() { From 0d880c1eb7d486d8db5f7f2315a69cda55c5e8de Mon Sep 17 00:00:00 2001 From: Mathieu Guindon Date: Mon, 12 Nov 2018 21:57:26 -0500 Subject: [PATCH 37/59] fixes #3765 --- .../UnassignedVariableUsageInspection.cs | 13 +- .../AssignmentNotUsedInspectionTests.cs | 1 + .../UnassignedVariableUsageInspectionTests.cs | 201 ++++++++---------- 3 files changed, 101 insertions(+), 114 deletions(-) diff --git a/Rubberduck.CodeAnalysis/Inspections/Concrete/UnassignedVariableUsageInspection.cs b/Rubberduck.CodeAnalysis/Inspections/Concrete/UnassignedVariableUsageInspection.cs index 15157be98a..b7aea1d264 100644 --- a/Rubberduck.CodeAnalysis/Inspections/Concrete/UnassignedVariableUsageInspection.cs +++ b/Rubberduck.CodeAnalysis/Inspections/Concrete/UnassignedVariableUsageInspection.cs @@ -5,6 +5,7 @@ using Rubberduck.Inspections.Abstract; using Rubberduck.Inspections.Results; using Rubberduck.Parsing; +using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Inspections.Abstract; using Rubberduck.Resources.Inspections; using Rubberduck.Parsing.Symbols; @@ -30,7 +31,7 @@ public UnassignedVariableUsageInspection(RubberduckParserState state) protected override IEnumerable DoGetInspectionResults() { var declarations = State.DeclarationFinder.UserDeclarations(DeclarationType.Variable) - .Where(declaration => + .Where(declaration => !declaration.IsArray && State.DeclarationFinder.MatchName(declaration.AsTypeName) .All(d => d.DeclarationType != DeclarationType.UserDefinedType) && !declaration.IsSelfAssigned @@ -43,12 +44,22 @@ protected override IEnumerable DoGetInspectionResults() .SelectMany(d => d.References) .Distinct() .Where(r => !r.IsIgnoringInspectionResultFor(AnnotationName)) + .Where(r => !r.Context.TryGetAncestor(out _) && !IsArraySubscriptAssignment(r)) .Select(r => new IdentifierReferenceInspectionResult(this, string.Format(InspectionResults.UnassignedVariableUsageInspection, r.IdentifierName), State, r)).ToList(); } + private static bool IsArraySubscriptAssignment(IdentifierReference reference) + { + var isLetAssignment = reference.Context.TryGetAncestor(out var letStmt); + var isSetAssignment = reference.Context.TryGetAncestor(out var setStmt); + + return isLetAssignment && letStmt.lExpression() is VBAParser.IndexExprContext || + isSetAssignment && setStmt.lExpression() is VBAParser.IndexExprContext; + } + private static bool DeclarationReferencesContainsReference(Declaration parentDeclaration, Declaration target) { foreach (var targetReference in target.References) diff --git a/RubberduckTests/Inspections/AssignmentNotUsedInspectionTests.cs b/RubberduckTests/Inspections/AssignmentNotUsedInspectionTests.cs index 949fe4b8d9..754d858a6a 100644 --- a/RubberduckTests/Inspections/AssignmentNotUsedInspectionTests.cs +++ b/RubberduckTests/Inspections/AssignmentNotUsedInspectionTests.cs @@ -45,6 +45,7 @@ public void IgnoresImplicitArrays() const string code = @" Sub Foo() Dim bar As Variant + ReDim bar(1 To 10) bar(1) = ""Z"" End Sub "; diff --git a/RubberduckTests/Inspections/UnassignedVariableUsageInspectionTests.cs b/RubberduckTests/Inspections/UnassignedVariableUsageInspectionTests.cs index a2fba4885f..be29296437 100644 --- a/RubberduckTests/Inspections/UnassignedVariableUsageInspectionTests.cs +++ b/RubberduckTests/Inspections/UnassignedVariableUsageInspectionTests.cs @@ -1,7 +1,9 @@ +using System.Collections.Generic; using System.Linq; using System.Threading; using NUnit.Framework; using Rubberduck.Inspections.Concrete; +using Rubberduck.Parsing.Inspections.Abstract; using Rubberduck.VBEditor.SafeComWrappers; using RubberduckTests.Mocks; @@ -10,150 +12,137 @@ namespace RubberduckTests.Inspections [TestFixture] public class UnassignedVariableUsageInspectionTests { - [Test] - [Category("Inspections")] - public void UnassignedVariableUsage_ReturnsResult() + private IEnumerable GetInspectionResults(string code) { - const string inputCode = @" -Sub Foo() - Dim b As Boolean - Dim bb As Boolean - bb = b -End Sub"; - - var vbe = MockVbeBuilder.BuildFromSingleModule(inputCode, ComponentType.ClassModule, out _); + var vbe = MockVbeBuilder.BuildFromSingleModule(code, ComponentType.ClassModule, out _); using (var state = MockParser.CreateAndParse(vbe.Object)) { var inspection = new UnassignedVariableUsageInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - Assert.AreEqual(1, inspectionResults.Count()); + return inspection.GetInspectionResults(CancellationToken.None); } } - // this test will eventually be removed once we can fire the inspection on a specific reference [Test] [Category("Inspections")] - public void UnassignedVariableUsage_ReturnsSingleResult_MultipleReferences() + public void IgnoresExplicitArrays() { - const string inputCode = - @"Sub tester() - Dim myarr() As Variant - Dim i As Long - - ReDim myarr(1 To 10) - - For i = 1 To 10 - DoSomething myarr(i) - Next - + const string code = @" +Sub Foo() + Dim bar() As String + bar(1) = ""value"" End Sub +"; + var results = GetInspectionResults(code); + Assert.AreEqual(0, results.Count()); + } -Sub DoSomething(ByVal foo As Variant) + [Test] + [Category("Inspections")] + public void IgnoresArrayReDim() + { + const string code = @" +Sub Foo() + Dim bar As Variant + ReDim bar(1 To 10) End Sub "; + var results = GetInspectionResults(code); + Assert.AreEqual(0, results.Count()); + } - var vbe = MockVbeBuilder.BuildFromSingleModule(inputCode, ComponentType.ClassModule, out _); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new UnassignedVariableUsageInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); + [Test] + [Category("Inspections")] + public void IgnoresArraySubscripts() + { + const string code = @" +Sub Foo() + Dim bar As Variant + ReDim bar(1 To 10) + bar(1) = 42 +End Sub +"; + var results = GetInspectionResults(code); + Assert.AreEqual(0, results.Count()); + } - Assert.AreEqual(2, inspectionResults.Count()); - } + [Test] + [Category("Inspections")] + public void UnassignedVariableUsage_ReturnsResult() + { + const string code = @" +Sub Foo() + Dim b As Boolean + Dim bb As Boolean + bb = b +End Sub +"; + var results = GetInspectionResults(code); + Assert.AreEqual(1, results.Count()); } [Test] [Category("Inspections")] public void UnassignedVariableUsage_DoesNotReturnResult() { - const string inputCode = - @"Sub Foo() + const string code = @" +Sub Foo() Dim b As Boolean Dim bb As Boolean b = True bb = b -End Sub"; - - var vbe = MockVbeBuilder.BuildFromSingleModule(inputCode, ComponentType.ClassModule, out _); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new UnassignedVariableUsageInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); +End Sub +"; - Assert.IsFalse(inspectionResults.Any()); - } + var results = GetInspectionResults(code); + Assert.AreEqual(0, results.Count()); } [Test] [Category("Inspections")] public void UnassignedVariableUsage_Ignored_DoesNotReturnResult() { - const string inputCode = - @"Sub Foo() + const string code = @" +Sub Foo() Dim b As Boolean Dim bb As Boolean '@Ignore UnassignedVariableUsage bb = b -End Sub"; - - var vbe = MockVbeBuilder.BuildFromSingleModule(inputCode, ComponentType.ClassModule, out _); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new UnassignedVariableUsageInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - Assert.IsFalse(inspectionResults.Any()); - } +End Sub +"; + var results = GetInspectionResults(code); + Assert.AreEqual(0, results.Count()); } [Test] [Category("Inspections")] public void UnassignedVariableUsage_Ignored_DoesNotReturnResultMultipleIgnores() { - const string inputCode = - @"Sub Foo() + const string code = @" +Sub Foo() Dim b As Boolean Dim bb As Boolean '@Ignore UnassignedVariableUsage, VariableNotAssigned bb = b -End Sub"; - - var vbe = MockVbeBuilder.BuildFromSingleModule(inputCode, ComponentType.ClassModule, out _); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new UnassignedVariableUsageInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - Assert.IsFalse(inspectionResults.Any()); - } +End Sub +"; + var results = GetInspectionResults(code); + Assert.AreEqual(0, results.Count()); } [Test] [Category("Inspections")] public void UnassignedVariableUsage_NoResultIfNoReferences() { - const string inputCode = - @"Sub DoSomething() + const string code = @" +Sub DoSomething() Dim foo -End Sub"; - - var vbe = MockVbeBuilder.BuildFromSingleModule(inputCode, ComponentType.ClassModule, out _); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new UnassignedVariableUsageInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - Assert.IsFalse(inspectionResults.Any()); - } +End Sub +"; + var results = GetInspectionResults(code); + Assert.AreEqual(0, results.Count()); } [Test] @@ -161,21 +150,14 @@ Dim foo [Category("Inspections")] public void UnassignedVariableUsage_NoResultForLenFunction() { - const string inputCode = - @"Sub DoSomething() + const string code = @" +Sub DoSomething() Dim foo As LongPtr Debug.Print Len(foo) -End Sub"; - - var vbe = MockVbeBuilder.BuildFromSingleModule(inputCode, ComponentType.ClassModule, out _); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new UnassignedVariableUsageInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - Assert.IsFalse(inspectionResults.Any()); - } +End Sub +"; + var results = GetInspectionResults(code); + Assert.AreEqual(0, results.Count()); } [Test] @@ -183,21 +165,14 @@ Debug.Print Len(foo) [Category("Inspections")] public void UnassignedVariableUsage_NoResultForLenBFunction() { - const string inputCode = - @"Sub DoSomething() + const string code = @" +Sub DoSomething() Dim foo As LongPtr Debug.Print LenB(foo) -End Sub"; - - var vbe = MockVbeBuilder.BuildFromSingleModule(inputCode, ComponentType.ClassModule, out _); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new UnassignedVariableUsageInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - Assert.IsFalse(inspectionResults.Any()); - } +End Sub +"; + var results = GetInspectionResults(code); + Assert.AreEqual(0, results.Count()); } [Test] From b4f45bf0f076519375fc3a0467d1974c919477af Mon Sep 17 00:00:00 2001 From: Mathieu Guindon Date: Mon, 12 Nov 2018 22:20:57 -0500 Subject: [PATCH 38/59] fixes #4036 --- .../FunctionReturnValueNotUsedInspection.cs | 3 +- ...nctionReturnValueNotUsedInspectionTests.cs | 339 ++++++++---------- 2 files changed, 150 insertions(+), 192 deletions(-) diff --git a/Rubberduck.CodeAnalysis/Inspections/Concrete/FunctionReturnValueNotUsedInspection.cs b/Rubberduck.CodeAnalysis/Inspections/Concrete/FunctionReturnValueNotUsedInspection.cs index 624c026d62..5981f4ec5d 100644 --- a/Rubberduck.CodeAnalysis/Inspections/Concrete/FunctionReturnValueNotUsedInspection.cs +++ b/Rubberduck.CodeAnalysis/Inspections/Concrete/FunctionReturnValueNotUsedInspection.cs @@ -28,7 +28,8 @@ protected override IEnumerable DoGetInspectionResults() var interfaceImplementationMembers = State.DeclarationFinder.FindAllInterfaceImplementingMembers(); var functions = State.DeclarationFinder .UserDeclarations(DeclarationType.Function) - .Where(item => !IsIgnoringInspectionResultFor(item, AnnotationName)) + .Where(item => !IsIgnoringInspectionResultFor(item, AnnotationName) && + item.References.Any(r => !IsReturnStatement(item, r) && !r.IsAssignment)) .ToList(); var interfaceMemberIssues = GetInterfaceMemberIssues(interfaceMembers); var nonInterfaceFunctions = functions.Except(interfaceMembers.Union(interfaceImplementationMembers)); diff --git a/RubberduckTests/Inspections/FunctionReturnValueNotUsedInspectionTests.cs b/RubberduckTests/Inspections/FunctionReturnValueNotUsedInspectionTests.cs index 6122b330aa..4a5b8aff06 100644 --- a/RubberduckTests/Inspections/FunctionReturnValueNotUsedInspectionTests.cs +++ b/RubberduckTests/Inspections/FunctionReturnValueNotUsedInspectionTests.cs @@ -1,7 +1,9 @@ +using System.Collections.Generic; using System.Linq; using System.Threading; using NUnit.Framework; using Rubberduck.Inspections.Concrete; +using Rubberduck.Parsing.Inspections.Abstract; using Rubberduck.VBEditor.SafeComWrappers; using RubberduckTests.Mocks; @@ -10,27 +12,47 @@ namespace RubberduckTests.Inspections [TestFixture] public class FunctionReturnValueNotUsedInspectionTests { + private IEnumerable GetInspectionResults(string code) + { + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(code, out _); + using (var state = MockParser.CreateAndParse(vbe.Object)) + { + + var inspection = new FunctionReturnValueNotUsedInspection(state); + return inspection.GetInspectionResults(CancellationToken.None); + } + } + + [Test] + [Category("Inspections")] + [Category("Unused Value")] + public void FunctionReturnValueNotUsed_IgnoresUnusedFunction() + { + const string code = @" +Public Function Foo() As Long + Foo = 42 +End Function +"; + var results = GetInspectionResults(code); + Assert.AreEqual(0, results.Count()); + } + [Test] [Category("Inspections")] [Category("Unused Value")] public void FunctionReturnValueNotUsed_ReturnsResult_ExplicitCallWithoutAssignment() { - const string inputCode = - @"Public Function Foo(ByVal bar As String) As Integer + const string code = @" +Public Function Foo(ByVal bar As String) As Integer Foo = 42 End Function + Public Sub Bar() Call Foo(""Test"") -End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new FunctionReturnValueNotUsedInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - Assert.AreEqual(1, inspectionResults.Count()); - } +End Sub +"; + var results = GetInspectionResults(code); + Assert.AreEqual(1, results.Count()); } [Test] @@ -38,22 +60,17 @@ Call Foo(""Test"") [Category("Unused Value")] public void FunctionReturnValueNotUsed_ReturnsResult_CallWithoutAssignment() { - const string inputCode = - @"Public Function Foo(ByVal bar As String) As Integer + const string code = @" +Public Function Foo(ByVal bar As String) As Integer Foo = 42 End Function + Public Sub Bar() Foo ""Test"" -End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new FunctionReturnValueNotUsedInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - Assert.AreEqual(1, inspectionResults.Count()); - } +End Sub +"; + var results = GetInspectionResults(code); + Assert.AreEqual(1, results.Count()); } [Test] @@ -61,22 +78,17 @@ Public Sub Bar() [Category("Unused Value")] public void FunctionReturnValueNotUsed_ReturnsResult_AddressOf() { - const string inputCode = - @"Public Function Foo(ByVal bar As String) As Integer + const string code = @" +Public Function Foo(ByVal bar As String) As Integer Foo = 42 End Function + Public Sub Bar() Bar AddressOf Foo -End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new FunctionReturnValueNotUsedInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - Assert.AreEqual(1, inspectionResults.Count()); - } +End Sub +"; + var results = GetInspectionResults(code); + Assert.AreEqual(1, results.Count()); } [Test] @@ -84,21 +96,16 @@ Bar AddressOf Foo [Category("Unused Value")] public void FunctionReturnValueNotUsed_ReturnsResult_NoReturnValueAssignment() { - const string inputCode = - @"Public Function Foo() As Integer + const string code = @" +Public Function Foo() As Integer End Function + Public Sub Bar() Foo -End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new FunctionReturnValueNotUsedInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - Assert.AreEqual(1, inspectionResults.Count()); - } +End Sub +"; + var results = GetInspectionResults(code); + Assert.AreEqual(1, results.Count()); } [Test] @@ -106,23 +113,18 @@ Public Sub Bar() [Category("Unused Value")] public void FunctionReturnValueNotUsed_Ignored_DoesNotReturnResult_AddressOf() { - const string inputCode = - @"'@Ignore FunctionReturnValueNotUsed + const string code = @" +'@Ignore FunctionReturnValueNotUsed Public Function Foo(ByVal bar As String) As Integer Foo = 42 End Function + Public Sub Bar() Bar AddressOf Foo -End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new FunctionReturnValueNotUsedInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - Assert.IsFalse(inspectionResults.Any()); - } +End Sub +"; + var results = GetInspectionResults(code); + Assert.AreEqual(0, results.Count()); } [Test] @@ -130,22 +132,17 @@ Bar AddressOf Foo [Category("Unused Value")] public void FunctionReturnValueNotUsed_DoesNotReturnResult_MultipleConsecutiveCalls() { - const string inputCode = - @"Public Function Foo(ByVal bar As String) As Integer + const string code = @" +Public Function Foo(ByVal bar As String) As Integer Foo = 42 End Function + Public Sub Baz() Foo Foo(Foo(""Bar"")) -End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new FunctionReturnValueNotUsedInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - Assert.AreEqual(0, inspectionResults.Count()); - } +End Sub +"; + var results = GetInspectionResults(code); + Assert.AreEqual(0, results.Count()); } [Test] @@ -153,23 +150,18 @@ Foo Foo(Foo(""Bar"")) [Category("Unused Value")] public void FunctionReturnValueNotUsed_DoesNotReturnResult_IfStatement() { - const string inputCode = - @"Public Function Foo(ByVal bar As String) As Integer + const string code = @" +Public Function Foo(ByVal bar As String) As Integer Foo = 42 End Function + Public Sub Baz() If Foo(""Test"") Then End If -End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new FunctionReturnValueNotUsedInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - Assert.AreEqual(0, inspectionResults.Count()); - } +End Sub +"; + var results = GetInspectionResults(code); + Assert.AreEqual(0, results.Count()); } [Test] @@ -177,25 +169,21 @@ End If [Category("Unused Value")] public void FunctionReturnValueNotUsed_DoesNotReturnResult_ForEachStatement() { - const string inputCode = - @"Public Function Foo(ByVal bar As String) As Integer + const string code = @" +Public Function Foo(ByVal bar As String) As Integer Foo = 42 End Function + Sub Bar(ByVal fizz As Boolean) End Sub + Public Sub Baz() For Each Bar In Foo Next Bar -End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new FunctionReturnValueNotUsedInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - Assert.AreEqual(0, inspectionResults.Count()); - } +End Sub +"; + var results = GetInspectionResults(code); + Assert.AreEqual(0, results.Count()); } [Test] @@ -203,25 +191,21 @@ Next Bar [Category("Unused Value")] public void FunctionReturnValueNotUsed_DoesNotReturnResult_WhileStatement() { - const string inputCode = - @"Public Function Foo(ByVal bar As String) As Integer + const string code = @" +Public Function Foo(ByVal bar As String) As Integer Foo = 42 End Function + Sub Bar(ByVal fizz As Boolean) End Sub + Public Sub Baz() While Foo Wend -End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new FunctionReturnValueNotUsedInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - Assert.AreEqual(0, inspectionResults.Count()); - } +End Sub +"; + var results = GetInspectionResults(code); + Assert.AreEqual(0, results.Count()); } [Test] @@ -229,25 +213,21 @@ While Foo [Category("Unused Value")] public void FunctionReturnValueNotUsed_DoesNotReturnResult_DoUntilStatement() { - const string inputCode = - @"Public Function Foo(ByVal bar As String) As Integer + const string code = @" +Public Function Foo(ByVal bar As String) As Integer Foo = 42 End Function + Sub Bar(ByVal fizz As Boolean) End Sub + Public Sub Baz() Do Until Foo Loop -End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new FunctionReturnValueNotUsedInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - Assert.AreEqual(0, inspectionResults.Count()); - } +End Sub +"; + var results = GetInspectionResults(code); + Assert.AreEqual(0, results.Count()); } [Test] @@ -255,22 +235,17 @@ Do Until Foo [Category("Unused Value")] public void FunctionReturnValueNotUsed_DoesNotReturnResult_ReturnValueAssignment() { - const string inputCode = - @"Public Function Foo(ByVal bar As String) As Integer + const string code = @" +Public Function Foo(ByVal bar As String) As Integer Foo = 42 End Function + Public Sub Baz() TestVal = Foo(""Test"") -End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new FunctionReturnValueNotUsedInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - Assert.AreEqual(0, inspectionResults.Count()); - } +End Sub +"; + var results = GetInspectionResults(code); + Assert.AreEqual(0, results.Count()); } [Test] @@ -278,23 +253,17 @@ Public Sub Baz() [Category("Unused Value")] public void FunctionReturnValueNotUsed_DoesNotReturnResult_RecursiveFunction() { - const string inputCode = - @"Public Function Factorial(ByVal n As Long) As Long + const string code = @" +Public Function Factorial(ByVal n As Long) As Long If n <= 1 Then Factorial = 1 Else Factorial = Factorial(n - 1) * n End If -End Function"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new FunctionReturnValueNotUsedInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - Assert.AreEqual(0, inspectionResults.Count()); - } +End Function +"; + var results = GetInspectionResults(code); + Assert.AreEqual(0, results.Count()); } [Test] @@ -302,24 +271,20 @@ End If [Category("Unused Value")] public void FunctionReturnValueNotUsed_DoesNotReturnResult_ArgumentFunctionCall() { - const string inputCode = - @"Public Function Foo(ByVal bar As String) As Integer + const string code = @" +Public Function Foo(ByVal bar As String) As Integer Foo = 42 End Function + Sub Bar(ByVal fizz As Boolean) End Sub + Public Sub Baz() Bar Foo(""Test"") -End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new FunctionReturnValueNotUsedInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - Assert.AreEqual(0, inspectionResults.Count()); - } +End Sub +"; + var results = GetInspectionResults(code); + Assert.AreEqual(0, results.Count()); } [Test] @@ -327,20 +292,14 @@ Bar Foo(""Test"") [Category("Unused Value")] public void FunctionReturnValueNotUsed_DoesNotReturnResult_IgnoresBuiltInFunctions() { - const string inputCode = - @"Public Sub Dummy() + const string code = @" +Public Sub Dummy() MsgBox ""Test"" Workbooks.Add -End Sub"; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _); - using (var state = MockParser.CreateAndParse(vbe.Object)) - { - - var inspection = new FunctionReturnValueNotUsedInspection(state); - var inspectionResults = inspection.GetInspectionResults(CancellationToken.None); - - Assert.AreEqual(0, inspectionResults.Count()); - } +End Sub +"; + var results = GetInspectionResults(code); + Assert.AreEqual(0, results.Count()); } [Test] @@ -348,25 +307,24 @@ public void FunctionReturnValueNotUsed_DoesNotReturnResult_IgnoresBuiltInFunctio [Category("Unused Value")] public void GivenInterfaceImplementationMember_ReturnsNoResult() { - const string interfaceCode = - @"Public Function Test() As Integer -End Function"; - - const string implementationCode = - @"Implements IFoo + const string interfaceCode = @" +Public Function Test() As Integer +End Function +"; + const string implementationCode = @" +Implements IFoo Public Function IFoo_Test() As Integer IFoo_Test = 42 -End Function"; - - const string callSiteCode = - @" +End Function +"; + const string callSiteCode = @" Public Sub Baz() Dim testObj As IFoo Set testObj = new Bar Dim result As Integer result = testObj.Test -End Sub"; - +End Sub +"; var builder = new MockVbeBuilder(); var vbe = builder.ProjectBuilder("TestProject", ProjectProtection.Unprotected) .AddComponent("IFoo", ComponentType.ClassModule, interfaceCode) @@ -389,24 +347,23 @@ Dim result As Integer [Category("Unused Value")] public void FunctionReturnValueNotUsed_ReturnsResult_InterfaceMember() { - const string interfaceCode = - @"Public Function Test() As Integer -End Function"; - - const string implementationCode = + const string interfaceCode = @" +Public Function Test() As Integer +End Function +"; + const string implementationCode = @"Implements IFoo Public Function IFoo_Test() As Integer IFoo_Test = 42 -End Function"; - - const string callSiteCode = - @" +End Function +"; + const string callSiteCode = @" Public Sub Baz() Dim testObj As IFoo Set testObj = new Bar testObj.Test -End Sub"; - +End Sub +"; var builder = new MockVbeBuilder(); var vbe = builder.ProjectBuilder("TestProject", ProjectProtection.Unprotected) .AddComponent("IFoo", ComponentType.ClassModule, interfaceCode) From 4629f488d47696567d2625a66680a51f57e62b52 Mon Sep 17 00:00:00 2001 From: Mathieu Guindon Date: Mon, 12 Nov 2018 22:24:51 -0500 Subject: [PATCH 39/59] removed comented-out code --- .../Inspections/Concrete/AssignmentNotUsedInspection.cs | 1 - 1 file changed, 1 deletion(-) diff --git a/Rubberduck.CodeAnalysis/Inspections/Concrete/AssignmentNotUsedInspection.cs b/Rubberduck.CodeAnalysis/Inspections/Concrete/AssignmentNotUsedInspection.cs index 1075dc9c1d..88e3bc0f8f 100644 --- a/Rubberduck.CodeAnalysis/Inspections/Concrete/AssignmentNotUsedInspection.cs +++ b/Rubberduck.CodeAnalysis/Inspections/Concrete/AssignmentNotUsedInspection.cs @@ -36,7 +36,6 @@ protected override IEnumerable DoGetInspectionResults() } return nodes - //.Where(n => !n.Context.TryGetChildContext(out var lhs) || !lhs.TryGetChildContext(out _)) .Select(issue => new IdentifierReferenceInspectionResult(this, Description, State, issue)) .ToList(); } From a6355ac5eb7c78412d2cc87752b03cd1dd504ff5 Mon Sep 17 00:00:00 2001 From: Mathieu Guindon Date: Mon, 12 Nov 2018 22:53:02 -0500 Subject: [PATCH 40/59] fixed broken tests --- .../ConvertToProcedureQuickFixTests.cs | 28 ++++++++++++++++--- 1 file changed, 24 insertions(+), 4 deletions(-) diff --git a/RubberduckTests/QuickFixes/ConvertToProcedureQuickFixTests.cs b/RubberduckTests/QuickFixes/ConvertToProcedureQuickFixTests.cs index 9a3ad20c61..dd46a586a3 100644 --- a/RubberduckTests/QuickFixes/ConvertToProcedureQuickFixTests.cs +++ b/RubberduckTests/QuickFixes/ConvertToProcedureQuickFixTests.cs @@ -23,7 +23,12 @@ If True Then Else Foo = False End If -End Function"; +End Function + +Public Sub Test() + Foo ""test"" +End Sub +"; const string expectedCode = @"Public Sub Foo(ByVal bar As String) @@ -32,7 +37,12 @@ If True Then Else End If -End Sub"; +End Sub + +Public Sub Test() + Foo ""test"" +End Sub +"; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); using (var state = MockParser.CreateAndParse(vbe.Object)) @@ -59,7 +69,12 @@ public void FunctionReturnValueNotUsed_QuickFixWorks_NoInterface_ManyBodyStateme End Function Sub goo() -End Sub"; +End Sub + +Public Sub Test() + foo ""test"" +End Sub +"; const string expectedCode = @"Sub foo(ByRef fizz As Boolean) @@ -70,7 +85,12 @@ Sub goo() End Sub Sub goo() -End Sub"; +End Sub + +Public Sub Test() + foo ""test"" +End Sub +"; var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); using (var state = MockParser.CreateAndParse(vbe.Object)) From bbb31037382a288e6e15334a3152250e18a3985c Mon Sep 17 00:00:00 2001 From: Mathieu Guindon Date: Mon, 12 Nov 2018 23:04:12 -0500 Subject: [PATCH 41/59] fixes #4361 (bindings) --- .../ExtractInterface/InterfaceMemberViewModel.cs | 14 +++++--------- 1 file changed, 5 insertions(+), 9 deletions(-) diff --git a/Rubberduck.Core/UI/Refactorings/ExtractInterface/InterfaceMemberViewModel.cs b/Rubberduck.Core/UI/Refactorings/ExtractInterface/InterfaceMemberViewModel.cs index f67315e644..9aa5f4e007 100644 --- a/Rubberduck.Core/UI/Refactorings/ExtractInterface/InterfaceMemberViewModel.cs +++ b/Rubberduck.Core/UI/Refactorings/ExtractInterface/InterfaceMemberViewModel.cs @@ -4,18 +4,14 @@ namespace Rubberduck.UI.Refactorings.ExtractInterface { internal class InterfaceMemberViewModel : ViewModelBase { - private readonly InterfaceMember _wrapped; - internal InterfaceMember Wrapped { get => _wrapped; } - - - private bool _isSelected; - private InterfaceMember model; - public InterfaceMemberViewModel(InterfaceMember model) { - this.model = model; + Wrapped = model; } + internal InterfaceMember Wrapped { get; } + + private bool _isSelected; public bool IsSelected { get => _isSelected; @@ -26,7 +22,7 @@ public bool IsSelected } } - public string FullMemberSignature { get => _wrapped.FullMemberSignature; } + public string FullMemberSignature => Wrapped?.FullMemberSignature; } internal static class ConversionExtensions From 5e9668e4b6b00534f41a66b61e068100c8c0b4a4 Mon Sep 17 00:00:00 2001 From: Mathieu Guindon Date: Mon, 12 Nov 2018 23:19:14 -0500 Subject: [PATCH 42/59] fixed scrolling --- .../ExtractInterfaceView.xaml | 32 ++++++++++--------- 1 file changed, 17 insertions(+), 15 deletions(-) diff --git a/Rubberduck.Core/UI/Refactorings/ExtractInterface/ExtractInterfaceView.xaml b/Rubberduck.Core/UI/Refactorings/ExtractInterface/ExtractInterfaceView.xaml index c7b933b8d7..18bfea2733 100644 --- a/Rubberduck.Core/UI/Refactorings/ExtractInterface/ExtractInterfaceView.xaml +++ b/Rubberduck.Core/UI/Refactorings/ExtractInterface/ExtractInterfaceView.xaml @@ -59,35 +59,36 @@ - + + + - - - - - - + + + + + + + + + + Grid.Row="1" Margin="5" Padding="5"> @@ -146,7 +147,8 @@ - + + From 3ce37919e97f55ed26ceebaad9bbf0c3725096ef Mon Sep 17 00:00:00 2001 From: comintern Date: Tue, 13 Nov 2018 07:15:07 -0600 Subject: [PATCH 43/59] fix min and max properties --- Rubberduck.Core/UI/Controls/NumberPicker.xaml.cs | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/Rubberduck.Core/UI/Controls/NumberPicker.xaml.cs b/Rubberduck.Core/UI/Controls/NumberPicker.xaml.cs index 73a6be6898..99a5c0493f 100644 --- a/Rubberduck.Core/UI/Controls/NumberPicker.xaml.cs +++ b/Rubberduck.Core/UI/Controls/NumberPicker.xaml.cs @@ -27,14 +27,13 @@ public int NumValue } } - public int MinNumber { get => (int)GetValue(MinNumberProperty); set { SetValue(MinNumberProperty, value); - OnPropertyChanged(new DependencyPropertyChangedEventArgs(MinNumberProperty, NumValue - 1, NumValue)); + OnPropertyChanged(new DependencyPropertyChangedEventArgs(MinNumberProperty, GetValue(MinNumberProperty), value)); } } @@ -44,7 +43,7 @@ public int MaxNumber set { SetValue(MaxNumberProperty, value); - OnPropertyChanged(new DependencyPropertyChangedEventArgs(MaxNumberProperty, NumValue - 1, NumValue)); + OnPropertyChanged(new DependencyPropertyChangedEventArgs(MaxNumberProperty, GetValue(MaxNumberProperty), value)); } } From 184d32a6284630ca916d009be96d966717482062 Mon Sep 17 00:00:00 2001 From: comintern Date: Tue, 13 Nov 2018 07:41:12 -0600 Subject: [PATCH 44/59] Add missing resource string. --- Rubberduck.Core/UI/Settings/AutoCompleteSettings.xaml | 2 +- Rubberduck.Resources/Settings/AutoCompletesPage.resx | 3 +++ 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/Rubberduck.Core/UI/Settings/AutoCompleteSettings.xaml b/Rubberduck.Core/UI/Settings/AutoCompleteSettings.xaml index a54d24fc96..6b73849bec 100644 --- a/Rubberduck.Core/UI/Settings/AutoCompleteSettings.xaml +++ b/Rubberduck.Core/UI/Settings/AutoCompleteSettings.xaml @@ -111,7 +111,7 @@ IsChecked="{Binding ConcatVbNewLine}" Content="{Resx ResxName=Rubberduck.Resources.Settings.AutoCompletesPage, Key=ConcatVbNewLine}" /> -