From 2978af440e3d8d5c28bd0abcaea1e2d6b90f25b0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Erik=20K=C3=A4ll=C3=A9n?= <erik_kallen@hotmail.com>
Date: Wed, 27 Feb 2013 00:00:07 +0100
Subject: [PATCH] No conversions in body for void lambdas

---
 .../Resolver/ResolveVisitor.cs                | 16 +++++++----
 .../CSharp/Resolver/LambdaTests.cs            | 28 +++++++++++++++++--
 2 files changed, 36 insertions(+), 8 deletions(-)

diff --git a/ICSharpCode.NRefactory.CSharp/Resolver/ResolveVisitor.cs b/ICSharpCode.NRefactory.CSharp/Resolver/ResolveVisitor.cs
index 221c2c54d8..267d061bbb 100644
--- a/ICSharpCode.NRefactory.CSharp/Resolver/ResolveVisitor.cs
+++ b/ICSharpCode.NRefactory.CSharp/Resolver/ResolveVisitor.cs
@@ -2032,9 +2032,11 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 						Analyze();
 						if (returnValues.Count == 1) {
 							bodyRR = returnValues[0];
-							var conv = storedContext.conversions.ImplicitConversion(bodyRR, actualReturnType);
-							if (!conv.IsIdentityConversion)
-								bodyRR = new ConversionResolveResult(actualReturnType, bodyRR, conv, storedContext.CheckForOverflow);
+							if (!actualReturnType.Equals(SpecialType.UnknownType)) {
+								var conv = storedContext.conversions.ImplicitConversion(bodyRR, actualReturnType);
+								if (!conv.IsIdentityConversion)
+									bodyRR = new ConversionResolveResult(actualReturnType, bodyRR, conv, storedContext.CheckForOverflow);
+							}
 							return bodyRR;
 						}
 					}
@@ -2465,9 +2467,11 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				lambda.parameters = lambdaParameters; // replace untyped parameters with typed parameters
 				if (lambda.BodyExpression is Expression && returnValues.Count == 1) {
 					lambda.bodyResult = returnValues[0];
-					var conv = storedContext.conversions.ImplicitConversion(lambda.bodyResult, returnType);
-					if (!conv.IsIdentityConversion)
-						lambda.bodyResult = new ConversionResolveResult(returnType, lambda.bodyResult, conv, storedContext.CheckForOverflow);
+					if (!returnType.IsKnownType(KnownTypeCode.Void)) {
+						var conv = storedContext.conversions.ImplicitConversion(lambda.bodyResult, returnType);
+						if (!conv.IsIdentityConversion)
+							lambda.bodyResult = new ConversionResolveResult(returnType, lambda.bodyResult, conv, storedContext.CheckForOverflow);
+					}
 				}
 				
 				Log.WriteLine("Applying return type {0} to implicitly-typed lambda {1}", returnType, lambda.LambdaExpression);
diff --git a/ICSharpCode.NRefactory.Tests/CSharp/Resolver/LambdaTests.cs b/ICSharpCode.NRefactory.Tests/CSharp/Resolver/LambdaTests.cs
index 0c59016623..178f525a97 100644
--- a/ICSharpCode.NRefactory.Tests/CSharp/Resolver/LambdaTests.cs
+++ b/ICSharpCode.NRefactory.Tests/CSharp/Resolver/LambdaTests.cs
@@ -670,7 +670,7 @@ class C
 		}
 
 		[Test]
-		public void ConversionInExplicitLambdaResult() {
+		public void ConversionInExplicitlyTypedLambdaBody() {
 			string program = @"using System;
 class Test {
 	public object M() {
@@ -683,7 +683,7 @@ class Test {
 		}
 
 		[Test]
-		public void ConversionInImplicitLambdaResult() {
+		public void ConversionInImplicitlyTypedLambdaBody() {
 			string program = @"using System;
 class Test {
 	public object M() {
@@ -694,5 +694,29 @@ class Test {
 			Assert.IsInstanceOf<ConversionResolveResult>(rr.Body);
 			Assert.That(((ConversionResolveResult)rr.Body).Conversion.IsNullLiteralConversion);
 		}
+
+		[Test]
+		public void NoConversionInVoidExplicitlyTypedLambdaBody() {
+			string program = @"using System;
+class Test {
+	public object M() {
+		System.Action<int, string> f = $(int i) => i++$;
+	}
+}";
+			var rr = Resolve<LambdaResolveResult>(program);
+			Assert.IsInstanceOf<OperatorResolveResult>(rr.Body);
+		}
+
+		[Test]
+		public void NoConversionInVoidImplicitlyTypedLambdaBody() {
+			string program = @"using System;
+class Test {
+	public object M() {
+		System.Action<int> f = $i => i++$;
+	}
+}";
+			var rr = Resolve<LambdaResolveResult>(program);
+			Assert.IsInstanceOf<OperatorResolveResult>(rr.Body);
+		}
 	}
 }