Recover lost updates for SubstmtContext to ArgListContext

BZngr · BZngr · commit e567400f9dba · 2017-02-15T23:50:20.000-08:00
diff --git a/RetailCoder.VBE/Inspections/Concrete/Inspector.cs b/RetailCoder.VBE/Inspections/Concrete/Inspector.cs
@@ -139,7 +139,7 @@ before moving them into the ParseTreeResults after qualifying them
 
                     if (argListWithOneByRefParamListener != null)
                     {
-                        result.AddRange(argListWithOneByRefParamListener.Contexts.Select(context => new QualifiedContext<VBAParser.SubstmtContext>(componentTreePair.Key, context)));
+                        result.AddRange(argListWithOneByRefParamListener.Contexts.Select(context => new QualifiedContext<VBAParser.ArgListContext>(componentTreePair.Key, context)));
                     }
                     if (emptyStringLiteralListener != null)
                     {
diff --git a/RetailCoder.VBE/Inspections/ProcedureCanBeWrittenAsFunctionInspection.cs b/RetailCoder.VBE/Inspections/ProcedureCanBeWrittenAsFunctionInspection.cs
@@ -27,7 +27,7 @@ public ProcedureCanBeWrittenAsFunctionInspection(RubberduckParserState state)
         public override string Description { get { return InspectionsUI.ProcedureCanBeWrittenAsFunctionInspectionName; } }
         public override CodeInspectionType InspectionType { get { return CodeInspectionType.LanguageOpportunities; } }
 
-        public IEnumerable<QualifiedContext<VBAParser.SubstmtContext>> ParseTreeResults { get { return _results.OfType<QualifiedContext<VBAParser.SubstmtContext>>(); } }
+        public IEnumerable<QualifiedContext<VBAParser.ArgListContext>> ParseTreeResults { get { return _results.OfType<QualifiedContext<VBAParser.ArgListContext>>(); } }
 
         public void SetResults(IEnumerable<QualifiedContext> results)
         {
@@ -62,17 +62,17 @@ public override IEnumerable<InspectionResultBase> GetInspectionResults()
                                    .Select(result => new ProcedureCanBeWrittenAsFunctionInspectionResult(
                                                          this, 
                                                          State, 
-                                                         new QualifiedContext<VBAParser.SubstmtContext>(result.QualifiedName,result.Context.GetChild<VBAParser.SubstmtContext>(0)),
+                                                         new QualifiedContext<VBAParser.ArgListContext>(result.QualifiedName,result.Context.GetChild<VBAParser.ArgListContext>(0)),
                                                          new QualifiedContext<VBAParser.SubStmtContext>(result.QualifiedName, (VBAParser.SubStmtContext)result.Context))
                                    );                   
         }
 
         public class SingleByRefParamArgListListener : VBAParserBaseListener
         {
-            private readonly IList<VBAParser.SubstmtContext> _contexts = new List<VBAParser.SubstmtContext>();
-            public IEnumerable<VBAParser.SubstmtContext> Contexts { get { return _contexts; } }
+            private readonly IList<VBAParser.ArgListContext> _contexts = new List<VBAParser.ArgListContext>();
+            public IEnumerable<VBAParser.ArgListContext> Contexts { get { return _contexts; } }
 
-            public override void ExitArgList(VBAParser.SubstmtContext context)
+            public override void ExitArgList(VBAParser.ArgListContext context)
             {
                 var args = context.arg();
                 if (args != null && args.All(a => a.PARAMARRAY() == null && a.LPAREN() == null) && args.Count(a => a.BYREF() != null || (a.BYREF() == null && a.BYVAL() == null)) == 1)
diff --git a/RetailCoder.VBE/Inspections/QuickFixes/DeclareAsExplicitVariantQuickFix.cs b/RetailCoder.VBE/Inspections/QuickFixes/DeclareAsExplicitVariantQuickFix.cs
@@ -68,9 +68,9 @@ private string DeclareExplicitVariant(VBAParser.ArgContext context, out string i
             var fix = string.Empty;
             foreach (var child in memberContext.children)
             {
-                if (child is VBAParser.SubstmtContext)
+                if (child is VBAParser.ArgListContext)
                 {
-                    foreach (var tree in ((VBAParser.SubstmtContext) child).children)
+                    foreach (var tree in ((VBAParser.ArgListContext) child).children)
                     {
                         if (tree.Equals(context))
                         {
diff --git a/RetailCoder.VBE/Inspections/QuickFixes/PassParameterByReferenceQuickFix.cs b/RetailCoder.VBE/Inspections/QuickFixes/PassParameterByReferenceQuickFix.cs
@@ -39,9 +39,9 @@ private ArgContext GetArgContextForIdentifier(ParserRuleContext context, string
             var procStmtCtxChildren = procStmtCtx.children;
             for (int idx = 0; idx < procStmtCtxChildren.Count; idx++)
             {
-                if (procStmtCtxChildren[idx] is SubstmtContext)
+                if (procStmtCtxChildren[idx] is ArgListContext)
                 {
-                    var procStmtCtxChild = (SubstmtContext)procStmtCtxChildren[idx];
+                    var procStmtCtxChild = (ArgListContext)procStmtCtxChildren[idx];
                     var arg = procStmtCtxChild.children;
                     for (int idx2 = 0; idx2 < arg.Count; idx2++)
                     {
diff --git a/RetailCoder.VBE/Inspections/Results/ProcedureCanBeWrittenAsFunctionInspectionResult.cs b/RetailCoder.VBE/Inspections/Results/ProcedureCanBeWrittenAsFunctionInspectionResult.cs
@@ -16,12 +16,12 @@ namespace Rubberduck.Inspections.Results
     public class ProcedureCanBeWrittenAsFunctionInspectionResult : InspectionResultBase
     {
        private IEnumerable<QuickFixBase> _quickFixes;
-       private readonly QualifiedContext<VBAParser.SubstmtContext> _argListQualifiedContext;
+       private readonly QualifiedContext<VBAParser.ArgListContext> _argListQualifiedContext;
        private readonly QualifiedContext<VBAParser.SubStmtContext> _subStmtQualifiedContext;
        private readonly RubberduckParserState _state;
 
        public ProcedureCanBeWrittenAsFunctionInspectionResult(IInspection inspection, RubberduckParserState state, 
-           QualifiedContext<VBAParser.SubstmtContext> argListQualifiedContext, QualifiedContext<VBAParser.SubStmtContext> subStmtQualifiedContext)
+           QualifiedContext<VBAParser.ArgListContext> argListQualifiedContext, QualifiedContext<VBAParser.SubStmtContext> subStmtQualifiedContext)
            : base(inspection, subStmtQualifiedContext.ModuleName, subStmtQualifiedContext.Context.subroutineName())
         {
             _target = state.AllUserDeclarations.Single(declaration => declaration.DeclarationType == DeclarationType.Procedure
@@ -57,14 +57,14 @@ public class ChangeProcedureToFunction : QuickFixBase
         public override bool CanFixInProject { get { return false; } }
 
         private readonly RubberduckParserState _state;
-        private readonly QualifiedContext<VBAParser.SubstmtContext> _argListQualifiedContext;
+        private readonly QualifiedContext<VBAParser.ArgListContext> _argListQualifiedContext;
         private readonly QualifiedContext<VBAParser.SubStmtContext> _subStmtQualifiedContext;
         private readonly QualifiedContext<VBAParser.ArgContext> _argQualifiedContext;
 
         private int _lineOffset;
 
         public ChangeProcedureToFunction(RubberduckParserState state,
-                                         QualifiedContext<VBAParser.SubstmtContext> argListQualifiedContext,
+                                         QualifiedContext<VBAParser.ArgListContext> argListQualifiedContext,
                                          QualifiedContext<VBAParser.SubStmtContext> subStmtQualifiedContext,
                                          QualifiedSelection selection)
             : base(subStmtQualifiedContext.Context, selection, InspectionsUI.ProcedureShouldBeFunctionInspectionQuickFix)
diff --git a/RetailCoder.VBE/Navigation/CodeExplorer/CodeExplorerMemberViewModel.cs b/RetailCoder.VBE/Navigation/CodeExplorer/CodeExplorerMemberViewModel.cs
@@ -117,7 +117,7 @@ public override string NameWithSignature
                 }
 
                 var context =
-                    _declaration.Context.children.FirstOrDefault(d => d is VBAParser.SubstmtContext) as VBAParser.SubstmtContext;
+                    _declaration.Context.children.FirstOrDefault(d => d is VBAParser.ArgListContext) as VBAParser.ArgListContext;
 
                 if (context == null)
                 {
diff --git a/RetailCoder.VBE/Refactorings/IntroduceParameter/IntroduceParameterRefactoring.cs b/RetailCoder.VBE/Refactorings/IntroduceParameter/IntroduceParameterRefactoring.cs
@@ -142,7 +142,7 @@ private void UpdateSignature(Declaration targetVariable)
             var functionDeclaration = _declarations.FindTarget(targetVariable.QualifiedSelection, ValidDeclarationTypes);
 
             var proc = (dynamic)functionDeclaration.Context;
-            var paramList = (VBAParser.SubstmtContext)proc.argList();
+            var paramList = (VBAParser.ArgListContext)proc.argList();
             var module = functionDeclaration.QualifiedName.QualifiedModuleName.Component.CodeModule;
             {
                 var interfaceImplementation = GetInterfaceImplementation(functionDeclaration);
@@ -182,14 +182,14 @@ private void UpdateSignature(Declaration targetVariable)
         private void UpdateSignature(Declaration targetMethod, Declaration targetVariable)
         {
             var proc = (dynamic)targetMethod.Context;
-            var paramList = (VBAParser.SubstmtContext)proc.argList();
+            var paramList = (VBAParser.ArgListContext)proc.argList();
             var module = targetMethod.QualifiedName.QualifiedModuleName.Component.CodeModule;
             {
                 AddParameter(targetMethod, targetVariable, paramList, module);
             }
         }
 
-        private void AddParameter(Declaration targetMethod, Declaration targetVariable, VBAParser.SubstmtContext paramList, ICodeModule module)
+        private void AddParameter(Declaration targetMethod, Declaration targetVariable, VBAParser.ArgListContext paramList, ICodeModule module)
         {
             var argList = paramList.arg();
             var lastParam = argList.LastOrDefault();
diff --git a/RetailCoder.VBE/Refactorings/RemoveParameters/RemoveParametersRefactoring.cs b/RetailCoder.VBE/Refactorings/RemoveParameters/RemoveParametersRefactoring.cs
@@ -279,7 +279,7 @@ private string GetOldSignature(Declaration target)
         private void AdjustSignatures()
         {
             var proc = (dynamic)_model.TargetDeclaration.Context;
-            var paramList = (VBAParser.SubstmtContext)proc.argList();
+            var paramList = (VBAParser.ArgListContext)proc.argList();
             var module = _model.TargetDeclaration.QualifiedName.QualifiedModuleName.Component.CodeModule;
             {
                 // if we are adjusting a property getter, check if we need to adjust the letter/setter too
@@ -336,23 +336,23 @@ private void AdjustSignatures(Declaration declaration)
             var proc = (dynamic)declaration.Context.Parent;
             var module = declaration.QualifiedName.QualifiedModuleName.Component.CodeModule;
             {
-                VBAParser.SubstmtContext paramList;
+                VBAParser.ArgListContext paramList;
 
                 if (declaration.DeclarationType == DeclarationType.PropertySet
                     || declaration.DeclarationType == DeclarationType.PropertyLet)
                 {
-                    paramList = (VBAParser.SubstmtContext)proc.children[0].argList();
+                    paramList = (VBAParser.ArgListContext)proc.children[0].argList();
                 }
                 else
                 {
-                    paramList = (VBAParser.SubstmtContext)proc.subStmt().argList();
+                    paramList = (VBAParser.ArgListContext)proc.subStmt().argList();
                 }
 
                 RemoveSignatureParameters(declaration, paramList, module);
             }
         }
 
-        private void RemoveSignatureParameters(Declaration target, VBAParser.SubstmtContext paramList, ICodeModule module)
+        private void RemoveSignatureParameters(Declaration target, VBAParser.ArgListContext paramList, ICodeModule module)
         {
             // property set/let have one more parameter than is listed in the getter parameters
             var nonRemovedParamNames = paramList.arg().Where((a, s) => s >= _model.Parameters.Count || !_model.Parameters[s].IsRemoved).Select(s => s.GetText());
diff --git a/RetailCoder.VBE/Refactorings/Rename/RenameRefactoring.cs b/RetailCoder.VBE/Refactorings/Rename/RenameRefactoring.cs
@@ -335,7 +335,7 @@ private void RenameDeclaration(Declaration target, string newName)
 
                 if (target.DeclarationType == DeclarationType.Parameter)
                 {
-                    var argList = (VBAParser.SubstmtContext)target.Context.Parent;
+                    var argList = (VBAParser.ArgListContext)target.Context.Parent;
                     var lineNum = argList.GetSelection().LineCount;
 
                     // delete excess lines to prevent removing our own changes
diff --git a/RetailCoder.VBE/Refactorings/ReorderParameters/ReorderParametersModel.cs b/RetailCoder.VBE/Refactorings/ReorderParameters/ReorderParametersModel.cs
@@ -50,7 +50,7 @@ private void LoadParameters()
             Parameters.Clear();
 
             var procedure = (dynamic)TargetDeclaration.Context;
-            var argList = (VBAParser.SubstmtContext)procedure.argList();
+            var argList = (VBAParser.ArgListContext)procedure.argList();
             var args = argList.arg();
 
             var index = 0;
diff --git a/RetailCoder.VBE/Refactorings/ReorderParameters/ReorderParametersRefactoring.cs b/RetailCoder.VBE/Refactorings/ReorderParameters/ReorderParametersRefactoring.cs
@@ -189,7 +189,7 @@ private void RewriteCall(VBAParser.ArgumentListContext paramList, ICodeModule mo
         private void AdjustSignatures()
         {
             var proc = (dynamic)_model.TargetDeclaration.Context;
-            var paramList = (VBAParser.SubstmtContext)proc.argList();
+            var paramList = (VBAParser.ArgListContext)proc.argList();
             var module = _model.TargetDeclaration.QualifiedName.QualifiedModuleName.Component.CodeModule;
 
             // if we are reordering a property getter, check if we need to reorder a letter/setter too
@@ -242,22 +242,22 @@ private void AdjustSignatures(Declaration declaration)
             var proc = (dynamic)declaration.Context.Parent;
             var module = declaration.QualifiedName.QualifiedModuleName.Component.CodeModule;
             {
-                VBAParser.SubstmtContext paramList;
+                VBAParser.ArgListContext paramList;
 
                 if (declaration.DeclarationType == DeclarationType.PropertySet || declaration.DeclarationType == DeclarationType.PropertyLet)
                 {
-                    paramList = (VBAParser.SubstmtContext)proc.children[0].argList();
+                    paramList = (VBAParser.ArgListContext)proc.children[0].argList();
                 }
                 else
                 {
-                    paramList = (VBAParser.SubstmtContext)proc.subStmt().argList();
+                    paramList = (VBAParser.ArgListContext)proc.subStmt().argList();
                 }
 
                 RewriteSignature(declaration, paramList, module);
             }
         }
 
-        private void RewriteSignature(Declaration target, VBAParser.SubstmtContext paramList, ICodeModule module)
+        private void RewriteSignature(Declaration target, VBAParser.ArgListContext paramList, ICodeModule module)
         {
             var parameters = paramList.arg().Select((s, i) => new {Index = i, Text = s.GetText()}).ToList();
 
diff --git a/Rubberduck.Parsing/Grammar/VBAParser.cs b/Rubberduck.Parsing/Grammar/VBAParser.cs
@@ -5512,8 +5512,8 @@ public IdentifierContext identifier() {
 		public VisibilityContext visibility() {
 			return GetRuleContext<VisibilityContext>(0);
 		}
-		public SubstmtContext argList() {
-			return GetRuleContext<SubstmtContext>(0);
+		public ArgListContext argList() {
+			return GetRuleContext<ArgListContext>(0);
 		}
 		public ITerminalNode LIB() { return GetToken(VBAParser.LIB, 0); }
 		public ITerminalNode FUNCTION() { return GetToken(VBAParser.FUNCTION, 0); }
@@ -5631,7 +5631,7 @@ public DeclareStmtContext declareStmt() {
 		return _localctx;
 	}
 
-	public partial class SubstmtContext : ParserRuleContext {
+	public partial class ArgListContext : ParserRuleContext {
 		public ArgContext arg(int i) {
 			return GetRuleContext<ArgContext>(i);
 		}
@@ -5650,7 +5650,7 @@ public IReadOnlyList<ArgContext> arg() {
 		public ITerminalNode COMMA(int i) {
 			return GetToken(VBAParser.COMMA, i);
 		}
-		public SubstmtContext(ParserRuleContext parent, int invokingState)
+		public ArgListContext(ParserRuleContext parent, int invokingState)
 			: base(parent, invokingState)
 		{
 		}
@@ -5671,8 +5671,8 @@ public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
 	}
 
 	[RuleVersion(0)]
-	public SubstmtContext argList() {
-		SubstmtContext _localctx = new SubstmtContext(_ctx, State);
+	public ArgListContext argList() {
+		ArgListContext _localctx = new ArgListContext(_ctx, State);
 		EnterRule(_localctx, 140, RULE_argList);
 		int _la;
 		try {
@@ -7041,8 +7041,8 @@ public ErrorStmtContext errorStmt() {
 	}
 
 	public partial class EventStmtContext : ParserRuleContext {
-		public SubstmtContext argList() {
-			return GetRuleContext<SubstmtContext>(0);
+		public ArgListContext argList() {
+			return GetRuleContext<ArgListContext>(0);
 		}
 		public WhiteSpaceContext whiteSpace(int i) {
 			return GetRuleContext<WhiteSpaceContext>(i);
@@ -7350,8 +7350,8 @@ public ForNextStmtContext forNextStmt() {
 	}
 
 	public partial class FunctionStmtContext : ParserRuleContext {
-		public SubstmtContext argList() {
-			return GetRuleContext<SubstmtContext>(0);
+		public ArgListContext argList() {
+			return GetRuleContext<ArgListContext>(0);
 		}
 		public FunctionNameContext functionName() {
 			return GetRuleContext<FunctionNameContext>(0);
@@ -8930,8 +8930,8 @@ public OnGoSubStmtContext onGoSubStmt() {
 	}
 
 	public partial class PropertyGetStmtContext : ParserRuleContext {
-		public SubstmtContext argList() {
-			return GetRuleContext<SubstmtContext>(0);
+		public ArgListContext argList() {
+			return GetRuleContext<ArgListContext>(0);
 		}
 		public FunctionNameContext functionName() {
 			return GetRuleContext<FunctionNameContext>(0);
@@ -9048,8 +9048,8 @@ public PropertyGetStmtContext propertyGetStmt() {
 	}
 
 	public partial class PropertySetStmtContext : ParserRuleContext {
-		public SubstmtContext argList() {
-			return GetRuleContext<SubstmtContext>(0);
+		public ArgListContext argList() {
+			return GetRuleContext<ArgListContext>(0);
 		}
 		public WhiteSpaceContext whiteSpace(int i) {
 			return GetRuleContext<WhiteSpaceContext>(i);
@@ -9155,8 +9155,8 @@ public PropertySetStmtContext propertySetStmt() {
 
 	public partial class PropertyLetStmtContext : ParserRuleContext {
 		public ITerminalNode PROPERTY_LET() { return GetToken(VBAParser.PROPERTY_LET, 0); }
-		public SubstmtContext argList() {
-			return GetRuleContext<SubstmtContext>(0);
+		public ArgListContext argList() {
+			return GetRuleContext<ArgListContext>(0);
 		}
 		public WhiteSpaceContext whiteSpace(int i) {
 			return GetRuleContext<WhiteSpaceContext>(i);
@@ -10999,8 +10999,8 @@ public SetStmtContext setStmt() {
 	}
 
 	public partial class SubStmtContext : ParserRuleContext {
-		public SubstmtContext argList() {
-			return GetRuleContext<SubstmtContext>(0);
+		public ArgListContext argList() {
+			return GetRuleContext<ArgListContext>(0);
 		}
 		public WhiteSpaceContext whiteSpace(int i) {
 			return GetRuleContext<WhiteSpaceContext>(i);
diff --git a/Rubberduck.Parsing/Grammar/VBAParserBaseListener.cs b/Rubberduck.Parsing/Grammar/VBAParserBaseListener.cs
@@ -2534,13 +2534,13 @@ public virtual void ExitSelectStartValue([NotNull] VBAParser.SelectStartValueCon
 	/// <para>The default implementation does nothing.</para>
 	/// </summary>
 	/// <param name="context">The parse tree.</param>
-	public virtual void EnterArgList([NotNull] VBAParser.SubstmtContext context) { }
+	public virtual void EnterArgList([NotNull] VBAParser.ArgListContext context) { }
 	/// <summary>
 	/// Exit a parse tree produced by <see cref="VBAParser.argList"/>.
 	/// <para>The default implementation does nothing.</para>
 	/// </summary>
 	/// <param name="context">The parse tree.</param>
-	public virtual void ExitArgList([NotNull] VBAParser.SubstmtContext context) { }
+	public virtual void ExitArgList([NotNull] VBAParser.ArgListContext context) { }
 
 	/// <summary>
 	/// Enter a parse tree produced by <see cref="VBAParser.arrayDim"/>.
diff --git a/Rubberduck.Parsing/Grammar/VBAParserBaseVisitor.cs b/Rubberduck.Parsing/Grammar/VBAParserBaseVisitor.cs
@@ -2153,7 +2153,7 @@ public partial class VBAParserBaseVisitor<Result> : AbstractParseTreeVisitor<Res
 	/// </summary>
 	/// <param name="context">The parse tree.</param>
 	/// <return>The visitor result.</return>
-	public virtual Result VisitArgList([NotNull] VBAParser.SubstmtContext context) { return VisitChildren(context); }
+	public virtual Result VisitArgList([NotNull] VBAParser.ArgListContext context) { return VisitChildren(context); }
 
 	/// <summary>
 	/// Visit a parse tree produced by <see cref="VBAParser.arrayDim"/>.
diff --git a/Rubberduck.Parsing/Grammar/VBAParserListener.cs b/Rubberduck.Parsing/Grammar/VBAParserListener.cs
@@ -2207,12 +2207,12 @@ public interface IVBAParserListener : IParseTreeListener {
 	/// Enter a parse tree produced by <see cref="VBAParser.argList"/>.
 	/// </summary>
 	/// <param name="context">The parse tree.</param>
-	void EnterArgList([NotNull] VBAParser.SubstmtContext context);
+	void EnterArgList([NotNull] VBAParser.ArgListContext context);
 	/// <summary>
 	/// Exit a parse tree produced by <see cref="VBAParser.argList"/>.
 	/// </summary>
 	/// <param name="context">The parse tree.</param>
-	void ExitArgList([NotNull] VBAParser.SubstmtContext context);
+	void ExitArgList([NotNull] VBAParser.ArgListContext context);
 
 	/// <summary>
 	/// Enter a parse tree produced by <see cref="VBAParser.arrayDim"/>.
diff --git a/Rubberduck.Parsing/Grammar/VBAParserVisitor.cs b/Rubberduck.Parsing/Grammar/VBAParserVisitor.cs
diff --git a/Rubberduck.Parsing/Symbols/DeclarationSymbolsListener.cs b/Rubberduck.Parsing/Symbols/DeclarationSymbolsListener.cs

Original file line number	Diff line number	Diff line change
`@@ -139,7 +139,7 @@ before moving them into the ParseTreeResults after qualifying them`
`139`	`139`
`140`	`140`	`if (argListWithOneByRefParamListener != null)`
`141`	`141`	`{`
`142`		`- result.AddRange(argListWithOneByRefParamListener.Contexts.Select(context => new QualifiedContext<VBAParser.SubstmtContext>(componentTreePair.Key, context)));`
	`142`	`+ result.AddRange(argListWithOneByRefParamListener.Contexts.Select(context => new QualifiedContext<VBAParser.ArgListContext>(componentTreePair.Key, context)));`
`143`	`143`	`}`
`144`	`144`	`if (emptyStringLiteralListener != null)`
`145`	`145`	`{`
Original file line number	Diff line number	Diff line change
`@@ -68,9 +68,9 @@ private string DeclareExplicitVariant(VBAParser.ArgContext context, out string i`
`68`	`68`	`var fix = string.Empty;`
`69`	`69`	`foreach (var child in memberContext.children)`
`70`	`70`	`{`
`71`		`- if (child is VBAParser.SubstmtContext)`
	`71`	`+ if (child is VBAParser.ArgListContext)`
`72`	`72`	`{`
`73`		`- foreach (var tree in ((VBAParser.SubstmtContext) child).children)`
	`73`	`+ foreach (var tree in ((VBAParser.ArgListContext) child).children)`
`74`	`74`	`{`
`75`	`75`	`if (tree.Equals(context))`
`76`	`76`	`{`
Original file line number	Diff line number	Diff line change
`@@ -39,9 +39,9 @@ private ArgContext GetArgContextForIdentifier(ParserRuleContext context, string`
`39`	`39`	`var procStmtCtxChildren = procStmtCtx.children;`
`40`	`40`	`for (int idx = 0; idx < procStmtCtxChildren.Count; idx++)`
`41`	`41`	`{`
`42`		`- if (procStmtCtxChildren[idx] is SubstmtContext)`
	`42`	`+ if (procStmtCtxChildren[idx] is ArgListContext)`
`43`	`43`	`{`
`44`		`- var procStmtCtxChild = (SubstmtContext)procStmtCtxChildren[idx];`
	`44`	`+ var procStmtCtxChild = (ArgListContext)procStmtCtxChildren[idx];`
`45`	`45`	`var arg = procStmtCtxChild.children;`
`46`	`46`	`for (int idx2 = 0; idx2 < arg.Count; idx2++)`
`47`	`47`	`{`
Original file line number	Diff line number	Diff line change
`@@ -117,7 +117,7 @@ public override string NameWithSignature`
`117`	`117`	`}`
`118`	`118`
`119`	`119`	`var context =`
`120`		`- _declaration.Context.children.FirstOrDefault(d => d is VBAParser.SubstmtContext) as VBAParser.SubstmtContext;`
	`120`	`+ _declaration.Context.children.FirstOrDefault(d => d is VBAParser.ArgListContext) as VBAParser.ArgListContext;`
`121`	`121`
`122`	`122`	`if (context == null)`
`123`	`123`	`{`
Original file line number	Diff line number	Diff line change
`@@ -142,7 +142,7 @@ private void UpdateSignature(Declaration targetVariable)`
`142`	`142`	`var functionDeclaration = _declarations.FindTarget(targetVariable.QualifiedSelection, ValidDeclarationTypes);`
`143`	`143`
`144`	`144`	`var proc = (dynamic)functionDeclaration.Context;`
`145`		`- var paramList = (VBAParser.SubstmtContext)proc.argList();`
	`145`	`+ var paramList = (VBAParser.ArgListContext)proc.argList();`
`146`	`146`	`var module = functionDeclaration.QualifiedName.QualifiedModuleName.Component.CodeModule;`
`147`	`147`	`{`
`148`	`148`	`var interfaceImplementation = GetInterfaceImplementation(functionDeclaration);`
`@@ -182,14 +182,14 @@ private void UpdateSignature(Declaration targetVariable)`
`182`	`182`	`private void UpdateSignature(Declaration targetMethod, Declaration targetVariable)`
`183`	`183`	`{`
`184`	`184`	`var proc = (dynamic)targetMethod.Context;`
`185`		`- var paramList = (VBAParser.SubstmtContext)proc.argList();`
	`185`	`+ var paramList = (VBAParser.ArgListContext)proc.argList();`
`186`	`186`	`var module = targetMethod.QualifiedName.QualifiedModuleName.Component.CodeModule;`
`187`	`187`	`{`
`188`	`188`	`AddParameter(targetMethod, targetVariable, paramList, module);`
`189`	`189`	`}`
`190`	`190`	`}`
`191`	`191`
`192`		`- private void AddParameter(Declaration targetMethod, Declaration targetVariable, VBAParser.SubstmtContext paramList, ICodeModule module)`
	`192`	`+ private void AddParameter(Declaration targetMethod, Declaration targetVariable, VBAParser.ArgListContext paramList, ICodeModule module)`
`193`	`193`	`{`
`194`	`194`	`var argList = paramList.arg();`
`195`	`195`	`var lastParam = argList.LastOrDefault();`
Original file line number	Diff line number	Diff line change
`@@ -279,7 +279,7 @@ private string GetOldSignature(Declaration target)`
`279`	`279`	`private void AdjustSignatures()`
`280`	`280`	`{`
`281`	`281`	`var proc = (dynamic)_model.TargetDeclaration.Context;`
`282`		`- var paramList = (VBAParser.SubstmtContext)proc.argList();`
	`282`	`+ var paramList = (VBAParser.ArgListContext)proc.argList();`
`283`	`283`	`var module = _model.TargetDeclaration.QualifiedName.QualifiedModuleName.Component.CodeModule;`
`284`	`284`	`{`
`285`	`285`	`// if we are adjusting a property getter, check if we need to adjust the letter/setter too`
`@@ -336,23 +336,23 @@ private void AdjustSignatures(Declaration declaration)`
`336`	`336`	`var proc = (dynamic)declaration.Context.Parent;`
`337`	`337`	`var module = declaration.QualifiedName.QualifiedModuleName.Component.CodeModule;`
`338`	`338`	`{`
`339`		`- VBAParser.SubstmtContext paramList;`
	`339`	`+ VBAParser.ArgListContext paramList;`
`340`	`340`
`341`	`341`	`if (declaration.DeclarationType == DeclarationType.PropertySet`
`342`	`342`	`\|\| declaration.DeclarationType == DeclarationType.PropertyLet)`
`343`	`343`	`{`
`344`		`- paramList = (VBAParser.SubstmtContext)proc.children[0].argList();`
	`344`	`+ paramList = (VBAParser.ArgListContext)proc.children[0].argList();`
`345`	`345`	`}`
`346`	`346`	`else`
`347`	`347`	`{`
`348`		`- paramList = (VBAParser.SubstmtContext)proc.subStmt().argList();`
	`348`	`+ paramList = (VBAParser.ArgListContext)proc.subStmt().argList();`
`349`	`349`	`}`
`350`	`350`
`351`	`351`	`RemoveSignatureParameters(declaration, paramList, module);`
`352`	`352`	`}`
`353`	`353`	`}`
`354`	`354`
`355`		`- private void RemoveSignatureParameters(Declaration target, VBAParser.SubstmtContext paramList, ICodeModule module)`
	`355`	`+ private void RemoveSignatureParameters(Declaration target, VBAParser.ArgListContext paramList, ICodeModule module)`
`356`	`356`	`{`
`357`	`357`	`// property set/let have one more parameter than is listed in the getter parameters`
`358`	`358`	`var nonRemovedParamNames = paramList.arg().Where((a, s) => s >= _model.Parameters.Count \|\| !_model.Parameters[s].IsRemoved).Select(s => s.GetText());`
Original file line number	Diff line number	Diff line change
`@@ -335,7 +335,7 @@ private void RenameDeclaration(Declaration target, string newName)`
`335`	`335`
`336`	`336`	`if (target.DeclarationType == DeclarationType.Parameter)`
`337`	`337`	`{`
`338`		`- var argList = (VBAParser.SubstmtContext)target.Context.Parent;`
	`338`	`+ var argList = (VBAParser.ArgListContext)target.Context.Parent;`
`339`	`339`	`var lineNum = argList.GetSelection().LineCount;`
`340`	`340`
`341`	`341`	`// delete excess lines to prevent removing our own changes`