Implemented as abstract factory pattern per comments

BZngr · BZngr · commit e21a5adc52e3 · 2017-02-25T16:52:05.000-08:00
diff --git a/RetailCoder.VBE/Inspections/AssignedByValParameterInspection.cs b/RetailCoder.VBE/Inspections/AssignedByValParameterInspection.cs
@@ -6,15 +6,19 @@
 using Rubberduck.Parsing.Grammar;
 using Rubberduck.Parsing.Symbols;
 using Rubberduck.Parsing.VBA;
+using Rubberduck.UI.Refactorings;
 
 namespace Rubberduck.Inspections
 {
     public sealed class AssignedByValParameterInspection : InspectionBase
     {
-        public AssignedByValParameterInspection(RubberduckParserState state)
+        private IAssignedByValParameterQuickFixDialogFactory _dialogFactory;
+        public AssignedByValParameterInspection(RubberduckParserState state, IAssignedByValParameterQuickFixDialogFactory dialogFactory)
             : base(state)
         {
             Severity = DefaultSeverity;
+            _dialogFactory = dialogFactory;
+
         }
 
         public override string Meta { get { return InspectionsUI.AssignedByValParameterInspectionMeta; } }
@@ -31,7 +35,7 @@ public override IEnumerable<InspectionResultBase> GetInspectionResults()
                 .ToList();
 
             return parameters
-                .Select(param => new AssignedByValParameterInspectionResult(this, param))
+                .Select(param => new AssignedByValParameterInspectionResult(this, param, _dialogFactory))
                 .ToList();
         }
     }
diff --git a/RetailCoder.VBE/Inspections/QuickFixes/AssignedByValParameterMakeLocalCopyQuickFix.cs b/RetailCoder.VBE/Inspections/QuickFixes/AssignedByValParameterMakeLocalCopyQuickFix.cs
@@ -17,15 +17,15 @@ namespace Rubberduck.Inspections.QuickFixes
     public class AssignedByValParameterMakeLocalCopyQuickFix : QuickFixBase
     {
         private readonly Declaration _target;
+        private readonly IAssignedByValParameterQuickFixDialogFactory _dialogFactory;
         private string _localCopyVariableName;
         private string[] _variableNamesAccessibleToProcedureContext;
-        private IAssignedByValParameterQuickFixDialogFactory _factory;
 
-        public AssignedByValParameterMakeLocalCopyQuickFix(Declaration target, QualifiedSelection selection, IAssignedByValParameterQuickFixDialogFactory factory)
+        public AssignedByValParameterMakeLocalCopyQuickFix(Declaration target, QualifiedSelection selection, IAssignedByValParameterQuickFixDialogFactory dialogFactory)
             : base(target.Context, selection, InspectionsUI.AssignedByValParameterMakeLocalCopyQuickFix)
         {
             _target = target;
-            _factory = factory;
+            _dialogFactory = dialogFactory;
             _localCopyVariableName = "x" + _target.IdentifierName.CapitalizeFirstLetter();
             _variableNamesAccessibleToProcedureContext = GetVariableNamesAccessibleToProcedureContext(_target.Context.Parent.Parent);
         }
@@ -49,7 +49,7 @@ public override void Fix()
 
         private void RequestLocalCopyVariableName()
         {
-            using( var view = _factory.Create(_target.IdentifierName, _target.DeclarationType.ToString()))
+            using( var view = _dialogFactory.Create(_target.IdentifierName, _target.DeclarationType.ToString()))
             {
                 view.NewName = _localCopyVariableName;
                 view.IdentifierNamesAlreadyDeclared = _variableNamesAccessibleToProcedureContext;
diff --git a/RetailCoder.VBE/Inspections/Results/AssignedByValParameterInspectionResult.cs b/RetailCoder.VBE/Inspections/Results/AssignedByValParameterInspectionResult.cs
@@ -11,8 +11,13 @@ namespace Rubberduck.Inspections.Results
     public class AssignedByValParameterInspectionResult : InspectionResultBase
     {
         private IEnumerable<QuickFixBase> _quickFixes;
+        private IAssignedByValParameterQuickFixDialogFactory _dialogFactory;
 
-        public AssignedByValParameterInspectionResult(IInspection inspection, Declaration target) : base(inspection, target) { }
+        public AssignedByValParameterInspectionResult(IInspection inspection, Declaration target, IAssignedByValParameterQuickFixDialogFactory dialogFactory) 
+            : base(inspection, target)
+        {
+            _dialogFactory = dialogFactory;
+        }
 
         public override string Description
         {
@@ -26,10 +31,9 @@ public override IEnumerable<QuickFixBase> QuickFixes
         {
             get
             {
-                IAssignedByValParameterQuickFixDialogFactory factory = new AssignedByValParameterQuickFixDialogFactory();
                 return _quickFixes ?? (_quickFixes = new QuickFixBase[]
                 {
-                    new AssignedByValParameterMakeLocalCopyQuickFix(Target, QualifiedSelection, factory),
+                    new AssignedByValParameterMakeLocalCopyQuickFix(Target, QualifiedSelection, _dialogFactory),
                     new PassParameterByReferenceQuickFix(Target, QualifiedSelection),
                     new IgnoreOnceQuickFix(Context, QualifiedSelection, Inspection.AnnotationName)
                 });
diff --git a/RetailCoder.VBE/Root/RubberduckModule.cs b/RetailCoder.VBE/Root/RubberduckModule.cs
@@ -36,6 +36,8 @@
 using Rubberduck.VBEditor.SafeComWrappers.Abstract;
 using Rubberduck.VBEditor.SafeComWrappers.Office.Core.Abstract;
 using ReparseCommandMenuItem = Rubberduck.UI.Command.MenuItems.CommandBars.ReparseCommandMenuItem;
+using Rubberduck.UI.Refactorings;
+using Rubberduck.Inspections;
 
 namespace Rubberduck.Root
 {
@@ -69,6 +71,7 @@ public override void Load()
             Bind<IOperatingSystem>().To<WindowsOperatingSystem>().InSingletonScope();
 
             Bind<CommandBase>().To<VersionCheckCommand>().WhenInjectedExactlyInto<App>();
+
             BindCodeInspectionTypes();
 
             var assemblies = new[]
@@ -146,6 +149,7 @@ public override void Load()
             ConfigureProjectExplorerContextMenu();
             
             BindWindowsHooks();
+
         }
 
         private void BindDockableToolwindows()
@@ -425,6 +429,10 @@ private IEnumerable<ICommandMenuItem> GetRubberduckCommandBarItems()
 
         private IEnumerable<IMenuItem> GetRubberduckMenuItems()
         {
+            //This bind needs to occur before the the new array is built by the function calls
+            Bind<IAssignedByValParameterQuickFixDialogFactory>().To<AssignedByValParameterQuickFixDialogFactory>()
+                .WhenInjectedInto<AssignedByValParameterInspection>();
+
             return new[]
             {
                 KernelInstance.Get<AboutCommandMenuItem>(),
diff --git a/RetailCoder.VBE/Rubberduck.csproj b/RetailCoder.VBE/Rubberduck.csproj
@@ -471,8 +471,10 @@
     <Compile Include="UI\CodeExplorer\Commands\AddTestModuleCommand.cs" />
     <Compile Include="UI\ModernFolderBrowser.cs" />
     <Compile Include="UI\Refactorings\AssignedByValParameterQuickFixDialogFactory.cs" />
+    <Compile Include="UI\Refactorings\AssignedByValParameterQuickFixMockDialogFactory.cs" />
     <Compile Include="UI\Refactorings\IAssignedByValParameterQuickFixDialog.cs" />
     <Compile Include="UI\Refactorings\IAssignedByValParameterQuickFixDialogFactory.cs" />
+    <Compile Include="UI\Refactorings\AssignedByValParameterQuickFixMockDialog.cs" />
     <Compile Include="VersionCheck\IVersionCheck.cs" />
     <Compile Include="UI\Command\MenuItems\CommandBars\AppCommandBarBase.cs" />
     <Compile Include="UI\Command\MenuItems\CommandBars\ContextSelectionLabelMenuItem.cs" />
diff --git a/RetailCoder.VBE/UI/REfactorings/AssignedByValParameterQuickFixMockDialog.cs b/RetailCoder.VBE/UI/REfactorings/AssignedByValParameterQuickFixMockDialog.cs
@@ -0,0 +1,36 @@
+﻿using System.Windows.Forms;
+
+namespace Rubberduck.UI.Refactorings
+{
+    public class AssignedByValParameterQuickFixMockDialog : IAssignedByValParameterQuickFixDialog
+    {
+        private string _testLocalVariableName;
+        internal AssignedByValParameterQuickFixMockDialog(string testLocalVariableName = "")
+        {
+            _testLocalVariableName = testLocalVariableName;
+        }
+        public DialogResult ShowDialog() { return DialogResult.OK; }
+
+        public void Dispose()
+        {
+        }
+        public DialogResult DialogResult { set; get; }
+        private string _newName;
+        public string NewName
+        {
+            get
+            {
+                if (_testLocalVariableName.Length > 0)
+                {
+                    return _testLocalVariableName;
+                }
+                else
+                {
+                    return _newName;
+                }
+            }
+            set { _newName = value; }
+        }
+        public string[] IdentifierNamesAlreadyDeclared { get; set; }
+    }
+}
diff --git a/RetailCoder.VBE/UI/Refactorings/AssignedByValParameterQuickFixDialog.cs b/RetailCoder.VBE/UI/Refactorings/AssignedByValParameterQuickFixDialog.cs
@@ -10,7 +10,7 @@ public partial class AssignedByValParameterQuickFixDialog : Form, IAssignedByVal
         private string[] _identifierNamesAlreadyDeclared;
         private string _identifierName;
 
-        public AssignedByValParameterQuickFixDialog(string identifierName, string declarationType)
+        internal AssignedByValParameterQuickFixDialog(string identifierName, string declarationType)
         {
             InitializeComponent();
             InitializeCaptions(identifierName, declarationType);
diff --git a/RetailCoder.VBE/UI/Refactorings/AssignedByValParameterQuickFixDialogFactory.cs b/RetailCoder.VBE/UI/Refactorings/AssignedByValParameterQuickFixDialogFactory.cs
@@ -1,11 +1,4 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Rubberduck.Parsing.Symbols;
-using Rubberduck.VBEditor;
-
+﻿
 namespace Rubberduck.UI.Refactorings
 {
     public class AssignedByValParameterQuickFixDialogFactory : IAssignedByValParameterQuickFixDialogFactory
diff --git a/RetailCoder.VBE/UI/Refactorings/AssignedByValParameterQuickFixMockDialogFactory.cs b/RetailCoder.VBE/UI/Refactorings/AssignedByValParameterQuickFixMockDialogFactory.cs
@@ -0,0 +1,20 @@
+﻿
+namespace Rubberduck.UI.Refactorings
+{
+    public class AssignedByValParameterQuickFixMockDialogFactory : IAssignedByValParameterQuickFixDialogFactory
+    {
+        private string _userEnteredVariableName;
+        public AssignedByValParameterQuickFixMockDialogFactory()
+        {
+            _userEnteredVariableName = string.Empty;
+        }
+        public AssignedByValParameterQuickFixMockDialogFactory(string userEnteredVariableName)
+        {
+            _userEnteredVariableName = userEnteredVariableName;
+        }
+        IAssignedByValParameterQuickFixDialog IAssignedByValParameterQuickFixDialogFactory.Create(string identifier, string identifierType)
+        {
+            return new AssignedByValParameterQuickFixMockDialog(_userEnteredVariableName);
+        }
+    }
+}
diff --git a/RubberduckTests/Inspections/AssignedByValParameterInspectionTests.cs b/RubberduckTests/Inspections/AssignedByValParameterInspectionTests.cs
@@ -145,7 +145,7 @@ Public Sub Foo(ByVal arg1 As String)
         [TestCategory("Inspections")]
         public void InspectionType()
         {
-            var inspection = new AssignedByValParameterInspection(null);
+            var inspection = new AssignedByValParameterInspection(null,null);
             Assert.AreEqual(CodeInspectionType.CodeQualityIssues, inspection.InspectionType);
         }
 
@@ -154,7 +154,7 @@ public void InspectionType()
         public void InspectionName()
         {
             const string inspectionName = "AssignedByValParameterInspection";
-            var inspection = new AssignedByValParameterInspection(null);
+            var inspection = new AssignedByValParameterInspection(null,null);
 
             Assert.AreEqual(inspectionName, inspection.Name);
         }
@@ -194,7 +194,7 @@ private string GetModuleContent(Mock<IVBE> vbe)
             parser.Parse(new CancellationTokenSource());
             if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); }
 
-            var inspection = new AssignedByValParameterInspection(parser.State);
+            var inspection = new AssignedByValParameterInspection(parser.State,null);
             return inspection.GetInspectionResults();
         }
 
diff --git a/RubberduckTests/Inspections/AssignedByValParameterMakeLocalCopyQuickFixTests.cs b/RubberduckTests/Inspections/AssignedByValParameterMakeLocalCopyQuickFixTests.cs
@@ -10,18 +10,14 @@
 using RubberduckTests.Mocks;
 using System.Threading;
 using Rubberduck.UI.Refactorings;
-using Rubberduck.Parsing.Symbols;
-using Rubberduck.VBEditor;
-using System;
-using System.Windows.Forms;
+
 
 namespace RubberduckTests.Inspections
 {
 
     [TestClass]
-    public class AssignedByValParameterMakeLocalCopyQuickFixTests : IAssignedByValParameterQuickFixDialogFactory
+    public class AssignedByValParameterMakeLocalCopyQuickFixTests
     {
-        private IAssignedByValParameterQuickFixDialog _mockDialog;
 
         [TestMethod]
         [TestCategory("Inspections")]
@@ -442,7 +438,7 @@ End Function
         [TestCategory("Inspections")]
         public void InspectionType()
         {
-            var inspection = new AssignedByValParameterInspection(null);
+            var inspection = new AssignedByValParameterInspection(null,null);
             Assert.AreEqual(CodeInspectionType.CodeQualityIssues, inspection.InspectionType);
         }
 
@@ -451,102 +447,42 @@ public void InspectionType()
         public void InspectionName()
         {
             const string inspectionName = "AssignedByValParameterInspection";
-            var inspection = new AssignedByValParameterInspection(null);
+            var inspection = new AssignedByValParameterInspection(null,null);
 
             Assert.AreEqual(inspectionName, inspection.Name);
         }
 
         private string ApplyLocalVariableQuickFixToVBAFragment(string inputCode, string userEnteredName = "")
         {
             var vbe = BuildMockVBEStandardModuleForVBAFragment(inputCode);
-            var inspectionResults = GetInspectionResults(vbe);
-
-            //If the test calls for a specific user entered variable name, then
-            //make the Mock dialog now so we can retain the input
-            if (userEnteredName.Length > 0)
-            {
-                var mockDialog = new MockAssignedByValParameterQuickFixDialog();
-                mockDialog.SetupUserEnteredName(userEnteredName);
-                _mockDialog = (IAssignedByValParameterQuickFixDialog)mockDialog;
-            }
+            var inspectionResults = GetInspectionResults(vbe, userEnteredName);
 
-            var quickFixBase = inspectionResults.First().QuickFixes.Single(s => s is AssignedByValParameterMakeLocalCopyQuickFix);
-
-            //Create a new instance of the QuickFix referencing the test-version of the dialog factory
-            var testQuickFix = new AssignedByValParameterMakeLocalCopyQuickFix(inspectionResults.FirstOrDefault().Target, quickFixBase.Selection, this);
-            testQuickFix.Fix();
+            inspectionResults.First().QuickFixes.Single(s => s is AssignedByValParameterMakeLocalCopyQuickFix).Fix();
 
             return GetModuleContent(vbe);
         }
-        private string GetModuleContent(Mock<IVBE> vbe)
-        {
-            var project = vbe.Object.VBProjects[0];
-            var module = project.VBComponents[0].CodeModule;
-            return module.Content();
-        }
-
-        private IEnumerable<Rubberduck.Inspections.Abstract.InspectionResultBase> GetInspectionResults(Mock<IVBE> vbe)
-        {
-            var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object));
-            parser.Parse(new CancellationTokenSource());
-            if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); }
-
-            var inspection = new AssignedByValParameterInspection(parser.State);
-            return inspection.GetInspectionResults();
-        }
 
         private Mock<IVBE> BuildMockVBEStandardModuleForVBAFragment(string inputCode)
         {
             var builder = new MockVbeBuilder();
             IVBComponent component;
             return builder.BuildFromSingleStandardModule(inputCode, out component);
         }
-
-        //Test class provides the dialog factory implementation for tests
-        public IAssignedByValParameterQuickFixDialog Create(string identifier, string identifierType)
+        private IEnumerable<Rubberduck.Inspections.Abstract.InspectionResultBase> GetInspectionResults(Mock<IVBE> vbe, string userEnteredName)
         {
-            if(_mockDialog == null)
-            {
-                _mockDialog = (IAssignedByValParameterQuickFixDialog)new MockAssignedByValParameterQuickFixDialog();
-            }
-            return _mockDialog;
+            var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object));
+            parser.Parse(new CancellationTokenSource());
+            if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); }
+
+            var inspection = new AssignedByValParameterInspection(parser.State,new AssignedByValParameterQuickFixMockDialogFactory(userEnteredName));
+            return inspection.GetInspectionResults();
         }
 
-        //Provide an IAssignedByValParameterQuickFixDialog implementation for testing
-        public class MockAssignedByValParameterQuickFixDialog : IAssignedByValParameterQuickFixDialog
+        private string GetModuleContent(Mock<IVBE> vbe)
         {
-            private string _testLocalVariableName;
-            public MockAssignedByValParameterQuickFixDialog()
-            {
-                _testLocalVariableName = string.Empty;
-            }
-            public DialogResult ShowDialog() { return DialogResult.OK; }
-
-            public void Dispose()
-            {
-            }
-            public void SetupUserEnteredName(string response)
-            {
-                _testLocalVariableName = response;
-            }
-            public DialogResult DialogResult { set;  get; }
-            private string _newName;
-            public string NewName
-            {
-                get
-                {
-                    if (_testLocalVariableName.Length > 0)
-                    {
-                        return _testLocalVariableName;
-                    }
-                    else
-                    {
-                        return _newName;
-                    }
-                }
-                set {   _newName = value;  }
-            }
-            public string[] IdentifierNamesAlreadyDeclared { get; set; }
+            var project = vbe.Object.VBProjects[0];
+            var module = project.VBComponents[0].CodeModule;
+            return module.Content();
         }
     }
 }
diff --git a/RubberduckTests/Inspections/PassParameterByReferenceQuickFixTests.cs b/RubberduckTests/Inspections/PassParameterByReferenceQuickFixTests.cs

Original file line number	Diff line number	Diff line change
`@@ -6,15 +6,19 @@`
`6`	`6`	`using Rubberduck.Parsing.Grammar;`
`7`	`7`	`using Rubberduck.Parsing.Symbols;`
`8`	`8`	`using Rubberduck.Parsing.VBA;`
	`9`	`+using Rubberduck.UI.Refactorings;`
`9`	`10`
`10`	`11`	`namespace Rubberduck.Inspections`
`11`	`12`	`{`
`12`	`13`	`public sealed class AssignedByValParameterInspection : InspectionBase`
`13`	`14`	`{`
`14`		`- public AssignedByValParameterInspection(RubberduckParserState state)`
	`15`	`+ private IAssignedByValParameterQuickFixDialogFactory _dialogFactory;`
	`16`	`+ public AssignedByValParameterInspection(RubberduckParserState state, IAssignedByValParameterQuickFixDialogFactory dialogFactory)`
`15`	`17`	`: base(state)`
`16`	`18`	`{`
`17`	`19`	`Severity = DefaultSeverity;`
	`20`	`+ _dialogFactory = dialogFactory;`
	`21`	`+`
`18`	`22`	`}`
`19`	`23`
`20`	`24`	`public override string Meta { get { return InspectionsUI.AssignedByValParameterInspectionMeta; } }`
`@@ -31,7 +35,7 @@ public override IEnumerable<InspectionResultBase> GetInspectionResults()`
`31`	`35`	`.ToList();`
`32`	`36`
`33`	`37`	`return parameters`
`34`		`- .Select(param => new AssignedByValParameterInspectionResult(this, param))`
	`38`	`+ .Select(param => new AssignedByValParameterInspectionResult(this, param, _dialogFactory))`
`35`	`39`	`.ToList();`
`36`	`40`	`}`
`37`	`41`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,15 +17,15 @@ namespace Rubberduck.Inspections.QuickFixes`
`17`	`17`	`public class AssignedByValParameterMakeLocalCopyQuickFix : QuickFixBase`
`18`	`18`	`{`
`19`	`19`	`private readonly Declaration _target;`
	`20`	`+ private readonly IAssignedByValParameterQuickFixDialogFactory _dialogFactory;`
`20`	`21`	`private string _localCopyVariableName;`
`21`	`22`	`private string[] _variableNamesAccessibleToProcedureContext;`
`22`		`- private IAssignedByValParameterQuickFixDialogFactory _factory;`
`23`	`23`
`24`		`- public AssignedByValParameterMakeLocalCopyQuickFix(Declaration target, QualifiedSelection selection, IAssignedByValParameterQuickFixDialogFactory factory)`
	`24`	`+ public AssignedByValParameterMakeLocalCopyQuickFix(Declaration target, QualifiedSelection selection, IAssignedByValParameterQuickFixDialogFactory dialogFactory)`
`25`	`25`	`: base(target.Context, selection, InspectionsUI.AssignedByValParameterMakeLocalCopyQuickFix)`
`26`	`26`	`{`
`27`	`27`	`_target = target;`
`28`		`- _factory = factory;`
	`28`	`+ _dialogFactory = dialogFactory;`
`29`	`29`	`_localCopyVariableName = "x" + _target.IdentifierName.CapitalizeFirstLetter();`
`30`	`30`	`_variableNamesAccessibleToProcedureContext = GetVariableNamesAccessibleToProcedureContext(_target.Context.Parent.Parent);`
`31`	`31`	`}`
`@@ -49,7 +49,7 @@ public override void Fix()`
`49`	`49`
`50`	`50`	`private void RequestLocalCopyVariableName()`
`51`	`51`	`{`
`52`		`- using( var view = _factory.Create(_target.IdentifierName, _target.DeclarationType.ToString()))`
	`52`	`+ using( var view = _dialogFactory.Create(_target.IdentifierName, _target.DeclarationType.ToString()))`
`53`	`53`	`{`
`54`	`54`	`view.NewName = _localCopyVariableName;`
`55`	`55`	`view.IdentifierNamesAlreadyDeclared = _variableNamesAccessibleToProcedureContext;`
Original file line number	Diff line number	Diff line change
`@@ -11,8 +11,13 @@ namespace Rubberduck.Inspections.Results`
`11`	`11`	`public class AssignedByValParameterInspectionResult : InspectionResultBase`
`12`	`12`	`{`
`13`	`13`	`private IEnumerable<QuickFixBase> _quickFixes;`
	`14`	`+ private IAssignedByValParameterQuickFixDialogFactory _dialogFactory;`
`14`	`15`
`15`		`- public AssignedByValParameterInspectionResult(IInspection inspection, Declaration target) : base(inspection, target) { }`
	`16`	`+ public AssignedByValParameterInspectionResult(IInspection inspection, Declaration target, IAssignedByValParameterQuickFixDialogFactory dialogFactory)`
	`17`	`+ : base(inspection, target)`
	`18`	`+ {`
	`19`	`+ _dialogFactory = dialogFactory;`
	`20`	`+ }`
`16`	`21`
`17`	`22`	`public override string Description`
`18`	`23`	`{`
`@@ -26,10 +31,9 @@ public override IEnumerable<QuickFixBase> QuickFixes`
`26`	`31`	`{`
`27`	`32`	`get`
`28`	`33`	`{`
`29`		`- IAssignedByValParameterQuickFixDialogFactory factory = new AssignedByValParameterQuickFixDialogFactory();`
`30`	`34`	`return _quickFixes ?? (_quickFixes = new QuickFixBase[]`
`31`	`35`	`{`
`32`		`- new AssignedByValParameterMakeLocalCopyQuickFix(Target, QualifiedSelection, factory),`
	`36`	`+ new AssignedByValParameterMakeLocalCopyQuickFix(Target, QualifiedSelection, _dialogFactory),`
`33`	`37`	`new PassParameterByReferenceQuickFix(Target, QualifiedSelection),`
`34`	`38`	`new IgnoreOnceQuickFix(Context, QualifiedSelection, Inspection.AnnotationName)`
`35`	`39`	`});`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ public partial class AssignedByValParameterQuickFixDialog : Form, IAssignedByVal`
`10`	`10`	`private string[] _identifierNamesAlreadyDeclared;`
`11`	`11`	`private string _identifierName;`
`12`	`12`
`13`		`- public AssignedByValParameterQuickFixDialog(string identifierName, string declarationType)`
	`13`	`+ internal AssignedByValParameterQuickFixDialog(string identifierName, string declarationType)`
`14`	`14`	`{`
`15`	`15`	`InitializeComponent();`
`16`	`16`	`InitializeCaptions(identifierName, declarationType);`
Original file line number	Diff line number	Diff line change
`@@ -145,7 +145,7 @@ Public Sub Foo(ByVal arg1 As String)`
`145`	`145`	`[TestCategory("Inspections")]`
`146`	`146`	`public void InspectionType()`
`147`	`147`	`{`
`148`		`- var inspection = new AssignedByValParameterInspection(null);`
	`148`	`+ var inspection = new AssignedByValParameterInspection(null,null);`
`149`	`149`	`Assert.AreEqual(CodeInspectionType.CodeQualityIssues, inspection.InspectionType);`
`150`	`150`	`}`
`151`	`151`
`@@ -154,7 +154,7 @@ public void InspectionType()`
`154`	`154`	`public void InspectionName()`
`155`	`155`	`{`
`156`	`156`	`const string inspectionName = "AssignedByValParameterInspection";`
`157`		`- var inspection = new AssignedByValParameterInspection(null);`
	`157`	`+ var inspection = new AssignedByValParameterInspection(null,null);`
`158`	`158`
`159`	`159`	`Assert.AreEqual(inspectionName, inspection.Name);`
`160`	`160`	`}`
`@@ -194,7 +194,7 @@ private string GetModuleContent(Mock<IVBE> vbe)`
`194`	`194`	`parser.Parse(new CancellationTokenSource());`
`195`	`195`	`if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); }`
`196`	`196`
`197`		`- var inspection = new AssignedByValParameterInspection(parser.State);`
	`197`	`+ var inspection = new AssignedByValParameterInspection(parser.State,null);`
`198`	`198`	`return inspection.GetInspectionResults();`
`199`	`199`	`}`
`200`	`200`