SimplifyAnonymousMethodToDelegateIssues now doesn't touch too complex

expressions.

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

@@ -62,14 +62,27 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 				return null;
 			}
 
-			public override void VisitLambdaExpression(LambdaExpression lambdaExpression)
+			static bool IsSimpleTarget(Expression target)
 			{
-				base.VisitLambdaExpression(lambdaExpression);
+				if (target is IdentifierExpression)
-				var invocation = AnalyzeBody(lambdaExpression.Body);
+					return true;
+				var mref = target as MemberReferenceExpression;
+				if (mref != null)
+					return IsSimpleTarget (mref.Target);
+				var pref = target as PointerReferenceExpression;
+				if (pref != null)
+					return IsSimpleTarget (pref.Target);
+				return false;
+			}
+
+			void AnalyzeExpression(AstNode expression, AstNode body, AstNodeCollection<ParameterDeclaration> parameters)
+			{
+				var invocation = AnalyzeBody(body);
 				if (invocation == null)
 					return;
-
+				if (!IsSimpleTarget (invocation.Target))
-				var lambdaParameters = lambdaExpression.Parameters.ToList();
+					return;
+				var lambdaParameters = parameters.ToList();
 				if (lambdaParameters.Count != invocation.Arguments.Count)
 					return;
 				int i = 0;
@@ -77,42 +90,25 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 					var id = param as IdentifierExpression;
 					if (id == null)
 						return;
-					if (lambdaParameters [i].Name != id.Identifier)
+					if (lambdaParameters[i].Name != id.Identifier)
 						return;
 					i++;
 				}
+				AddIssue(expression, ctx.TranslateString("Expression can be reduced to delegate"), script =>  {
+					script.Replace(expression, invocation.Target.Clone());
+				});
+			}
 
-				AddIssue(
+			public override void VisitLambdaExpression(LambdaExpression lambdaExpression)
-					lambdaExpression, 
+			{
-					ctx.TranslateString("Expression can be reduced to delegate"),
+				base.VisitLambdaExpression(lambdaExpression);
-					script => { script.Replace (lambdaExpression, invocation.Target.Clone ()); });
+				AnalyzeExpression(lambdaExpression, lambdaExpression.Body, lambdaExpression.Parameters);
 			}
 
 			public override void VisitAnonymousMethodExpression(AnonymousMethodExpression anonymousMethodExpression)
 			{
 				base.VisitAnonymousMethodExpression(anonymousMethodExpression);
-
+				AnalyzeExpression(anonymousMethodExpression, anonymousMethodExpression.Body, anonymousMethodExpression.Parameters);
-				var invocation = AnalyzeBody(anonymousMethodExpression.Body);
-				if (invocation == null)
-					return;
-
-				var lambdaParameters = anonymousMethodExpression.Parameters.ToList();
-				if (lambdaParameters.Count != invocation.Arguments.Count)
-					return;
-				int i = 0;
-				foreach (var param in invocation.Arguments) {
-					var id = param as IdentifierExpression;
-					if (id == null)
-						return;
-					if (lambdaParameters [i].Name != id.Identifier)
-						return;
-					i++;
-				}
-				
-				AddIssue(
-					anonymousMethodExpression, 
-					ctx.TranslateString("Expression can be reduced to delegate"),
-					script => { script.Replace (anonymousMethodExpression, invocation.Target.Clone ()); });
 			}
 		}
 	}

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

@@ -123,7 +123,28 @@ namespace ICSharpCode.NRefactory.CSharp.CodeIssues
 		}
 
 		[Test]
-		public void TestSimpleInvalidAnonymousMethod ()
+		public void TestSkipComplexCase ()
+		{
+			var input = @"using System;
+using System.Linq;
+
+class Foo
+{
+	int MyMethod (int x, int y) { return x * y; }
+
+	void Bar (string str)
+	{
+		var action = $() => str.Where (c => c != 'a').ToArray ();
+	}
+}";
+			
+			TestRefactoringContext context;
+			var issues = GetIssues (new SimplifyAnonymousMethodToDelegateIssue (), input, out context);
+			Assert.AreEqual (0, issues.Count);
+		}
+
+		[Test]
+		public void TestComplexCase ()
 		{
 			var input = @"class Foo
 {