Clean-up, improve test coverage - some renaming

BZngr · BZngr · commit 34a17f38c5fb · 2018-01-17T18:39:42.000-08:00
diff --git a/RetailCoder.VBE/Common/DeclarationExtensions.cs b/RetailCoder.VBE/Common/DeclarationExtensions.cs
@@ -573,7 +573,7 @@ public static Declaration FindInterface(this IEnumerable<Declaration> declaratio
             {
                 foreach (var reference in declaration.References)
                 {
-                    var implementsStmt = reference.Context.GetParent<VBAParser.ImplementsStmtContext>();
+                    var implementsStmt = reference.Context.GetAncestor<VBAParser.ImplementsStmtContext>();
 
                     if (implementsStmt == null) { continue; }
 
diff --git a/RetailCoder.VBE/Refactorings/RemoveParameters/RemoveParametersRefactoring.cs b/RetailCoder.VBE/Refactorings/RemoveParameters/RemoveParametersRefactoring.cs
@@ -123,7 +123,7 @@ private void AdjustReferences(IEnumerable<IdentifierReference> references, Decla
             foreach (var reference in references.Where(item => item.Context != method.Context))
             {
                 VBAParser.ArgumentListContext argumentList = null;
-                var callStmt = reference.Context.GetParent<VBAParser.CallStmtContext>();
+                var callStmt = reference.Context.GetAncestor<VBAParser.CallStmtContext>();
                 if (callStmt != null)
                 {
                     argumentList = CallStatement.GetArgumentList(callStmt);
@@ -132,7 +132,7 @@ private void AdjustReferences(IEnumerable<IdentifierReference> references, Decla
                 if (argumentList == null)
                 {
                     var indexExpression =
-                        reference.Context.GetParent<VBAParser.IndexExprContext>();
+                        reference.Context.GetAncestor<VBAParser.IndexExprContext>();
                     if (indexExpression != null)
                     {
                         argumentList = indexExpression.GetChild<VBAParser.ArgumentListContext>();
diff --git a/RetailCoder.VBE/Refactorings/Rename/RenameRefactoring.cs b/RetailCoder.VBE/Refactorings/Rename/RenameRefactoring.cs
@@ -423,7 +423,7 @@ private void RenameModule()
             {
                 foreach (var reference in _model.Target.References)
                 {
-                    var ctxt = reference.Context.GetParent<VBAParser.ImplementsStmtContext>();
+                    var ctxt = reference.Context.GetAncestor<VBAParser.ImplementsStmtContext>();
                     if (ctxt != null)
                     {
                         RenameDefinedFormatMembers(_state.DeclarationFinder.FindInterfaceMembersForImplementsContext(ctxt), _appendUnderscoreFormat);
diff --git a/RetailCoder.VBE/Refactorings/ReorderParameters/ReorderParametersRefactoring.cs b/RetailCoder.VBE/Refactorings/ReorderParameters/ReorderParametersRefactoring.cs
@@ -124,15 +124,15 @@ private void AdjustReferences(IEnumerable<IdentifierReference> references)
             {
                 var module = reference.QualifiedModuleName.Component.CodeModule;
                 VBAParser.ArgumentListContext argumentList = null;
-                var callStmt = reference.Context.GetParent<VBAParser.CallStmtContext>();
+                var callStmt = reference.Context.GetAncestor<VBAParser.CallStmtContext>();
                 if (callStmt != null)
                 {
                     argumentList = CallStatement.GetArgumentList(callStmt);
                 }
                 
                 if (argumentList == null)
                 {
-                    var indexExpression = reference.Context.GetParent<VBAParser.IndexExprContext>();
+                    var indexExpression = reference.Context.GetAncestor<VBAParser.IndexExprContext>();
                     if (indexExpression != null)
                     {
                         argumentList = indexExpression.GetChild<VBAParser.ArgumentListContext>();
diff --git a/Rubberduck.Inspections/Concrete/FunctionReturnValueNotUsedInspection.cs b/Rubberduck.Inspections/Concrete/FunctionReturnValueNotUsedInspection.cs
@@ -108,7 +108,7 @@ private bool IsIndexExprOrCallStmt(IdentifierReference usage)
 
         private bool IsCallStmt(IdentifierReference usage)
         {
-            var callStmt = usage.Context.GetParent<VBAParser.CallStmtContext>();
+            var callStmt = usage.Context.GetAncestor<VBAParser.CallStmtContext>();
             if (callStmt == null)
             {
                 return false;
@@ -123,7 +123,7 @@ private bool IsCallStmt(IdentifierReference usage)
 
         private bool IsIndexExprContext(IdentifierReference usage)
         {
-            var indexExpr = usage.Context.GetParent<VBAParser.IndexExprContext>();
+            var indexExpr = usage.Context.GetAncestor<VBAParser.IndexExprContext>();
             if (indexExpr == null)
             {
                 return false;
@@ -138,14 +138,14 @@ private bool IsIndexExprContext(IdentifierReference usage)
 
         private bool IsLet(IdentifierReference usage)
         {
-            var letStmt = usage.Context.GetParent<VBAParser.LetStmtContext>();
+            var letStmt = usage.Context.GetAncestor<VBAParser.LetStmtContext>();
 
             return letStmt != null && letStmt == usage.Context;
         }
 
         private bool IsSet(IdentifierReference usage)
         {
-            var setStmt = usage.Context.GetParent<VBAParser.SetStmtContext>();
+            var setStmt = usage.Context.GetAncestor<VBAParser.SetStmtContext>();
 
             return setStmt != null && setStmt == usage.Context;
         }
diff --git a/Rubberduck.Inspections/Concrete/ImplicitDefaultMemberAssignmentInspection.cs b/Rubberduck.Inspections/Concrete/ImplicitDefaultMemberAssignmentInspection.cs
@@ -27,7 +27,7 @@ protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
                 .SelectMany(declaration => declaration.References)
                 .Where(reference =>
                 {
-                    var letStmtContext = reference.Context.GetParent<VBAParser.LetStmtContext>();
+                    var letStmtContext = reference.Context.GetAncestor<VBAParser.LetStmtContext>();
                     return reference.IsAssignment && letStmtContext != null && letStmtContext.LET() == null;
                 });
 
diff --git a/Rubberduck.Inspections/Concrete/ObjectVariableNotSetInspection.cs b/Rubberduck.Inspections/Concrete/ObjectVariableNotSetInspection.cs
@@ -45,10 +45,10 @@ protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
         private bool FlagIfObjectVariableNotSet(IdentifierReference reference)
         {
             var allrefs = reference.Declaration.References;
-            var letStmtContext = reference.Context.GetParent<VBAParser.LetStmtContext>();
+            var letStmtContext = reference.Context.GetAncestor<VBAParser.LetStmtContext>();
 
             return reference.IsAssignment && (letStmtContext != null
-                   || allrefs.Where(r => r.IsAssignment).All(r => r.Context.GetParent<VBAParser.SetStmtContext>()?.expression()?.GetText().Equals(Tokens.Nothing, StringComparison.InvariantCultureIgnoreCase) ?? false));
+                   || allrefs.Where(r => r.IsAssignment).All(r => r.Context.GetAncestor<VBAParser.SetStmtContext>()?.expression()?.GetText().Equals(Tokens.Nothing, StringComparison.InvariantCultureIgnoreCase) ?? false));
         }
     }
 }
diff --git a/Rubberduck.Inspections/QuickFixes/ChangeProcedureToFunctionQuickFix.cs b/Rubberduck.Inspections/QuickFixes/ChangeProcedureToFunctionQuickFix.cs
@@ -64,7 +64,7 @@ private void UpdateSignature(Declaration target, ParameterDeclaration arg)
         private void UpdateCall(IdentifierReference reference, int argIndex)
         {
             var rewriter = _state.GetRewriter(reference.QualifiedModuleName);
-            var callStmtContext = reference.Context.GetParent<VBAParser.CallStmtContext>();
+            var callStmtContext = reference.Context.GetAncestor<VBAParser.CallStmtContext>();
             var argListContext = callStmtContext.GetChild<VBAParser.ArgumentListContext>();
 
             var arg = argListContext.argument()[argIndex];
diff --git a/Rubberduck.Inspections/QuickFixes/RemoveUnassignedVariableUsageQuickFix.cs b/Rubberduck.Inspections/QuickFixes/RemoveUnassignedVariableUsageQuickFix.cs
@@ -24,8 +24,8 @@ public override void Fix(IInspectionResult result)
         {
             var rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName);
 
-            var assignmentContext = result.Context.GetParent<VBAParser.LetStmtContext>() ??
-                                                  (ParserRuleContext)result.Context.GetParent<VBAParser.CallStmtContext>();
+            var assignmentContext = result.Context.GetAncestor<VBAParser.LetStmtContext>() ??
+                                                  (ParserRuleContext)result.Context.GetAncestor<VBAParser.CallStmtContext>();
 
             rewriter.Remove(assignmentContext);
         }
diff --git a/Rubberduck.Inspections/VariableRequiresSetAssignmentEvaluator.cs b/Rubberduck.Inspections/VariableRequiresSetAssignmentEvaluator.cs
@@ -118,7 +118,7 @@ private static bool ObjectOrVariantRequiresSetAssignment(IdentifierReference obj
             }
 
             //Variants can be assigned with or without 'Set' depending...
-            var letStmtContext = objectOrVariantRef.Context.GetParent<VBAParser.LetStmtContext>();
+            var letStmtContext = objectOrVariantRef.Context.GetAncestor<VBAParser.LetStmtContext>();
 
             //A potential error is only possible for let statements: rset, lset and other type specific assignments are always let assignments; 
             //assignemts in for each loop statements are do not require the set keyword.
@@ -149,13 +149,13 @@ private static bool ObjectOrVariantRequiresSetAssignment(IdentifierReference obj
 
         private static bool IsLetAssignment(IdentifierReference reference)
         {
-            var letStmtContext = reference.Context.GetParent<VBAParser.LetStmtContext>();
+            var letStmtContext = reference.Context.GetAncestor<VBAParser.LetStmtContext>();
             return (reference.IsAssignment && letStmtContext != null);
         }
 
         private static bool IsAlreadyAssignedUsingSet(IdentifierReference reference)
         {
-            var setStmtContext = reference.Context.GetParent<VBAParser.SetStmtContext>();
+            var setStmtContext = reference.Context.GetAncestor<VBAParser.SetStmtContext>();
             return (reference.IsAssignment && setStmtContext?.SET() != null);
         }
 
diff --git a/Rubberduck.Parsing/ParserRuleContextExtensions.cs b/Rubberduck.Parsing/ParserRuleContextExtensions.cs
@@ -10,6 +10,9 @@ namespace Rubberduck.Parsing
 {
     public static class ParserRuleContextExtensions
     {
+        /// <summary>
+        ///  Returns a Selection structure containing the context
+        /// </summary>
         public static Selection GetSelection(this ParserRuleContext context)
         {
             // if we have an empty module, `Stop` is null
@@ -26,25 +29,6 @@ public static Selection GetSelection(this ParserRuleContext context)
                                  context.Stop.EndColumn() + 1);
         }
 
-//TODO: Question - remove?  None of the GetProcedureSelection overloads below are referenced (except for one...in a test)
-        //https://github.com/rubberduck-vba/Rubberduck/issues/2164
-        //This set of overloads returns the selection for the entire procedure statement body, i.e. Public Function Foo(bar As String) As String
-        public static Selection GetProcedureSelection(this VBAParser.FunctionStmtContext context) { return GetProcedureContextSelection(context); }
-        public static Selection GetProcedureSelection(this VBAParser.SubStmtContext context) { return GetProcedureContextSelection(context); }
-        public static Selection GetProcedureSelection(this VBAParser.PropertyGetStmtContext context) { return GetProcedureContextSelection(context); }
-        public static Selection GetProcedureSelection(this VBAParser.PropertyLetStmtContext context) { return GetProcedureContextSelection(context); }
-        public static Selection GetProcedureSelection(this VBAParser.PropertySetStmtContext context) { return GetProcedureContextSelection(context); }
-
-        private static Selection GetProcedureContextSelection(ParserRuleContext context)
-        {
-            var endContext1 = context.GetRuleContext<VBAParser.EndOfStatementContext>(0);
-            var endContext = context.GetChild<VBAParser.EndOfStatementContext>();
-            return new Selection(context.Start.Line == 0 ? 1 : context.Start.Line,
-                                 context.Start.Column + 1,
-                                 endContext.Start.Line == 0 ? 1 : endContext.Start.Line,
-                                 endContext.Start.Column + 1);
-        }
-
         /// <summary>
         ///  Gets the tokens belonging to the context from the token stream.
         /// </summary>
@@ -90,27 +74,32 @@ public static TContext GetChild<TContext>(this ParserRuleContext context) where
         /// </summary>
         public static bool IsDescendentOf<TContext>(this ParserRuleContext context)
         {
-            if(context is TContext)
+            if (context == null)
+            {
+                return false;
+            }
+
+            if (context is TContext)
             {
-                return GetParent_Recursive<TContext>((ParserRuleContext)context.Parent) != null;
+                return GetAncestor_Recursive<TContext>((ParserRuleContext)context.Parent) != null;
             }
-            return GetParent_Recursive<TContext>(context) != null;
+            return GetAncestor_Recursive<TContext>(context) != null;
         }
 
         /// <summary>
-        /// Determines if any of the context's ancestors are equal to the parameter 'parent'.
+        /// Determines if any of the context's ancestors are equal to the parameter 'ancestor'.
         /// </summary>
-        public static bool IsDescendentOf<T>(this ParserRuleContext context, T parent) where T : ParserRuleContext
+        public static bool IsDescendentOf<T>(this ParserRuleContext context, T ancestor) where T : ParserRuleContext
         {
-            if (context == null || parent == null)
+            if (context == null || ancestor == null)
             {
                 return false;
             }
-            if (context != parent)
+            if (context == ancestor)
             {
-                return IsDescendentOf_Recursive(context, parent);
+                return IsDescendentOf_Recursive(context.Parent, ancestor);
             }
-            return false;
+            return IsDescendentOf_Recursive(context, ancestor);
         }
 
         private static bool IsDescendentOf_Recursive(IParseTree context, IParseTree targetParent)
@@ -126,28 +115,23 @@ private static bool IsDescendentOf_Recursive(IParseTree context, IParseTree targ
             return IsDescendentOf_Recursive(context.Parent, targetParent);
         }
 
-        //TODO: Question: I would like to rename GetParent<T>(...) function to GetAncestor<T>(...)
-        //With a name like GetParent, I would expected the code to simply be: "return context.Parent;"
-        //This function is called when the caller is interested in looking 'up' the hierarchy including 
-        //and above the immediate parent.
-
         /// <summary>
         /// Returns the context's first ancestor of the generic Type.
         /// </summary>
-        public static TContext GetParent<TContext>(this ParserRuleContext context)
+        public static TContext GetAncestor<TContext>(this ParserRuleContext context)
         {
             if (context == null)
             {
                 return default;
             }
             if (context is TContext)
             {
-                return GetParent_Recursive<TContext>((ParserRuleContext)context.Parent);
+                return GetAncestor_Recursive<TContext>((ParserRuleContext)context.Parent);
             }
-            return GetParent_Recursive<TContext>(context);
+            return GetAncestor_Recursive<TContext>(context);
         }
 
-        private static TContext GetParent_Recursive<TContext>(ParserRuleContext context)
+        private static TContext GetAncestor_Recursive<TContext>(ParserRuleContext context)
         {
             if (context == null)
             {
@@ -157,15 +141,7 @@ private static TContext GetParent_Recursive<TContext>(ParserRuleContext context)
             {
                 return (TContext)System.Convert.ChangeType(context, typeof(TContext));
             }
-            return GetParent_Recursive<TContext>((ParserRuleContext)context.Parent);
-        }
-
-        /// <summary>
-        /// Determines if the any of the child contexts child.GetText() equals token .
-        /// </summary>
-        public static bool HasChildToken(this ParserRuleContext context, string token)
-        {
-            return context.children.Any(ch => ch.GetText().Equals(token));
+            return GetAncestor_Recursive<TContext>((ParserRuleContext)context.Parent);
         }
 
         /// <summary>
diff --git a/Rubberduck.Parsing/Symbols/DeclarationFinder.cs b/Rubberduck.Parsing/Symbols/DeclarationFinder.cs
@@ -199,7 +199,7 @@ private void InitializeLazyCollections()
                             IdentifierReference = reference,
                             Context = reference.Context is VBAParser.ImplementsStmtContext ? 
                                 (VBAParser.ImplementsStmtContext)reference.Context 
-                                    : reference.Context.GetParent<VBAParser.ImplementsStmtContext>()
+                                    : reference.Context.GetAncestor<VBAParser.ImplementsStmtContext>()
                         }
                     )
                 ).ToList();
@@ -234,7 +234,7 @@ private IDictionary<Declaration, List<Declaration>> FindAllIinterfaceMembersByMo
                             IdentifierReference = reference,
                             Context = reference.Context is VBAParser.ImplementsStmtContext ?
                                 (VBAParser.ImplementsStmtContext)reference.Context
-                                : reference.Context.GetParent<VBAParser.ImplementsStmtContext>()
+                                : reference.Context.GetAncestor<VBAParser.ImplementsStmtContext>()
                         }
                     )
                 );
diff --git a/RubberduckTests/Grammar/ParserRuleContextExtensionTests.cs b/RubberduckTests/Grammar/ParserRuleContextExtensionTests.cs

Original file line number	Diff line number	Diff line change
`@@ -573,7 +573,7 @@ public static Declaration FindInterface(this IEnumerable<Declaration> declaratio`
`573`	`573`	`{`
`574`	`574`	`foreach (var reference in declaration.References)`
`575`	`575`	`{`
`576`		`- var implementsStmt = reference.Context.GetParent<VBAParser.ImplementsStmtContext>();`
	`576`	`+ var implementsStmt = reference.Context.GetAncestor<VBAParser.ImplementsStmtContext>();`
`577`	`577`
`578`	`578`	`if (implementsStmt == null) { continue; }`
`579`	`579`
Original file line number	Diff line number	Diff line change
`@@ -123,7 +123,7 @@ private void AdjustReferences(IEnumerable<IdentifierReference> references, Decla`
`123`	`123`	`foreach (var reference in references.Where(item => item.Context != method.Context))`
`124`	`124`	`{`
`125`	`125`	`VBAParser.ArgumentListContext argumentList = null;`
`126`		`- var callStmt = reference.Context.GetParent<VBAParser.CallStmtContext>();`
	`126`	`+ var callStmt = reference.Context.GetAncestor<VBAParser.CallStmtContext>();`
`127`	`127`	`if (callStmt != null)`
`128`	`128`	`{`
`129`	`129`	`argumentList = CallStatement.GetArgumentList(callStmt);`
`@@ -132,7 +132,7 @@ private void AdjustReferences(IEnumerable<IdentifierReference> references, Decla`
`132`	`132`	`if (argumentList == null)`
`133`	`133`	`{`
`134`	`134`	`var indexExpression =`
`135`		`- reference.Context.GetParent<VBAParser.IndexExprContext>();`
	`135`	`+ reference.Context.GetAncestor<VBAParser.IndexExprContext>();`
`136`	`136`	`if (indexExpression != null)`
`137`	`137`	`{`
`138`	`138`	`argumentList = indexExpression.GetChild<VBAParser.ArgumentListContext>();`
Original file line number	Diff line number	Diff line change
`@@ -423,7 +423,7 @@ private void RenameModule()`
`423`	`423`	`{`
`424`	`424`	`foreach (var reference in _model.Target.References)`
`425`	`425`	`{`
`426`		`- var ctxt = reference.Context.GetParent<VBAParser.ImplementsStmtContext>();`
	`426`	`+ var ctxt = reference.Context.GetAncestor<VBAParser.ImplementsStmtContext>();`
`427`	`427`	`if (ctxt != null)`
`428`	`428`	`{`
`429`	`429`	`RenameDefinedFormatMembers(_state.DeclarationFinder.FindInterfaceMembersForImplementsContext(ctxt), _appendUnderscoreFormat);`
Original file line number	Diff line number	Diff line change
`@@ -124,15 +124,15 @@ private void AdjustReferences(IEnumerable<IdentifierReference> references)`
`124`	`124`	`{`
`125`	`125`	`var module = reference.QualifiedModuleName.Component.CodeModule;`
`126`	`126`	`VBAParser.ArgumentListContext argumentList = null;`
`127`		`- var callStmt = reference.Context.GetParent<VBAParser.CallStmtContext>();`
	`127`	`+ var callStmt = reference.Context.GetAncestor<VBAParser.CallStmtContext>();`
`128`	`128`	`if (callStmt != null)`
`129`	`129`	`{`
`130`	`130`	`argumentList = CallStatement.GetArgumentList(callStmt);`
`131`	`131`	`}`
`132`	`132`
`133`	`133`	`if (argumentList == null)`
`134`	`134`	`{`
`135`		`- var indexExpression = reference.Context.GetParent<VBAParser.IndexExprContext>();`
	`135`	`+ var indexExpression = reference.Context.GetAncestor<VBAParser.IndexExprContext>();`
`136`	`136`	`if (indexExpression != null)`
`137`	`137`	`{`
`138`	`138`	`argumentList = indexExpression.GetChild<VBAParser.ArgumentListContext>();`
Original file line number	Diff line number	Diff line change
`@@ -108,7 +108,7 @@ private bool IsIndexExprOrCallStmt(IdentifierReference usage)`
`108`	`108`
`109`	`109`	`private bool IsCallStmt(IdentifierReference usage)`
`110`	`110`	`{`
`111`		`- var callStmt = usage.Context.GetParent<VBAParser.CallStmtContext>();`
	`111`	`+ var callStmt = usage.Context.GetAncestor<VBAParser.CallStmtContext>();`
`112`	`112`	`if (callStmt == null)`
`113`	`113`	`{`
`114`	`114`	`return false;`
`@@ -123,7 +123,7 @@ private bool IsCallStmt(IdentifierReference usage)`
`123`	`123`
`124`	`124`	`private bool IsIndexExprContext(IdentifierReference usage)`
`125`	`125`	`{`
`126`		`- var indexExpr = usage.Context.GetParent<VBAParser.IndexExprContext>();`
	`126`	`+ var indexExpr = usage.Context.GetAncestor<VBAParser.IndexExprContext>();`
`127`	`127`	`if (indexExpr == null)`
`128`	`128`	`{`
`129`	`129`	`return false;`
`@@ -138,14 +138,14 @@ private bool IsIndexExprContext(IdentifierReference usage)`
`138`	`138`
`139`	`139`	`private bool IsLet(IdentifierReference usage)`
`140`	`140`	`{`
`141`		`- var letStmt = usage.Context.GetParent<VBAParser.LetStmtContext>();`
	`141`	`+ var letStmt = usage.Context.GetAncestor<VBAParser.LetStmtContext>();`
`142`	`142`
`143`	`143`	`return letStmt != null && letStmt == usage.Context;`
`144`	`144`	`}`
`145`	`145`
`146`	`146`	`private bool IsSet(IdentifierReference usage)`
`147`	`147`	`{`
`148`		`- var setStmt = usage.Context.GetParent<VBAParser.SetStmtContext>();`
	`148`	`+ var setStmt = usage.Context.GetAncestor<VBAParser.SetStmtContext>();`
`149`	`149`
`150`	`150`	`return setStmt != null && setStmt == usage.Context;`
`151`	`151`	`}`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ protected override IEnumerable<IInspectionResult> DoGetInspectionResults()`
`27`	`27`	`.SelectMany(declaration => declaration.References)`
`28`	`28`	`.Where(reference =>`
`29`	`29`	`{`
`30`		`- var letStmtContext = reference.Context.GetParent<VBAParser.LetStmtContext>();`
	`30`	`+ var letStmtContext = reference.Context.GetAncestor<VBAParser.LetStmtContext>();`
`31`	`31`	`return reference.IsAssignment && letStmtContext != null && letStmtContext.LET() == null;`
`32`	`32`	`});`
`33`	`33`
Original file line number	Diff line number	Diff line change
`@@ -45,10 +45,10 @@ protected override IEnumerable<IInspectionResult> DoGetInspectionResults()`
`45`	`45`	`private bool FlagIfObjectVariableNotSet(IdentifierReference reference)`
`46`	`46`	`{`
`47`	`47`	`var allrefs = reference.Declaration.References;`
`48`		`- var letStmtContext = reference.Context.GetParent<VBAParser.LetStmtContext>();`
	`48`	`+ var letStmtContext = reference.Context.GetAncestor<VBAParser.LetStmtContext>();`
`49`	`49`
`50`	`50`	`return reference.IsAssignment && (letStmtContext != null`
`51`		`- \|\| allrefs.Where(r => r.IsAssignment).All(r => r.Context.GetParent<VBAParser.SetStmtContext>()?.expression()?.GetText().Equals(Tokens.Nothing, StringComparison.InvariantCultureIgnoreCase) ?? false));`
	`51`	`+ \|\| allrefs.Where(r => r.IsAssignment).All(r => r.Context.GetAncestor<VBAParser.SetStmtContext>()?.expression()?.GetText().Equals(Tokens.Nothing, StringComparison.InvariantCultureIgnoreCase) ?? false));`
`52`	`52`	`}`
`53`	`53`	`}`
`54`	`54`	`}`
Original file line number	Diff line number	Diff line change
`@@ -64,7 +64,7 @@ private void UpdateSignature(Declaration target, ParameterDeclaration arg)`
`64`	`64`	`private void UpdateCall(IdentifierReference reference, int argIndex)`
`65`	`65`	`{`
`66`	`66`	`var rewriter = _state.GetRewriter(reference.QualifiedModuleName);`
`67`		`- var callStmtContext = reference.Context.GetParent<VBAParser.CallStmtContext>();`
	`67`	`+ var callStmtContext = reference.Context.GetAncestor<VBAParser.CallStmtContext>();`
`68`	`68`	`var argListContext = callStmtContext.GetChild<VBAParser.ArgumentListContext>();`
`69`	`69`
`70`	`70`	`var arg = argListContext.argument()[argIndex];`
Original file line number	Diff line number	Diff line change
`@@ -24,8 +24,8 @@ public override void Fix(IInspectionResult result)`
`24`	`24`	`{`
`25`	`25`	`var rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName);`
`26`	`26`
`27`		`- var assignmentContext = result.Context.GetParent<VBAParser.LetStmtContext>() ??`
`28`		`- (ParserRuleContext)result.Context.GetParent<VBAParser.CallStmtContext>();`
	`27`	`+ var assignmentContext = result.Context.GetAncestor<VBAParser.LetStmtContext>() ??`
	`28`	`+ (ParserRuleContext)result.Context.GetAncestor<VBAParser.CallStmtContext>();`
`29`	`29`
`30`	`30`	`rewriter.Remove(assignmentContext);`
`31`	`31`	`}`
Original file line number	Diff line number	Diff line change
`@@ -118,7 +118,7 @@ private static bool ObjectOrVariantRequiresSetAssignment(IdentifierReference obj`
`118`	`118`	`}`
`119`	`119`
`120`	`120`	`//Variants can be assigned with or without 'Set' depending...`
`121`		`- var letStmtContext = objectOrVariantRef.Context.GetParent<VBAParser.LetStmtContext>();`
	`121`	`+ var letStmtContext = objectOrVariantRef.Context.GetAncestor<VBAParser.LetStmtContext>();`
`122`	`122`
`123`	`123`	`//A potential error is only possible for let statements: rset, lset and other type specific assignments are always let assignments;`
`124`	`124`	`//assignemts in for each loop statements are do not require the set keyword.`
`@@ -149,13 +149,13 @@ private static bool ObjectOrVariantRequiresSetAssignment(IdentifierReference obj`
`149`	`149`
`150`	`150`	`private static bool IsLetAssignment(IdentifierReference reference)`
`151`	`151`	`{`
`152`		`- var letStmtContext = reference.Context.GetParent<VBAParser.LetStmtContext>();`
	`152`	`+ var letStmtContext = reference.Context.GetAncestor<VBAParser.LetStmtContext>();`
`153`	`153`	`return (reference.IsAssignment && letStmtContext != null);`
`154`	`154`	`}`
`155`	`155`
`156`	`156`	`private static bool IsAlreadyAssignedUsingSet(IdentifierReference reference)`
`157`	`157`	`{`
`158`		`- var setStmtContext = reference.Context.GetParent<VBAParser.SetStmtContext>();`
	`158`	`+ var setStmtContext = reference.Context.GetAncestor<VBAParser.SetStmtContext>();`
`159`	`159`	`return (reference.IsAssignment && setStmtContext?.SET() != null);`
`160`	`160`	`}`
`161`	`161`