Only set IsAssignment flag on last reference in a chain (#1536)

* Close #1532

* Add tests, kill bug.

* Use better ternary condition

Author: Hosch250

Rubberduck.Parsing/Symbols/IdentifierReferenceResolver.cs

@@ -167,7 +167,10 @@ private void ResolveDefault(ParserRuleContext context, string expression,
                 _boundExpressionVisitor.AddIdentifierReferences(boundExpression,
                     (exprCtx, identifier, declaration) =>
                         CreateReference(context, identifier, declaration,
-                            RubberduckParserState.CreateBindingSelection(context, exprCtx), isAssignmentTarget,
+                            RubberduckParserState.CreateBindingSelection(context, exprCtx),
+                            boundExpression is MemberAccessExpression
+                                ? isAssignmentTarget && boundExpression.Context.children.Last() == exprCtx
+                                : isAssignmentTarget,
                             hasExplicitLetStatement));
             }
             else

RubberduckTests/Grammar/ResolverTests.cs

@@ -1976,5 +1976,152 @@ End Property
 
             Assert.AreEqual(1, usages.Count());
         }
+
+        [TestMethod]
+        public void QualifiedSetStatement_FirstSectionDoesNotHaveAssignmentFlag()
+        {
+            // arrange
+            var variableDeclarationClass = @"
+Public foo As Boolean
+";
+
+            var classVariableDeclarationClass = @"
+Public myClass As Class1
+";
+
+            var variableCallClass = @"
+Public Sub bar()
+    Dim myClassN As Class2
+    Set myClassN.myClass.foo = True
+End Sub
+";
+            // act
+            var state = Resolve(variableDeclarationClass, classVariableDeclarationClass, variableCallClass);
+
+            // assert
+            var declaration = state.AllUserDeclarations.Single(item =>
+                item.DeclarationType == DeclarationType.Variable && item.IdentifierName == "myClassN");
+
+            Assert.IsFalse(declaration.References.ElementAt(0).IsAssignment);
+        }
+
+        [TestMethod]
+        public void QualifiedSetStatement_MiddleSectionDoesNotHaveAssignmentFlag()
+        {
+            // arrange
+            var variableDeclarationClass = @"
+Public foo As Boolean
+";
+
+            var classVariableDeclarationClass = @"
+Public myClass As Class1
+";
+
+            var variableCallClass = @"
+Public Sub bar()
+    Dim myClassN As Class2
+    Set myClassN.myClass.foo = True
+End Sub
+";
+            // act
+            var state = Resolve(variableDeclarationClass, classVariableDeclarationClass, variableCallClass);
+
+            // assert
+            var declaration = state.AllUserDeclarations.Single(item =>
+                item.DeclarationType == DeclarationType.Variable && item.IdentifierName == "myClass");
+
+            Assert.IsFalse(declaration.References.ElementAt(0).IsAssignment);
+        }
+
+        [TestMethod]
+        public void QualifiedSetStatement_LastSectionHasAssignmentFlag()
+        {
+            // arrange
+            var variableDeclarationClass = @"
+Public foo As Boolean
+";
+
+            var classVariableDeclarationClass = @"
+Public myClass As Class1
+";
+
+            var variableCallClass = @"
+Public Sub bar()
+    Dim myClassN As Class2
+    Set myClassN.myClass.foo = True
+End Sub
+";
+            // act
+            var state = Resolve(variableDeclarationClass, classVariableDeclarationClass, variableCallClass);
+
+            // assert
+            var declaration = state.AllUserDeclarations.Single(item =>
+                item.DeclarationType == DeclarationType.Variable && item.IdentifierName == "foo");
+
+            Assert.IsTrue(declaration.References.ElementAt(0).IsAssignment);
+        }
+
+        [TestMethod]
+        public void SetStatement_HasAssignmentFlag()
+        {
+            // arrange
+            var variableDeclarationClass = @"
+Public foo As Variant
+
+Public Sub bar()
+    Set foo = New Class2
+End Sub
+";
+            // act
+            var state = Resolve(variableDeclarationClass, string.Empty);
+
+            // assert
+            var declaration = state.AllUserDeclarations.Single(item =>
+                item.DeclarationType == DeclarationType.Variable && item.IdentifierName == "foo");
+
+            Assert.IsTrue(declaration.References.ElementAt(0).IsAssignment);
+        }
+
+        [TestMethod]
+        public void ImplicitLetStatement_HasAssignmentFlag()
+        {
+            // arrange
+            var variableDeclarationClass = @"
+Public foo As Boolean
+
+Public Sub bar()
+    foo = True
+End Sub
+";
+            // act
+            var state = Resolve(variableDeclarationClass);
+
+            // assert
+            var declaration = state.AllUserDeclarations.Single(item =>
+                item.DeclarationType == DeclarationType.Variable && item.IdentifierName == "foo");
+
+            Assert.IsTrue(declaration.References.ElementAt(0).IsAssignment);
+        }
+
+        [TestMethod]
+        public void ExplicitLetStatement_HasAssignmentFlag()
+        {
+            // arrange
+            var variableDeclarationClass = @"
+Public foo As Boolean
+
+Public Sub bar()
+    Let foo = True
+End Sub
+";
+            // act
+            var state = Resolve(variableDeclarationClass);
+
+            // assert
+            var declaration = state.AllUserDeclarations.Single(item =>
+                item.DeclarationType == DeclarationType.Variable && item.IdentifierName == "foo");
+
+            Assert.IsTrue(declaration.References.ElementAt(0).IsAssignment);
+        }
     }
 }