RedundantAssignment issue is now more careful when removing

invocations.

ICSharpCode.NRefactory.CSharp/Refactoring/CodeIssues/RedundantAssignmentIssue.cs

@@ -140,12 +140,40 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 				ProcessNodes (startNode);
 			}
 
+			class SearchInvocationsVisitor  : DepthFirstAstVisitor
+			{
+				bool foundInvocations;
+
+				public bool ContainsInvocations(AstNode node)
+				{
+					foundInvocations = false;
+					node.AcceptVisitor (this);
+					return foundInvocations;
+				}
+
+				protected override void VisitChildren (AstNode node)
+				{
+					AstNode next;
+					for (var child = node.FirstChild; child != null && !foundInvocations; child = next) {
+						next = child.NextSibling;
+						child.AcceptVisitor (this);
+					}
+				}
+
+				public override void VisitInvocationExpression(InvocationExpression invocationExpression)
+				{
+					foundInvocations = true;
+				}
+			}
+
 			void AddIssue (AstNode node)
 			{
 				var title = ctx.TranslateString ("Remove redundant assignment");
 
 				var variableInitializer = node as VariableInitializer;
 				if (variableInitializer != null) {
+					if (new SearchInvocationsVisitor ().ContainsInvocations (variableInitializer.Initializer))
+						return;
 					AddIssue (variableInitializer.Initializer, title,
 						script => {
 							var replacement = (VariableInitializer)node.Clone ();

ICSharpCode.NRefactory.Tests/CSharp/CodeIssues/RedundantAssignmentIssueTests.cs

@@ -390,6 +390,22 @@ class TestClass
 			// nothing
 		}
 	}
+}";
+			Test<RedundantAssignmentIssue> (input, 0);
+		}
+
+		[Test]
+		public void TestAssignmentWithFunction ()
+		{
+			var input = @"using System;
+class TestClass
+{
+    void Test(TestClass a) { }
+	TestClass  Func () { return null; }
+	void TestMethod ()
+	{
+		var a = Func ();
+	}
 }";
 			Test<RedundantAssignmentIssue> (input, 0);
 		}