F1HelpTests.cs

// 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.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.Test.Utilities;
using Microsoft.VisualStudio.LanguageServices.CSharp.LanguageService;
using Microsoft.VisualStudio.LanguageServices.Implementation.F1Help;
using Microsoft.VisualStudio.LanguageServices.UnitTests;
using Roslyn.Test.Utilities;
using Roslyn.Utilities;
using Xunit;
 
namespace Microsoft.VisualStudio.LanguageServices.CSharp.UnitTests.F1Help;
 
[UseExportProvider]
[Trait(Traits.Feature, Traits.Features.F1Help)]
public sealed class F1HelpTests
{
    private static async Task TestAsync([StringSyntax(PredefinedEmbeddedLanguageNames.CSharpTest)] string markup, string expectedText)
    {
        using var workspace = TestWorkspace.CreateCSharp(markup, composition: VisualStudioTestCompositions.LanguageServices);
        var caret = workspace.Documents.First().CursorPosition;
 
        var service = Assert.IsType<CSharpHelpContextService>(workspace.Services.GetLanguageServices(LanguageNames.CSharp).GetService<IHelpContextService>());
        var actualText = await service.GetHelpTermAsync(workspace.CurrentSolution.Projects.First().Documents.First(), workspace.Documents.First().SelectedSpans.First(), CancellationToken.None);
        Assert.Equal(expectedText, actualText);
    }
 
    private static async Task Test_KeywordAsync([StringSyntax(PredefinedEmbeddedLanguageNames.CSharpTest)] string markup, string expectedText)
    {
        await TestAsync(markup, expectedText + "_CSharpKeyword");
    }
 
    [Fact]
    public async Task TestInternal()
    {
        await Test_KeywordAsync(
            """
            intern[||]al class C
            {
            }
            """, "internal");
    }
 
    [Fact]
    public async Task TestProtected()
    {
        await Test_KeywordAsync(
            """
            public class C
            {
                protec[||]ted void goo();
            }
            """, "protected");
    }
 
    [Fact]
    public async Task TestProtectedInternal1()
    {
        await Test_KeywordAsync(
            """
            public class C
            {
                internal protec[||]ted void goo();
            }
            """, "protectedinternal");
    }
 
    [Fact]
    public async Task TestProtectedInternal2()
    {
        await Test_KeywordAsync(
            """
            public class C
            {
                protec[||]ted internal void goo();
            }
            """, "protectedinternal");
    }
 
    [Fact]
    public async Task TestPrivateProtected1()
    {
        await Test_KeywordAsync(
            """
            public class C
            {
                private protec[||]ted void goo();
            }
            """, "privateprotected");
    }
 
    [Fact]
    public async Task TestPrivateProtected2()
    {
        await Test_KeywordAsync(
            """
            public class C
            {
                priv[||]ate protected void goo();
            }
            """, "privateprotected");
    }
 
    [Fact]
    public async Task TestPrivateProtected3()
    {
        await Test_KeywordAsync(
            """
            public class C
            {
                protected priv[||]ate void goo();
            }
            """, "privateprotected");
    }
 
    [Fact]
    public async Task TestPrivateProtected4()
    {
        await Test_KeywordAsync(
            """
            public class C
            {
                prot[||]ected private void goo();
            }
            """, "privateprotected");
    }
 
    [Fact]
    public async Task TestModifierSoup()
    {
        await Test_KeywordAsync(
"""
public class C
{
    private new prot[||]ected static unsafe void foo()
    {
    }
}
""", "privateprotected");
    }
 
    [Fact]
    public async Task TestModifierSoupField()
    {
        await Test_KeywordAsync(
"""
public class C
{
    new prot[||]ected static unsafe private goo;
}
""", "privateprotected");
    }
 
    [Fact]
    public async Task TestVoid()
    {
        await Test_KeywordAsync(
            """
            class C
            {
                vo[||]id goo()
                {
                }
            }
            """, "void");
    }
 
    [Fact]
    public async Task TestReturn()
    {
        await Test_KeywordAsync(
            """
            class C
            {
                void goo()
                {
                    ret[||]urn;
                }
            }
            """, "return");
    }
 
    [Fact]
    public async Task TestClassPartialType()
    {
        await Test_KeywordAsync(
            """
            part[||]ial class C
            {
                partial void goo();
            }
            """, "partialtype");
    }
 
    [Fact]
    public async Task TestRecordPartialType()
    {
        await Test_KeywordAsync(
            """
            part[||]ial record C
            {
                partial void goo();
            }
            """, "partialtype");
    }
 
    [Fact]
    public async Task TestRecordWithPrimaryConstructorPartialType()
    {
        await Test_KeywordAsync(
            """
            part[||]ial record C(string S)
            {
                partial void goo();
            }
            """, "partialtype");
    }
 
    [Fact]
    public async Task TestPartialMethodInClass()
    {
        await Test_KeywordAsync(
            """
            partial class C
            {
                par[||]tial void goo();
            }
            """, "partialmethod");
    }
 
    [Fact]
    public async Task TestPartialMethodInRecord()
    {
        await Test_KeywordAsync(
            """
            partial record C
            {
                par[||]tial void goo();
            }
            """, "partialmethod");
    }
 
    [Fact]
    public async Task TestExtendedPartialMethod()
    {
        await Test_KeywordAsync(
            """
            partial class C
            {
                public par[||]tial void goo();
            }
            """, "partialmethod");
    }
 
    [Fact]
    public async Task TestWhereClause()
    {
        await Test_KeywordAsync(
            """
            using System.Linq;
 
            class Program<T> where T : class
            {
                void goo(string[] args)
                {
                    var x = from a in args
                            whe[||]re a.Length > 0
                            select a;
                }
            }
            """, "whereclause");
    }
 
    [Fact]
    public async Task TestWhereConstraint()
    {
        await Test_KeywordAsync(
            """
            using System.Linq;
 
            class Program<T> wh[||]ere T : class
            {
                void goo(string[] args)
                {
                    var x = from a in args
                            where a.Length > 0
                            select a;
                }
            }
            """, "whereconstraint");
    }
 
    [Fact]
    public async Task TestPreprocessor()
    {
        await TestAsync(
            """
            #regi[||]on
            #endregion
            """, "#region");
    }
 
    [Fact]
    public async Task TestPreprocessor2()
    {
        await TestAsync(
            """
            #region[||]
            #endregion
            """, "#region");
    }
 
    [Fact]
    public async Task TestConstructor()
    {
        await TestAsync(
            """
            namespace N
            {
                class C
                {
                    void goo()
                    {
                        var x = new [|C|]();
                    }
                }
            }
            """, "N.C.#ctor");
    }
 
    [Fact]
    public async Task TestGenericClass()
    {
        await TestAsync(
            """
            namespace N
            {
                class C<T>
                {
                    void goo()
                    {
                        [|C|]<int> c;
                    }
                }
            }
            """, "N.C`1");
    }
 
    [Fact]
    public async Task TestGenericMethod()
    {
        await TestAsync(
            """
            namespace N
            {
                class C<T>
                {
                    void goo<T, U, V>(T t, U u, V v)
                    {
                        C<int> c;
                        c.g[|oo|](1, 1, 1);
                    }
                }
            }
            """, "N.C`1.goo``3");
    }
 
    [Theory]
    [InlineData("+")]
    [InlineData("-")]
    [InlineData("&")]
    [InlineData("|")]
    [InlineData("/")]
    [InlineData("^")]
    [InlineData(">")]
    [InlineData(">=")]
    [InlineData("!=")]
    [InlineData("<")]
    [InlineData("<=")]
    [InlineData("<<")]
    [InlineData(">>")]
    [InlineData(">>>")]
    [InlineData("*")]
    [InlineData("%")]
    [InlineData("&&")]
    [InlineData("||")]
    [InlineData("==")]
    public async Task TestBinaryOperator(string operatorText)
    {
        await TestAsync(
            $$"""
            namespace N
            {
                class C
                {
                    void goo()
                    {
                        var two = 1 [|{{operatorText}}|] 1;
                    }
                }
            }
            """, $"{operatorText}_CSharpKeyword");
    }
 
    [Theory]
    [InlineData("+=")]
    [InlineData("-=")]
    [InlineData("/=")]
    [InlineData("*=")]
    [InlineData("%=")]
    [InlineData("&=")]
    [InlineData("|=")]
    [InlineData("^=")]
    [InlineData("<<=")]
    [InlineData(">>=")]
    [InlineData(">>>=")]
    public async Task TestCompoundOperator(string operatorText)
    {
        await TestAsync(
            $$"""
            namespace N
            {
                class C
                {
                    void goo(int x)
                    {
                        x [|{{operatorText}}|] x;
                    }
                }
            }
            """, $"{operatorText}_CSharpKeyword");
    }
 
    [Theory]
    [InlineData("++")]
    [InlineData("--")]
    [InlineData("!")]
    [InlineData("~")]
    public async Task TestPrefixOperator(string operatorText)
    {
        await TestAsync(
            $$"""
            namespace N
            {
                class C
                {
                    void goo(int x)
                    {
                        x = [|{{operatorText}}|]x;
                    }
                }
            }
            """, $"{operatorText}_CSharpKeyword");
    }
 
    [Theory]
    [InlineData("++")]
    [InlineData("--")]
    public async Task TestPostfixOperator(string operatorText)
    {
        await TestAsync(
            $$"""
            namespace N
            {
                class C
                {
                    void goo(int x)
                    {
                        x = x[|{{operatorText}}|];
                    }
                }
            }
            """, $"{operatorText}_CSharpKeyword");
    }
 
    [Fact]
    public async Task TestRelationalPattern()
    {
        await TestAsync(
            """
            namespace N
            {
                class C
                {
                    void goo(string x)
                    {
                        if (x is { Length: [||]> 5 }) { }
                    }
                }
            }
            """, ">_CSharpKeyword");
    }
 
    [Fact]
    public async Task TestGreaterThanInFunctionPointer()
    {
        await TestAsync("""
            unsafe class C
            {
                delegate*[||]<int> f;
            }
            """, "functionPointer_CSharpKeyword");
    }
 
    [Fact]
    public async Task TestLessThanInFunctionPointer()
    {
        await TestAsync("""
            unsafe class C
            {
                delegate*[||]<int> f;
            }
            """, "functionPointer_CSharpKeyword");
    }
 
    [Fact]
    public async Task TestEqualsOperatorInParameter()
    {
        await TestAsync(
            """
            namespace N
            {
                class C
                {
                    void goo(int x [|=|] 0)
                    {
                    }
                }
            }
            """, "optionalParameter_CSharpKeyword");
    }
 
    [Fact]
    public async Task TestEqualsOperatorInPropertyInitializer()
    {
        await TestAsync(
            """
            namespace N
            {
                class C
                {
                    int P { get; } [|=|] 5;
                }
            }
            """, "propertyInitializer_CSharpKeyword");
    }
 
    [Fact]
    public async Task TestVar()
    {
        await TestAsync(
            """
            using System;
            using System.Collections.Generic;
            using System.Linq;
            using System.Threading.Tasks;
 
            class Program
            {
                static void Main(string[] args)
                {
                    var[||] x = 3;
                }
            }
            """, "var_CSharpKeyword");
    }
 
    [Fact]
    public async Task TestEquals()
    {
        await TestAsync(
            """
            using System;
            using System.Collections.Generic;
            using System.Linq;
            using System.Threading.Tasks;
 
            class Program
            {
                static void Main(string[] args)
                {
                    var x =[||] 3;
                }
            }
            """, "=_CSharpKeyword");
    }
 
    [Fact]
    public async Task TestEqualsInEnum()
    {
        await TestAsync(
            """
            enum E
            {
                A [||]= 1
            }
            """, "enum_CSharpKeyword");
    }
 
    [Fact]
    public async Task TestEqualsInAttribute()
    {
        await TestAsync(
            """
            using System;
 
            [AttributeUsage(AttributeTargets.Class, Inherited [|=|] true)]
            class MyAttribute : Attribute
            {
            }
            """, "attributeNamedArgument_CSharpKeyword");
    }
 
    [Fact]
    public async Task TestEqualsInUsingAlias()
    {
        await TestAsync(
            """
            using SC [||]= System.Console;
            """, "using_CSharpKeyword");
    }
 
    [Fact]
    public async Task TestEqualsInAnonymousObjectMemberDeclarator()
    {
        await TestAsync(
            """
            class C
            {
                void M()
                {
                    var x = new { X [||]= 0 };
                }
            }
            """, "anonymousObject_CSharpKeyword");
    }
 
    [Fact]
    public async Task TestEqualsInDocumentationComment()
    {
        await TestAsync(
            """
            class C
            {
                /// <summary>
                /// <a b[||]="c" />
                /// </summary>
                void M()
                {
                    var x = new { X [||]= 0 };
                }
            }
            """, "see");
    }
 
    [Fact]
    public async Task TestEqualsInLet()
    {
        await TestAsync(
            """
            class C
            {
                void M()
                {
                    var y =
                        from x1 in x2
                        let x3 [||]= x4
                        select x5;
                }
            }
            """, "let_CSharpKeyword");
    }
 
    [Fact]
    public async Task TestLetKeyword()
    {
        await TestAsync(
            """
            class C
            {
                void M()
                {
                    var y =
                        from x1 in x2
                        [||]let x3 = x4
                        select x5;
                }
            }
            """, "let_CSharpKeyword");
    }
 
    [Fact]
    public async Task TestFromIn()
    {
        await TestAsync(
            """
            using System;
            using System.Collections.Generic;
            using System.Linq;
            using System.Threading.Tasks;
 
            class Program
            {
                static void Main(string[] args)
                {
                    var x = from n i[||]n {
                        1}
 
                    select n
                }
            }
            """, "from_CSharpKeyword");
    }
 
    [Fact]
    public async Task TestProperty()
    {
        await TestAsync(
            """
            using System;
            using System.Collections.Generic;
            using System.Linq;
            using System.Threading.Tasks;
 
            class Program
            {
                static void Main(string[] args)
                {
                    new UriBuilder().Fragm[||]ent;
                }
            }
            """, "System.UriBuilder.Fragment");
    }
 
    [Fact]
    public async Task TestForeachIn()
    {
        await TestAsync(
            """
            using System;
            using System.Collections.Generic;
            using System.Linq;
            using System.Threading.Tasks;
 
            class Program
            {
                static void Main(string[] args)
                {
                    foreach (var x in[||] {
                        1} )
                    {
                    }
                }
            }
            """, "in_CSharpKeyword");
    }
 
    [Fact]
    public async Task TestRegionDescription()
    {
        await TestAsync(
            """
            class Program
            {
                static void Main(string[] args)
                {
                    #region Begin MyR[||]egion for testing
                    #endregion End
                }
            }
            """, "#region");
    }
 
    [Fact]
    public async Task TestGenericAngle_LessThanToken_TypeArgument()
    {
        await TestAsync(
            """
            class Program
            {
                static void generic<T>(T t)
                {
                    generic[||]<int>(0);
                }
            }
            """, "generics_CSharpKeyword");
    }
 
    [Fact]
    public async Task TestGenericAngle_GreaterThanToken_TypeArgument()
    {
        await TestAsync(
            """
            class Program
            {
                static void generic<T>(T t)
                {
                    generic<int[|>|](0);
                }
            }
            """, "generics_CSharpKeyword");
    }
 
    [Fact]
    public async Task TestGenericAngle_LessThanToken_TypeParameter()
    {
        await TestAsync(
            """
            class Program
            {
                static void generic[|<|]T>(T t)
                {
                    generic<int>(0);
                }
            }
            """, "generics_CSharpKeyword");
    }
 
    [Fact]
    public async Task TestGenericAngle_GreaterThanToken_TypeParameter()
    {
        await TestAsync(
            """
            class Program
            {
                static void generic<T[|>|](T t)
                {
                    generic<int>(0);
                }
            }
            """, "generics_CSharpKeyword");
    }
 
    [Fact]
    public async Task TestLocalReferenceIsType()
    {
        await TestAsync(
            """
            using System;
            using System.Collections.Generic;
            using System.Linq;
            using System.Threading.Tasks;
 
            class Program
            {
                static void Main(string[] args)
                {
                    int x;
                    x[||];
                }
            }
            """, "System.Int32");
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/864266")]
    public async Task TestConstantField()
    {
        await TestAsync(
            """
            class Program
            {
                static void Main(string[] args)
                {
                    var i = int.Ma[||]xValue;
                }
            }
            """, "System.Int32.MaxValue");
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/862420")]
    public async Task TestParameter()
    {
        await TestAsync(
            """
            class Class2
            {
                void M1(int par[||]ameter)  // 1
                {
                }
 
                void M2()
                {
                    int argument = 1;
                    M1(parameter: argument);   // 2
                }
            }
            """, "System.Int32");
    }
 
    [Fact]
    public async Task TestRefReadonlyParameter_Ref()
    {
        await TestAsync(
            """
            class C
            {
                void M(r[||]ef readonly int x)
                {
                }
            }
            """, "ref_CSharpKeyword");
    }
 
    [Fact]
    public async Task TestRefReadonlyParameter_ReadOnly()
    {
        await TestAsync(
            """
            class C
            {
                void M(ref read[||]only int x)
                {
                }
            }
            """, "readonly_CSharpKeyword");
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/862420")]
    public async Task TestArgumentType()
    {
        await TestAsync(
            """
            class Class2
            {
                void M1(int pa[||]rameter)  // 1
                {
                }
 
                void M2()
                {
                    int argument = 1;
                    M1(parameter: argument);   // 2
                }
            }
            """, "System.Int32");
    }
 
    [Fact]
    public async Task TestYieldReturn_OnYield()
    {
        await TestAsync("""
            using System.Collections.Generic;
 
            public class C
            {
                public IEnumerable<int> M()
                {
                    [|yield|] return 0;
                }
            }
            """, "yield_CSharpKeyword");
    }
 
    [Fact]
    public async Task TestYieldReturn_OnReturn()
    {
        await TestAsync("""
            using System.Collections.Generic;
 
            public class C
            {
                public IEnumerable<int> M()
                {
                    yield [|return|] 0;
                }
            }
            """, "yield_CSharpKeyword");
    }
 
    [Fact]
    public async Task TestYieldBreak_OnYield()
    {
        await TestAsync("""
            using System.Collections.Generic;
 
            public class C
            {
                public IEnumerable<int> M()
                {
                    [|yield|] break;
                }
            }
            """, "yield_CSharpKeyword");
    }
 
    [Fact]
    public async Task TestYieldBreak_OnBreak()
    {
        await TestAsync("""
            using System.Collections.Generic;
 
            public class C
            {
                public IEnumerable<int> M()
                {
                    yield [|break|] 0;
                }
            }
            """, "yield_CSharpKeyword");
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/862396")]
    public async Task TestNoToken()
    {
        await TestAsync(
            """
            class Program
            {
                static void Main(string[] args)
                {
                }
            }[||]
            """, "vs.texteditor");
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/862328")]
    public async Task TestLiteral()
    {
        await TestAsync(
            """
            class Program
            {
                static void Main(string[] args)
                {
                    Main(new string[] { "fo[||]o" });
                }
            }
            """, "System.String");
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/862478")]
    public async Task TestColonColon()
    {
        await TestAsync(
            """
            using System;
            using System.Collections.Generic;
            using System.Linq;
            using System.Threading.Tasks;
 
            class Program
            {
                static void Main(string[] args)
                {
                    global:[||]:System.Console.Write(");
                }
            }
            """, "::_CSharpKeyword");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/46986")]
    public async Task TestStringInterpolation()
    {
        await TestAsync(
            """
            using System;
 
            class Program
            {
                static void Main(string[] args)
                {
                    Console.WriteLine($[||]"Hello, {args[0]}");
                }
            }
            """, "$_CSharpKeyword");
    }
 
    [Fact]
    public async Task TestUtf8String()
    {
        await TestAsync(
            """
            using System;
 
            class Program
            {
                static void Main(string[] args)
                {
                    var x = "Hel[||]lo"u8;
                }
            }
            """, "Utf8StringLiteral_CSharpKeyword");
    }
 
    [Fact]
    public async Task TestRawString()
    {
        await TestAsync(
            """"
            using System;
 
            class Program
            {
                static void Main(string[] args)
                {
                    var x = """Hel[||]lo""";
                }
            }
            """", "RawStringLiteral_CSharpKeyword");
    }
 
    [Fact]
    public async Task TestUtf8RawString()
    {
        await TestAsync(
            """"
            using System;
 
            class Program
            {
                static void Main(string[] args)
                {
                    var x = """Hel[||]lo"""u8;
                }
            }
            """", "Utf8StringLiteral_CSharpKeyword");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/46986")]
    public async Task TestVerbatimString()
    {
        await TestAsync(
            """
            using System;
 
            class Program
            {
                static void Main(string[] args)
                {
                    Console.WriteLine(@[||]"Hello\");
                }
            }
            """, "@_CSharpKeyword");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/46986")]
    public async Task TestVerbatimInterpolatedString1()
    {
        await TestAsync(
            """
            using System;
 
            class Program
            {
                static void Main(string[] args)
                {
                    Console.WriteLine(@[||]$"Hello\ {args[0]}");
                }
            }
            """, "@$_CSharpKeyword");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/46986")]
    public async Task TestVerbatimInterpolatedString2()
    {
        await TestAsync(
            """
            using System;
 
            class Program
            {
                static void Main(string[] args)
                {
                    Console.WriteLine($[||]@"Hello\ {args[0]}");
                }
            }
            """, "@$_CSharpKeyword");
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/864658")]
    public async Task TestNullable()
    {
        await TestAsync(
            """
            using System;
            using System.Collections.Generic;
            using System.Linq;
            using System.Threading.Tasks;
 
            class Program
            {
                static void Main(string[] args)
                {
                    int?[||] a = int.MaxValue;
                    a.Value.GetHashCode();
                }
            }
            """, "System.Nullable`1");
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/863517")]
    public async Task TestAfterLastToken()
    {
        await TestAsync(
            """
            using System;
            using System.Collections.Generic;
            using System.Linq;
            using System.Threading.Tasks;
 
            class Program
            {
                static void Main(string[] args)
                {
                    foreach (char var in "!!!")$$[||]
                    {
                    }
                }
            }
            """, "vs.texteditor");
    }
 
    [Fact]
    public async Task TestConditional()
    {
        await TestAsync(
            """
            class Program
            {
                static void Main(string[] args)
                {
                    var x = true [|?|] true : false;
                }
            }
            """, "?_CSharpKeyword");
    }
 
    [Fact]
    public async Task TestLocalVar()
    {
        await TestAsync(
            """
            class C
            {
                void M()
                {
                    var a = 0;
                    int v[||]ar = 1;
                }
            }
            """, "System.Int32");
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/867574")]
    public async Task TestFatArrow()
    {
        await TestAsync(
            """
            class C
            {
                void M()
                {
                    var a = new System.Action(() =[||]> {
                    });
                }
            }
            """, "=>_CSharpKeyword");
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/867572")]
    public async Task TestSubscription()
    {
        await TestAsync(
            """
            class CCC
            {
                event System.Action e;
 
                void M()
                {
                    e +[||]= () => {
                    };
                }
            }
            """, "+=_CSharpKeyword");
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/867554")]
    public async Task TestComment()
    {
        await TestAsync(@"// some comm[||]ents here", "comments");
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/867529")]
    public async Task TestDynamic()
    {
        await TestAsync(
            """
            class C
            {
                void M()
                {
                    dyna[||]mic d = 0;
                }
            }
            """, "dynamic_CSharpKeyword");
    }
 
    [Fact]
    public async Task TestRangeVariable()
    {
        await TestAsync(
            """
            using System;
            using System.Collections.Generic;
            using System.Linq;
            using System.Threading.Tasks;
 
            class Program
            {
                static void Main(string[] args)
                {
                    var zzz = from y in args
                              select [||]y;
                }
            }
            """, "System.String");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/36001")]
    public async Task TestNameof()
    {
        await Test_KeywordAsync(
            """
            class C
            {
                void goo()
                {
                    var v = [||]nameof(goo);
                }
            }
            """, "nameof");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/46988")]
    public async Task TestNullForgiving()
    {
        await Test_KeywordAsync(
            """
            #nullable enable
            class C
            {
                int goo(string? x)
                {
                    return x[||]!.GetHashCode();
                }
            }
            """, "nullForgiving");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/46988")]
    public async Task TestLogicalNot()
    {
        await Test_KeywordAsync(
            """
            class C
            {
                bool goo(bool x)
                {
                    return [||]!x;
                }
            }
            """, "!");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/48392")]
    public async Task TestDefaultSwitchCase()
    {
        await Test_KeywordAsync(
            """
            class C
            {
                void M1(int parameter)
                {
                    switch(parameter) {
                        defa[||]ult:
                            parameter = default;
                            break;
                    }
                }
            }
            """, "defaultcase");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/48392")]
    public async Task TestDefaultLiteralExpressionInsideSwitch()
    {
        await Test_KeywordAsync(
            """
            class C
            {
                void M1(int parameter)
                {
                    switch(parameter) {
                        default:
                            parameter = defa[||]ult;
                            break;
                    }
                }
            }
            """, "default");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/48392")]
    public async Task TestDefaultExpressionInsideSwitch()
    {
        await Test_KeywordAsync(
            """
            class C
            {
                void M1(int parameter)
                {
                    switch(parameter) {
                        default:
                            parameter = defa[||]ult(int);
                            break;
                    }
                }
            }
            """, "default");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/48392")]
    public async Task TestDefaultLiteralExpression()
    {
        await Test_KeywordAsync(
            """
            class C
            {
                int field = defa[||]ult;
            }
            """, "default");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/48392")]
    public async Task TestDefaultExpression()
    {
        await Test_KeywordAsync(
            """
            class C
            {
                int field = defa[||]ult(int);
            }
            """, "default");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/48392")]
    public async Task TestDefaultLiteralExpressionInOptionalParameter()
    {
        await Test_KeywordAsync(
            """
            class C
            {
                void M1(int parameter = defa[||]ult) {
                }
            }
            """, "default");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/48392")]
    public async Task TestDefaultExpressionInOptionalParameter()
    {
        await Test_KeywordAsync(
            """
            class C
            {
                void M1(int parameter = defa[||]ult(int)) {
                }
            }
            """, "default");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/48392")]
    public async Task TestDefaultLiteralExpressionInMethodCall()
    {
        await Test_KeywordAsync(
            """
            class C
            {
                void M1() {
                    M2(defa[||]ult);
                }
            }
            """, "default");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/48392")]
    public async Task TestDefaultExpressionInMethodCall()
    {
        await Test_KeywordAsync(
            """
            class C
            {
                void M1() {
                    M2(defa[||]ult(int));
                }
            }
            """, "default");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/48392")]
    public async Task TestOuterClassDeclaration()
    {
        await Test_KeywordAsync(
            """
            cla[||]ss OuterClass<T> where T : class
            { 
                class InnerClass<T> where T : class { }
            }
            """, "class");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/48392")]
    public async Task TestInnerClassDeclaration()
    {
        await Test_KeywordAsync(
            """
            class OuterClass<T> where T : class
            { 
                cla[||]ss InnerClass<T> where T : class { }
            }
            """, "class");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/48392")]
    public async Task TestClassConstraintInOuterClass()
    {
        await Test_KeywordAsync(
            """
            class OuterClass<T> where T : cla[||]ss
            { 
                class InnerClass<T> where T : class { }
            }
            """, "classconstraint");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/48392")]
    public async Task TestClassConstraintInInnerClass()
    {
        await Test_KeywordAsync(
            """
            class OuterClass<T> where T : class
            { 
                class InnerClass<T> where T : cla[||]ss { }
            }
            """, "classconstraint");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/48392")]
    public async Task TestClassConstraintInGenericMethod()
    {
        await Test_KeywordAsync(
            """
            class C
            { 
                void M1<T>() where T : cla[||]ss { }
            }
            """, "classconstraint");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/48392")]
    public async Task TestClassConstraintInGenericDelegate()
    {
        await Test_KeywordAsync(
            """
            class C
            { 
                delegate T MyDelegate<T>() where T : cla[||]ss;
            }
            """, "classconstraint");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/48392")]
    public async Task TestOuterStructDeclaration()
    {
        await Test_KeywordAsync(
            """
            str[||]uct OuterStruct<T> where T : struct
            { 
                struct InnerStruct<T> where T : struct { }
            }
            """, "struct");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/48392")]
    public async Task TestInnerStructDeclaration()
    {
        await Test_KeywordAsync(
            """
            struct OuterStruct<T> where T : struct
            { 
                str[||]uct InnerStruct<T> where T : struct { }
            }
            """, "struct");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/48392")]
    public async Task TestStructConstraintInOuterStruct()
    {
        await Test_KeywordAsync(
            """
            struct OuterStruct<T> where T : str[||]uct
            { 
                struct InnerStruct<T> where T : struct { }
            }
            """, "structconstraint");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/48392")]
    public async Task TestStructConstraintInInnerStruct()
    {
        await Test_KeywordAsync(
            """
            struct OuterStruct<T> where T : struct
            { 
                struct InnerStruct<T> where T : str[||]uct { }
            }
            """, "structconstraint");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/48392")]
    public async Task TestStructConstraintInGenericMethod()
    {
        await Test_KeywordAsync(
            """
            struct C
            { 
                void M1<T>() where T : str[||]uct { }
            }
            """, "structconstraint");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/48392")]
    public async Task TestStructConstraintInGenericDelegate()
    {
        await Test_KeywordAsync(
            """
            struct C
            { 
                delegate T MyDelegate<T>() where T : str[||]uct;
            }
            """, "structconstraint");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/48392")]
    public async Task TestAllowsRefStructAntiConstraint()
    {
        await Test_KeywordAsync(
            """
            class C
            { 
                void M<T>()
                    where T : all[||]ows ref struct
                {
                }
            }
            """, "allows");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/48392")]
    public async Task TestUsingStaticOnUsingKeyword()
    {
        await Test_KeywordAsync(
            """
            us[||]ing static namespace.Class;
 
            static class C
            { 
                static int Field;
 
                static void Method() {}
            }
            """, "using-static");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/48392")]
    public async Task TestNormalUsingDirective()
    {
        await Test_KeywordAsync(
            """
            us[||]ing namespace.Class;
 
            static class C
            { 
                static int Field;
 
                static void Method() {}
            }
            """, "using");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/48392")]
    public async Task TestUsingStatement()
    {
        await Test_KeywordAsync(
            """
            using namespace.Class;
 
            class C
            { 
                void Method(String someString) {
                    us[||]ing (var reader = new StringReader(someString))
                    {
                    }
                }
            }
            """, "using-statement");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/48392")]
    public async Task TestUsingDeclaration()
    {
        await Test_KeywordAsync(
            """
            using namespace.Class;
 
            class C
            { 
                void Method(String someString) {
                    us[||]ing var reader = new StringReader(someString);
                }
            }
            """, "using-statement");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/48392")]
    public async Task TestUsingStaticOnStaticKeyword()
    {
        await Test_KeywordAsync(
            """
            using sta[||]tic namespace.Class;
 
            static class C
            { 
                static int Field;
 
                static void Method() {}
            }
            """, "using-static");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/48392")]
    public async Task TestStaticClass()
    {
        await Test_KeywordAsync(
            """
            using static namespace.Class;
 
            sta[||]tic class C
            { 
                static int Field;
 
                static void Method() {}
            }
            """, "static");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/48392")]
    public async Task TestStaticField()
    {
        await Test_KeywordAsync(
            """
            using static namespace.Class;
 
            static class C
            { 
                sta[||]tic int Field;
 
                static void Method() {}
            }
            """, "static");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/48392")]
    public async Task TestStaticMethod()
    {
        await Test_KeywordAsync(
            """
            using static namespace.Class;
 
            static class C
            { 
                static int Field;
 
                sta[||]tic void Method() {}
            }
            """, "static");
    }
 
    [Fact]
    public async Task TestWithKeyword()
    {
        await Test_KeywordAsync(
            """
            public record Point(int X, int Y);
 
            public static class Program
            { 
                public static void Main()
                {
                    var p1 = new Point(0, 0);
                    var p2 = p1 w[||]ith { X = 5 };
                }
            }
            """, "with");
    }
 
    [Fact]
    public async Task TestDiscard()
    {
        await Test_KeywordAsync(
            """
            class C
            {
                void M()
                {
                    [||]_ = Goo();
                }
 
                object Goo() => null;
            }
            """, "discard");
    }
 
    [Fact]
    public async Task TestChecked_01()
    {
        await Test_KeywordAsync(
            """
            public class C
            {
                void goo()
                {
                    chec[||]ked
                    {
                    }
                }
            }
            """, "checked");
    }
 
    [Fact]
    public async Task TestChecked_02()
    {
        await Test_KeywordAsync(
            """
            public class C
            {
                int goo()
                {
                    return chec[||]ked(0);
                }
            }
            """, "checked");
    }
 
    [Fact]
    public async Task TestChecked_03()
    {
        await Test_KeywordAsync(
            """
            public class C
            {
                C operator chec[||]ked -(C x) {}
            }
            """, "checked");
    }
 
    [Fact]
    public async Task TestChecked_04()
    {
        await Test_KeywordAsync(
            """
            public class C
            {
                C operator chec[||]ked +(C x, C y) {}
            }
            """, "checked");
    }
 
    [Fact]
    public async Task TestChecked_05()
    {
        await Test_KeywordAsync(
            """
            public class C
            {
                explicit operator chec[||]ked string(C x) {}
            }
            """, "checked");
    }
 
    [Fact]
    public async Task TestChecked_06()
    {
        await Test_KeywordAsync(
            """
            public class C
            {
                C I1.operator chec[||]ked -(C x) {}
            }
            """, "checked");
    }
 
    [Fact]
    public async Task TestChecked_07()
    {
        await Test_KeywordAsync(
            """
            public class C
            {
                C I1.operator chec[||]ked +(C x, C y) {}
            }
            """, "checked");
    }
 
    [Fact]
    public async Task TestChecked_08()
    {
        await Test_KeywordAsync(
            """
            public class C
            {
                explicit I1.operator chec[||]ked string(C x) {}
            }
            """, "checked");
    }
 
    [Fact]
    public async Task TestChecked_09()
    {
        await Test_KeywordAsync(
            """
            public class C
            {
                /// <summary>
                /// <see cref="operator chec[||]ked +(C, C)"/>
                /// </summary>
                void goo()
                {
                }
            }
            """, "checked");
    }
 
    [Fact]
    public async Task TestChecked_10()
    {
        await Test_KeywordAsync(
            """
            public class C
            {
                /// <summary>
                /// <see cref="operator chec[||]ked -(C)"/>
                /// </summary>
                void goo()
                {
                }
            }
            """, "checked");
    }
 
    [Fact]
    public async Task TestChecked_11()
    {
        await Test_KeywordAsync(
            """
            public class C
            {
                /// <summary>
                /// <see cref="explicit operator chec[||]ked string(C)"/>
                /// </summary>
                void goo()
                {
                }
            }
            """, "checked");
    }
 
    [Fact]
    public async Task TestRequired()
    {
        await Test_KeywordAsync("""
            public class C
            {
                re[||]quired int Field;
            }
            """, "required");
    }
 
    [Fact]
    public async Task TestDefaultConstraint()
    {
        await Test_KeywordAsync("""
            public class Base
            {
                virtual void M<T>(T? t) { }
            }
            public class C
            {
                override void M<T>() where T : def[||]ault { }
            }
            """, expectedText: "defaultconstraint");
    }
 
    [Fact]
    public async Task TestDefaultCase()
    {
        await Test_KeywordAsync("""
            public class C
            {
                void M(object o)
                {
                    switch (o)
                    {
                        case 1:
                            goto def[||]ault;
                        default:
                            return;
                    }
                }
            }
            """, expectedText: "defaultcase");
    }
 
    [Fact]
    public async Task TestGotoDefault()
    {
        await Test_KeywordAsync("""
            public class C
            {
                void M(object o)
                {
                    switch (o)
                    {
                        case 1:
                            goto default;
                        def[||]ault:
                            return;
                    }
                }
            }
            """, expectedText: "defaultcase");
    }
 
    [Fact]
    public async Task TestLineDefault()
    {
        await Test_KeywordAsync("""
            #line def[||]ault
            """, expectedText: "defaultline");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/65311")]
    public async Task TestNotnull_OnType()
    {
        await Test_KeywordAsync("""
            public class C<T> where T : not[||]null
            {
            }
            """, expectedText: "notnull");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/65311")]
    public async Task TestNotnull_OnMethod()
    {
        await Test_KeywordAsync("""
            public class C
            {
                void M<T>() where T : not[||]null
                {
                }
            }
            """, expectedText: "notnull");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/65311")]
    public async Task TestNotnull_FieldName()
    {
        await TestAsync("""
            public class C
            {
                int not[||]null = 0;
            }
            """, expectedText: "C.notnull");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/65311")]
    public async Task TestUnmanaged_OnType()
    {
        await Test_KeywordAsync("""
            public class C<T> where T : un[||]managed
            {
            }
            """, expectedText: "unmanaged");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/65311")]
    public async Task TestUnmanaged_OnMethod()
    {
        await Test_KeywordAsync("""
            public class C
            {
                void M<T>() where T : un[||]managed
                {
                }
            }
            """, expectedText: "unmanaged");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/65311")]
    public async Task TestUnmanaged_LocalName()
    {
        await TestAsync("""
            int un[||]managed = 0;
            """, expectedText: "System.Int32");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/65312")]
    public async Task TestSwitchStatement()
    {
        await Test_KeywordAsync("""
            swit[||]ch (1) { default: break; }
            """, expectedText: "switch");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/65312")]
    public async Task TestSwitchExpression()
    {
        await Test_KeywordAsync("""
            _ = 1 swit[||]ch { _ => 0 };
            """, expectedText: "switch-expression");
    }
 
    [Fact]
    public async Task TestFile()
    {
        await Test_KeywordAsync("""
            fi[||]le class C { }
            """, expectedText: "file");
    }
 
    [Fact]
    public async Task TestRightShift()
    {
        await Test_KeywordAsync("""
            _ = 1 >[||]> 2;
            """, expectedText: ">>");
    }
 
    [Fact]
    public async Task TestUnsignedRightShift()
    {
        await Test_KeywordAsync("""
            _ = 1 >>[||]> 2;
            """, expectedText: ">>>");
    }
 
    [Fact]
    public async Task TestUnsignedRightShiftAssignment()
    {
        await Test_KeywordAsync("""
            1 >>[||]>= 2;
            """, expectedText: ">>>=");
    }
 
    [Fact]
    public async Task TestPreprocessorIf()
    {
        await TestAsync(
            """
            #i[||]f ANY
            #endif
            """, "#if");
    }
 
    [Fact]
    public async Task TestPreprocessorIf2()
    {
        await TestAsync(
            """
            #if ANY[||]
            #endif
            """, "#if");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/66009")]
    public async Task TestPreprocessorIf3()
    {
        await TestAsync(
            """
            #if ANY[||]THING
            #endif
            """, "#if");
    }
 
    [Fact]
    public async Task TestPreprocessorEndIf()
    {
        await TestAsync(
            """
            #if ANY
            #en[||]dif
            """, "#endif");
    }
 
    [Fact]
    public async Task TestPreprocessorEndIf2()
    {
        await TestAsync(
            """
            #if ANY
            #endif[||]
 
            """, "#endif");
    }
 
    [Fact]
    public async Task TestPreprocessorElse()
    {
        await TestAsync(
            """
            #if ANY
            #el[||]se
            #endif
            """, "#else");
    }
 
    [Fact]
    public async Task TestPreprocessorElse2()
    {
        await TestAsync(
            """
            #if ANY
            #else[||]
            #endif
            """, "#else");
    }
 
    [Fact]
    public async Task TestPreprocessorElIf()
    {
        await TestAsync(
            """
            #if ANY
            #el[||]if SOME
            #endif
            """, "#elif");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/66009")]
    public async Task TestPreprocessorElIf2()
    {
        await TestAsync(
            """
            #if ANY
            #elif S[||]OME
            #endif
            """, "#elif");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/66009")]
    public async Task TestPreprocessorPragmaWarning1()
    {
        await TestAsync(
            """
            #pragma warning disable CS[||]0312
            """, "#pragma");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/66009")]
    public async Task TestPreprocessorPragmaWarning2()
    {
        await TestAsync(
            """
            #pragm[||]a warning disable CS0312
            """, "#pragma");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/66009")]
    public async Task TestPreprocessorPragmaWarning3()
    {
        await TestAsync(
            """
            #pragma warni[||]ng disable CS0312
            """, "#warning");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/66009")]
    public async Task TestPreprocessorPragmaWarning4()
    {
        await TestAsync(
            """
            #pragma warning dis[||]able CS0312
            """, "#disable");
    }
}
File: F1Help\F1HelpTests.cs	Web Access
Project: src\src\VisualStudio\CSharp\Test\Microsoft.VisualStudio.LanguageServices.CSharp.UnitTests.csproj (Microsoft.VisualStudio.LanguageServices.CSharp.UnitTests)