No conversions in body for void lambdas

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 (!actualReturnType.Equals(SpecialType.UnknownType)) {
-							if (!conv.IsIdentityConversion)
+								var conv = storedContext.conversions.ImplicitConversion(bodyRR, actualReturnType);
-								bodyRR = new ConversionResolveResult(actualReturnType, bodyRR, conv, storedContext.CheckForOverflow);
+								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 (!returnType.IsKnownType(KnownTypeCode.Void)) {
-					if (!conv.IsIdentityConversion)
+						var conv = storedContext.conversions.ImplicitConversion(lambda.bodyResult, returnType);
-						lambda.bodyResult = new ConversionResolveResult(returnType, lambda.bodyResult, conv, storedContext.CheckForOverflow);
+						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);

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);
+		}
 	}
 }