Merge branch 'ninjectMemoryLeaks' of https://github.com/Hosch250/Rubberduck

Author: Hosch250

RetailCoder.VBE/Inspections/InspectionsUI.Designer.cs

@@ -565,4 +565,7 @@ If the parameter can be null, ignore this inspection result; passing a null valu
   <data name="MalformedAnnotationInspectionResultFormat" xml:space="preserve">
     <value>Malformed '{0}' annotation.</value>
   </data>
-</root>
+  <data name="WriteOnlyPropertyQuickFix" xml:space="preserve">
+    <value>Add property get</value>
+  </data>
+</root>

RetailCoder.VBE/Inspections/InspectionsUI.resx

@@ -54,6 +54,7 @@ public override IEnumerable<CodeInspectionQuickFix> QuickFixes
             {
                 return new CodeInspectionQuickFix[]
                 {
+                    new WriteOnlyPropertyQuickFix(Context, Target),
                     new IgnoreOnceQuickFix(Context, QualifiedSelection, Inspection.AnnotationName)
                 };
             }

RetailCoder.VBE/Inspections/WriteOnlyPropertyInspection.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Linq;
+using Antlr4.Runtime;
+using Rubberduck.Parsing.Grammar;
+using Rubberduck.Parsing.Symbols;
+
+namespace Rubberduck.Inspections
+{
+    public class WriteOnlyPropertyQuickFix : CodeInspectionQuickFix 
+    {
+        private readonly Declaration _target;
+
+        public WriteOnlyPropertyQuickFix(ParserRuleContext context, Declaration target)
+            : base(context, target.QualifiedSelection, InspectionsUI.WriteOnlyPropertyQuickFix)
+        {
+            _target = target;
+        }
+
+        public override void Fix()
+        {
+            var parameters = ((IDeclarationWithParameter) _target).Parameters.Cast<ParameterDeclaration>().ToList();
+
+            var signatureParams = parameters.Except(new[] {parameters.Last()}).Select(GetParamText);
+            var propertyGet = "Public Property Get " + _target.IdentifierName + "(" + string.Join(", ", signatureParams) +
+                              ") As " + parameters.Last().AsTypeName + Environment.NewLine + "End Property";
+
+            var module = _target.QualifiedName.QualifiedModuleName.Component.CodeModule;
+            module.InsertLines(_target.Selection.StartLine, propertyGet);
+        }
+
+        private string GetParamText(ParameterDeclaration param)
+        {
+            return (((VBAParser.ArgContext)param.Context).BYVAL() == null ? "ByRef " : "ByVal ") + param.IdentifierName + " As " + param.AsTypeName;
+        }
+    }
+}

RetailCoder.VBE/Inspections/WriteOnlyPropertyQuickFix.cs

@@ -373,6 +373,7 @@
     <Compile Include="Inspections\MalformedAnnotationInspection.cs" />
     <Compile Include="Inspections\ObjectVariableNotSetInspection.cs" />
     <Compile Include="Inspections\RemoveExplicitCallStatmentQuickFix.cs" />
+    <Compile Include="Inspections\WriteOnlyPropertyQuickFix.cs" />
     <Compile Include="Navigation\CodeExplorer\ICodeExplorerDeclarationViewModel.cs" />
     <Compile Include="Navigation\Folders\FolderHelper.cs" />
     <Compile Include="Refactorings\ExtractMethod\ExtractedMethod.cs" />

RetailCoder.VBE/Rubberduck.csproj

@@ -37,6 +37,8 @@ protected override bool CanExecuteImpl(object parameter)
 
         protected override void ExecuteImpl(object parameter)
         {
+            EnsureRubberduckIsReferencedForEarlyBoundTests();
+
             if (!_state.IsDirty())
             {
                 RunTests();
@@ -48,6 +50,18 @@ protected override void ExecuteImpl(object parameter)
             }
         }
 
+        private void EnsureRubberduckIsReferencedForEarlyBoundTests()
+        {
+            foreach (var member in _state.AllUserDeclarations)
+            {
+                if (member.AsTypeName == "Rubberduck.PermissiveAssertClass" ||
+                    member.AsTypeName == "Rubberduck.AssertClass")
+                {
+                    member.Project.EnsureReferenceToAddInLibrary();
+                }
+            }
+        }
+
         private void TestsRefreshed(object sender, EventArgs e)
         {
             RunTests();

RetailCoder.VBE/UI/Command/RunAllTestsCommand.cs

@@ -228,8 +228,22 @@ private bool CanExecuteRefreshCommand(object parameter)
             return !Model.IsBusy && _state.IsDirty();
         }
 
+        private void EnsureRubberduckIsReferencedForEarlyBoundTests()
+        {
+            foreach (var member in _state.AllUserDeclarations)
+            {
+                if (member.AsTypeName == "Rubberduck.PermissiveAssertClass" ||
+                    member.AsTypeName == "Rubberduck.AssertClass")
+                {
+                    member.Project.EnsureReferenceToAddInLibrary();
+                }
+            }
+        }
+
         private void ExecuteRepeatLastRunCommand(object parameter)
         {
+            EnsureRubberduckIsReferencedForEarlyBoundTests();
+
             var tests = _model.LastRun.ToList();
             _model.ClearLastRun();
 
@@ -246,6 +260,8 @@ private void ExecuteRepeatLastRunCommand(object parameter)
 
         private void ExecuteRunNotExecutedTestsCommand(object parameter)
         {
+            EnsureRubberduckIsReferencedForEarlyBoundTests();
+
             _model.ClearLastRun();
 
             var stopwatch = new Stopwatch();
@@ -261,6 +277,8 @@ private void ExecuteRunNotExecutedTestsCommand(object parameter)
 
         private void ExecuteRunFailedTestsCommand(object parameter)
         {
+            EnsureRubberduckIsReferencedForEarlyBoundTests();
+
             _model.ClearLastRun();
 
             var stopwatch = new Stopwatch();
@@ -276,6 +294,8 @@ private void ExecuteRunFailedTestsCommand(object parameter)
 
         private void ExecuteRunPassedTestsCommand(object parameter)
         {
+            EnsureRubberduckIsReferencedForEarlyBoundTests();
+
             _model.ClearLastRun();
 
             var stopwatch = new Stopwatch();
@@ -301,6 +321,8 @@ private void ExecuteSelectedTestCommand(object obj)
                 return;
             }
 
+            EnsureRubberduckIsReferencedForEarlyBoundTests();
+
             _model.ClearLastRun();
 
             var stopwatch = new Stopwatch();

RetailCoder.VBE/UI/UnitTesting/TestExplorerViewModel.cs

@@ -193,6 +193,117 @@ Property Let Foo(value)
             Assert.IsFalse(inspectionResults.Any());
         }
 
+        [TestMethod]
+        [TestCategory("Inspections")]
+        public void WriteOnlyProperty_AddPropertyGetQuickFixWorks_ImplicitTypesAndAccessibility()
+        {
+            const string inputCode =
+@"Property Let Foo(value)
+End Property";
+
+            const string expectedCode =
+@"Public Property Get Foo() As Variant
+End Property
+Property Let Foo(value)
+End Property";
+
+            //Arrange
+            var builder = new MockVbeBuilder();
+            var project = builder.ProjectBuilder("VBAProject", vbext_ProjectProtection.vbext_pp_none)
+                .AddComponent("MyClass", vbext_ComponentType.vbext_ct_ClassModule, inputCode)
+                .Build();
+            var module = project.Object.VBComponents.Item(0).CodeModule;
+            var vbe = builder.AddProject(project).Build();
+
+            var mockHost = new Mock<IHostApplication>();
+            mockHost.SetupAllProperties();
+            var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock<ISinks>().Object));
+
+            parser.Parse(new CancellationTokenSource());
+            if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); }
+
+            var inspection = new WriteOnlyPropertyInspection(parser.State);
+            var inspectionResults = inspection.GetInspectionResults();
+
+            inspectionResults.First().QuickFixes.Single(s => s is WriteOnlyPropertyQuickFix).Fix();
+
+            Assert.AreEqual(expectedCode, module.Lines());
+        }
+
+        [TestMethod]
+        [TestCategory("Inspections")]
+        public void WriteOnlyProperty_AddPropertyGetQuickFixWorks_ExlicitTypesAndAccessibility()
+        {
+            const string inputCode =
+@"Public Property Let Foo(ByVal value As Integer)
+End Property";
+
+            const string expectedCode =
+@"Public Property Get Foo() As Integer
+End Property
+Public Property Let Foo(ByVal value As Integer)
+End Property";
+
+            //Arrange
+            var builder = new MockVbeBuilder();
+            var project = builder.ProjectBuilder("VBAProject", vbext_ProjectProtection.vbext_pp_none)
+                .AddComponent("MyClass", vbext_ComponentType.vbext_ct_ClassModule, inputCode)
+                .Build();
+            var module = project.Object.VBComponents.Item(0).CodeModule;
+            var vbe = builder.AddProject(project).Build();
+
+            var mockHost = new Mock<IHostApplication>();
+            mockHost.SetupAllProperties();
+            var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock<ISinks>().Object));
+
+            parser.Parse(new CancellationTokenSource());
+            if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); }
+
+            var inspection = new WriteOnlyPropertyInspection(parser.State);
+            var inspectionResults = inspection.GetInspectionResults();
+
+            inspectionResults.First().QuickFixes.Single(s => s is WriteOnlyPropertyQuickFix).Fix();
+
+            Assert.AreEqual(expectedCode, module.Lines());
+        }
+
+        [TestMethod]
+        [TestCategory("Inspections")]
+        public void WriteOnlyProperty_AddPropertyGetQuickFixWorks_MultipleParams()
+        {
+            const string inputCode =
+@"Public Property Let Foo(value1, ByVal value2 As Integer, ByRef value3 As Long, value4 As Date, ByVal value5, value6 As String)
+End Property";
+
+            const string expectedCode =
+@"Public Property Get Foo(ByRef value1 As Variant, ByVal value2 As Integer, ByRef value3 As Long, ByRef value4 As Date, ByVal value5 As Variant) As String
+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";
+
+            //Arrange
+            var builder = new MockVbeBuilder();
+            var project = builder.ProjectBuilder("VBAProject", vbext_ProjectProtection.vbext_pp_none)
+                .AddComponent("MyClass", vbext_ComponentType.vbext_ct_ClassModule, inputCode)
+                .Build();
+            var module = project.Object.VBComponents.Item(0).CodeModule;
+            var vbe = builder.AddProject(project).Build();
+
+            var mockHost = new Mock<IHostApplication>();
+            mockHost.SetupAllProperties();
+            var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock<ISinks>().Object));
+
+            parser.Parse(new CancellationTokenSource());
+            if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); }
+
+            var inspection = new WriteOnlyPropertyInspection(parser.State);
+            var inspectionResults = inspection.GetInspectionResults();
+
+            inspectionResults.First().QuickFixes.Single(s => s is WriteOnlyPropertyQuickFix).Fix();
+
+            Assert.AreEqual(expectedCode, module.Lines());
+        }
+
         [TestMethod]
         [TestCategory("Inspections")]
         public void WriteOnlyProperty_IgnoreQuickFixWorks()