Simplify ObjectVariableNotSetInspection

It now works using failed Let coercion references.

Author: MDoerner

Rubberduck.CodeAnalysis/Inspections/Concrete/ObjectVariableNotSetInspection.cs

@@ -1,13 +1,18 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.Linq;
+using Antlr4.Runtime;
 using Rubberduck.Inspections.Abstract;
 using Rubberduck.Inspections.Results;
 using Rubberduck.Parsing.Inspections.Abstract;
 using Rubberduck.Resources.Inspections;
 using Rubberduck.Parsing.Symbols;
 using Rubberduck.Parsing.VBA;
 using Rubberduck.Inspections.Inspections.Extensions;
+using Rubberduck.Parsing;
+using Rubberduck.Parsing.Grammar;
 using Rubberduck.Parsing.VBA.DeclarationCaching;
+using Rubberduck.VBEditor;
 
 namespace Rubberduck.Inspections.Concrete
 {
@@ -45,10 +50,9 @@ protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
         {
             var finder = State.DeclarationFinder;
 
-            var failedLetResolutionAssignments = FailedLetResolutionAssignments(finder);
-            var interestingOtherReferences = InterestingReferences();
+            var failedLetResolutionResults = FailedLetResolutionResults(finder);
 
-            return failedLetResolutionAssignments.Concat(interestingOtherReferences)
+            return failedLetResolutionResults
                 .Select(reference =>
                     new IdentifierReferenceInspectionResult(
                         this,
@@ -57,7 +61,7 @@ protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
                         reference));
         }
 
-        private IEnumerable<IdentifierReference> FailedLetResolutionAssignments(DeclarationFinder finder)
+        private IEnumerable<IdentifierReference> FailedLetResolutionResults(DeclarationFinder finder)
         {
             var results = new List<IdentifierReference>();
             foreach (var moduleDeclaration in finder.UserDeclarations(DeclarationType.Module))
@@ -67,33 +71,55 @@ private IEnumerable<IdentifierReference> FailedLetResolutionAssignments(Declarat
                     continue;
                 }
 
-                var failedLetCoercionAssignmentsInModule = finder
-                    .FailedLetCoercions(moduleDeclaration.QualifiedModuleName)
-                    .Where(reference => reference.IsAssignment);
-
+                var module = moduleDeclaration.QualifiedModuleName;
+                var failedLetCoercionAssignmentsInModule = FailedLetResolutionAssignments(module, finder);
+                var possiblyObjectLhsLetAssignmentsWithFailedLetResolutionOnRhs = PossiblyObjectLhsLetAssignmentsWithNonValueOnRhs(module, finder);
                 results.AddRange(failedLetCoercionAssignmentsInModule);
+                results.AddRange(possiblyObjectLhsLetAssignmentsWithFailedLetResolutionOnRhs);
             }
 
             return results.Where(reference => !reference.IsIgnoringInspectionResultFor(AnnotationName));
         }
 
-        private IEnumerable<IdentifierReference> InterestingReferences()
+        private static IEnumerable<IdentifierReference> FailedLetResolutionAssignments(QualifiedModuleName module, DeclarationFinder finder)
         {
-            var result = new List<IdentifierReference>();
-            foreach (var moduleReferences in State.DeclarationFinder.IdentifierReferences())
-            {
-                var module = State.DeclarationFinder.ModuleDeclaration(moduleReferences.Key);
-                if (module == null || !module.IsUserDefined || module.IsIgnoringInspectionResultFor(AnnotationName))
-                {
-                    // module isn't user code (?), or this inspection is ignored at module-level
-                    continue;
-                }
+            return finder.FailedLetCoercions(module)
+                .Where(reference => reference.IsAssignment);
+        }
 
-                result.AddRange(moduleReferences.Value.Where(reference => !reference.IsSetAssignment
-                    && VariableRequiresSetAssignmentEvaluator.RequiresSetAssignment(reference, State)));
-            }
+        private static IEnumerable<IdentifierReference> PossiblyObjectLhsLetAssignmentsWithNonValueOnRhs(QualifiedModuleName module, DeclarationFinder finder)
+        {
+            return PossiblyObjectLhsLetAssignments(module, finder)
+                .Where(tpl => finder.FailedLetCoercions(module)
+                        .Any(reference => reference.Selection.Equals(tpl.rhs.GetSelection()))
+                        || Tokens.Nothing.Equals(tpl.rhs.GetText(), StringComparison.InvariantCultureIgnoreCase))
+                .Select(tpl => tpl.assignment);
+        }
+
+        private static IEnumerable<(IdentifierReference assignment, ParserRuleContext rhs)> PossiblyObjectLhsLetAssignments(QualifiedModuleName module, DeclarationFinder finder)
+        {
+            return PossiblyObjectNonSetAssignments(module, finder)
+                .Select(reference => (reference, RhsOfLetAssignment(reference)))
+                .Where(tpl => tpl.Item2 != null);
+        }
+
+        private static ParserRuleContext RhsOfLetAssignment(IdentifierReference letAssignment)
+        {
+            var letStatement = letAssignment.Context.Parent as VBAParser.LetStmtContext;
+            return letStatement?.expression();
+        }
+
+        private static IEnumerable<IdentifierReference> PossiblyObjectNonSetAssignments(QualifiedModuleName module, DeclarationFinder finder)
+        {
+            var assignments = finder.IdentifierReferences(module)
+                .Where(reference => reference.IsAssignment
+                                    && !reference.IsSetAssignment
+                                    && (reference.IsNonIndexedDefaultMemberAccess 
+                                        || Tokens.Variant.Equals(reference.Declaration.AsTypeName, StringComparison.InvariantCultureIgnoreCase)));
+            var unboundAssignments = finder.UnboundDefaultMemberAccesses(module)
+                .Where(reference => reference.IsAssignment);
 
-            return result.Where(reference => !reference.IsIgnoringInspectionResultFor(AnnotationName));
+            return assignments.Concat(unboundAssignments);
         }
     }
 }

RubberduckTests/Grammar/ResolverTests.cs

@@ -5672,7 +5672,7 @@ End Sub
         [TestCase("    For Each fooBar In cls.Baz : Foo = 42 : Next", 24, 31)]
         [TestCase("    Foo = cls.Baz Is fooBar", 11, 18)]
         [TestCase("    Foo = fooBar Is cls.Baz", 21, 28)]
-        public void NonLetCoercionExpressionHasNoFeiledLetCoercionReference(string statement, int selectionStartColumn, int selectionEndColumn)
+        public void NonLetCoercionExpressionHasNoFailedLetCoercionReference(string statement, int selectionStartColumn, int selectionEndColumn)
         {
             var class1Code = @"
 Public Function Foo() As Long