Add QualifyWithMeQuickFix for ImplicitContainingWorkbook/WorksheetRef…

…erenceInspection

It does what the name suggests.

Rubberduck.CodeAnalysis/QuickFixes/Concrete/QualifyWithMeQuickFix.cs

@@ -0,0 +1,61 @@
+using Rubberduck.CodeAnalysis.Inspections;
+using Rubberduck.CodeAnalysis.Inspections.Concrete;
+using Rubberduck.CodeAnalysis.QuickFixes.Abstract;
+using Rubberduck.Parsing.Grammar;
+using Rubberduck.Parsing.Rewriter;
+
+namespace Rubberduck.CodeAnalysis.QuickFixes.Concrete
+{
+    /// <summary>
+    /// Qualifies an implicit reference with 'Me'.
+    /// </summary>
+    /// <inspections>
+    /// <inspection name="ImplicitContainingWorksheetReferenceInspection" />
+    /// <inspection name="ImplicitContainingWorkbookReferenceInspection" />
+    /// </inspections>
+    /// <canfix multiple="true" procedure="true" module="true" project="true" all="true" />
+    /// <example>
+    /// <before>
+    /// <![CDATA[
+    /// Private Sub Example()
+    ///     Dim foo As Range
+    ///     Set foo = Range("A1")
+    /// End Sub
+    /// ]]>
+    /// </before>
+    /// <after>
+    /// <![CDATA[
+    /// Private Sub Example()
+    ///     Dim foo As Range
+    ///     Set foo = Me.Range("A1")
+    /// End Sub
+    /// ]]>
+    /// </after>
+    /// </example>
+    internal class QualifyWithMeQuickFix : QuickFixBase
+    {
+        public QualifyWithMeQuickFix()
+            : base(typeof(ImplicitContainingWorkbookReferenceInspection),
+                typeof(ImplicitContainingWorksheetReferenceInspection))
+        {}
+
+        public override void Fix(IInspectionResult result, IRewriteSession rewriteSession)
+        {
+            var rewriter = rewriteSession.CheckOutModuleRewriter(result.QualifiedSelection.QualifiedName);
+
+            var context = result.Context;
+            rewriter.InsertBefore(context.Start.TokenIndex, $"{Tokens.Me}.");
+        }
+
+        public override string Description(IInspectionResult result)
+        {
+            return Resources.Inspections.QuickFixes.QualifyWithMeQuickFix;
+        }
+
+        public override bool CanFixMultiple => true;
+        public override bool CanFixInProcedure => true;
+        public override bool CanFixInModule => true;
+        public override bool CanFixInProject => true;
+        public override bool CanFixAll => true;
+    }
+}

Rubberduck.Resources/Inspections/QuickFixes.de.resx

@@ -300,4 +300,7 @@
   <data name="IgnoreInModuleQuickFix" xml:space="preserve">
     <value>In Modul ignorieren</value>
   </data>
+  <data name="QualifyWithMeQuickFix" xml:space="preserve">
+    <value>Qualifiziere die Referenz mit 'Me'.</value>
+  </data>
 </root>

Rubberduck.Resources/Inspections/QuickFixes.resx

@@ -300,4 +300,7 @@
   <data name="IgnoreInModuleQuickFix" xml:space="preserve">
     <value>Ignore in module</value>
   </data>
+  <data name="QualifyWithMeQuickFix" xml:space="preserve">
+    <value>Qualify reference with 'Me'.</value>
+  </data>
 </root>

RubberduckTests/QuickFixes/QualifyWithMeQuickFixTests.cs

@@ -0,0 +1,124 @@
+using System.Linq;
+using System.Threading;
+using NUnit.Framework;
+using Rubberduck.CodeAnalysis.Inspections.Concrete;
+using Rubberduck.CodeAnalysis.QuickFixes;
+using Rubberduck.CodeAnalysis.QuickFixes.Concrete;
+using Rubberduck.Parsing.Symbols;
+using Rubberduck.Parsing.VBA;
+using Rubberduck.VBEditor.SafeComWrappers;
+using RubberduckTests.Mocks;
+
+namespace RubberduckTests.QuickFixes
+{
+    [TestFixture]
+    public class QualifyWithMeQuickFixTests : QuickFixTestBase
+    {
+        [Test]
+        [Category("QuickFixes")]
+        public void QualifiesImplicitWorkbookReferencesInWorkbooks()
+        {
+            const string inputCode =
+                @"
+Sub foo()
+    Dim sheet As Worksheet
+    Set sheet = Worksheets(""Sheet1"")
+End Sub";
+
+            const string expectedCode =
+                @"
+Sub foo()
+    Dim sheet As Worksheet
+    Set sheet = Me.Worksheets(""Sheet1"")
+End Sub";
+
+            var actualCode = ApplyQuickFixToFirstInspectionResultForImplicitWorkbookInspection(inputCode);
+            Assert.AreEqual(expectedCode, actualCode);
+        }
+
+        private string ApplyQuickFixToFirstInspectionResultForImplicitWorkbookInspection(string inputCode)
+        {
+            var inputModule = ("SomeWorkbook", inputCode, ComponentType.Document);
+            var vbe = MockVbeBuilder.BuildFromModules(inputModule, ReferenceLibrary.Excel).Object;
+
+            var (state, rewriteManager) = MockParser.CreateAndParseWithRewritingManager(vbe);
+            using (state)
+            {
+                var documentModule = state.DeclarationFinder.UserDeclarations(DeclarationType.Document)
+                    .OfType<DocumentModuleDeclaration>()
+                    .Single();
+                documentModule.AddSupertypeName("Workbook");
+
+                var inspection = new ImplicitContainingWorkbookReferenceInspection(state);
+                var inspectionResults = inspection.GetInspectionResults(CancellationToken.None);
+
+                var rewriteSession = rewriteManager.CheckOutCodePaneSession();
+
+                var quickFix = QuickFix(state);
+
+                var resultToFix = inspectionResults.First();
+                quickFix.Fix(resultToFix, rewriteSession);
+
+                var module = state.DeclarationFinder.AllModules.First(qmn => qmn.ComponentName == "SomeWorkbook");
+
+                return rewriteSession.CheckOutModuleRewriter(module).GetText();
+            }
+        }
+
+        [Test]
+        [Category("QuickFixes")]
+        public void QualifiesImplicitWorksheetReferencesInWorksheets()
+        {
+            const string inputCode =
+                @"
+Private Sub Example()
+    Dim foo As Range
+    Set foo = Range(""A1"") 
+End Sub";
+
+            const string expectedCode =
+                @"
+Private Sub Example()
+    Dim foo As Range
+    Set foo = Me.Range(""A1"") 
+End Sub";
+
+            var actualCode = ApplyQuickFixToFirstInspectionResultForImplicitWorksheetInspection(inputCode);
+            Assert.AreEqual(expectedCode, actualCode);
+        }
+
+        private string ApplyQuickFixToFirstInspectionResultForImplicitWorksheetInspection(string inputCode)
+        {
+            var inputModule = ("Sheet1", inputCode, ComponentType.Document);
+            var vbe = MockVbeBuilder.BuildFromModules(inputModule, ReferenceLibrary.Excel).Object;
+
+            var (state, rewriteManager) = MockParser.CreateAndParseWithRewritingManager(vbe);
+            using (state)
+            {
+                var documentModule = state.DeclarationFinder.UserDeclarations(DeclarationType.Document)
+                    .OfType<DocumentModuleDeclaration>()
+                    .Single();
+                documentModule.AddSupertypeName("Worksheet");
+
+                var inspection = new ImplicitContainingWorksheetReferenceInspection(state);
+                var inspectionResults = inspection.GetInspectionResults(CancellationToken.None);
+
+                var rewriteSession = rewriteManager.CheckOutCodePaneSession();
+
+                var quickFix = QuickFix(state);
+
+                var resultToFix = inspectionResults.First();
+                quickFix.Fix(resultToFix, rewriteSession);
+
+                var module = state.DeclarationFinder.AllModules.First(qmn => qmn.ComponentName == "Sheet1");
+
+                return rewriteSession.CheckOutModuleRewriter(module).GetText();
+            }
+        }
+
+        protected override IQuickFix QuickFix(RubberduckParserState state)
+        {
+            return new QualifyWithMeQuickFix();
+        }
+    }
+}