Reorganizing Rewriting

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;
@@ -98,8 +96,6 @@ internal Parser(object vbe) : this()
             var projectRepository = new ProjectsRepository(_vbe);
             _state = new RubberduckParserState(_vbe, projectRepository, declarationFinderFactory, _vbeEvents);
             _state.StateChanged += _state_StateChanged;
-
-            var sourceFileHandler = _vbe.TempSourceFileHandler;
             var vbeVersion = double.Parse(_vbe.Version, CultureInfo.InvariantCulture);
             var predefinedCompilationConstants = new VBAPredefinedCompilationConstants(vbeVersion);
             var typeLibProvider = new TypeLibWrapperProvider(projectRepository);
@@ -112,7 +108,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);
@@ -133,14 +128,12 @@ internal Parser(object vbe) : this()
                     }
                 );
             var codePaneSourceCodeHandler = new CodePaneSourceCodeHandler(projectRepository);
-            var moduleRewriterFactory = new ModuleRewriterFactory(
-                codePaneSourceCodeHandler,
-                attributesSourceCodeHandler);
+            var sourceFileHandler = _vbe.TempSourceFileHandler;
+            var attributesSourceCodeHandler = new SourceFileHandlerSourceCodeHandlerAdapter(sourceFileHandler, projectRepository);
             var moduleParser = new ModuleParser(
                 codePaneSourceCodeHandler,
                 attributesSourceCodeHandler,
-                stringParser,
-                moduleRewriterFactory);
+                stringParser);
             var parseRunner = new ParseRunner(
                 _state,
                 parserStateManager,

Rubberduck.CodeAnalysis/Inspections/Abstract/QuickFixBase.cs

@@ -3,8 +3,9 @@
 using System.Linq;
 using NLog;
 using Rubberduck.Parsing.Inspections.Abstract;
-using Rubberduck.Parsing.VBA;
+using Rubberduck.Parsing.Rewriter;
 using Rubberduck.Parsing.VBA.Extensions;
+using Rubberduck.Parsing.VBA.Parsing;
 
 namespace Rubberduck.Inspections.Abstract
 {
@@ -39,7 +40,9 @@ public void RemoveInspections(params Type[] inspections)
             _supportedInspections = _supportedInspections.Except(inspections).ToHashSet();
         }
 
-        public abstract void Fix(IInspectionResult result);
+        public virtual CodeKind TargetCodeKind => CodeKind.CodePaneCode;
+
+        public abstract void Fix(IInspectionResult result, IRewriteSession rewriteSession);
         public abstract string Description(IInspectionResult result);
 
         public abstract bool CanFixInProcedure { get; }

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.
         /// </summary>
         /// <param name="reference">The identifier reference to analyze</param>
-        /// <param name="state">The parser state</param>
-        public static bool RequiresSetAssignment(IdentifierReference reference, RubberduckParserState state)
+        /// <param name="declarationFinderProvider">The parser state</param>
+        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<VBAParser.LetStmtContext>() == 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));
         }

Rubberduck.CodeAnalysis/QuickFixes/AccessSheetUsingCodeNameQuickFix.cs

@@ -6,25 +6,26 @@
 using Rubberduck.Parsing;
 using Rubberduck.Parsing.Grammar;
 using Rubberduck.Parsing.Inspections.Abstract;
+using Rubberduck.Parsing.Rewriter;
 using Rubberduck.Parsing.VBA;
 
 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)
+        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<VBAParser.SetStmtContext>();
             var isArgument = referenceResult.Context.GetAncestor<VBAParser.ArgumentContext>() != null;
@@ -36,14 +37,14 @@ 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
             {
                 // 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<VBAParser.ModuleBodyElementContext>();
@@ -71,7 +72,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);

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,8 @@ public AddIdentifierToWhiteListQuickFix(IPersistanceService<CodeInspectionSettin
             _settings = settings;
         }
 
-        public override void Fix(IInspectionResult result)
+        //The rewriteSession is optional since it is not used in this particular quickfix.
+        public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null)
         {
             var inspectionSettings = _settings.Load(new CodeInspectionSettings()) ?? new CodeInspectionSettings();
             var whitelist = inspectionSettings.WhitelistedIdentifiers;

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)
+        public override void Fix(IInspectionResult result, IRewriteSession rewriteSession)
         {
-            IModuleRewriter 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)
                 {

Rubberduck.CodeAnalysis/QuickFixes/ApplicationWorksheetFunctionQuickFix.cs

@@ -1,23 +1,19 @@
 using Rubberduck.Inspections.Abstract;
 using Rubberduck.Inspections.Concrete;
 using Rubberduck.Parsing.Inspections.Abstract;
-using Rubberduck.Parsing.VBA;
+using Rubberduck.Parsing.Rewriter;
 
 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)
+        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.");
         }
 

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)
+        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<VBAParser.EndOfStatementContext>());
@@ -42,7 +42,7 @@ public override void Fix(IInspectionResult result)
                 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)
         {
@@ -116,7 +116,7 @@ private void InsertLocalVariableDeclarationAndAssignment(IModuleRewriter rewrite
             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}";

Rubberduck.CodeAnalysis/QuickFixes/ChangeDimToPrivateQuickFix.cs

@@ -2,23 +2,19 @@
 using Rubberduck.Inspections.Concrete;
 using Rubberduck.Parsing.Grammar;
 using Rubberduck.Parsing.Inspections.Abstract;
-using Rubberduck.Parsing.VBA;
+using Rubberduck.Parsing.Rewriter;
 
 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)
+        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);