Mark Line Input, Input, and Get references as assignments

Author: Hosch250

Rubberduck.Parsing/Symbols/IdentifierReferenceResolver.cs

@@ -163,7 +163,7 @@ private void ResolveDefault(
                        "Default Context: Failed to resolve {0}. Binding as much as we can.",
                        expression.GetText()));
             }
-            _boundExpressionVisitor.AddIdentifierReferences(boundExpression, _qualifiedModuleName, _currentScope, _currentParent, isAssignmentTarget, false);
+            _boundExpressionVisitor.AddIdentifierReferences(boundExpression, _qualifiedModuleName, _currentScope, _currentParent, isAssignmentTarget, hasExplicitLetStatement);
         }
 
         private void ResolveType(ParserRuleContext expression)
@@ -444,7 +444,7 @@ private void ResolveRecordRange(VBAParser.RecordRangeContext recordRange)
         public void Resolve(VBAParser.LineInputStmtContext context)
         {
             ResolveDefault(context.markedFileNumber().expression());
-            ResolveDefault(context.variableName().expression());
+            ResolveDefault(context.variableName().expression(), isAssignmentTarget: true);
         }
 
         public void Resolve(VBAParser.WidthStmtContext context)
@@ -496,7 +496,7 @@ public void Resolve(VBAParser.InputStmtContext context)
             ResolveDefault(context.markedFileNumber().expression());
             foreach (var inputVariable in context.inputList().inputVariable())
             {
-                ResolveDefault(inputVariable.expression());
+                ResolveDefault(inputVariable.expression(), isAssignmentTarget: true);
             }
         }
 
@@ -522,7 +522,7 @@ public void Resolve(VBAParser.GetStmtContext context)
             }
             if (context.variable() != null)
             {
-                ResolveDefault(context.variable().expression());
+                ResolveDefault(context.variable().expression(), isAssignmentTarget: true);
             }
         }
 

RubberduckTests/Grammar/ResolverTests.cs

@@ -1848,6 +1848,26 @@ End Sub
             Assert.AreEqual(2, declaration.References.Count());
         }
 
+        [TestMethod]
+        public void LineInputStmt_ReferenceIsAssignment()
+        {
+            // arrange
+            var code = @"
+Public Sub Test()
+    Dim file As Integer, content
+    Line Input #file, content
+End Sub
+";
+            // act
+            var state = Resolve(code);
+
+            // assert
+            var declaration = state.AllUserDeclarations.Single(item =>
+                item.DeclarationType == DeclarationType.Variable && item.IdentifierName == "content");
+
+            Assert.IsTrue(declaration.References.Single().IsAssignment);
+        }
+
         [TestMethod]
         public void WidthStmt_IsReferenceToLocalVariable()
         {
@@ -1928,6 +1948,39 @@ End Sub
             Assert.AreEqual(2, declaration.References.Count());
         }
 
+        [TestMethod]
+        public void InputStmt_ReferenceIsAssignment()
+        {
+            // arrange
+            var code = @"
+Public Sub Test()
+    Dim str As String
+    Dim xCoord, yCoord, zCoord As Double
+    Input #1, str, xCoord, yCoord, zCoord
+End Sub
+";
+            // act
+            var state = Resolve(code);
+
+            // assert
+            var strDeclaration = state.AllUserDeclarations.Single(item =>
+                item.DeclarationType == DeclarationType.Variable && item.IdentifierName == "str");
+
+            var xCoordDeclaration = state.AllUserDeclarations.Single(item =>
+                item.DeclarationType == DeclarationType.Variable && item.IdentifierName == "xCoord");
+
+            var yCoordDeclaration = state.AllUserDeclarations.Single(item =>
+                item.DeclarationType == DeclarationType.Variable && item.IdentifierName == "yCoord");
+
+            var zCoordDeclaration = state.AllUserDeclarations.Single(item =>
+                item.DeclarationType == DeclarationType.Variable && item.IdentifierName == "zCoord");
+
+            Assert.IsTrue(strDeclaration.References.Single().IsAssignment);
+            Assert.IsTrue(xCoordDeclaration.References.Single().IsAssignment);
+            Assert.IsTrue(yCoordDeclaration.References.Single().IsAssignment);
+            Assert.IsTrue(zCoordDeclaration.References.Single().IsAssignment);
+        }
+
         [TestMethod]
         public void PutStmt_IsReferenceToLocalVariable()
         {
@@ -1955,7 +2008,7 @@ public void GetStmt_IsReferenceToLocalVariable()
             var code = @"
 Public Sub Test()
     Dim referenced As Integer
-    Get referenced,referenced,referenced
+    Get #referenced,referenced,referenced
 End Sub
 ";
             // act
@@ -1968,6 +2021,26 @@ End Sub
             Assert.AreEqual(3, declaration.References.Count());
         }
 
+        [TestMethod]
+        public void GetStmt_ReferenceIsAssignment()
+        {
+            // arrange
+            var code = @"
+Public Sub Test()
+    Dim fileNumber As Integer, recordNumber, variable
+    Get #fileNumber, recordNumber, variable
+End Sub
+";
+            // act
+            var state = Resolve(code);
+
+            // assert
+            var variableDeclaration = state.AllUserDeclarations.Single(item =>
+                item.DeclarationType == DeclarationType.Variable && item.IdentifierName == "variable");
+
+            Assert.IsTrue(variableDeclaration.References.Single().IsAssignment);
+        }
+
         [TestMethod]
         public void LineSpecialForm_IsReferenceToLocalVariable()
         {

RubberduckTests/Inspections/ParameterCanBeByValInspectionTests.cs

@@ -333,6 +333,74 @@ Sub Foo(arg1 As String)
             Assert.IsFalse(inspectionResults.Any());
         }
 
+        [TestMethod]
+        public void ParameterCanBeByVal_InterfaceMember()
+        {
+            //Input
+            const string inputCode1 =
+@"Public Sub DoSomething(ByRef a As Integer)
+End Sub";
+            const string inputCode2 =
+@"Implements IClass1
+
+Private Sub IClass1_DoSomething(ByRef a As Integer)
+End Sub";
+
+            //Arrange
+            var builder = new MockVbeBuilder();
+            var project = builder.ProjectBuilder("TestProject1", vbext_ProjectProtection.vbext_pp_none)
+                .AddComponent("IClass1", vbext_ComponentType.vbext_ct_ClassModule, inputCode1)
+                .AddComponent("Class1", vbext_ComponentType.vbext_ct_ClassModule, inputCode2)
+                .Build();
+            var vbe = builder.AddProject(project).Build();
+
+            var mockHost = new Mock<IHostApplication>();
+            mockHost.SetupAllProperties();
+            var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock<ISinks>().Object));
+
+            parser.Parse(new CancellationTokenSource());
+            if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); }
+
+            var inspection = new ParameterCanBeByValInspection(parser.State);
+            var inspectionResults = inspection.GetInspectionResults();
+
+            Assert.IsFalse(inspectionResults.Any());
+        }
+        
+        [TestMethod]
+        public void ParameterCanBeByVal_Event()
+        {
+            //Input
+            const string inputCode1 =
+@"Public Event Foo(ByVal arg1 As Integer, ByVal arg2 As String)";
+
+            const string inputCode2 =
+@"Private WithEvents abc As Class1
+
+Private Sub abc_Foo(ByVal arg1 As Integer, ByVal arg2 As String)
+End Sub";
+
+            //Arrange
+            var builder = new MockVbeBuilder();
+            var project = builder.ProjectBuilder("TestProject1", vbext_ProjectProtection.vbext_pp_none)
+                .AddComponent("Class1", vbext_ComponentType.vbext_ct_ClassModule, inputCode1)
+                .AddComponent("Class2", vbext_ComponentType.vbext_ct_ClassModule, inputCode2)
+                .Build();
+            var vbe = builder.AddProject(project).Build();
+
+            var mockHost = new Mock<IHostApplication>();
+            mockHost.SetupAllProperties();
+            var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock<ISinks>().Object));
+
+            parser.Parse(new CancellationTokenSource());
+            if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); }
+
+            var inspection = new ParameterCanBeByValInspection(parser.State);
+            var inspectionResults = inspection.GetInspectionResults();
+
+            Assert.IsFalse(inspectionResults.Any());
+        }
+
         [TestMethod]
         [TestCategory("Inspections")]
         public void ParameterCanBeByVal_QuickFixWorks_SubNameStartsWithParamName()