Suggestion to simplify lambda and delegate syntax

[jnm2]

The aim of this issue is simplification, while the aim of the alternative https://github.com/dotnet/roslyn/issues/40366 is performance.

↓ denotes where the suggestion span would be and _ denotes the spans that would be faded as unnecessary.

class C
{
    bool IsEven(int x) => x % 2 == 0;

    void Example1()
    {
        // 💡 Replace lambda with method group
        //                          _____↓↓↓↓↓↓___
        _ = new[] { 1, 2, 3 }.Where(n => IsEven(n));

        // 🛠 Fix result:
        _ = new[] { 1, 2, 3 }.Where(IsEven);
    }

    void Example2()
    {
        var neverReassigned = new Func<int, bool>(IsEven);

        // 💡 Replace lambda with delegate
        //                          _____↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓___
        _ = new[] { 1, 2, 3 }.Where(n => neverReassigned(n));

        // 💡 Replace lambda with delegate
        //                          _____↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓__________
        _ = new[] { 1, 2, 3 }.Where(n => neverReassigned.Invoke(n));

        // 💡 Replace Invoke method with delegate
        //                          ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓_______
        _ = new[] { 1, 2, 3 }.Where(neverReassigned.Invoke);


        // 🛠 Fix result:
        _ = new[] { 1, 2, 3 }.Where(neverReassigned);
    }

    void Example3()
    {
        var reassigned = new Func<int, bool>(IsEven);

        // No diagnostic
        _ = new[] { 1, 2, 3 }.Where(n => reassigned.Invoke(n));

        // 💡 Replace Invoke method with delegate
        //                          ↓↓↓↓↓↓↓↓↓↓_______
        _ = new[] { 1, 2, 3 }.Where(reassigned.Invoke);

        reassigned = n => !IsEven(n);


        // 🛠 Fix result:
        _ = new[] { 1, 2, 3 }.Where(reassigned);
    }

    void Example4()
    {
        var differentTypeWithSameSignature = new Predicate<int>(IsEven);

        // 💡 Replace lambda with Invoke method
        //                          _____↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓___
        _ = new[] { 1, 2, 3 }.Where(n => differentTypeWithSameSignature(n));

        // 💡 Replace lambda with Invoke method
        //                          _____↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓___
        _ = new[] { 1, 2, 3 }.Where(n => differentTypeWithSameSignature.Invoke(n));


        // 🛠 Fix result:
        _ = new[] { 1, 2, 3 }.Where(differentTypeWithSameSignature.Invoke);
    }
}

[JohanLarsson]

Note that this refactoring introduces allocations. Probably good to have a analyzer & fix for the other direction also.

[jnm2]

Good point. Also, some of the above cases are neutral or remove allocations. (I ran across .Select(foo.Invoke) where .Select(foo) would have worked.)

[CyrusNajmabadi]

Note: i did write this feature in the past (i think the code is still in roslyn). It just didn't ship because of hte allocation issue.

[CyrusNajmabadi]

Good point. Also, some of the above cases are neutral or remove allocations. (I ran across .Select(foo.Invoke) where .Select(foo) would have worked.)

Too niche IMO.

[jnm2]

Avoiding allocations is starting to seem more interesting to me than simplification. Alt: https://github.com/dotnet/roslyn/issues/40366, expecting to close this issue given the history Cyrus cites.