Lambda doesn't match delegate signature but compiles just fine

[woojamon]

I would expect the first method below to not compile, because the return type of the lambda does not match the signature of the delegate. However, it does compile. I've also explored the issue several other ways below that.

class SomeClass{};

delegate void DoStuff();

public void ShouldNotCompileButDoesCompile()
{
    DoStuff x = () => new SomeClass(); // issue is here
}

public void ShouldNotCompileAndDoesNotCompile()
{
    DoStuff x = () => {return new SomeClass();}; // behaves as expected
}

public void ShouldCompileAndDoesCompile()
{
    DoStuff x = () => {new SomeClass(); return;}; // behaves as expected
}

public void ShouldAlsoNotCompileAndDoesNotCompile_Struct()
{
    DoStuff x = () => 4; // behaves as expected
}

public void ShouldAlsoNotCompileAndDoesNotCompile_ReferenceType()
{
    var y = new SomeClass();
    DoStuff x = () => y; // behaves as expected
}

I think that the compiler is injecting a return behind the scenes for the example that should not compile, essentially making it like the third example that does compile. However, if that were the case then the fourth and fifth examples would also compile, but it does not. As far as I can tell this only happens when calling a constructor directly in the lambda and the delegate returns void. If the delegate returns something other than void then the first example does not compile (which is the expected behavior).

Is this compiling by design or by accident?

[alrz]

I think the rule is that any expression that is allowed as an statement is allowed as the body of a void-returning lambda.

new C(); // ok
1; // error

That's why you get the same error here.

[333fred]

This is correct. The compiler infers the return type of the lambda to be void, and does not return it. ShouldNotCompileButDoesCompile and ShouldCompileAndDoesCompile are the same, but the latter is written out the long way.