File: src\Analyzers\CSharp\Tests\GenerateMethod\GenerateMethodTests.cs
Web Access
Project: src\src\CodeStyle\CSharp\Tests\Microsoft.CodeAnalysis.CSharp.CodeStyle.UnitTests.csproj (Microsoft.CodeAnalysis.CSharp.CodeStyle.UnitTests)
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
 
using System.Threading.Tasks;
using Microsoft.CodeAnalysis.CodeFixes;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.CodeFixes.GenerateMethod;
using Microsoft.CodeAnalysis.CSharp.CodeStyle;
using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
using Microsoft.CodeAnalysis.Diagnostics;
using Microsoft.CodeAnalysis.Test.Utilities;
using Roslyn.Test.Utilities;
using Xunit;
using Xunit.Abstractions;
 
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Diagnostics.GenerateMethod;
 
[Trait(Traits.Feature, Traits.Features.CodeActionsGenerateMethod)]
public sealed class GenerateMethodTests(ITestOutputHelper logger) : AbstractCSharpDiagnosticProviderBasedUserDiagnosticTest_NoEditor(logger)
{
    internal override (DiagnosticAnalyzer?, CodeFixProvider) CreateDiagnosticProviderAndFixer(Workspace workspace)
        => (null, new GenerateMethodCodeFixProvider());
 
    [Fact]
    public async Task TestSimpleInvocationIntoSameType()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                void Method()
                {
                    [|Goo|]();
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method()
                {
                    Goo();
                }
 
                private void Goo()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestOnRightOfNullCoalescingAssignment_NullableBool()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                void Method(bool? b)
                {
                    b ??= [|Goo|]();
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method(bool? b)
                {
                    b ??= Goo();
                }
 
                private bool? Goo()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestOnRightOfNullCoalescingAssignment_String()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                void Method(string s)
                {
                    s ??= [|Goo|]();
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method(string s)
                {
                    s ??= Goo();
                }
 
                private string Goo()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestSimpleInvocationIntoSameType_CodeStyle1()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                void Method()
                {
                    [|Goo|]();
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method()
                {
                    Goo();
                }
 
                private void Goo() => throw new NotImplementedException();
            }
            """,
            options: Option(CSharpCodeStyleOptions.PreferExpressionBodiedMethods, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement));
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/11518")]
    public async Task NameMatchesNamespaceName()
    {
        await TestInRegularAndScriptAsync(
            """
            namespace N
            {
                class Class
                {
                    void Method()
                    {
                        [|N|]();
                    }
                }
            }
            """,
            """
            using System;
 
            namespace N
            {
                class Class
                {
                    void Method()
                    {
                        N();
                    }
 
                    private void N()
                    {
                        throw new NotImplementedException();
                    }
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestSimpleInvocationOffOfThis()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                void Method()
                {
                    this.[|Goo|]();
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method()
                {
                    this.Goo();
                }
 
                private void Goo()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestSimpleInvocationOffOfType()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                void Method()
                {
                    Class.[|Goo|]();
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method()
                {
                    Class.Goo();
                }
 
                private static void Goo()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestSimpleInvocationValueExpressionArg()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                void Method()
                {
                    [|Goo|](0);
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method()
                {
                    Goo(0);
                }
 
                private void Goo(int v)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestSimpleInvocationMultipleValueExpressionArg()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                void Method()
                {
                    [|Goo|](0, 0);
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method()
                {
                    Goo(0, 0);
                }
 
                private void Goo(int v1, int v2)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestSimpleInvocationValueArg()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                void Method(int i)
                {
                    [|Goo|](i);
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method(int i)
                {
                    Goo(i);
                }
 
                private void Goo(int i)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestSimpleInvocationValueNullableReferenceType()
    {
        await TestInRegularAndScriptAsync(
            """
            #nullable enable
 
            class Class
            {
                void Method(string? s)
                {
                    [|Goo|](s);
                }
            }
            """,
            """
            #nullable enable
 
            using System;
 
            class Class
            {
                void Method(string? s)
                {
                    Goo(s);
                }
 
                private void Goo(string? s)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestSimpleInvocationUnassignedNullableReferenceType()
    {
        await TestInRegularAndScriptAsync(
            """
            #nullable enable
 
            class Class
            {
                void Method()
                {
                    string? s;
                    [|Goo|](s);
                }
            }
            """,
            """
            #nullable enable
 
            using System;
 
            class Class
            {
                void Method()
                {
                    string? s;
                    Goo(s);
                }
 
                private void Goo(string? s)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestSimpleInvocationCrossingNullableAnnotationsEnabled()
    {
        await TestInRegularAndScriptAsync(
            """
            #nullable enable
 
            class NullableEnable
            {
                void Method(string? s)
                {
                    [|NullableDisable.Goo|](s);
                }
            }
 
            #nullable disable
 
            class NullableDisable
            {
            }
            """,
            """
            #nullable enable
 
            using System;
 
            class NullableEnable
            {
                void Method(string? s)
                {
                    [|NullableDisable.Goo|](s);
                }
            }
 
            #nullable disable
 
            class NullableDisable
            {
                internal static void Goo(string s)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestSimpleInvocationValueNestedNullableReferenceType()
    {
        await TestInRegularAndScriptAsync(
            """
            #nullable enable
 
            using System.Collections.Generic;
 
            class Class
            {
                void Method(List<string?> l)
                {
                    [|Goo|](l);
                }
            }
            """,
            """
            #nullable enable
 
            using System;
            using System.Collections.Generic;
 
            class Class
            {
                void Method(List<string?> l)
                {
                    Goo(l);
                }
 
                private void Goo(List<string?> l)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestSimpleInvocationNamedValueArg()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                void Method(int i)
                {
                    [|Goo|](bar: i);
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method(int i)
                {
                    Goo(bar: i);
                }
 
                private void Goo(int bar)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestGenerateAfterMethod()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                void Method()
                {
                    [|Goo|]();
                }
 
                void NextMethod()
                {
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method()
                {
                    Goo();
                }
 
                private void Goo()
                {
                    throw new NotImplementedException();
                }
 
                void NextMethod()
                {
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestInterfaceNaming()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                void Method(int i)
                {
                    [|Goo|](NextMethod());
                }
 
                IGoo NextMethod()
                {
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method(int i)
                {
                    Goo(NextMethod());
                }
 
                private void Goo(IGoo goo)
                {
                    throw new NotImplementedException();
                }
 
                IGoo NextMethod()
                {
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestFuncArg0()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                void Method(int i)
                {
                    [|Goo|](NextMethod);
                }
 
                string NextMethod()
                {
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method(int i)
                {
                    Goo(NextMethod);
                }
 
                private void Goo(Func<string> nextMethod)
                {
                    throw new NotImplementedException();
                }
 
                string NextMethod()
                {
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestFuncArg1()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                void Method(int i)
                {
                    [|Goo|](NextMethod);
                }
 
                string NextMethod(int i)
                {
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method(int i)
                {
                    Goo(NextMethod);
                }
 
                private void Goo(Func<int, string> nextMethod)
                {
                    throw new NotImplementedException();
                }
 
                string NextMethod(int i)
                {
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestActionArg()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                void Method(int i)
                {
                    [|Goo|](NextMethod);
                }
 
                void NextMethod()
                {
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method(int i)
                {
                    Goo(NextMethod);
                }
 
                private void Goo(Action nextMethod)
                {
                    throw new NotImplementedException();
                }
 
                void NextMethod()
                {
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestActionArg1()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                void Method(int i)
                {
                    [|Goo|](NextMethod);
                }
 
                void NextMethod(int i)
                {
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method(int i)
                {
                    Goo(NextMethod);
                }
 
                private void Goo(Action<int> nextMethod)
                {
                    throw new NotImplementedException();
                }
 
                void NextMethod(int i)
                {
                }
            }
            """);
    }
 
    // Note: we only test type inference once.  This is just to verify that it's being used
    // properly by Generate Method.  The full wealth of type inference tests can be found
    // elsewhere and don't need to be repeated here.
    [Fact]
    public async Task TestTypeInference()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                void Method()
                {
                    if ([|Goo|]())
                    {
                    }
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method()
                {
                    if (Goo())
                    {
                    }
                }
 
                private bool Goo()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/784793")]
    public async Task TestOutRefArguments()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                void Method()
                {
                    [|Goo|](out a, ref b);
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method()
                {
                    Goo(out a, ref b);
                }
 
                private void Goo(out object a, ref object b)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/54212")]
    public async Task TestInArgument()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class Example
            {
                void M()
                {
                    int i = 0;
                    [|M2(in i)|];
                }
            }
            """,
            """
            using System;
 
            class Example
            {
                void M()
                {
                    int i = 0;
                    [|M2(in i)|];
                }
 
                private void M2(in int i)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestMemberAccessArgumentName()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                void Method()
                {
                    [|Goo|](this.Bar);
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method()
                {
                    Goo(this.Bar);
                }
 
                private void Goo(object bar)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/784793")]
    public async Task TestParenthesizedArgumentName()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                void Method()
                {
                    [|Goo|]((Bar));
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method()
                {
                    Goo((Bar));
                }
 
                private void Goo(object bar)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/784793")]
    public async Task TestCastedArgumentName()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                void Method()
                {
                    [|Goo|]((Bar)this.Baz);
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method()
                {
                    Goo((Bar)this.Baz);
                }
 
                private void Goo(Bar baz)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestNullableArgument()
    {
        await TestInRegularAndScriptAsync(
            """
            class C
            {
                void Method()
                {
                    [|Goo|]((int?)1);
                }
            }
            """,
            """
            using System;
 
            class C
            {
                void Method()
                {
                    Goo((int?)1);
                }
 
                private void Goo(int? v)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestNullArgument()
    {
        await TestInRegularAndScriptAsync(
            """
            class C
            {
                void Method()
                {
                    [|Goo|](null);
                }
            }
            """,
            """
            using System;
 
            class C
            {
                void Method()
                {
                    Goo(null);
                }
 
                private void Goo(object value)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestTypeofArgument()
    {
        await TestInRegularAndScriptAsync(
            """
            class C
            {
                void Method()
                {
                    [|Goo|](typeof(int));
                }
            }
            """,
            """
            using System;
 
            class C
            {
                void Method()
                {
                    Goo(typeof(int));
                }
 
                private void Goo(Type type)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestDefaultArgument()
    {
        await TestInRegularAndScriptAsync(
            """
            class C
            {
                void Method()
                {
                    [|Goo|](default(int));
                }
            }
            """,
            """
            using System;
 
            class C
            {
                void Method()
                {
                    Goo(default(int));
                }
 
                private void Goo(int v)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestAsArgument()
    {
        await TestInRegularAndScriptAsync(
            """
            class C
            {
                void Method()
                {
                    [|Goo|](1 as int?);
                }
            }
            """,
            """
            using System;
 
            class C
            {
                void Method()
                {
                    Goo(1 as int?);
                }
 
                private void Goo(int? v)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestPointArgument()
    {
        await TestInRegularAndScriptAsync(
            """
            class C
            {
                void Method()
                {
                    int* p;
                    [|Goo|](p);
                }
            }
            """,
            """
            using System;
 
            class C
            {
                void Method()
                {
                    int* p;
                    Goo(p);
                }
 
                private unsafe void Goo(int* p)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestArgumentWithPointerName()
    {
        await TestInRegularAndScriptAsync(
            """
            class C
            {
                void Method()
                {
                    int* p;
                    [|Goo|](p);
                }
            }
            """,
            """
            using System;
 
            class C
            {
                void Method()
                {
                    int* p;
                    Goo(p);
                }
 
                private unsafe void Goo(int* p)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestArgumentWithPointTo()
    {
        await TestInRegularAndScriptAsync(
            """
            class C
            {
                void Method()
                {
                    int* p;
                    [|Goo|](*p);
                }
            }
            """,
            """
            using System;
 
            class C
            {
                void Method()
                {
                    int* p;
                    Goo(*p);
                }
 
                private void Goo(int v)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestArgumentWithAddress()
    {
        await TestInRegularAndScriptAsync(
            """
            class C
            {
                unsafe void Method()
                {
                    int a = 10;
                    [|Goo|](&a);
                }
            }
            """,
            """
            using System;
 
            class C
            {
                unsafe void Method()
                {
                    int a = 10;
                    Goo(&a);
                }
 
                private unsafe void Goo(int* v)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestGenerateWithPointerReturn()
    {
        await TestInRegularAndScriptAsync(
            """
            class C
            {
                void Method()
                {
                    int* p = [|Goo|]();
                }
            }
            """,
            """
            using System;
 
            class C
            {
                void Method()
                {
                    int* p = Goo();
                }
 
                private unsafe int* Goo()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/784793")]
    public async Task TestDuplicateNames()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                void Method()
                {
                    [|Goo|]((Bar)this.Baz, this.Baz);
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method()
                {
                    Goo((Bar)this.Baz, this.Baz);
                }
 
                private void Goo(Bar baz1, object baz2)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/784793")]
    public async Task TestDuplicateNamesWithNamedArgument()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                void Method()
                {
                    [|Goo|]((Bar)this.Baz, this.Baz, baz: this.Baz);
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method()
                {
                    Goo((Bar)this.Baz, this.Baz, baz: this.Baz);
                }
 
                private void Goo(Bar baz1, object baz2, object baz)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    // Note: we do not test the range of places where a delegate type can be inferred.  This is
    // just to verify that it's being used properly by Generate Method.  The full wealth of
    // delegate inference tests can be found elsewhere and don't need to be repeated here.
    [Fact]
    public async Task TestSimpleDelegate()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class Class
            {
                void Method()
                {
                    Func<int, string, bool> f = [|Goo|];
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method()
                {
                    Func<int, string, bool> f = Goo;
                }
 
                private bool Goo(int arg1, string arg2)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestSimpleAssignmentWithNullableReferenceType()
    {
        await TestInRegularAndScriptAsync(
            """
            #nullable enable
 
            using System;
 
            class Class
            {
                void Method()
                {
                    string? f = [|Goo|]();
                }
            }
            """,
            """
            #nullable enable
 
            using System;
 
            class Class
            {
                void Method()
                {
                    string? f = [|Goo|]();
                }
 
                private string? Goo()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestGenericAssignmentWithTopLevelNullableReferenceTypeBeingAssignedTo()
    {
        // Here we assert that if the type argument was string, but the return value was string?, we still
        // make the return value T, and assume the user just wanted to assign it to a nullable value because they
        // might be assigning null later in the caller.
        await TestInRegularAndScriptAsync(
            """
            #nullable enable
 
            using System;
 
            class Class
            {
                void Method()
                {
                    string? f = [|Goo|]<string>("s");
                }
            }
            """,
            """
            #nullable enable
 
            using System;
 
            class Class
            {
                void Method()
                {
                    string? f = [|Goo|]<string>("s");
                }
 
                private T Goo<T>(T v)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestGenericAssignmentWithNestedNullableReferenceTypeBeingAssignedTo()
    {
        // Here, we are asserting that the return type of the generated method is T, effectively discarding
        // the difference of nested nullability. Since there's no way to generate a method any other way,
        // we're assuming this is betetr than inferring that the return type is explicitly IEnumerable<string>
        await TestInRegularAndScriptAsync(
            """
            #nullable enable
 
            using System;
 
            class Class
            {
                void Method()
                {
                    IEnumerable<string> e;
                    IEnumerable<string?> f = [|Goo|]<IEnumerable<string>>(e);
                }
            }
            """,
            """
            #nullable enable
 
            using System;
 
            class Class
            {
                void Method()
                {
                    IEnumerable<string> e;
                    IEnumerable<string?> f = [|Goo|]<IEnumerable<string>>(e);
                }
 
                private T Goo<T>(T e)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestDelegateWithRefParameter()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                void Method()
                {
                    Goo f = [|Bar|];
                }
            }
 
            delegate void Goo(ref int i);
            """,
            """
            using System;
 
            class Class
            {
                void Method()
                {
                    Goo f = Bar;
                }
 
                private void Bar(ref int i)
                {
                    throw new NotImplementedException();
                }
            }
 
            delegate void Goo(ref int i);
            """);
    }
 
    // TODO(cyrusn): Add delegate tests that cover delegates with interesting signatures (i.e.
    // out/ref).
    //
    // add negative tests to verify that Generate Method doesn't show up in unexpected places.
 
    [Fact]
    public async Task TestGenericArgs1()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class Class
            {
                void Method()
                {
                    [|Goo<int>|]();
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method()
                {
                    Goo<int>();
                }
 
                private void Goo<T>()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestGenericArgs2()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class Class
            {
                void Method()
                {
                    [|Goo<int, string>|]();
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method()
                {
                    Goo<int, string>();
                }
 
                private void Goo<T1, T2>()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestGenericArgsFromMethod()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class Class
            {
                void Method<X, Y>(X x, Y y)
                {
                    [|Goo|](x);
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method<X, Y>(X x, Y y)
                {
                    Goo(x);
                }
 
                private void Goo<X>(X x)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestMultipleGenericArgsFromMethod()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class Class
            {
                void Method<X, Y>(X x, Y y)
                {
                    [|Goo|](x, y);
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method<X, Y>(X x, Y y)
                {
                    Goo(x, y);
                }
 
                private void Goo<X, Y>(X x, Y y)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestMultipleGenericArgsFromMethod2()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class Class
            {
                void Method<X, Y>(Func<X> x, Y[] y)
                {
                    [|Goo|](y, x);
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method<X, Y>(Func<X> x, Y[] y)
                {
                    Goo(y, x);
                }
 
                private void Goo<Y, X>(Y[] y, Func<X> x)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestGenericArgThatIsTypeParameter()
    {
        await TestInRegularAndScriptAsync(
            """
            class Program
            {
                void Main<T>(T t)
                {
                    [|Goo<T>|](t);
                }
            }
            """,
            """
            using System;
 
            class Program
            {
                void Main<T>(T t)
                {
                    Goo<T>(t);
                }
 
                private void Goo<T>(T t)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestMultipleGenericArgsThatAreTypeParameters()
    {
        await TestInRegularAndScriptAsync(
            """
            class Program
            {
                void Main<T, U>(T t, U u)
                {
                    [|Goo<T, U>|](t, u);
                }
            }
            """,
            """
            using System;
 
            class Program
            {
                void Main<T, U>(T t, U u)
                {
                    Goo<T, U>(t, u);
                }
 
                private void Goo<T, U>(T t, U u)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestGenerateIntoOuterThroughInstance()
    {
        await TestInRegularAndScriptAsync(
            """
            class Outer
            {
                class Class
                {
                    void Method(Outer o)
                    {
                        o.[|Goo|]();
                    }
                }
            }
            """,
            """
            using System;
 
            class Outer
            {
                class Class
                {
                    void Method(Outer o)
                    {
                        o.Goo();
                    }
                }
 
                private void Goo()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestGenerateIntoOuterThroughClass()
    {
        await TestInRegularAndScriptAsync(
            """
            class Outer
            {
                class Class
                {
                    void Method(Outer o)
                    {
                        Outer.[|Goo|]();
                    }
                }
            }
            """,
            """
            using System;
 
            class Outer
            {
                class Class
                {
                    void Method(Outer o)
                    {
                        Outer.Goo();
                    }
                }
 
                private static void Goo()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestGenerateIntoSiblingThroughInstance()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                void Method(Sibling s)
                {
                    s.[|Goo|]();
                }
            }
 
            class Sibling
            {
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method(Sibling s)
                {
                    s.Goo();
                }
            }
 
            class Sibling
            {
                internal void Goo()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestGenerateIntoSiblingThroughClass()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                void Method(Sibling s)
                {
                    Sibling.[|Goo|]();
                }
            }
 
            class Sibling
            {
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method(Sibling s)
                {
                    Sibling.Goo();
                }
            }
 
            class Sibling
            {
                internal static void Goo()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestGenerateIntoInterfaceThroughInstance()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                void Method(ISibling s)
                {
                    s.[|Goo|]();
                }
            }
 
            interface ISibling
            {
            }
            """,
            """
            class Class
            {
                void Method(ISibling s)
                {
                    s.Goo();
                }
            }
 
            interface ISibling
            {
                void Goo();
            }
            """);
    }
 
    [Fact]
    public async Task TestGenerateIntoInterfaceThroughInstanceWithDelegate()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class Class
            {
                void Method(ISibling s)
                {
                    Func<int, string> f = s.[|Goo|];
                }
            }
 
            interface ISibling
            {
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method(ISibling s)
                {
                    Func<int, string> f = s.Goo;
                }
            }
 
            interface ISibling
            {
                string Goo(int arg);
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/29584")]
    public async Task TestGenerateAbstractIntoSameType()
    {
        await TestInRegularAndScriptAsync(
            """
            abstract class Class
            {
                void Method()
                {
                    [|Goo|]();
                }
            }
            """,
            """
            abstract class Class
            {
                void Method()
                {
                    Goo();
                }
 
                protected abstract void Goo();
            }
            """,
index: 1);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/537906")]
    public async Task TestMethodReturningDynamic()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                void Method()
                {
                    dynamic d = [|Goo|]();
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method()
                {
                    dynamic d = Goo();
                }
 
                private dynamic Goo()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/537906")]
    public async Task TestMethodTakingDynamicArg()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                void Method(dynamic d)
                {
                    [|Goo|](d);
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method(dynamic d)
                {
                    Goo(d);
                }
 
                private void Goo(dynamic d)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem(3203, "DevDiv_Projects/Roslyn")]
    public async Task TestNegativeWithNamedOptionalArg1()
    {
        await TestMissingInRegularAndScriptAsync(
            """
            namespace SyntaxError
            {
                class C1
                {
                    public void Method(int num, string str)
                    {
                    }
                }
 
                class C2
                {
                    static void Method2()
                    {
                        (new C1()).[|Method|](num: 5, "hi");
                    }
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/537972")]
    public async Task TestWithNamedOptionalArg2()
    {
        await TestInRegularAndScriptAsync(
            """
            namespace SyntaxError
            {
                class C1
                {
                    void Method(int num, string str)
                    {
                    }
                }
 
                class C2
                {
                    static void Method2()
                    {
                        (new C1()).[|Method|](num: 5, "hi");
                    }
                }
            }
            """,
            """
            using System;
 
            namespace SyntaxError
            {
                class C1
                {
                    void Method(int num, string str)
                    {
                    }
 
                    internal void Method(int num, string v)
                    {
                        throw new NotImplementedException();
                    }
                }
 
                class C2
                {
                    static void Method2()
                    {
                        (new C1()).Method(num: 5, "hi");
                    }
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestArgOrderInNamedArgs()
    {
        await TestInRegularAndScriptAsync(
            """
            class Goo
            {
                static void Test()
                {
                    (new Goo()).[|Method|](3, 4, n1: 5, n3: 6, n2: 7, n0: 8);
                }
            }
            """,
            """
            using System;
 
            class Goo
            {
                static void Test()
                {
                    (new Goo()).Method(3, 4, n1: 5, n3: 6, n2: 7, n0: 8);
                }
 
                private void Method(int v1, int v2, int n1, int n3, int n2, int n0)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestForMissingOptionalArg()
    {
        await TestMissingInRegularAndScriptAsync(
            """
            class Goo
            {
                static void Test()
                {
                    (new Goo()).[|Method|](s: "hello", b: true);
                }
 
                private void Method(double n = 3.14, string s, bool b)
                {
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestNamingOfArgWithClashes()
    {
        await TestInRegularAndScriptAsync(
            """
            class Goo
            {
                static int i = 32;
 
                static void Test()
                {
                    (new Goo()).[|Method|](s: "hello", i: 52);
                }
            }
            """,
            """
            using System;
 
            class Goo
            {
                static int i = 32;
 
                static void Test()
                {
                    (new Goo()).Method(s: "hello", i: 52);
                }
 
                private void Method(string s, int i)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestFixCountGeneratingIntoInterface()
    {
        await TestActionCountAsync(
            """
            interface I2
            {
            }
 
            class C2 : I2
            {
                public void Meth()
                {
                    I2 i = (I2)this;
                    i.[|M|]();
                }
            }
            """,
count: 1);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/527278")]
    public async Task TestInvocationOffOfBase()
    {
        await TestInRegularAndScriptAsync(
            """
            class C3A
            {
            }
 
            class C3 : C3A
            {
                public void C4()
                {
                    base.[|M|]();
                }
            }
            """,
            """
            using System;
 
            class C3A
            {
                internal void M()
                {
                    throw new NotImplementedException();
                }
            }
 
            class C3 : C3A
            {
                public void C4()
                {
                    base.M();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestInvocationWithinCtor()
    {
        await TestInRegularAndScriptAsync(
            """
            class C1
            {
                C1()
                {
                    [|M|]();
                }
            }
            """,
            """
            using System;
 
            class C1
            {
                C1()
                {
                    M();
                }
 
                private void M()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestInvocationWithinBaseCtor()
    {
        await TestInRegularAndScriptAsync(
            """
            class C1
            {
                C1()
                {
                    [|M|]();
                }
            }
            """,
            """
            using System;
 
            class C1
            {
                C1()
                {
                    M();
                }
 
                private void M()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem(3095, "DevDiv_Projects/Roslyn")]
    public async Task TestForMultipleSmartTagsInvokingWithinCtor()
    {
        await TestMissingInRegularAndScriptAsync(
            """
            using System;
 
            class C1
            {
                C1()
                {
                    [|M|]();
                }
 
                private void M()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestInvocationWithinDestructor()
    {
        await TestInRegularAndScriptAsync(
            """
            class C1
            {
                ~C1()
                {
                    [|M|]();
                }
            }
            """,
            """
            using System;
 
            class C1
            {
                ~C1()
                {
                    M();
                }
 
                private void M()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestInvocationWithinConditional()
    {
        await TestInRegularAndScriptAsync(
            """
            class C4
            {
                void A()
                {
                    string s;
                    if ((s = [|M|]()) == null)
                    {
                    }
                }
            }
            """,
            """
            using System;
 
            class C4
            {
                void A()
                {
                    string s;
                    if ((s = M()) == null)
                    {
                    }
                }
 
                private string M()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestGenerateIntoStaticClass()
    {
        await TestInRegularAndScriptAsync(
            """
            class Bar
            {
                void Test()
                {
                    Goo.[|M|]();
                }
            }
 
            static class Goo
            {
            }
            """,
            """
            using System;
 
            class Bar
            {
                void Test()
                {
                    Goo.M();
                }
            }
 
            static class Goo
            {
                internal static void M()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestGenerateIntoAbstractClass()
    {
        await TestInRegularAndScriptAsync(
            """
            class Bar
            {
                void Test()
                {
                    Goo.[|M|]();
                }
            }
 
            abstract class Goo
            {
            }
            """,
            """
            using System;
 
            class Bar
            {
                void Test()
                {
                    Goo.M();
                }
            }
 
            abstract class Goo
            {
                internal static void M()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestGenerateIntoAbstractClassThoughInstance1()
    {
        await TestInRegularAndScriptAsync(
            """
            class C
            {
                void Test(Goo f)
                {
                    f.[|M|]();
                }
            }
 
            abstract class Goo
            {
            }
            """,
            """
            using System;
 
            class C
            {
                void Test(Goo f)
                {
                    f.M();
                }
            }
 
            abstract class Goo
            {
                internal void M()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestGenerateIntoAbstractClassThoughInstance2()
    {
        await TestInRegularAndScriptAsync(
            """
            class C
            {
                void Test(Goo f)
                {
                    f.[|M|]();
                }
            }
 
            abstract class Goo
            {
            }
            """,
            """
            class C
            {
                void Test(Goo f)
                {
                    f.M();
                }
            }
 
            abstract class Goo
            {
                internal abstract void M();
            }
            """,
index: 1);
    }
 
    [Fact]
    public async Task TestGenerateIntoPartialClass1()
    {
        await TestInRegularAndScriptAsync(
            """
            class Bar
            {
                void Test()
                {
                    Goo.[|M|]();
                }
            }
 
            partial class Goo
            {
            }
 
            partial class Goo
            {
            }
            """,
            """
            using System;
 
            class Bar
            {
                void Test()
                {
                    Goo.M();
                }
            }
 
            partial class Goo
            {
                internal static void M()
                {
                    throw new NotImplementedException();
                }
            }
 
            partial class Goo
            {
            }
            """);
    }
 
    [Fact]
    public async Task TestGenerateIntoPartialClass2()
    {
        await TestInRegularAndScriptAsync(
            """
            partial class Goo
            {
                void Test()
                {
                    Goo.[|M|]();
                }
            }
 
            partial class Goo
            {
            }
            """,
            """
            using System;
 
            partial class Goo
            {
                void Test()
                {
                    Goo.M();
                }
 
                private static void M()
                {
                    throw new NotImplementedException();
                }
            }
 
            partial class Goo
            {
            }
            """);
    }
 
    [Fact]
    public async Task TestGenerateIntoStruct()
    {
        await TestInRegularAndScriptAsync(
            """
            class Goo
            {
                void Test()
                {
                    (new S()).[|M|]();
                }
            }
 
            struct S
            {
            }
            """,
            """
            using System;
 
            class Goo
            {
                void Test()
                {
                    (new S()).M();
                }
            }
 
            struct S
            {
                internal void M()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/527291")]
    public async Task TestInvocationOffOfIndexer()
    {
        await TestInRegularAndScriptAsync(
            """
            class Bar
            {
                Goo f = new Goo();
 
                void Test()
                {
                    this[1].[|M|]();
                }
 
                Goo this[int i]
                {
                    get
                    {
                        return f;
                    }
 
                    set
                    {
                        f = value;
                    }
                }
            }
 
            class Goo
            {
            }
            """,
            """
            using System;
 
            class Bar
            {
                Goo f = new Goo();
 
                void Test()
                {
                    this[1].M();
                }
 
                Goo this[int i]
                {
                    get
                    {
                        return f;
                    }
 
                    set
                    {
                        f = value;
                    }
                }
            }
 
            class Goo
            {
                internal void M()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/527292")]
    public async Task TestInvocationWithinForEach()
    {
        await TestInRegularAndScriptAsync(
            """
            class C8
            {
                C8A[] items = {
                    new C8A(),
                    new C8A()
                };
 
                public IEnumerable GetItems()
                {
                    for (int i = items.Length - 1; i >= 0; --i)
                    {
                        yield return items[i];
                    }
                }
 
                void Test()
                {
                    foreach (C8A c8a in this.GetItems())
                    {
                        c8a.[|M|]();
                    }
                }
            }
 
            class C8A
            {
            }
            """,
            """
            using System;
 
            class C8
            {
                C8A[] items = {
                    new C8A(),
                    new C8A()
                };
 
                public IEnumerable GetItems()
                {
                    for (int i = items.Length - 1; i >= 0; --i)
                    {
                        yield return items[i];
                    }
                }
 
                void Test()
                {
                    foreach (C8A c8a in this.GetItems())
                    {
                        c8a.M();
                    }
                }
            }
 
            class C8A
            {
                internal void M()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/48064")]
    public async Task TestInvocationWithinSynchronousForEach()
    {
        await TestInRegularAndScriptAsync(
            """
            class C
            {
                void M(ISomeInterface _someInterface)
                {
                     foreach (var item in _someInterface.[|GetItems|]())
                     {
                     }
                }
            }
 
            interface ISomeInterface
            {
            }
            """,
            """
            using System.Collections.Generic;
 
            class C
            {
                void M(ISomeInterface _someInterface)
                {
                     foreach (var item in _someInterface.GetItems())
                     {
                     }
                }
            }
 
            interface ISomeInterface
            {
                IEnumerable<object> GetItems();
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/48064")]
    public async Task TestInvocationWithinAsynchronousForEach_IAsyncEnumerableDoesNotExist_FallbackToIEnumerable()
    {
        await TestInRegularAndScriptAsync(
            """
            class C
            {
                async void M(ISomeInterface _someInterface)
                {
                     await foreach (var item in _someInterface.[|GetItems|]())
                     {
                     }
                }
            }
 
            interface ISomeInterface
            {
            }
            """,
            """
            using System.Collections.Generic;
 
            class C
            {
                async void M(ISomeInterface _someInterface)
                {
                     await foreach (var item in _someInterface.GetItems())
                     {
                     }
                }
            }
 
            interface ISomeInterface
            {
                IEnumerable<object> GetItems();
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/48064")]
    public async Task TestInvocationWithinAsynchronousForEach_IAsyncEnumerableExists_UseIAsyncEnumerable()
    {
        await TestInRegularAndScriptAsync(
            """
            class C
            {
                async void M(ISomeInterface _someInterface)
                {
                     await foreach (var item in _someInterface.[|GetItems|]())
                     {
                     }
                }
            }
 
            interface ISomeInterface
            {
            }
 
            """ + IAsyncEnumerable,
            """
            class C
            {
                async void M(ISomeInterface _someInterface)
                {
                     await foreach (var item in _someInterface.GetItems())
                     {
                     }
                }
            }
 
            interface ISomeInterface
            {
                System.Collections.Generic.IAsyncEnumerable<object> GetItems();
            }
 
            """ + IAsyncEnumerable);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/48064")]
    public async Task TestInvocationWithinAsynchronousForEach_IAsyncEnumerableExists_UseIAsyncEnumerableOfString()
    {
        await TestInRegularAndScriptAsync(
            """
            class C
            {
                async void M(ISomeInterface _someInterface)
                {
                     await foreach (string item in _someInterface.[|GetItems|]())
                     {
                     }
                }
            }
 
            interface ISomeInterface
            {
            }
 
            """ + IAsyncEnumerable,
            """
            class C
            {
                async void M(ISomeInterface _someInterface)
                {
                     await foreach (string item in _someInterface.GetItems())
                     {
                     }
                }
            }
 
            interface ISomeInterface
            {
                System.Collections.Generic.IAsyncEnumerable<string> GetItems();
            }
 
            """ + IAsyncEnumerable);
    }
 
    [Fact]
    public async Task TestInvocationOffOfAnotherMethodCall()
    {
        await TestInRegularAndScriptAsync(
            """
            class C9
            {
                C9A m_item = new C9A();
 
                C9A GetItem()
                {
                    return m_item;
                }
 
                void Test()
                {
                    GetItem().[|M|]();
                }
            }
 
            struct C9A
            {
            }
            """,
            """
            using System;
 
            class C9
            {
                C9A m_item = new C9A();
 
                C9A GetItem()
                {
                    return m_item;
                }
 
                void Test()
                {
                    GetItem().M();
                }
            }
 
            struct C9A
            {
                internal void M()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestInvocationIntoNestedNamespaces()
    {
        await TestInRegularAndScriptAsync(
            """
            namespace NS11X
            {
                namespace NS11Y
                {
                    class C11
                    {
                        void Test()
                        {
                            NS11A.NS11B.C11A.[|M|]();
                        }
                    }
                }
            }
 
            namespace NS11A
            {
                namespace NS11B
                {
                    class C11A
                    {
                    }
                }
            }
            """,
            """
            using System;
 
            namespace NS11X
            {
                namespace NS11Y
                {
                    class C11
                    {
                        void Test()
                        {
                            NS11A.NS11B.C11A.M();
                        }
                    }
                }
            }
 
            namespace NS11A
            {
                namespace NS11B
                {
                    class C11A
                    {
                        internal static void M()
                        {
                            throw new NotImplementedException();
                        }
                    }
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestInvocationIntoAliasedNamespaces()
    {
        await TestInRegularAndScriptAsync(
            """
            namespace NS11X
            {
                using NS = NS11A.NS11B;
 
                class C11
                {
                    void Test()
                    {
                        NS.C11A.[|M|]();
                    }
                }
 
                namespace NS11A
                {
                    namespace NS11B
                    {
                        class C11A
                        {
                        }
                    }
                }
            }
            """,
            """
            namespace NS11X
            {
                using System;
                using NS = NS11A.NS11B;
 
                class C11
                {
                    void Test()
                    {
                        NS.C11A.M();
                    }
                }
 
                namespace NS11A
                {
                    namespace NS11B
                    {
                        class C11A
                        {
                            internal static void M()
                            {
                                throw new NotImplementedException();
                            }
                        }
                    }
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestInvocationOnGlobalNamespace()
    {
        await TestInRegularAndScriptAsync(
            """
            namespace NS13X
            {
                namespace NS13A
                {
                    namespace NS13B
                    {
                        struct S13B
                        {
                        }
                    }
                }
 
                class C13
                {
                    void Test()
                    {
                        global::NS13A.NS13B.S13A.[|M|]();
                    }
                }
            }
 
            namespace NS13A
            {
                namespace NS13B
                {
                    struct S13A
                    {
                    }
                }
            }
            """,
            """
            using System;
 
            namespace NS13X
            {
                namespace NS13A
                {
                    namespace NS13B
                    {
                        struct S13B
                        {
                        }
                    }
                }
 
                class C13
                {
                    void Test()
                    {
                        global::NS13A.NS13B.S13A.M();
                    }
                }
            }
 
            namespace NS13A
            {
                namespace NS13B
                {
                    struct S13A
                    {
                        internal static void M()
                        {
                            throw new NotImplementedException();
                        }
                    }
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/538353")]
    public async Task TestGenerateIntoAppropriatePart()
    {
        await TestInRegularAndScriptAsync(
            """
            public partial class C
            {
            }
 
            public partial class C
            {
                void Method()
                {
                    [|Test|]();
                }
            }
            """,
            """
            using System;
 
            public partial class C
            {
            }
 
            public partial class C
            {
                void Method()
                {
                    Test();
                }
 
                private void Test()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/538541")]
    public async Task TestGenerateWithVoidArgument()
    {
        await TestInRegularAndScriptAsync(
            """
            class C
            {
                void VoidMethod()
                {
                }
 
                void Method()
                {
                    [|Test|](VoidMethod());
                }
            }
            """,
            """
            using System;
 
            class C
            {
                void VoidMethod()
                {
                }
 
                void Method()
                {
                    Test(VoidMethod());
                }
 
                private void Test(object v)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/538993")]
    public async Task TestGenerateInSimpleLambda()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class Program
            {
                static void Main(string[] args)
                {
                    Func<string, int> f = x => [|Goo|](x);
                }
            }
            """,
            """
            using System;
 
            class Program
            {
                static void Main(string[] args)
                {
                    Func<string, int> f = x => Goo(x);
                }
 
                private static int Goo(string x)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestGenerateInParenthesizedLambda()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class Program
            {
                static void Main(string[] args)
                {
                    Func<int> f = () => [|Goo|]();
                }
            }
            """,
            """
            using System;
 
            class Program
            {
                static void Main(string[] args)
                {
                    Func<int> f = () => Goo();
                }
 
                private static int Goo()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/30232")]
    public async Task TestGenerateInAsyncTaskOfTSimpleLambda()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
            using System.Threading.Tasks;
 
            class Program
            {
                static void Main(string[] args)
                {
                    Func<string, Task<int>> f = async x => [|Goo|](x);
                }
            }
            """,
            """
            using System;
            using System.Threading.Tasks;
 
            class Program
            {
                static void Main(string[] args)
                {
                    Func<string, Task<int>> f = async x => Goo(x);
                }
 
                private static int Goo(string x)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/30232")]
    public async Task TestGenerateInAsyncTaskOfTParenthesizedLambda()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
            using System.Threading.Tasks;
 
            class Program
            {
                static void Main(string[] args)
                {
                    Func<Task<int>> f = async () => [|Goo|]();
                }
            }
            """,
            """
            using System;
            using System.Threading.Tasks;
 
            class Program
            {
                static void Main(string[] args)
                {
                    Func<Task<int>> f = async () => Goo();
                }
 
                private static int Goo()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/30232")]
    public async Task TestGenerateInAsyncTaskSimpleLambda()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
            using System.Threading.Tasks;
 
            class Program
            {
                static void Main(string[] args)
                {
                    Func<string, Task> f = async x => [|Goo|](x);
                }
            }
            """,
            """
            using System;
            using System.Threading.Tasks;
 
            class Program
            {
                static void Main(string[] args)
                {
                    Func<string, Task> f = async x => Goo(x);
                }
 
                private static void Goo(string x)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/30232")]
    public async Task TestGenerateInAsyncTaskParenthesizedLambda()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
            using System.Threading.Tasks;
 
            class Program
            {
                static void Main(string[] args)
                {
                    Func<Task> f = async () => [|Goo|]();
                }
            }
            """,
            """
            using System;
            using System.Threading.Tasks;
 
            class Program
            {
                static void Main(string[] args)
                {
                    Func<Task> f = async () => Goo();
                }
 
                private static void Goo()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestGenerateInAsyncVoidSimpleLambda()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
            using System.Threading.Tasks;
 
            class Program
            {
                static void Main(string[] args)
                {
                    Action<string> f = async x => [|Goo|](x);
                }
            }
            """,
            """
            using System;
            using System.Threading.Tasks;
 
            class Program
            {
                static void Main(string[] args)
                {
                    Action<string> f = async x => Goo(x);
                }
 
                private static void Goo(string x)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestGenerateInAsyncVoidParenthesizedLambda()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
            using System.Threading.Tasks;
 
            class Program
            {
                static void Main(string[] args)
                {
                    Action f = async () => [|Goo|]();
                }
            }
            """,
            """
            using System;
            using System.Threading.Tasks;
 
            class Program
            {
                static void Main(string[] args)
                {
                    Action f = async () => Goo();
                }
 
                private static void Goo()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestGenerateInAssignmentInAnonymousMethod()
    {
        await TestInRegularAndScriptAsync(
            """
            class C
            {
                void M()
                {
                    System.Action<int> v = delegate (int x) {
                        x = [|Goo|](x);
                    };
                }
            }
            """,
            """
            using System;
 
            class C
            {
                void M()
                {
                    System.Action<int> v = delegate (int x) {
                        x = Goo(x);
                    };
                }
 
                private int Goo(int x)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/539024")]
    public async Task TestGenerateOffOfExplicitInterface1()
    {
        await TestInRegularAndScriptAsync(
            """
            interface I
            {
            }
 
            class A : I
            {
                [|void I.Goo()
                {
                }|]
            }
            """,
            """
            interface I
            {
                void Goo();
            }
 
            class A : I
            {
                void I.Goo()
                {
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/539024")]
    public async Task TestGenerateOffOfExplicitInterface2()
    {
        await TestInRegularAndScriptAsync(
            """
            interface I
            {
            }
 
            class A : I
            {
                [|int I.Goo()
                {
                }|]
            }
            """,
            """
            interface I
            {
                int Goo();
            }
 
            class A : I
            {
                int I.Goo()
                {
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/539024")]
    public async Task TestGenerateOffOfExplicitInterface3()
    {
        await TestInRegularAndScriptAsync(
            """
            interface I
            {
            }
 
            class A : I
            {
                [|void I.Goo(int i)
                {
                }|]
            }
            """,
            """
            interface I
            {
                void Goo(int i);
            }
 
            class A : I
            {
                void I.Goo(int i)
                {
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/539024")]
    public async Task TestGenerateOffOfExplicitInterface4()
    {
        await TestInRegularAndScriptAsync(
            """
            interface I
            {
            }
 
            class A : I
            {
                void I.[|Goo|]<T>()
                {
                }
            }
            """,
            """
            interface I
            {
                void Goo<T>();
            }
 
            class A : I
            {
                void I.Goo<T>()
                {
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/539024")]
    public async Task TestGenerateOffOfExplicitInterface5()
    {
        await TestInRegularAndScriptAsync(
            """
            interface I
            {
            }
 
            class A : I
            {
                void I.[|Goo|]<in T>()
                {
                }
            }
            """,
            """
            interface I
            {
                void Goo<T>();
            }
 
            class A : I
            {
                void I.Goo<in T>()
                {
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/539024")]
    public async Task TestGenerateOffOfExplicitInterface6()
    {
        await TestMissingInRegularAndScriptAsync(
            """
            interface I
            {
                void Goo();
            }
 
            class A : I
            {
                void I.[|Goo|]()
                {
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/539024")]
    public async Task TestGenerateOffOfExplicitInterface7()
    {
        await TestMissingInRegularAndScriptAsync(
            """
            interface I
            {
            }
 
            class A
            {
                void I.[|Goo|]()
                {
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/539024")]
    public async Task TestGenerateOffOfExplicitInterface8()
    {
        await TestInRegularAndScriptAsync(
            """
            interface I<T>
            {
            }
 
            class A : I<int>
            {
                void I<int>.[|Goo|]()
                {
                }
            }
            """,
            """
            interface I<T>
            {
                void Goo();
            }
 
            class A : I<int>
            {
                void I<int>.Goo()
                {
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/539024")]
    public async Task TestGenerateOffOfExplicitInterface9()
    {
        // TODO(cyrusn): It might be nice if we generated "Goo(T i)" here in the future.
        await TestInRegularAndScriptAsync(
            """
            interface I<T>
            {
            }
 
            class A : I<int>
            {
                void I<int>.[|Goo|](int i)
                {
                }
            }
            """,
            """
            interface I<T>
            {
                void Goo(int i);
            }
 
            class A : I<int>
            {
                void I<int>.Goo(int i)
                {
                }
            }
            """);
    }
 
    [Fact, WorkItem(5016, "DevDiv_Projects/Roslyn")]
    public async Task TestGenerateMethodWithArgumentFromBaseConstructorsArgument()
    {
        await TestInRegularAndScriptAsync(
            """
            class A
            {
                public A(string s)
                {
                }
            }
 
            class B : A
            {
                B(string s) : base([|M|](s))
                {
                }
            }
            """,
            """
            using System;
 
            class A
            {
                public A(string s)
                {
                }
            }
 
            class B : A
            {
                B(string s) : base(M(s))
                {
                }
 
                private static string M(string s)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem(5016, "DevDiv_Projects/Roslyn")]
    public async Task TestGenerateMethodWithArgumentFromGenericConstructorsArgument()
    {
        await TestInRegularAndScriptAsync(
            """
            class A<T>
            {
                public A(T t)
                {
                }
            }
 
            class B : A<int>
            {
                B() : base([|M|]())
                {
                }
            }
            """,
            """
            using System;
 
            class A<T>
            {
                public A(T t)
                {
                }
            }
 
            class B : A<int>
            {
                B() : base(M())
                {
                }
 
                private static int M()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestGenerateMethodWithVar()
    {
        await TestInRegularAndScriptAsync(
            """
            class C
            {
                void M()
                {
                    var v = 10;
                    v = [|Goo|](v);
                }
            }
            """,
            """
            using System;
 
            class C
            {
                void M()
                {
                    var v = 10;
                    v = Goo(v);
                }
 
                private int Goo(int v)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/539489")]
    public async Task TestEscapedName()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                void Method()
                {
                    [|@Goo|]();
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method()
                {
                    @Goo();
                }
 
                private void Goo()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/539489")]
    public async Task TestEscapedKeyword()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                void Method()
                {
                    [|@int|]();
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method()
                {
                    @int();
                }
 
                private void @int()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/539527")]
    public async Task TestUnmentionableTypeParameter1()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class<A>
            {
                void Method(A a)
                {
                    B.[|C|](a);
                }
            }
 
            class B
            {
            }
            """,
            """
            using System;
 
            class Class<A>
            {
                void Method(A a)
                {
                    B.C(a);
                }
            }
 
            class B
            {
                internal static void C<A>(A a)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/539527")]
    public async Task TestUnmentionableTypeParameter2()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class<A>
            {
                void Method(A a)
                {
                    [|C|](a);
                }
            }
            """,
            """
            using System;
 
            class Class<A>
            {
                void Method(A a)
                {
                    C(a);
                }
 
                private void C(A a)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/539527")]
    public async Task TestUnmentionableTypeParameter3()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class<A>
            {
                class Internal
                {
                    void Method(A a)
                    {
                        [|C|](a);
                    }
                }
            }
            """,
            """
            using System;
 
            class Class<A>
            {
                class Internal
                {
                    void Method(A a)
                    {
                        C(a);
                    }
 
                    private void C(A a)
                    {
                        throw new NotImplementedException();
                    }
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/539527")]
    public async Task TestUnmentionableTypeParameter4()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class<A>
            {
                class Internal
                {
                    void Method(Class<A> c, A a)
                    {
                        c.[|M|](a);
                    }
                }
            }
            """,
            """
            using System;
 
            class Class<A>
            {
                class Internal
                {
                    void Method(Class<A> c, A a)
                    {
                        c.M(a);
                    }
                }
 
                private void M(A a)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/539527")]
    public async Task TestUnmentionableTypeParameter5()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class<A>
            {
                class Internal
                {
                    void Method(Class<int> c, A a)
                    {
                        c.[|M|](a);
                    }
                }
            }
            """,
            """
            using System;
 
            class Class<A>
            {
                class Internal
                {
                    void Method(Class<int> c, A a)
                    {
                        c.M(a);
                    }
                }
 
                private void M(A a)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/539596")]
    public async Task TestUnmentionableTypeParameter6()
    {
        await TestInRegularAndScriptAsync(
            """
            class Test
            {
                void F<U, V>(U u1, V v1)
                {
                    [|Goo<int, string>|](u1, v1);
                }
            }
            """,
            """
            using System;
 
            class Test
            {
                void F<U, V>(U u1, V v1)
                {
                    Goo<int, string>(u1, v1);
                }
 
                private void Goo<T1, T2>(object u1, object v1)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/539593")]
    public async Task TestUnmentionableTypeParameter7()
    {
        await TestInRegularAndScriptAsync(
            """
            class H<T>
            {
                void A(T t1)
                {
                    t1 = [|Goo<T>|](t1);
                }
            }
            """,
            """
            using System;
 
            class H<T>
            {
                void A(T t1)
                {
                    t1 = Goo<T>(t1);
                }
 
                private T1 Goo<T1>(T1 t1)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/539593")]
    public async Task TestUnmentionableTypeParameter8()
    {
        await TestInRegularAndScriptAsync(
            """
            class H<T1, T2>
            {
                void A(T1 t1)
                {
                    t1 = [|Goo<int, string>|](t1);
                }
            }
            """,
            """
            using System;
 
            class H<T1, T2>
            {
                void A(T1 t1)
                {
                    t1 = Goo<int, string>(t1);
                }
 
                private T1 Goo<T3, T4>(T1 t1)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/539597")]
    public async Task TestOddErrorType()
    {
        await TestInRegularAndScriptAsync(
            """
            public class C
            {
                void M()
                {
                    @public c = [|F|]();
                }
            }
            """,
            """
            using System;
 
            public class C
            {
                void M()
                {
                    @public c = F();
                }
 
                private @public F()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/539594")]
    public async Task TestGenericOverloads()
    {
        await TestInRegularAndScriptAsync(
            """
            class C
            {
                public C()
                {
                    CA.[|M<char, bool>|]();
                }
            }
 
            class CA
            {
                public static void M<V>()
                {
                }
 
                public static void M<V, W, X>()
                {
                }
            }
            """,
            """
            using System;
 
            class C
            {
                public C()
                {
                    CA.M<char, bool>();
                }
            }
 
            class CA
            {
                public static void M<V>()
                {
                }
 
                public static void M<V, W, X>()
                {
                }
 
                internal static void M<T1, T2>()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/537929")]
    public async Task TestInScript1()
    {
        await TestAsync(
            """
            using System;
 
            static void Main(string[] args)
            {
                [|Goo|]();
            }
            """,
            """
            using System;
 
            static void Main(string[] args)
            {
                Goo();
            }
 
            static void Goo()
            {
                throw new NotImplementedException();
            }
            """,
            parseOptions: GetScriptOptions());
    }
 
    [Fact]
    public async Task TestInTopLevelImplicitClass1()
    {
        await TestAsync(
            """
            using System;
 
            static void Main(string[] args)
            {
                [|Goo|]();
            }
            """,
            """
            using System;
 
            static void Main(string[] args)
            {
                Goo();
            }
 
            static void Goo()
            {
                throw new NotImplementedException();
            }
            """,
            parseOptions: GetScriptOptions());
    }
 
    [Fact]
    public async Task TestInNamespaceImplicitClass1()
    {
        await TestInRegularAndScriptAsync(
            """
            namespace N
            {
                using System;
 
                static void Main(string[] args)
                {
                    [|Goo|]();
                }
            }
            """,
            """
            namespace N
            {
                using System;
 
                static void Main(string[] args)
                {
                    Goo();
                }
 
                void Goo()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestInNamespaceImplicitClass_FieldInitializer()
    {
        await TestInRegularAndScriptAsync(
            """
            namespace N
            {
                using System;
 
                int f = [|Goo|]();
            }
            """,
            """
            namespace N
            {
                using System;
 
                int f = Goo();
 
                int Goo()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/539571")]
    public async Task TestSimplification1()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class Program
            {
                static void Main(string[] args)
                {
                    [|Bar|]();
                }
 
                private static void Goo()
                {
                    throw new System.NotImplementedException();
                }
            }
            """,
            """
            using System;
 
            class Program
            {
                static void Main(string[] args)
                {
                    Bar();
                }
 
                private static void Bar()
                {
                    throw new NotImplementedException();
                }
 
                private static void Goo()
                {
                    throw new System.NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/539571")]
    public async Task TestSimplification2()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class Program
            {
                static void Main(string[] args)
                {
                    System.Action a = [|Bar|](DateTime.Now);
                }
            }
            """,
            """
            using System;
 
            class Program
            {
                static void Main(string[] args)
                {
                    System.Action a = Bar(DateTime.Now);
                }
 
                private static Action Bar(DateTime now)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/539618")]
    public async Task TestClashesWithMethod1()
    {
        await TestMissingInRegularAndScriptAsync(
            """
            using System;
 
            class Program
            {
                void Main()
                {
                    [|Goo|](x: 1, true);
                }
 
                private void Goo(int x, bool b);
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/539618")]
    public async Task TestClashesWithMethod2()
    {
        await TestMissingInRegularAndScriptAsync(
            """
            class Program : IGoo
            {
                [|bool IGoo.Goo()
                {
                }|]
            } } interface IGoo
            {
                void Goo();
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/539637")]
    public async Task TestReservedParametername1()
    {
        await TestInRegularAndScriptAsync(
            """
            class C
            {
                public void Method()
                {
                    long Long = 10;
                    [|M|](Long);
                }
            }
            """,
            """
            using System;
 
            class C
            {
                public void Method()
                {
                    long Long = 10;
                    M(Long);
                }
 
                private void M(long @long)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/539751")]
    public async Task TestShadows1()
    {
        await TestMissingInRegularAndScriptAsync(
            """
            using System;
 
            class Program
            {
                static void Main(string[] args)
                {
                    int Name;
                    Name = [|Name|]();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/539769")]
    public async Task TestShadows2()
    {
        await TestMissingInRegularAndScriptAsync(
            """
            using System;
 
            class Program
            {
                delegate void Func(int i, int j);
 
                static void Main(string[] args)
                {
                    Func myExp = (x, y) => Console.WriteLine(x == y);
                    myExp(10, 20);
                    [|myExp|](10, 20, 10);
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/539781")]
    public async Task TestInTopLevelMethod()
    {
        await TestInRegularAndScriptAsync(
            """
            void M()
            {
                [|Goo|]();
            }
            """,
            """
            using System;
 
            void M()
            {
                Goo();
            }
 
            void Goo()
            {
                throw new NotImplementedException();
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/539823")]
    public async Task TestLambdaReturnType()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class C<T, R>
            {
                private static Func<T, R> g = null;
                private static Func<T, R> f = (T) => {
                    return [|Goo<T, R>|](g);
                };
            }
            """,
            """
            using System;
 
            class C<T, R>
            {
                private static Func<T, R> g = null;
                private static Func<T, R> f = (T) => {
                    return Goo<T, R>(g);
                };
 
                private static T2 Goo<T1, T2>(Func<T1, T2> g)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestGenerateWithThrow()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
            using System.Collections.Generic;
            using System.Linq;
 
            class C
            {
                void M()
                {
                    throw [|F|]();
                }
            }
            """,
            """
            using System;
            using System.Collections.Generic;
            using System.Linq;
 
            class C
            {
                void M()
                {
                    throw F();
                }
 
                private Exception F()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestInDelegateConstructor()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            delegate void D(int x);
 
            class C
            {
                void M()
                {
                    D d = new D([|Test|]);
                }
            }
            """,
            """
            using System;
 
            delegate void D(int x);
 
            class C
            {
                void M()
                {
                    D d = new D(Test);
                }
 
                private void Test(int x)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/539871")]
    public async Task TestDelegateScenario()
    {
        await TestMissingInRegularAndScriptAsync(
            """
            class C<T>
            {
                public delegate void Goo<R>(R r);
 
                static void M()
                {
                    Goo<T> r = [|Goo<T>|];
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/539928")]
    public async Task TestInheritedTypeParameters1()
    {
        await TestInRegularAndScriptAsync(
            """
            class C<T, R>
            {
                void M()
                {
                    I<T, R> i1;
                    I<T, R> i2 = i1.[|Goo|]();
                }
            }
 
            interface I<T, R>
            {
            }
            """,
            """
            class C<T, R>
            {
                void M()
                {
                    I<T, R> i1;
                    I<T, R> i2 = i1.Goo();
                }
            }
 
            interface I<T, R>
            {
                I<T, R> Goo();
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/539928")]
    public async Task TestInheritedTypeParameters2()
    {
        await TestInRegularAndScriptAsync(
            """
            class C<T>
            {
                void M()
                {
                    I<T> i1;
                    I<T> i2 = i1.[|Goo|]();
                }
            }
 
            interface I<T>
            {
            }
            """,
            """
            class C<T>
            {
                void M()
                {
                    I<T> i1;
                    I<T> i2 = i1.Goo();
                }
            }
 
            interface I<T>
            {
                I<T> Goo();
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/539928")]
    public async Task TestInheritedTypeParameters3()
    {
        await TestInRegularAndScriptAsync(
            """
            class C<T>
            {
                void M()
                {
                    I<T> i1;
                    I<T> i2 = i1.[|Goo|]();
                }
            }
 
            interface I<X>
            {
            }
            """,
            """
            class C<T>
            {
                void M()
                {
                    I<T> i1;
                    I<T> i2 = i1.Goo();
                }
            }
 
            interface I<X>
            {
                I<object> Goo();
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/538995")]
    public async Task TestBug4777()
    {
        await TestInRegularAndScriptAsync(
            """
            class C
            {
                void M()
                {
                    F([|123.4|]);
                }
 
                void F(int x)
                {
                }
            }
            """,
            """
            using System;
 
            class C
            {
                void M()
                {
                    F(123.4);
                }
 
                private void F(double v)
                {
                    throw new NotImplementedException();
                }
 
                void F(int x)
                {
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/539856")]
    public async Task TestGenerateOnInvalidInvocation()
    {
        await TestMissingInRegularAndScriptAsync(
            """
            class C
            {
                public delegate int Func(ref int i);
 
                public int Goo { get; set; }
 
                public Func Goo()
                {
                    return [|Goo|](ref Goo);
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/539752")]
    public async Task TestMissingOnMultipleLambdaInferences()
    {
        await TestMissingInRegularAndScriptAsync(
            """
            using System;
            using System.Collections.Generic;
 
            class Program
            {
                static void Main(string[] args)
                {
                    C<int> c = new C<int>();
                    c.[|Sum|]((arg) => {
                        return 2;
                    });
                }
            }
 
            class C<T> : List<T>
            {
                public int Sum(Func<T, int> selector)
                {
                    return 2;
                }
 
                public int Sum(Func<T, double> selector)
                {
                    return 3;
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/540505")]
    public async Task TestParameterTypeAmbiguity()
    {
        await TestInRegularAndScriptAsync(
            """
            namespace N
            {
                class N
                {
                    static void Main(string[] args)
                    {
                        C c;
                        [|Goo|](c);
                    }
                }
 
                class C
                {
                }
            }
            """,
            """
            using System;
 
            namespace N
            {
                class N
                {
                    static void Main(string[] args)
                    {
                        C c;
                        Goo(c);
                    }
 
                    private static void Goo(C c)
                    {
                        throw new NotImplementedException();
                    }
                }
 
                class C
                {
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/541176")]
    public async Task TestTernaryWithBodySidesBroken1()
    {
        await TestInRegularAndScriptAsync(
            """
            public class C
            {
                void Method()
                {
                    int a = 5, b = 10;
                    int x = a > b ? [|M|](a) : M(b);
                }
            }
            """,
            """
            using System;
 
            public class C
            {
                void Method()
                {
                    int a = 5, b = 10;
                    int x = a > b ? M(a) : M(b);
                }
 
                private int M(int a)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/541176")]
    public async Task TestTernaryWithBodySidesBroken2()
    {
        await TestInRegularAndScriptAsync(
            """
            public class C
            {
                void Method()
                {
                    int a = 5, b = 10;
                    int x = a > b ? M(a) : [|M|](b);
                }
            }
            """,
            """
            using System;
 
            public class C
            {
                void Method()
                {
                    int a = 5, b = 10;
                    int x = a > b ? M(a) : M(b);
                }
 
                private int M(int b)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestNotOnLeftOfAssign()
    {
        await TestMissingInRegularAndScriptAsync(
            """
            using System;
 
            class C
            {
                public static void Main()
                {
                    string s = "Hello";
                    [|f|] = s.ExtensionMethod;
                }
            }
 
            public static class MyExtension
            {
                public static int ExtensionMethod(this String s)
                {
                    return s.Length;
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/541405")]
    public async Task TestMissingOnImplementedInterfaceMethod()
    {
        await TestMissingInRegularAndScriptAsync(
            """
            class Program<T> : ITest
            {
                [|void ITest.Method(T t)
                {
                }|]
            }
 
            interface ITest
            {
                void Method(object t);
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/541660")]
    public async Task TestDelegateNamedVar()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class Program
            {
                public static void Main()
                {
                    var v = [|M|];
                }
 
                delegate void var(int x);
            }
            """,
            """
            using System;
 
            class Program
            {
                public static void Main()
                {
                    var v = M;
                }
 
                private static void M(int x)
                {
                    throw new NotImplementedException();
                }
 
                delegate void var(int x);
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/540991")]
    public async Task TestErrorVersusNamedTypeInSignature()
    {
        await TestMissingAsync(
            """
            using System;
 
            class Outer
            {
                class Inner
                {
                }
 
                void M()
                {
                    A.[|Test|](new Inner());
                }
            }
 
            class A
            {
                internal static void Test(global::Outer.Inner inner)
                {
                    throw new NotImplementedException();
                }
            }
            """,
new TestParameters(new CSharpParseOptions(kind: SourceCodeKind.Regular)));
    }
 
    [Theory]
    [InlineData("class")]
    [InlineData("struct")]
    [InlineData("new()")]
    [InlineData("unmanaged")]
    [WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/542529")]
    public async Task TestTypeParameterConstraints(string constraint)
    {
        await TestInRegularAndScriptAsync(
            $$"""
            using System;
 
            class A<T> where T : {{constraint}}
            {
            }
 
            class Program
            {
                static void Goo<T>(A<T> x) where T : {{constraint}}
                {
                    [|Bar|](x);
                }
            }
            """,
            $$"""
            using System;
 
            class A<T> where T : {{constraint}}
            {
            }
 
            class Program
            {
                static void Goo<T>(A<T> x) where T : {{constraint}}
                {
                    Bar(x);
                }
 
                private static void Bar<T>(A<T> x) where T : {{constraint}}
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/542622")]
    public async Task TestLambdaTypeParameters()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
            using System.Collections.Generic;
 
            class Program
            {
                static void Goo<T>(List<T> x)
                {
                    [|Bar|](() => x);
                }
            }
            """,
            """
            using System;
            using System.Collections.Generic;
 
            class Program
            {
                static void Goo<T>(List<T> x)
                {
                    Bar(() => x);
                }
 
                private static void Bar<T>(Func<List<T>> value)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Theory]
    [InlineData("class")]
    [InlineData("struct")]
    [InlineData("new()")]
    [InlineData("unmanaged")]
    [WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/542626")]
    public async Task TestMethodConstraints(string constraint)
    {
        await TestInRegularAndScriptAsync(
            $$"""
            using System;
 
            class A<T> where T : {{constraint}}
            {
            }
 
            class Program
            {
                static void Goo<T>(A<T> x) where T : {{constraint}}
                {
                    [|Bar<T>|](x);
                }
            }
            """,
            $$"""
            using System;
 
            class A<T> where T : {{constraint}}
            {
            }
 
            class Program
            {
                static void Goo<T>(A<T> x) where T : {{constraint}}
                {
                    Bar<T>(x);
                }
 
                private static void Bar<T>(A<T> x) where T : {{constraint}}
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/542627")]
    public async Task TestCaptureMethodTypeParametersReferencedInOuterType1()
    {
        await TestInRegularAndScriptAsync(
            """
            using System.Collections.Generic;
 
            class Program
            {
                static void Goo<T>(List<T>.Enumerator x)
                {
                    [|Bar|](x);
                }
            }
            """,
            """
            using System;
            using System.Collections.Generic;
 
            class Program
            {
                static void Goo<T>(List<T>.Enumerator x)
                {
                    Bar(x);
                }
 
                private static void Bar<T>(List<T>.Enumerator x)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/542658")]
    public async Task TestCaptureTypeParametersInConstraints()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
            using System.Collections.Generic;
 
            class Program
            {
                static void Goo<T, S>(List<T> x) where T : S
                {
                    [|Bar|](x);
                }
            }
            """,
            """
            using System;
            using System.Collections.Generic;
 
            class Program
            {
                static void Goo<T, S>(List<T> x) where T : S
                {
                    Bar(x);
                }
 
                private static void Bar<T, S>(List<T> x) where T : S
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/542659")]
    public async Task TestConstraintOrder1()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class A<T, S> where T : ICloneable, S
            {
            }
 
            class B<S>
            {
                public virtual void Goo<T>(A<T, S> x) where T : ICloneable, S
                {
                }
            }
 
            class C : B<Exception>
            {
                public override void Goo<T>(A<T, Exception> x)
                {
                    [|Bar|](x);
                }
            }
            """,
            """
            using System;
 
            class A<T, S> where T : ICloneable, S
            {
            }
 
            class B<S>
            {
                public virtual void Goo<T>(A<T, S> x) where T : ICloneable, S
                {
                }
            }
 
            class C : B<Exception>
            {
                public override void Goo<T>(A<T, Exception> x)
                {
                    Bar(x);
                }
 
                private void Bar<T>(A<T, Exception> x) where T : Exception, ICloneable
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/542678")]
    public async Task TestConstraintOrder2()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class A<T, S, U> where T : U, S
            {
            }
 
            class B<S, U>
            {
                public virtual void Goo<T>(A<T, S, U> x) where T : U, S
                {
                }
            }
 
            class C<U> : B<Exception, U>
            {
                public override void Goo<T>(A<T, Exception, U> x)
                {
                    [|Bar|](x);
                }
            }
            """,
            """
            using System;
 
            class A<T, S, U> where T : U, S
            {
            }
 
            class B<S, U>
            {
                public virtual void Goo<T>(A<T, S, U> x) where T : U, S
                {
                }
            }
 
            class C<U> : B<Exception, U>
            {
                public override void Goo<T>(A<T, Exception, U> x)
                {
                    Bar(x);
                }
 
                private void Bar<T>(A<T, Exception, U> x) where T : Exception, U
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/542674")]
    public async Task TestGenerateStaticMethodInField()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class C
            {
                int x = [|Goo|]();
            }
            """,
            """
            using System;
 
            class C
            {
                int x = Goo();
 
                private static int Goo()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/542680")]
    public async Task TestGenerateIntoConstrainedTypeParameter()
    {
        await TestInRegularAndScriptAsync(
            """
            interface I
            {
            }
 
            class Program
            {
                static void Goo<T>(T x) where T : I
                {
                    x.[|Bar|]();
                }
            }
            """,
            """
            interface I
            {
                void Bar();
            }
 
            class Program
            {
                static void Goo<T>(T x) where T : I
                {
                    x.Bar();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/542750")]
    public async Task TestCaptureOuterTypeParameter()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
            using System.Collections.Generic;
 
            class C<T>
            {
                void Bar()
                {
                    D d = new D();
                    List<T> y;
                    d.[|Goo|](y);
                }
            }
 
            class D
            {
            }
            """,
            """
            using System;
            using System.Collections.Generic;
 
            class C<T>
            {
                void Bar()
                {
                    D d = new D();
                    List<T> y;
                    d.Goo(y);
                }
            }
 
            class D
            {
                internal void Goo<T>(List<T> y)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/542744")]
    public async Task TestMostDerivedTypeParameter()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class A<T, U> where T : U
            {
            }
 
            class B<U>
            {
                public virtual void Goo<T>(A<T, U> x) where T : Exception, U
                {
                }
            }
 
            class C<U> : B<ArgumentException>
            {
                public override void Goo<T>(A<T, ArgumentException> x)
                {
                    [|Bar|](x);
                }
            }
            """,
            """
            using System;
 
            class A<T, U> where T : U
            {
            }
 
            class B<U>
            {
                public virtual void Goo<T>(A<T, U> x) where T : Exception, U
                {
                }
            }
 
            class C<U> : B<ArgumentException>
            {
                public override void Goo<T>(A<T, ArgumentException> x)
                {
                    Bar(x);
                }
 
                private void Bar<T>(A<T, ArgumentException> x) where T : ArgumentException
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/543152")]
    public async Task TestAnonymousTypeArgument()
    {
        await TestInRegularAndScriptAsync(
            """
            class C
            {
                void M()
                {
                    [|M|](new { x = 1 });
                }
            }
            """,
            """
            using System;
 
            class C
            {
                void M()
                {
                    M(new { x = 1 });
                }
 
                private void M(object value)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestListOfAnonymousTypesArgument()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
            using System.Collections.Generic;
 
            class C
            {
                void M()
                {
                    var v = new { };
                    var u = Goo(v);
                    [|M|](u);
                }
 
                private List<T> Goo<T>(T v)
                {
                    return new List<T>();
                }
            }
            """,
            """
            using System;
            using System.Collections.Generic;
 
            class C
            {
                void M()
                {
                    var v = new { };
                    var u = Goo(v);
                    M(u);
                }
 
                private void M(List<object> u)
                {
                    throw new NotImplementedException();
                }
 
                private List<T> Goo<T>(T v)
                {
                    return new List<T>();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/543336")]
    public async Task TestGenerateImplicitlyTypedArrays()
    {
        await TestInRegularAndScriptAsync(
            """
            class C
            {
                void M()
                {
                    var a = new[] { [|goo|](2), 2, 3 };
                }
            }
            """,
            """
            using System;
 
            class C
            {
                void M()
                {
                    var a = new[] { goo(2), 2, 3 };
                }
 
                private int goo(int v)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/543510")]
    public async Task TestGenericArgWithMissingTypeParameter()
    {
        await TestMissingInRegularAndScriptAsync(
            """
            class Program
            {
                public static int goo(ref int i)
                {
                    return checked([|goo|]<>(ref i) * i);
                }
 
                public static int goo<T>(ref int i)
                {
                    return i;
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/544334")]
    public async Task TestDuplicateWithErrorType()
    {
        await TestMissingInRegularAndScriptAsync(
            """
            using System;
 
            class class1
            {
                public void Test()
                {
                    [|Goo|](x);
                }
 
                private void Goo(object x)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestNoGenerationIntoEntirelyHiddenType()
    {
        await TestMissingInRegularAndScriptAsync(
            """
            class C
            {
                void Goo()
                {
                    D.[|Bar|]();
                }
            }
 
            #line hidden
            class D
            {
            }
            #line default
            """);
    }
 
    [Fact]
    public async Task TestDoNotGenerateIntoHiddenRegion1()
    {
        await TestInRegularAndScriptAsync(
            """
            #line default
            class C
            {
                void Goo()
                {
                    [|Bar|]();
            #line hidden
                }
            #line default
            }
            """,
            """
            #line default
            class C
            {
                private void Bar()
                {
                    throw new System.NotImplementedException();
                }
 
                void Goo()
                {
                    Bar();
            #line hidden
                }
            #line default
            }
            """);
    }
 
    [Fact]
    public async Task TestDoNotGenerateIntoHiddenRegion2()
    {
        await TestInRegularAndScriptAsync(
            """
            #line default
            class C
            {
                void Goo()
                {
                    [|Bar|]();
            #line hidden
                }
 
                void Baz()
                {
            #line default
                }
            }
            """,
            """
            #line default
            class C
            {
                void Goo()
                {
                    Bar();
            #line hidden
                }
 
                void Baz()
                {
            #line default
                }
 
                private void Bar()
                {
                    throw new System.NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestDoNotGenerateIntoHiddenRegion3()
    {
        await TestInRegularAndScriptAsync(
            """
            #line default
            class C
            {
                void Goo()
                {
                    [|Bar|]();
            #line hidden
                }
 
                void Baz()
                {
            #line default
                }
 
                void Quux()
                {
                }
            }
            """,
            """
            #line default
            class C
            {
                void Goo()
                {
                    Bar();
            #line hidden
                }
 
                void Baz()
                {
            #line default
                }
 
                private void Bar()
                {
                    throw new System.NotImplementedException();
                }
 
                void Quux()
                {
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestDoNotAddImportsIntoHiddenRegion()
    {
        await TestInRegularAndScriptAsync(
            """
            #line hidden
            class C
            #line default
            {
                void Goo()
                {
                    [|Bar|]();
            #line hidden
                }
            #line default
            }
            """,
            """
            #line hidden
            class C
            #line default
            {
                private void Bar()
                {
                    throw new System.NotImplementedException();
                }
 
                void Goo()
                {
                    Bar();
            #line hidden
                }
            #line default
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/784793")]
    [WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/545397")]
    public async Task TestVarParameterTypeName()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class Program
            {
                void Main()
                {
                    var x;
                    [|goo|](out x);
                }
            }
            """,
            """
            using System;
 
            class Program
            {
                void Main()
                {
                    var x;
                    goo(out x);
                }
 
                private void goo(out object x)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/545269")]
    public async Task TestGenerateInVenus1()
    {
        await TestMissingInRegularAndScriptAsync(
            """
            class C
            {
            #line 1 "goo"
                void Goo()
                {
                    this.[|Bar|]();
                }
            #line default
            #line hidden
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/538521")]
    public async Task TestWithYieldReturnInMethod()
    {
        await TestInRegularAndScriptAsync(
            """
            using System.Collections.Generic;
 
            class Program
            {
                IEnumerable<int> Goo()
                {
                    yield return [|Bar|]();
                }
            }
            """,
            """
            using System;
            using System.Collections.Generic;
 
            class Program
            {
                IEnumerable<int> Goo()
                {
                    yield return Bar();
                }
 
                private int Bar()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestWithYieldReturnInAsyncMethod()
    {
        await TestInRegularAndScriptAsync(
            """
            using System.Collections.Generic;
 
            class Program
            {
                async IAsyncEnumerable<int> Goo()
                {
                    yield return [|Bar|]();
                }
            }
            """,
            """
            using System;
            using System.Collections.Generic;
 
            class Program
            {
                async IAsyncEnumerable<int> Goo()
                {
                    yield return Bar();
                }
 
                private int Bar()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/30235")]
    public async Task TestWithYieldReturnInLocalFunction()
    {
        await TestInRegularAndScriptAsync(
            """
            using System.Collections.Generic;
 
            class Program
            {
                void M()
                {
                    IEnumerable<int> F()
                    {
                        yield return [|Bar|]();
                    }
                }
            }
            """,
            """
            using System;
            using System.Collections.Generic;
 
            class Program
            {
                void M()
                {
                    IEnumerable<int> F()
                    {
                        yield return Bar();
                    }
                }
 
                private int Bar()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/784793")]
    public async Task TestGenerateMethodMissingForAnyArgumentInInvocationHavingErrorTypeAndNotBelongingToEnclosingNamedType()
    {
        await TestInRegularAndScriptAsync(
            """
            class Program
            {
                static void Main(string[] args)
                {
                    [|Main(args.Goo())|];
                }
            }
            """,
            """
            using System;
 
            class Program
            {
                static void Main(string[] args)
                {
                    Main(args.Goo());
                }
 
                private static void Main(object value)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/907612")]
    public async Task TestGenerateMethodWithLambda()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class Program
            {
                void Baz(string[] args)
                {
                    Baz([|() => { return true; }|]);
                }
            }
            """,
            """
            using System;
 
            class Program
            {
                void Baz(string[] args)
                {
                    Baz(() => { return true; });
                }
 
                private void Baz(Func<bool> value)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/889349")]
    public async Task TestGenerateMethodForDifferentParameterName()
    {
        await TestInRegularAndScriptAsync(
            """
            class C
            {
                void M()
                {
                    M([|x: 42|]);
                }
 
                void M(int y) { }
            }
            """,
            """
            using System;
 
            class C
            {
                void M()
                {
                    M(x: 42);
                }
 
                private void M(int x)
                {
                    throw new NotImplementedException();
                }
 
                void M(int y) { }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/889349")]
    public async Task TestGenerateMethodForDifferentParameterNameCaseSensitive()
    {
        await TestInRegularAndScriptAsync(
            """
            class C
            {
                void M()
                {
                    M([|Y: 42|]);
                }
 
                void M(int y) { }
            }
            """,
            """
            using System;
 
            class C
            {
                void M()
                {
                    M(Y: 42);
                }
 
                private void M(int Y)
                {
                    throw new NotImplementedException();
                }
 
                void M(int y) { }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/769760")]
    public async Task TestGenerateMethodForSameNamedButGenericUsage()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class Program
            {
                static void Main(string[] args)
                {
                    Goo();
                    [|Goo<int>|]();
                }
 
                private static void Goo()
                {
                    throw new NotImplementedException();
                }
            }
            """,
            """
            using System;
 
            class Program
            {
                static void Main(string[] args)
                {
                    Goo();
                    Goo<int>();
                }
 
                private static void Goo<T>()
                {
                    throw new NotImplementedException();
                }
 
                private static void Goo()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/910589")]
    public async Task TestGenerateMethodForNewErrorCodeCS7036()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
            class C
            {
                void M(int x)
                {
                    [|M|]();
                }
            }
            """,
            """
            using System;
            class C
            {
                void M(int x)
                {
                    M();
                }
 
                private void M()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/934729")]
    public async Task TestGenerateMethodUnknownReturnTypeInLambda()
    {
        await TestInRegularAndScriptAsync(
            """
            using System.Collections.Generic; 
            class C
            {
                void TestMethod(IEnumerable<C> c)
                {
                   new C().[|TestMethod((a,b) => c.Add)|]
                }
            }
            """,
            """
            using System;
            using System.Collections.Generic; 
            class C
            {
                void TestMethod(IEnumerable<C> c)
                {
                   new C().TestMethod((a,b) => c.Add)
                }
 
                private void TestMethod(Func<object, object, object> value)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/530177")]
    public async Task TestGenerateMethodInUnsafeMethod()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
            class C {
                unsafe void Method(he) {
                    int a = 10; [|TestMethod(&a)|];
                }
            }
            """,
            """
            using System;
            class C {
                unsafe void Method(he) {
                    int a = 10; TestMethod(&a);
                }
 
                private unsafe void TestMethod(int* v)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/530177")]
    public async Task TestGenerateMethodInUnsafeMethodWithPointerArray()
    {
        await TestInRegularAndScriptAsync(
            """
            class C
            {
                unsafe static void M1(int *[] o)
                {
                    [|M2(o)|];
                }
            }
            """,
            """
            using System;
 
            class C
            {
                unsafe static void M1(int *[] o)
                {
                    M2(o);
                }
 
                private static unsafe void M2(int*[] o)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/530177")]
    public async Task TestGenerateMethodInUnsafeBlock()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
            class Program
            {
                static void Main()
                {
                    unsafe
                    {
                        fixed (char* value = "sam")
                        {
                            [|TestMethod(value)|];
                        }
                    }
                }
            }
            """,
            """
            using System;
            class Program
            {
                static void Main()
                {
                    unsafe
                    {
                        fixed (char* value = "sam")
                        {
                            TestMethod(value);
                        }
                    }
                }
 
                private static unsafe void TestMethod(char* value)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/530177")]
    public async Task TestGenerateMethodInUnsafeMethodNoPointersInParameterList()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
            class C {
                unsafe void Method(he) {
                    int a = 10; [|TestMethod(a)|];
                }
            }
            """,
            """
            using System;
            class C {
                unsafe void Method(he) {
                    int a = 10; TestMethod(a);
                }
 
                private void TestMethod(int a)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/530177")]
    public async Task TestGenerateMethodInUnsafeBlockNoPointers()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
            class Program
            {
                static void Main()
                {
                    unsafe
                    {
                        fixed (char value = "sam")
                        {
                            [|TestMethod(value)|];
                        }
                    }
                }
            }
            """,
            """
            using System;
            class Program
            {
                static void Main()
                {
                    unsafe
                    {
                        fixed (char value = "sam")
                        {
                            TestMethod(value);
                        }
                    }
                }
 
                private static void TestMethod(char value)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/530177")]
    public async Task TestGenerateMethodUnsafeReturnType()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
            class Program
            {
                static void Main()
                {
                    int* a = [|Test()|];
                }
            }
            """,
            """
            using System;
            class Program
            {
                static void Main()
                {
                    int* a = Test();
                }
 
                private static unsafe int* Test()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/530177")]
    public async Task TestGenerateMethodUnsafeClass()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
            unsafe class Program
            {
                static void Main()
                {
                    int* a = [|Test()|];
                }
            }
            """,
            """
            using System;
            unsafe class Program
            {
                static void Main()
                {
                    int* a = Test();
                }
 
                private static int* Test()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/530177")]
    public async Task TestGenerateMethodUnsafeNestedClass()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
            unsafe class Program
            {
                class MyClass
                {
                    static void Main()
                    {
                        int* a = [|Test()|];
                    }
                }
            }
            """,
            """
            using System;
            unsafe class Program
            {
                class MyClass
                {
                    static void Main()
                    {
                        int* a = [|Test()|];
                    }
 
                    private static int* Test()
                    {
                        throw new NotImplementedException();
                    }
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/530177")]
    public async Task TestGenerateMethodUnsafeNestedClass2()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
            class Program
            {
                unsafe class MyClass
                {
                    static void Main(string[] args)
                    {
                        int* a = [|Program.Test()|];
                    }
                }
            }
            """,
            """
            using System;
            class Program
            {
                unsafe class MyClass
                {
                    static void Main(string[] args)
                    {
                        int* a = Program.Test();
                    }
                }
 
                private static unsafe int* Test()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestDoNotOfferMethodWithoutParenthesis()
    {
        await TestMissingInRegularAndScriptAsync(
            """
            class Class
            {
                void Method()
                {
                    [|Goo|];
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1032176")]
    public async Task TestGenerateMethodInsideNameOf()
    {
        await TestInRegularAndScriptAsync(
            """
            class C
            {
                void M()
                {
                    var x = nameof([|Z|]);
                }
            }
            """,
            """
            using System;
 
            class C
            {
                void M()
                {
                    var x = nameof(Z);
                }
 
                private object Z()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1032176")]
    public async Task TestGenerateMethodInsideNameOf2()
    {
        await TestInRegularAndScriptAsync(
            """
            class C
            {
                void M()
                {
                    var x = nameof([|Z.X|]);
                }
            }
            """,
            """
            using System;
 
            class C
            {
                void M()
                {
                    var x = nameof(Z.X);
                }
 
                private object nameof(object x)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1032176")]
    public async Task TestGenerateMethodInsideNameOf3()
    {
        await TestInRegularAndScriptAsync(
            """
            class C
            {
                void M()
                {
                    var x = nameof([|Z.X.Y|]);
                }
            }
            """,
            """
            using System;
 
            class C
            {
                void M()
                {
                    var x = nameof(Z.X.Y);
                }
 
                private object nameof(object y)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1032176")]
    public async Task TestGenerateMethodInsideNameOf4()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class C
            {
                void M()
                {
                    var x = nameof([|Z.X.Y|]);
                }
            }
 
            namespace Z
            {
                class X
                {
                }
            }
            """,
            """
            using System;
 
            class C
            {
                void M()
                {
                    var x = nameof(Z.X.Y);
                }
            }
 
            namespace Z
            {
                class X
                {
                    internal static object Y()
                    {
                        throw new NotImplementedException();
                    }
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1032176")]
    public async Task TestGenerateMethodInsideNameOf5()
    {
        await TestMissingInRegularAndScriptAsync(
            """
            class C
            {
                void M()
                {
                    var x = nameof([|1 + 2|]);
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1032176")]
    public async Task TestGenerateMethodInsideNameOf6()
    {
        await TestMissingInRegularAndScriptAsync(
            """
            class C
            {
                void M()
                {
                    var y = 1 + 2;
                    var x = [|nameof(y)|];
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1032176")]
    public async Task TestGenerateMethodInsideNameOf7()
    {
        await TestInRegularAndScriptAsync(
            """
            class C
            {
                void M()
                {
                    var y = 1 + 2;
                    var z = ";
                    var x = [|nameof(y, z)|];
                }
            }
            """,
            """
            using System;
 
            class C
            {
                void M()
                {
                    var y = 1 + 2;
                    var z = ";
                    var x = nameof(y, z);
                }
 
                private object nameof(int y, string z)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1032176")]
    public async Task TestGenerateMethodInsideNameOf8()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class C
            {
                void M()
                {
                    var x = [|nameof|](1 + 2, "");
                }
            }
            """,
            """
            using System;
 
            class C
            {
                void M()
                {
                    var x = nameof(1 + 2, "");
                }
 
                private object nameof(int v1, string v2)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1032176")]
    public async Task TestGenerateMethodInsideNameOf9()
    {
        await TestInRegularAndScriptAsync(
            """
            class C
            {
                void M()
                {
                    var x = [|nameof|](y, z);
                }
            }
            """,
            """
            using System;
 
            class C
            {
                void M()
                {
                    var x = nameof(y, z);
                }
 
                private object nameof(object y, object z)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1032176")]
    public async Task TestGenerateMethodInsideNameOf10()
    {
        await TestInRegularAndScriptAsync(
            """
            class C
            {
                void M()
                {
                    var x = nameof([|y|], z);
                }
            }
            """,
            """
            using System;
 
            class C
            {
                void M()
                {
                    var x = nameof(y, z);
                }
 
                private object y()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1032176")]
    public async Task TestGenerateMethodInsideNameOf11()
    {
        await TestInRegularAndScriptAsync(
            """
            class C
            {
                void M()
                {
                    var x = nameof(y, [|z|]);
                }
            }
            """,
            """
            using System;
 
            class C
            {
                void M()
                {
                    var x = nameof(y, z);
                }
 
                private object z()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1032176")]
    public async Task TestGenerateMethodInsideNameOf12()
    {
        await TestMissingInRegularAndScriptAsync(
            """
            using System;
 
            class C
            {
                void M()
                {
                    var x = [|nameof|](y, z);
                }
 
                private object nameof(object y, object z)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1032176")]
    public async Task TestGenerateMethodInsideNameOf13()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class C
            {
                void M()
                {
                    var x = nameof([|y|], z);
                }
 
                private object nameof(object y, object z)
                {
                    throw new NotImplementedException();
                }
            }
            """,
            """
            using System;
 
            class C
            {
                void M()
                {
                    var x = nameof(y, z);
                }
 
                private object y()
                {
                    throw new NotImplementedException();
                }
 
                private object nameof(object y, object z)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1032176")]
    public async Task TestGenerateMethodInsideNameOf14()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class C
            {
                void M()
                {
                    var x = nameof(y, [|z|]);
                }
 
                private object nameof(object y, object z)
                {
                    throw new NotImplementedException();
                }
            }
            """,
            """
            using System;
 
            class C
            {
                void M()
                {
                    var x = nameof(y, z);
                }
 
                private object z()
                {
                    throw new NotImplementedException();
                }
 
                private object nameof(object y, object z)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1032176")]
    public async Task TestGenerateMethodInsideNameOf15()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class C
            {
                void M()
                {
                    var x = [|nameof()|];
                }
 
                private object nameof(object y)
                {
                    throw new NotImplementedException();
                }
            }
            """,
            """
            using System;
 
            class C
            {
                void M()
                {
                    var x = nameof();
                }
 
                private object nameof()
                {
                    throw new NotImplementedException();
                }
 
                private object nameof(object y)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1032176")]
    public async Task TestGenerateMethodInsideNameOf16()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class C
            {
                void M()
                {
                    var x = [|nameof(1 + 2, 5)|];
                }
 
                private object nameof(object y)
                {
                    throw new NotImplementedException();
                }
            }
            """,
            """
            using System;
 
            class C
            {
                void M()
                {
                    var x = nameof(1 + 2, 5);
                }
 
                private object nameof(int v1, int v2)
                {
                    throw new NotImplementedException();
                }
 
                private object nameof(object y)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1075289")]
    public async Task TestGenerateMethodForInaccessibleMethod()
    {
        await TestInRegularAndScriptAsync(
            """
            namespace ConsoleApplication1
            {
                class Program
                {
                    static void Main(string[] args)
                    {
                    }
 
                    private void Test()
                    {
                    }
                }
 
                class Program2 : Program
                {
                    public Program2()
                    {
                        [|Test()|];
                    }
                }
            }
            """,
            """
            using System;
 
            namespace ConsoleApplication1
            {
                class Program
                {
                    static void Main(string[] args)
                    {
                    }
 
                    private void Test()
                    {
                    }
                }
 
                class Program2 : Program
                {
                    public Program2()
                    {
                        Test();
                    }
 
                    private void Test()
                    {
                        throw new NotImplementedException();
                    }
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1064748")]
    public async Task TestGenerateMethodInConditionalAccessMissing()
    {
        await TestMissingInRegularAndScriptAsync(
            """
            class C
            {
                void Main(C a)
                {
                    C x = new C? [|.B|]();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1064748")]
    public async Task TestGenerateMethodInConditionalAccess()
    {
        await TestInRegularAndScriptAsync(
            """
            public class C
            {
                void Main(C a)
                {
                    C x = a?[|.B|]();
                }
            }
            """,
            """
            using System;
 
            public class C
            {
                void Main(C a)
                {
                    C x = a?.B();
                }
 
                private C B()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1064748")]
    public async Task TestGenerateMethodInConditionalAccess2()
    {
        await TestInRegularAndScriptAsync(
            """
            public class C
            {
                void Main(C a)
                {
                    int x = a?[|.B|]();
                }
            }
            """,
            """
            using System;
 
            public class C
            {
                void Main(C a)
                {
                    int x = a?.B();
                }
 
                private int B()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1064748")]
    public async Task TestGenerateMethodInConditionalAccess3()
    {
        await TestInRegularAndScriptAsync(
            """
            public class C
            {
                void Main(C a)
                {
                    int? x = a?[|.B|]();
                }
            }
            """,
            """
            using System;
 
            public class C
            {
                void Main(C a)
                {
                    int? x = a?.B();
                }
 
                private int B()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1064748")]
    public async Task TestGenerateMethodInConditionalAccess4()
    {
        await TestInRegularAndScriptAsync(
            """
            public class C
            {
                void Main(C a)
                {
                    MyStruct? x = a?[|.B|]();
                }
            }
            """,
            """
            using System;
 
            public class C
            {
                void Main(C a)
                {
                    MyStruct? x = a?.B();
                }
 
                private MyStruct B()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1064748")]
    public async Task TestTestGenerateMethodInConditionalAccess5()
    {
        await TestInRegularAndScriptAsync(
            """
            class C
            {
                public E B { get; private set; }
 
                void Main(C a)
                {
                    C x = a?.B.[|C|]();
                }
 
                public class E
                {
                }
            }
            """,
            """
            using System;
 
            class C
            {
                public E B { get; private set; }
 
                void Main(C a)
                {
                    C x = a?.B.C();
                }
 
                public class E
                {
                    internal C C()
                    {
                        throw new NotImplementedException();
                    }
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1064748")]
    public async Task TestGenerateMethodInConditionalAccess6()
    {
        await TestInRegularAndScriptAsync(
            """
            class C
            {
                public E B { get; private set; }
 
                void Main(C a)
                {
                    int x = a?.B.[|C|]();
                }
 
                public class E
                {
                }
            }
            """,
            """
            using System;
 
            class C
            {
                public E B { get; private set; }
 
                void Main(C a)
                {
                    int x = a?.B.C();
                }
 
                public class E
                {
                    internal int C()
                    {
                        throw new NotImplementedException();
                    }
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1064748")]
    public async Task TestGenerateMethodInConditionalAccess7()
    {
        await TestInRegularAndScriptAsync(
            """
            class C
            {
                public E B { get; private set; }
 
                void Main(C a)
                {
                    int? x = a?.B.[|C|]();
                }
 
                public class E
                {
                }
            }
            """,
            """
            using System;
 
            class C
            {
                public E B { get; private set; }
 
                void Main(C a)
                {
                    int? x = a?.B.C();
                }
 
                public class E
                {
                    internal int C()
                    {
                        throw new NotImplementedException();
                    }
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1064748")]
    public async Task TestGenerateMethodInConditionalAccess8()
    {
        await TestInRegularAndScriptAsync(
            """
            class C
            {
                public E B { get; private set; }
 
                void Main(C a)
                {
                    var x = a?.B.[|C|]();
                }
 
                public class E
                {
                }
            }
            """,
            """
            using System;
 
            class C
            {
                public E B { get; private set; }
 
                void Main(C a)
                {
                    var x = a?.B.C();
                }
 
                public class E
                {
                    internal object C()
                    {
                        throw new NotImplementedException();
                    }
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1064748")]
    [WorkItem("https://github.com/dotnet/roslyn/issues/39001")]
    public async Task TestGenerateMethodInConditionalAccess9()
    {
        await TestInRegularAndScriptAsync(
            """
            struct C
            {
                void Main(C? c)
                {
                    int? v = c?.[|Bar|]();
                }
            }
            """,
            """
            using System;
 
            struct C
            {
                void Main(C? c)
                {
                    int? v = c?.Bar();
                }
 
                private int Bar()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestGenerateMethodInPropertyInitializer()
    {
        await TestInRegularAndScriptAsync(
            """
            class Program
            {
                public int MyProperty { get; } = [|y|]();
            }
            """,
            """
            using System;
 
            class Program
            {
                public int MyProperty { get; } = y();
 
                private static int y()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestGenerateMethodInExpressionBodiedProperty()
    {
        await TestInRegularAndScriptAsync(
            """
            class Program
            {
                public int Y => [|y|]();
            }
            """,
            """
            using System;
 
            class Program
            {
                public int Y => y();
 
                private int y()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestGenerateMethodInExpressionBodiedMethod()
    {
        await TestInRegularAndScriptAsync(
            """
            class C
            {
                public static C GetValue(C p) => [|x|]();
            }
            """,
            """
            using System;
 
            class C
            {
                public static C GetValue(C p) => x();
 
                private static C x()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/27647")]
    public async Task TestGenerateMethodInExpressionBodiedAsyncTaskOfTMethod()
    {
        await TestInRegularAndScriptAsync(
            """
            class C
            {
                public static async System.Threading.Tasks.Task<C> GetValue(C p) => [|x|]();
            }
            """,
            """
            using System;
 
            class C
            {
                public static async System.Threading.Tasks.Task<C> GetValue(C p) => x();
 
                private static C x()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/27647")]
    public async Task TestGenerateMethodInExpressionBodiedAsyncTaskMethod()
    {
        await TestInRegularAndScriptAsync(
            """
            class C
            {
                public static async System.Threading.Tasks.Task GetValue(C p) => [|x|]();
            }
            """,
            """
            using System;
 
            class C
            {
                public static async System.Threading.Tasks.Task GetValue(C p) => x();
 
                private static void x()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestGenerateMethodInExpressionBodiedAsyncVoidMethod()
    {
        await TestInRegularAndScriptAsync(
            """
            class C
            {
                public static async void GetValue(C p) => [|x|]();
            }
            """,
            """
            using System;
 
            class C
            {
                public static async void GetValue(C p) => x();
 
                private static void x()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestGenerateMethodInExpressionBodiedOperator()
    {
        await TestInRegularAndScriptAsync(
            """
            class C
            {
                public static C operator --(C p) => [|x|]();
            }
            """,
            """
            using System;
 
            class C
            {
                public static C operator --(C p) => x();
 
                private static C x()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestGenerateMethodInDictionaryInitializer()
    {
        await TestInRegularAndScriptAsync(
            """
            using System.Collections.Generic;
 
            class Program
            {
                static void Main(string[] args)
                {
                    var x = new Dictionary<string, int> { [[|key|]()] = 0 };
                }
            }
            """,
            """
            using System;
            using System.Collections.Generic;
 
            class Program
            {
                static void Main(string[] args)
                {
                    var x = new Dictionary<string, int> { [key()] = 0 };
                }
 
                private static string key()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestGenerateMethodInDictionaryInitializer2()
    {
        await TestInRegularAndScriptAsync(
            """
            using System.Collections.Generic;
 
            class Program
            {
                static void Main(string[] args)
                {
                    var x = new Dictionary<string, int> { ["Zero"] = 0, [[|One|]()] = 1, ["Two"] = 2 };
                }
            }
            """,
            """
            using System;
            using System.Collections.Generic;
 
            class Program
            {
                static void Main(string[] args)
                {
                    var x = new Dictionary<string, int> { ["Zero"] = 0, [One()] = 1, ["Two"] = 2 };
                }
 
                private static string One()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestGenerateMethodInDictionaryInitializer3()
    {
        await TestInRegularAndScriptAsync(
            """
            using System.Collections.Generic;
 
            class Program
            {
                static void Main(string[] args)
                {
                    var x = new Dictionary<string, int> { ["Zero"] = [|i|]() };
                }
            }
            """,
            """
            using System;
            using System.Collections.Generic;
 
            class Program
            {
                static void Main(string[] args)
                {
                    var x = new Dictionary<string, int> { ["Zero"] = i() };
                }
 
                private static int i()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/643")]
    [WorkItem("https://github.com/dotnet/roslyn/issues/14467")]
    public async Task TestGenerateMethodWithConfigureAwaitFalse()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
            using System.Collections.Generic;
            using System.Linq;
            using System.Threading.Tasks;
 
            class Program
            {
                static void Main(string[] args)
                {
                    bool x = await [|Goo|]().ConfigureAwait(false);
                }
            }
            """,
            """
            using System;
            using System.Collections.Generic;
            using System.Linq;
            using System.Threading.Tasks;
 
            class Program
            {
                static void Main(string[] args)
                {
                    bool x = await Goo().ConfigureAwait(false);
                }
 
                private static async Task<bool> Goo()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/643")]
    [WorkItem("https://github.com/dotnet/roslyn/issues/14467")]
    public async Task TestGenerateMethodWithMethodChaining()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
            using System.Collections.Generic;
            using System.Linq;
            using System.Threading.Tasks;
 
            class Program
            {
                static void Main(string[] args)
                {
                    bool x = await [|Goo|]().ConfigureAwait(false);
                }
            }
            """,
            """
            using System;
            using System.Collections.Generic;
            using System.Linq;
            using System.Threading.Tasks;
 
            class Program
            {
                static void Main(string[] args)
                {
                    bool x = await Goo().ConfigureAwait(false);
                }
 
                private static async Task<bool> Goo()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/643")]
    [WorkItem("https://github.com/dotnet/roslyn/issues/14467")]
    public async Task TestGenerateMethodWithMethodChaining2()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
            using System.Threading.Tasks;
 
            class C
            {
                static async void T()
                {
                    bool x = await [|M|]().ContinueWith(a => {
                        return true;
                    }).ContinueWith(a => {
                        return false;
                    });
                }
            }
            """,
            """
            using System;
            using System.Threading.Tasks;
 
            class C
            {
                static async void T()
                {
                    bool x = await M().ContinueWith(a => {
                        return true;
                    }).ContinueWith(a => {
                        return false;
                    });
                }
 
                private static async Task<object> M()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/529480")]
    public async Task TestInCollectionInitializers1()
    {
        await TestInRegularAndScriptAsync(
            """
            class C
            {
                void M()
                {
                    var x = new System.Collections.Generic.List<int> { [|T|]() };
                }
            }
            """,
            """
            using System;
 
            class C
            {
                void M()
                {
                    var x = new System.Collections.Generic.List<int> { T() };
                }
 
                private int T()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/529480")]
    public async Task TestInCollectionInitializers2()
    {
        await TestInRegularAndScriptAsync(
            """
            class C
            {
                void M()
                {
                    var x = new System.Collections.Generic.Dictionary<int, bool> { { 1, [|T|]() } };
                }
            }
            """,
            """
            using System;
 
            class C
            {
                void M()
                {
                    var x = new System.Collections.Generic.Dictionary<int, bool> { { 1, T() } };
                }
 
                private bool T()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/5338")]
    public async Task TestGenerateMethodLambdaOverload1()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
            using System.Collections.Concurrent;
 
            class JToken
            {
            }
 
            class Class1
            {
                private static readonly ConcurrentDictionary<Type, Func<JToken, object>> _deserializeHelpers = new ConcurrentDictionary<Type, Func<JToken, object>>();
 
                private static object DeserializeObject(JToken token, Type type)
                {
                    _deserializeHelpers.GetOrAdd(type, key => [|CreateDeserializeDelegate|](key));
                }
            }
            """,
            """
            using System;
            using System.Collections.Concurrent;
 
            class JToken
            {
            }
 
            class Class1
            {
                private static readonly ConcurrentDictionary<Type, Func<JToken, object>> _deserializeHelpers = new ConcurrentDictionary<Type, Func<JToken, object>>();
 
                private static object DeserializeObject(JToken token, Type type)
                {
                    _deserializeHelpers.GetOrAdd(type, key => CreateDeserializeDelegate(key));
                }
 
                private static Func<JToken, object> CreateDeserializeDelegate(JToken key)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/8010")]
    public async Task TestGenerateMethodFromStaticProperty()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            public class Test
            {
                public static int Property
                {
                    get
                    {
                        return [|Method|]();
                    }
                }
            }
            """,
            """
            using System;
 
            public class Test
            {
                public static int Property
                {
                    get
                    {
                        return Method();
                    }
                }
 
                private static int Method()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/8010")]
    public async Task TestGenerateMethodFromStaticProperty_FieldInitializer()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            public class OtherClass
            {
            }
 
            public class Test
            {
                public static OtherClass Property
                {
                    get
                    {
                        if (s_field == null)
                            s_field = [|InitializeProperty|]();
                        return s_field;
                    }
                }
 
                private static OtherClass s_field;
            }
            """,
            """
            using System;
 
            public class OtherClass
            {
            }
 
            public class Test
            {
                public static OtherClass Property
                {
                    get
                    {
                        if (s_field == null)
                            s_field = InitializeProperty();
                        return s_field;
                    }
                }
 
                private static OtherClass InitializeProperty()
                {
                    throw new NotImplementedException();
                }
 
                private static OtherClass s_field;
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/8230")]
    public async Task TestGenerateMethodForOverloadedSignatureWithDelegateType()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class PropertyMetadata
            {
                public PropertyMetadata(object defaultValue)
                {
                }
 
                public PropertyMetadata(EventHandler changedHandler)
                {
                }
            }
 
            class Program
            {
                static void Main()
                {
                    new PropertyMetadata([|OnChanged|]);
                }
            }
            """,
            """
            using System;
 
            class PropertyMetadata
            {
                public PropertyMetadata(object defaultValue)
                {
                }
 
                public PropertyMetadata(EventHandler changedHandler)
                {
                }
            }
 
            class Program
            {
                static void Main()
                {
                    new PropertyMetadata(OnChanged);
                }
 
                private static void OnChanged(object sender, EventArgs e)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/10004")]
    public async Task TestGenerateMethodWithMultipleOfSameGenericType()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            public class C
            {
            }
 
            public static class Ex
            {
                public static T M1<T>(this T t) where T : C
                {
                    return [|t.M<T, T>()|];
                }
            }
            """,
            """
            using System;
 
            public class C
            {
                internal T2 M<T1, T2>()
                    where T1 : C
                    where T2 : C
                {
                }
            }
 
            public static class Ex
            {
                public static T M1<T>(this T t) where T : C
                {
                    return t.M<T, T>();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/11141")]
    public async Task InferTypeParameters1()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class C
            {
                void M()
                {
                    List<int> list = null;
                    int i = [|First<int>(list)|];
                }
            }
            """,
            """
            using System;
 
            class C
            {
                void M()
                {
                    List<int> list = null;
                    int i = First<int>(list);
                }
 
                private T First<T>(List<T> list)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/42986")]
    public async Task MethodWithNativeIntegerTypes()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                void M(nint i, nuint i2)
                {
                    (nint, nuint) d = [|NewMethod|](i, i2);
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void M(nint i, nuint i2)
                {
                    (nint, nuint) d = NewMethod(i, i2);
                }
 
                private (nint, nuint) NewMethod(nint i, nuint i2)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task MethodWithTuple()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                void Method()
                {
                    (int, string) d = [|NewMethod|]((1, "hello"));
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method()
                {
                    (int, string) d = NewMethod((1, "hello"));
                }
 
                private (int, string) NewMethod((int, string) value)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task MethodWithTupleWithNames()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                void Method()
                {
                    (int a, string b) d = [|NewMethod|]((c: 1, d: "hello"));
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method()
                {
                    (int a, string b) d = NewMethod((c: 1, d: "hello"));
                }
 
                private (int a, string b) NewMethod((int c, string d) value)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task MethodWithTupleWithOneName()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                void Method()
                {
                    (int a, string) d = [|NewMethod|]((c: 1, "hello"));
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method()
                {
                    (int a, string) d = NewMethod((c: 1, "hello"));
                }
 
                private (int a, string) NewMethod((int c, string) value)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/12147")]
    public async Task TestOutVariableDeclaration_ImplicitlyTyped()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                void Method()
                {
                    [|Undefined|](out var c);
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method()
                {
                    Undefined(out var c);
                }
 
                private void Undefined(out object c)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/12147")]
    public async Task TestOutVariableDeclaration_ExplicitlyTyped()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                void Method()
                {
                    [|Undefined|](out int c);
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method()
                {
                    Undefined(out int c);
                }
 
                private void Undefined(out int c)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/12147")]
    public async Task TestOutVariableDeclaration_ImplicitlyTyped_NamedArgument()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                void Method()
                {
                    [|Undefined|](a: out var c);
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method()
                {
                    Undefined(a: out var c);
                }
 
                private void Undefined(out object a)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/12147")]
    public async Task TestOutVariableDeclaration_ExplicitlyTyped_NamedArgument()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                void Method()
                {
                    [|Undefined|](a: out int c);
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method()
                {
                    Undefined(a: out int c);
                }
 
                private void Undefined(out int a)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestOutVariableDeclaration_ImplicitlyTyped_CSharp6()
    {
        await TestAsync(
            """
            class Class
            {
                void Method()
                {
                    [|Undefined|](out var c);
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method()
                {
                    Undefined(out var c);
                }
 
                private void Undefined(out object c)
                {
                    throw new NotImplementedException();
                }
            }
            """,
            parseOptions: TestOptions.Regular.WithLanguageVersion(CodeAnalysis.CSharp.LanguageVersion.CSharp6));
    }
 
    [Fact]
    public async Task TestOutVariableDeclaration_ExplicitlyTyped_CSharp6()
    {
        await TestAsync(
            """
            class Class
            {
                void Method()
                {
                    [|Undefined|](out int c);
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method()
                {
                    Undefined(out int c);
                }
 
                private void Undefined(out int c)
                {
                    throw new NotImplementedException();
                }
            }
            """,
            parseOptions: TestOptions.Regular.WithLanguageVersion(CodeAnalysis.CSharp.LanguageVersion.CSharp6));
    }
 
    [Fact]
    public async Task TestOutVariableDeclaration_ImplicitlyTyped_NamedArgument_CSharp6()
    {
        await TestAsync(
            """
            class Class
            {
                void Method()
                {
                    [|Undefined|](a: out var c);
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method()
                {
                    Undefined(a: out var c);
                }
 
                private void Undefined(out object a)
                {
                    throw new NotImplementedException();
                }
            }
            """,
            parseOptions: TestOptions.Regular.WithLanguageVersion(CodeAnalysis.CSharp.LanguageVersion.CSharp6));
    }
 
    [Fact]
    public async Task TestOutVariableDeclaration_ExplicitlyTyped_NamedArgument_CSharp6()
    {
        await TestAsync(
            """
            class Class
            {
                void Method()
                {
                    [|Undefined|](a: out int c);
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method()
                {
                    Undefined(a: out int c);
                }
 
                private void Undefined(out int a)
                {
                    throw new NotImplementedException();
                }
            }
            """,
            parseOptions: TestOptions.Regular.WithLanguageVersion(CodeAnalysis.CSharp.LanguageVersion.CSharp6));
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/14136")]
    public async Task TestDeconstruction1()
    {
        await TestAsync(
            """
            using System;
 
            class C
            {
                public void M1()
                {
                    (int x, int y) = [|Method|]();
                }
            }
            """,
            """
            using System;
 
            class C
            {
                public void M1()
                {
                    (int x, int y) = Method();
                }
 
                private (int x, int y) Method()
                {
                    throw new NotImplementedException();
                }
            }
            """,
            parseOptions: TestOptions.Regular);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/14136")]
    public async Task TestDeconstruction2()
    {
        await TestAsync(
            """
            using System;
 
            class C
            {
                public void M1()
                {
                    (int x, (int y, int z)) = [|Method|]();
                }
            }
            """,
            """
            using System;
 
            class C
            {
                public void M1()
                {
                    (int x, (int y, int z)) = Method();
                }
 
                private (int x, (int y, int z)) Method()
                {
                    throw new NotImplementedException();
                }
            }
            """,
            parseOptions: TestOptions.Regular);
    }
 
    [Fact/*(Skip = "https://github.com/dotnet/roslyn/issues/15508")*/]
    [WorkItem("https://github.com/dotnet/roslyn/issues/14136")]
    public async Task TestDeconstruction3()
    {
        await TestAsync(
            """
            using System;
 
            class C
            {
                public void M1()
                {
                    (int x, (int, int)) = [|Method|]();
                }
            }
            """,
            """
            using System;
 
            class C
            {
                public void M1()
                {
                    (int x, (int, int)) = Method();
                }
 
                private object Method()
                {
                    throw new NotImplementedException();
                }
            }
            """,
            parseOptions: TestOptions.Regular);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/14136")]
    public async Task TestDeconstruction4()
    {
        await TestAsync(
            """
            using System;
 
            class C
            {
                public void M1()
                {
                    (int x, int) = [|Method|]();
                }
            }
            """,
            """
            using System;
 
            class C
            {
                public void M1()
                {
                    (int x, int) = Method();
                }
 
                private object Method()
                {
                    throw new NotImplementedException();
                }
            }
            """,
            parseOptions: TestOptions.Regular);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/15315")]
    public async Task TestInferBooleanTypeBasedOnName1()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                void Method(int i)
                {
                    var v = [|IsPrime|](i);
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method(int i)
                {
                    var v = IsPrime(i);
                }
 
                private bool IsPrime(int i)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/15315")]
    public async Task TestInferBooleanTypeBasedOnName2()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                void Method(int i)
                {
                    var v = [|Issue|](i);
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method(int i)
                {
                    var v = Issue(i);
                }
 
                private object Issue(int i)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/16398")]
    public async Task TestReturnsByRef()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class C 
            {
                public void Goo()
                {
                    ref int i = ref [|Bar|]();
                }
            }
            """,
            """
            using System;
 
            class C 
            {
                public void Goo()
                {
                    ref int i = ref Bar();
                }
 
                private ref int Bar()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/18969")]
    public async Task TestTupleElement1()
    {
        await TestAsync(
            """
            using System;
 
            class C
            {
                public void M1()
                {
                    (int x, string y) t = ([|Method|](), null);
                }
            }
            """,
            """
            using System;
 
            class C
            {
                public void M1()
                {
                    (int x, string y) t = (Method(), null);
                }
 
                private int Method()
                {
                    throw new NotImplementedException();
                }
            }
            """,
            parseOptions: TestOptions.Regular);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/18969")]
    public async Task TestTupleElement2()
    {
        await TestAsync(
            """
            using System;
 
            class C
            {
                public void M1()
                {
                    (int x, string y) t = (0, [|Method|]());
                }
            }
            """,
            """
            using System;
 
            class C
            {
                public void M1()
                {
                    (int x, string y) t = (0, Method());
                }
 
                private string Method()
                {
                    throw new NotImplementedException();
                }
            }
            """,
            parseOptions: TestOptions.Regular);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/25305")]
    public async Task TestTupleAssignment()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class C
            {
                void Main()
                {
                    int x, y;
                    (x, y) = [|Foo()|];
                }
            }
            """,
            """
            using System;
 
            class C
            {
                void Main()
                {
                    int x, y;
                    (x, y) = Foo();
                }
 
                private (int x, int y) Foo()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/25305")]
    public async Task TestTupleAssignment2()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class C
            {
                void Main()
                {
                    (x, y) = [|Foo()|];
                }
            }
            """,
            """
            using System;
 
            class C
            {
                void Main()
                {
                    (x, y) = Foo();
                }
 
                private (object x, object y) Foo()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/16975")]
    public async Task TestWithSameMethodNameAsTypeName1()
    {
        await TestAsync(
            """
            using System;
 
            class C
            {
                public void M1()
                {
                    [|Goo|]();
                }
            }
 
            class Goo { }
            """,
            """
            using System;
 
            class C
            {
                public void M1()
                {
                    Goo();
                }
 
                private void Goo()
                {
                    throw new NotImplementedException();
                }
            }
 
            class Goo { }
            """,
            parseOptions: TestOptions.Regular);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/16975")]
    public async Task TestWithSameMethodNameAsTypeName2()
    {
        await TestAsync(
            """
            using System;
 
            class C
            {
                public void M1()
                {
                    [|Goo|]();
                }
            }
 
            interface Goo { }
            """,
            """
            using System;
 
            class C
            {
                public void M1()
                {
                    Goo();
                }
 
                private void Goo()
                {
                    throw new NotImplementedException();
                }
            }
 
            interface Goo { }
            """,
            parseOptions: TestOptions.Regular);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/16975")]
    public async Task TestWithSameMethodNameAsTypeName3()
    {
        await TestAsync(
            """
            using System;
 
            class C
            {
                public void M1()
                {
                    [|Goo|]();
                }
            }
 
            struct Goo { }
            """,
            """
            using System;
 
            class C
            {
                public void M1()
                {
                    Goo();
                }
 
                private void Goo()
                {
                    throw new NotImplementedException();
                }
            }
 
            struct Goo { }
            """,
            parseOptions: TestOptions.Regular);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/16975")]
    public async Task TestWithSameMethodNameAsTypeName4()
    {
        await TestAsync(
            """
            using System;
 
            class C
            {
                public void M1()
                {
                    [|Goo|]();
                }
            }
 
            delegate void Goo()
            """,
            """
            using System;
 
            class C
            {
                public void M1()
                {
                    Goo();
                }
 
                private void Goo()
                {
                    throw new NotImplementedException();
                }
            }
 
            delegate void Goo()
            """,
            parseOptions: TestOptions.Regular);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/16975")]
    public async Task TestWithSameMethodNameAsTypeName5()
    {
        await TestAsync(
            """
            using System;
 
            class C
            {
                public void M1()
                {
                    [|Goo|]();
                }
            }
 
            namespace Goo { }
            """,
            """
            using System;
 
            class C
            {
                public void M1()
                {
                    Goo();
                }
 
                private void Goo()
                {
                    throw new NotImplementedException();
                }
            }
 
            namespace Goo { }
            """,
            parseOptions: TestOptions.Regular);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/16975")]
    public async Task TestWithSameMethodNameAsTypeName6()
    {
        await TestAsync(
            """
            using System;
 
            class C
            {
                public void M1()
                {
                    [|Goo|]();
                }
            }
 
            enum Goo { One }
            """,
            """
            using System;
 
            class C
            {
                public void M1()
                {
                    Goo();
                }
 
                private void Goo()
                {
                    throw new NotImplementedException();
                }
            }
 
            enum Goo { One }
            """,
            parseOptions: TestOptions.Regular);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/26957")]
    public async Task NotOnNonExistedMetadataMemberWhenInsideLambda()
    {
        await TestMissingInRegularAndScriptAsync(
            """
            using System;
 
            class Program
            {
                static void Test(Action<string> action)
                {
                }
 
                static void Main(string[] args)
                {
                    Test(arg =>
                    {
                        Console.WriteLine(arg.[|NotFound|]());
                    });
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/26993")]
    public async Task TestGenerateMethodInExpressionBodiedGetter()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                int Property
                {
                    get => [|GenerateMethod|]();
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                int Property
                {
                    get => GenerateMethod();
                }
 
                private int GenerateMethod()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/26993")]
    public async Task TestGenerateMethodInExpressionBodiedSetter()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                int Property
                {
                    set => [|GenerateMethod|](value);
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                int Property
                {
                    set => GenerateMethod(value);
                }
 
                private void GenerateMethod(int value)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/26993")]
    public async Task TestGenerateMethodInExpressionBodiedLocalFunction()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                void Method()
                {
                    int Local() => [|GenerateMethod()|];
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method()
                {
                    int Local() => GenerateMethod();
                }
 
                private int GenerateMethod()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/27647")]
    public async Task TestGenerateMethodInExpressionBodiedAsyncTaskOfTLocalFunction()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                void Method()
                {
                    async System.Threading.Tasks.Task<int> Local() => [|GenerateMethod()|];
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method()
                {
                    async System.Threading.Tasks.Task<int> Local() => GenerateMethod();
                }
 
                private int GenerateMethod()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/27647")]
    public async Task TestGenerateMethodInExpressionBodiedAsyncTaskLocalFunction()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                void Method()
                {
                    async System.Threading.Tasks.Task Local() => [|GenerateMethod()|];
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method()
                {
                    async System.Threading.Tasks.Task Local() => GenerateMethod();
                }
 
                private void GenerateMethod()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestGenerateMethodInExpressionBodiedAsyncVoidLocalFunction()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                void Method()
                {
                    async void Local() => [|GenerateMethod()|];
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method()
                {
                    async void Local() => GenerateMethod();
                }
 
                private void GenerateMethod()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/26993")]
    public async Task TestGenerateMethodInBlockBodiedLocalFunction()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                void Method()
                {
                    int Local()
                    {
                        return [|GenerateMethod()|];
                    }
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method()
                {
                    int Local()
                    {
                        return GenerateMethod();
                    }
                }
 
                private int GenerateMethod()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestGenerateMethodInBlockBodiedAsyncTaskOfTLocalFunction()
    {
        await TestInRegularAndScriptAsync(
            """
            class Class
            {
                void Method()
                {
                    async System.Threading.Tasks.Task<int> Local()
                    {
                        return [|GenerateMethod()|];
                    }
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method()
                {
                    async System.Threading.Tasks.Task<int> Local()
                    {
                        return GenerateMethod();
                    }
                }
 
                private int GenerateMethod()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/26993")]
    public async Task TestGenerateMethodInBlockBodiedLocalFunctionInsideLambdaExpression()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class Class
            {
                void Method()
                {
                    Action action = () =>  
                    {
                        int Local()
                        {
                            return [|GenerateMethod()|];
                        }
                    }
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method()
                {
                    Action action = () =>  
                    {
                        int Local()
                        {
                            return GenerateMethod();
                        }
                    }
                }
 
                private int GenerateMethod()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/26993")]
    public async Task TestGenerateMethodInExpressionBodiedLocalFunctionInsideLambdaExpression()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class Class
            {
                void Method()
                {
                    Action action = () =>  
                    {
                        int Local() => [|GenerateMethod()|];
                    }
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method()
                {
                    Action action = () =>  
                    {
                        int Local() => GenerateMethod();
                    }
                }
 
                private int GenerateMethod()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/24138")]
    public async Task TestInCaseWhenClause()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class Class
            {
                void M(object goo)
                {
                    switch (goo)
                    {
                        case int i when [|GreaterThanZero(i)|]:
                            break;
                    }
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void M(object goo)
                {
                    switch (goo)
                    {
                        case int i when GreaterThanZero(i):
                            break;
                    }
                }
 
                private bool GreaterThanZero(int i)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestWithFunctionPointerArgument()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class Class
            {
                unsafe void M()
                {
                    delegate*<int, float> y;
                    [|M2(y)|];
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                unsafe void M()
                {
                    delegate*<int, float> y;
                    [|M2(y)|];
                }
 
                private unsafe void M2(delegate*<int, float> y)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestWithFunctionPointerUnmanagedConvention()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class Class
            {
                unsafe void M()
                {
                    delegate* unmanaged<int, float> y;
                    [|M2(y)|];
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                unsafe void M()
                {
                    delegate* unmanaged<int, float> y;
                    [|M2(y)|];
                }
 
                private unsafe void M2(delegate* unmanaged<int, float> y)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Theory]
    [InlineData("Cdecl")]
    [InlineData("Fastcall")]
    [InlineData("Thiscall")]
    [InlineData("Stdcall")]
    [InlineData("Thiscall, Stdcall")]
    [InlineData("Bad")] // Bad conventions should still be generatable
    public async Task TestWithFunctionPointerUnmanagedSpecificConvention(string convention)
    {
        await TestInRegularAndScriptAsync(
            $$"""
            using System;
 
            class Class
            {
                unsafe void M()
                {
                    delegate* unmanaged[{{convention}}]<int, float> y;
                    [|M2(y)|];
                }
            }
            """,
            $$"""
            using System;
 
            class Class
            {
                unsafe void M()
                {
                    delegate* unmanaged[{{convention}}]<int, float> y;
                    [|M2(y)|];
                }
 
                private unsafe void M2(delegate* unmanaged[{{convention}}]<int, float> y)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestWithFunctionPointerUnmanagedMissingConvention()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class Class
            {
                unsafe void M()
                {
                    delegate* unmanaged[]<int, float> y;
                    [|M2(y)|];
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                unsafe void M()
                {
                    delegate* unmanaged[]<int, float> y;
                    [|M2(y)|];
                }
 
                private unsafe void M2(delegate* unmanaged<int, float> y)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestNegativeIfGeneratingInDocumentFromSourceGenerator()
    {
        await TestMissingAsync(
            """
             <Workspace>
                                <Project Language="C#" AssemblyName="ClassLibrary1" CommonReferences="true">
                                    <Document>
            public class C
            {
                public void M()
                {
                    GeneratedClass.Me$$thod();
                }
            }
                                    </Document>
                                    <DocumentFromSourceGenerator>
            public class GeneratedClass
            {
            }
                                    </DocumentFromSourceGenerator>
                                </Project>
                            </Workspace>
            """);
    }
 
    [Fact]
    public async Task TestIfGeneratingInPartialClassWithFileFromSourceGenerator()
    {
        await TestInRegularAndScriptAsync(
            """
             <Workspace>
                                <Project Language="C#" AssemblyName="ClassLibrary1" CommonReferences="true">
                                    <Document>
            public class C
            {
                public void M()
                {
                    ClassWithGeneratedPartial.Me$$thod();
                }
            }
                                    </Document>
            <Document>
            // regular file
            public partial class ClassWithGeneratedPartial
            {
            }
            </Document>
            <DocumentFromSourceGenerator>
            // generated file
            public partial class ClassWithGeneratedPartial
            {
            }
            </DocumentFromSourceGenerator>
                                </Project>
                            </Workspace>
            """, """
 
            // regular file
            using System;
 
            public partial class ClassWithGeneratedPartial
            {
                internal static void Method()
                {
                    throw new NotImplementedException();
                }
            }
 
            """);
    }
 
    [Fact]
    public async Task TestInSwitchExpression1()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class Class
            {
                string Method(int i)
                {
                    return i switch
                    {
                        0 => [|Goo|](),
                    };
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                string Method(int i)
                {
                    return i switch
                    {
                        0 => Goo(),
                    };
                }
 
                private string Goo()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact]
    public async Task TestInSwitchExpression2()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class Class
            {
                void Method(int i)
                {
                    var v = i switch
                    {
                        0 => "",
                        1 => [|Goo|](),
                    };
                }
            }
            """,
            """
            using System;
 
            class Class
            {
                void Method(int i)
                {
                    var v = i switch
                    {
                        0 => "",
                        1 => Goo(),
                    };
                }
 
                private string Goo()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/63883")]
    public async Task TestNullableCoalesce()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class Example
            {
                int? A() => [|B()|] ?? C();
 
                int? C() => null;
            }
            """,
            """
            using System;
 
            class Example
            {
                int? A() => [|B()|] ?? C();
 
                private int? B()
                {
                    throw new NotImplementedException();
                }
 
                int? C() => null;
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/28996")]
    public async Task TestPreferOverloadWithMatchingParameterCount()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            abstract class Barry
            {
                public void Method()
                {
                    Goo([|Baz|], null);
                }
 
                protected abstract void Goo(Action action);
                protected abstract void Goo(Action<object> action, object arg);
            }
            """,
            """
            using System;
 
            abstract class Barry
            {
                public void Method()
                {
                    Goo([|Baz|], null);
                }
 
                private void Baz(object obj)
                {
                    throw new NotImplementedException();
                }
 
                protected abstract void Goo(Action action);
                protected abstract void Goo(Action<object> action, object arg);
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/44861")]
    public async Task GenerateBasedOnFutureUsage1()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class C
            {
                int M()
                {
                    var v = [|NewExpr()|];
                    return v;
                }
            }
            """,
            """
            using System;
 
            class C
            {
                int M()
                {
                    var v = [|NewExpr()|];
                    return v;
                }
 
                private int NewExpr()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/44861")]
    public async Task GenerateBasedOnFutureUsage2()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class C
            {
                int M()
                {
                    var v = [|NewExpr()|];
                    if (v)
                    {
                    }
                }
            }
            """,
            """
            using System;
 
            class C
            {
                int M()
                {
                    var v = [|NewExpr()|];
                    if (v)
                    {
                    }
                }
 
                private bool NewExpr()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/44861")]
    public async Task GenerateBasedOnFutureUsage3()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class C
            {
                int M()
                {
                    var v = [|NewExpr()|];
                    var x = v;
                    return x;
                }
            }
            """,
            """
            using System;
 
            class C
            {
                int M()
                {
                    var v = [|NewExpr()|];
                    var x = v;
                    return x;
                }
 
                private int NewExpr()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/44861")]
    public async Task GenerateBasedOnFutureUsage4()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class C
            {
                int M()
                {
                    var (x, y) = [|NewExpr()|];
                    Goo(x, y);
                }
 
                void Goo(string x, int y) { }
            }
            """,
            """
            using System;
 
            class C
            {
                int M()
                {
                    var (x, y) = [|NewExpr()|];
                    Goo(x, y);
                }
 
                private (string x, int y) NewExpr()
                {
                    throw new NotImplementedException();
                }
 
                void Goo(string x, int y) { }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/12708")]
    public async Task GenerateEventHookupWithExistingMethod()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
            using System.Collections.Specialized;
 
            class Program
            {
                void Main(string[] args)
                {
                    INotifyCollectionChanged collection = null;
                    collection.CollectionChanged += [|OnChanged|];
                }
 
                private void OnChanged() { }
            }
            """,
            """
            using System;
            using System.Collections.Specialized;
 
            class Program
            {
                void Main(string[] args)
                {
                    INotifyCollectionChanged collection = null;
                    collection.CollectionChanged += OnChanged;
                }
 
                private void OnChanged(object sender, NotifyCollectionChangedEventArgs e)
                {
                    throw new NotImplementedException();
                }
 
                private void OnChanged() { }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/29761")]
    public async Task GenerateAlternativeNamesForFuncActionDelegates1()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class Program
            {
                void M()
                {
                    RegisterOperationAction([|Analyze|]);
                }
 
                private void RegisterOperationAction(Action<Context> analyze)
                {
                }
            }
 
            class Context
            {
            }
            """,
            """
            using System;
 
            class Program
            {
                void M()
                {
                    RegisterOperationAction(Analyze);
                }
 
                private void Analyze(Context context)
                {
                    throw new NotImplementedException();
                }
 
                private void RegisterOperationAction(Action<Context> analyze)
                {
                }
            }
 
            class Context
            {
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/29761")]
    public async Task GenerateAlternativeNamesForFuncActionDelegates2()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class Program
            {
                void M()
                {
                    RegisterOperationAction([|Analyze|]);
                }
 
                private void RegisterOperationAction(Action<Context, Context> analyze)
                {
                }
            }
 
            class Context
            {
            }
            """,
            """
            using System;
 
            class Program
            {
                void M()
                {
                    RegisterOperationAction(Analyze);
                }
 
                private void Analyze(Context context1, Context context2)
                {
                    throw new NotImplementedException();
                }
 
                private void RegisterOperationAction(Action<Context, Context> analyze)
                {
                }
            }
 
            class Context
            {
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/37825")]
    public async Task InferTypeFromNextSwitchArm1()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class E
            {
                void M(string s)
                {
                    var v = s switch
                    {
                        "" => [|Goo()|],
                        "a" => Bar(),
                    };
                }
 
                private int Bar()
                {
                    throw new NotImplementedException();
                }
            }
            """,
            """
            using System;
 
            class E
            {
                void M(string s)
                {
                    var v = s switch
                    {
                        "" => Goo(),
                        "a" => Bar(),
                    };
                }
 
                private int Goo()
                {
                    throw new NotImplementedException();
                }
 
                private int Bar()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/37825")]
    public async Task InferTypeFromNextSwitchArm2()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class E
            {
                void M(string s)
                {
                    var v = s switch
                    {
                        "" => [|Goo()|],
                        "a" => Bar(),
                    };
                }
            }
            """,
            """
            using System;
 
            class E
            {
                void M(string s)
                {
                    var v = s switch
                    {
                        "" => Goo(),
                        "a" => Bar(),
                    };
                }
 
                private object Goo()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/37825")]
    public async Task InferTypeFromNextSwitchArm3()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class E
            {
                void M(string s)
                {
                    var v = s switch
                    {
                        "" => Goo(),
                        "a" => [|Bar()|],
                    };
                }
            }
            """,
            """
            using System;
 
            class E
            {
                void M(string s)
                {
                    var v = s switch
                    {
                        "" => Goo(),
                        "a" => Bar(),
                    };
                }
 
                private object Bar()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/50764")]
    public async Task InferMethodFromAddressOf1()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            public unsafe class Bar
            {
                public static ZZZ()
                {
                     int* i = &[|Goo|]();
                }
            }
            """,
            """
            using System;
 
            public unsafe class Bar
            {
                public static ZZZ()
                {
                     int* i = &Goo();
                }
 
                private static int Goo()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/50764")]
    public async Task InferMethodFromAddressOf2()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            public unsafe class Bar
            {
                public static ZZZ()
                {
                     delegate*<void> i = &[|Goo|];
                }
            }
            """,
            """
            using System;
 
            public unsafe class Bar
            {
                public static ZZZ()
                {
                     delegate*<void> i = &Goo;
                }
 
                private static void Goo()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/50764")]
    public async Task InferMethodFromAddressOf3()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            public unsafe class Bar
            {
                public static ZZZ()
                {
                     delegate*<int, bool> i = &[|Goo|];
                }
            }
            """,
            """
            using System;
 
            public unsafe class Bar
            {
                public static ZZZ()
                {
                     delegate*<int, bool> i = &Goo;
                }
 
                private static bool Goo(int arg)
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/70565")]
    public async Task GenerateInsideStaticLambda1()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class C
            {
                void M()
                {
                    var v = static () =>
                    {
                        [|Goo|]();
                    };
                }
            }
            """,
            """
            using System;
 
            class C
            {
                void M()
                {
                    var v = static () =>
                    {
                        Goo();
                    };
                }
 
                private static void Goo()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/70565")]
    public async Task GenerateInsideStaticLocalFunction1()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class C
            {
                void M()
                {
                    static void X()
                    {
                        [|Goo|]();
                    };
                }
            }
            """,
            """
            using System;
 
            class C
            {
                void M()
                {
                    static void X()
                    {
                        Goo();
                    };
                }
 
                private static void Goo()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/71980")]
    public async Task AssignToTuple1()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class C
            {
                int M()
                {
                    var (x, y, ) = [|NewExpr()|];
                }
            }
            """,
            """
            using System;
            
            class C
            {
                int M()
                {
                    var (x, y, ) = NewExpr();
                }
            
                private object NewExpr()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/71980")]
    public async Task AssignToTuple2()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class C
            {
                int M()
                {
                    var (x, y, , z) = [|NewExpr()|];
                }
            }
            """,
            """
            using System;
            
            class C
            {
                int M()
                {
                    var (x, y, , z) = NewExpr();
                }
            
                private object NewExpr()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/71980")]
    public async Task AssignToTuple3()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class C
            {
                int M()
                {
                    var (x, y, 0) = [|NewExpr()|];
                }
            }
            """,
            """
            using System;
            
            class C
            {
                int M()
                {
                    var (x, y, 0) = NewExpr();
                }
            
                private object NewExpr()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/71980")]
    public async Task AssignToTuple4()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class C
            {
                int M()
                {
                    var (x, y, (z, w)) = [|NewExpr()|];
                }
            }
            """,
            """
            using System;
            
            class C
            {
                int M()
                {
                    var (x, y, (z, w)) = NewExpr();
                }
            
                private (object x, object y, (object z, object w)) NewExpr()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/71980")]
    public async Task AssignToTuple5()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class C
            {
                int M()
                {
                    var (x, y, (z, w, )) = [|NewExpr()|];
                }
            }
            """,
            """
            using System;
            
            class C
            {
                int M()
                {
                    var (x, y, (z, w, )) = NewExpr();
                }
            
                private object NewExpr()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/71980")]
    public async Task AssignToTuple6()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class C
            {
                int M()
                {
                    var (x, y, (z, w), ) = [|NewExpr()|];
                }
            }
            """,
            """
            using System;
            
            class C
            {
                int M()
                {
                    var (x, y, (z, w), ) = NewExpr();
                }
            
                private object NewExpr()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/71980")]
    public async Task AssignToTuple7()
    {
        await TestMissingInRegularAndScriptAsync(
            """
            using System;
            using System.Threading.Tasks;
 
            class C
            {
                async Task<int> M()
                {
                    var ([|NewExpr|]) = await G();
                }
 
                Task<(int, string)> G() => default;
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/71980")]
    public async Task AssignToTuple8()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class C
            {
                int M()
                {
                    var (x) = [|NewExpr()|];
                }
            }
            """,
            """
            using System;
            
            class C
            {
                int M()
                {
                    var (x) = NewExpr();
                }
            
                private (object x, object) NewExpr()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/70803")]
    public async Task GenerateInPrimaryConstructorBaseList()
    {
        await TestInRegularAndScriptAsync(
            """
            using System;
 
            class Base(int Alice);
            class Derived(int Other) : Base([|NewExpr()|])
            {
            }
            """,
            """
            using System;
 
            class Base(int Alice);
            class Derived(int Other) : Base(NewExpr())
            {
                private static int NewExpr()
                {
                    throw new NotImplementedException();
                }
            }
            """);
    }
}