Correctly remove parameters from contexts resolved into "IndexExpression"s (i.e. calls with paramers around the args).

Author: Hosch250

RetailCoder.VBE/Refactorings/RemoveParameters/RemoveParametersRefactoring.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using Antlr4.Runtime;
 using Antlr4.Runtime.Misc;
 using Microsoft.Vbe.Interop;
 using Rubberduck.Common;
@@ -103,6 +104,16 @@ private void AdjustReferences(IEnumerable<IdentifierReference> references, Decla
                 {
                     argumentList = CallStatement.GetArgumentList(callStmt);
                 }
+
+                if (argumentList == null)
+                {
+                    var indexExpression = ParserRuleContextHelper.GetParent<VBAParser.IndexExprContext>(reference.Context);
+                    if (indexExpression != null)
+                    {
+                        argumentList = ParserRuleContextHelper.GetChild<VBAParser.ArgumentListContext>(indexExpression);
+                    }
+                }
+
                 if (argumentList == null) { continue; }
                 RemoveCallParameter(argumentList, module);
             }

Rubberduck.Parsing/Symbols/ParserRuleContextHelper.cs

@@ -47,5 +47,24 @@ public static string GetText(ParserRuleContext context, ICharStream stream)
             // Gets the original source, without "synthetic" text such as "<EOF>".
             return stream.GetText(new Interval(context.Start.StartIndex, context.Stop.StopIndex));
         }
+
+        public static T GetChild<T>(RuleContext context)
+        {
+            if (context == null)
+            {
+                return default(T);
+            }
+
+            for (var index = 0; index < context.ChildCount; index++)
+            {
+                var child = context.GetChild(index);
+                if (context.GetChild(index) is T)
+                {
+                    return (T)child;
+                }
+            }
+
+            return default(T);
+        }
     }
 }

RubberduckTests/Refactoring/RemoveParametersTests.cs

@@ -675,6 +675,67 @@ End Sub
             Assert.AreEqual(expectedCode, module.Lines());
         }
 
+        [TestMethod]
+        public void RemoveParametersRefactoring_ClientReferencesAreUpdated_FirstParam_ParensAroundCall()
+        {
+            //Input
+            const string inputCode =
+@"Private Sub bar()
+    Dim x As Integer
+    Dim y As Integer
+    y = foo(x, 42)
+    Debug.Print y, x
+End Sub
+
+Private Function foo(ByRef a As Integer, ByVal b As Integer) As Integer
+    a = b
+    foo = a + b
+End Function";
+            var selection = new Selection(8, 20, 8, 20);
+
+            //Expectation
+            const string expectedCode =
+@"Private Sub bar()
+    Dim x As Integer
+    Dim y As Integer
+    y = foo(42)
+    Debug.Print y, x
+End Sub
+
+Private Function foo(ByVal b As Integer) As Integer
+    a = b
+    foo = a + b
+End Function";
+
+            //Arrange
+            var builder = new MockVbeBuilder();
+            VBComponent component;
+            var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection);
+            var module = component.CodeModule;
+            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 qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection);
+
+            //Specify Param(s) to remove
+            var model = new RemoveParametersModel(parser.State, qualifiedSelection, null);
+            model.Parameters[0].IsRemoved = true;
+
+            //SetupFactory
+            var factory = SetupFactory(model);
+
+            //Act
+            var refactoring = new RemoveParametersRefactoring(vbe.Object, factory.Object);
+            refactoring.Refactor(qualifiedSelection);
+
+            //Assert
+            Assert.AreEqual(expectedCode, module.Lines());
+        }
+
         [TestMethod]
         public void RemoveParametersRefactoring_ClientReferencesAreUpdated_LastParam()
         {