Add the RazorCSharp keywords to completion (#12522)

Add the csharp razor keywords to show up in completion after typing an '@'

Should fix #6927 and part of #12483

From David's analysis, which I didn't stray too far away from:

When Roslyn introduced semantic snippets, it broke Razor because it wouldn't offer the if snippet outside of a code block. This is because until you actually write code after an @ in Razor, the compiler doesn't know if it should go in the class, or the render method. Roslyn is "smart" enough not to show if as a completion option if you're at the class level, and of course as soon as you do type @if the Razor compiler is smart enough to put that in the render method, and everyone is happy. Except the user who was just trying to type :)

So as a consequence, we turned off semantic snippets for Razor files, as a temporary workaround. 3 years later is still temporary, right? Anyway, that "turn off for Razor files" is probably broken for cohosting, so we're back in this position. So the plan, in #6927, is for us to add back our own snippets for @ if (and maybe @ for, @ foreach etc.) to this list and then I think we might be good.

Author: ToddGrun

src/Razor/src/Microsoft.AspNetCore.Razor.LanguageServer/Extensions/IServiceCollectionExtensions.cs

@@ -87,6 +87,7 @@ public static void AddCompletionServices(this IServiceCollection services)
         services.AddSingleton<CompletionItemResolver, DelegatedCompletionItemResolver>();
         services.AddSingleton<ITagHelperCompletionService, TagHelperCompletionService>();
         services.AddSingleton<IRazorCompletionFactsService, LspRazorCompletionFactsService>();
+        services.AddSingleton<IRazorCompletionItemProvider, CSharpRazorKeywordCompletionItemProvider>();
         services.AddSingleton<IRazorCompletionItemProvider, DirectiveCompletionItemProvider>();
         services.AddSingleton<IRazorCompletionItemProvider, DirectiveAttributeCompletionItemProvider>();
         services.AddSingleton<IRazorCompletionItemProvider, DirectiveAttributeEventParameterCompletionItemProvider>();

src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Completion/CSharpRazorKeywordCompletionDescription.cs

@@ -0,0 +1,9 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.CodeAnalysis.Razor.Completion;
+
+internal sealed class CSharpRazorKeywordCompletionDescription(string description) : CompletionDescription
+{
+    public override string Description { get; } = string.Format(SR.KeywordDescription, description);
+}

src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Completion/CSharpRazorKeywordCompletionItemProvider.cs

@@ -0,0 +1,89 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Runtime.InteropServices;
+using Microsoft.AspNetCore.Razor.Language;
+using Microsoft.AspNetCore.Razor.Language.Syntax;
+
+namespace Microsoft.CodeAnalysis.Razor.Completion;
+
+internal class CSharpRazorKeywordCompletionItemProvider : IRazorCompletionItemProvider
+{
+    internal static readonly ImmutableArray<RazorCommitCharacter> KeywordCommitCharacters = RazorCommitCharacter.CreateArray([" "]);
+
+    // internal for testing
+    internal static readonly ImmutableArray<string> CSharpRazorKeywords =
+    [
+        "do", "for", "foreach", "if", "lock", "switch", "try", "while"
+    ];
+
+    // Internal for testing
+    internal static readonly ImmutableArray<RazorCompletionItem> CSharpRazorKeywordCompletionItems = GetCSharpRazorKeywordCompletionItems();
+
+    public ImmutableArray<RazorCompletionItem> GetCompletionItems(RazorCompletionContext context)
+    {
+        return ShouldProvideCompletions(context)
+            ? CSharpRazorKeywordCompletionItems
+            : [];
+    }
+
+    // Internal for testing
+    internal static bool ShouldProvideCompletions(RazorCompletionContext context)
+    {
+        var owner = context.Owner;
+        if (owner is null)
+        {
+            return false;
+        }
+
+        // Do not provide IntelliSense for explicit expressions. Explicit expressions will usually look like:
+        // @(DateTime.Now)
+        var implicitExpression = owner.FirstAncestorOrSelf<CSharpImplicitExpressionSyntax>();
+        if (implicitExpression is null)
+        {
+            return false;
+        }
+
+        if (implicitExpression.Width > 2 && context.Reason != CompletionReason.Invoked)
+        {
+            // We only want to provide razor csharp keyword completions if the implicit expression is empty "@|" or at the beginning of a word "@i|", this ensures
+            // we're consistent with how C# typically provides completion items.
+            return false;
+        }
+
+        if (owner.ChildNodesAndTokens().Any(static x => !x.AsToken(out var token) || !IsCSharpRazorKeywordCompletableToken(token)))
+        {
+            // Implicit expression contains nodes or tokens that aren't completable by a csharp razor keyword
+            return false;
+        }
+
+        return true;
+    }
+
+    private static bool IsCSharpRazorKeywordCompletableToken(AspNetCore.Razor.Language.Syntax.SyntaxToken token)
+    {
+        return token is { Kind: SyntaxKind.Identifier or SyntaxKind.Marker or SyntaxKind.Keyword }
+                     or { Kind: SyntaxKind.Transition, Parent.Kind: SyntaxKind.CSharpTransition };
+    }
+
+    private static ImmutableArray<RazorCompletionItem> GetCSharpRazorKeywordCompletionItems()
+    {
+        var completionItems = new RazorCompletionItem[CSharpRazorKeywords.Length];
+
+        for (var i = 0; i < CSharpRazorKeywords.Length; i++)
+        {
+            var keyword = CSharpRazorKeywords[i];
+
+            var keywordCompletionItem = RazorCompletionItem.CreateKeyword(
+                displayText: keyword,
+                insertText: keyword,
+                KeywordCommitCharacters);
+
+            completionItems[i] = keywordCompletionItem;
+        }
+
+        return ImmutableCollectionsMarshal.AsImmutableArray(completionItems);
+    }
+}

src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Completion/DirectiveCompletionDescription.cs

@@ -1,21 +1,9 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System;
-
 namespace Microsoft.CodeAnalysis.Razor.Completion;
 
-internal class DirectiveCompletionDescription : CompletionDescription
+internal sealed class DirectiveCompletionDescription(string description) : CompletionDescription
 {
-    public override string Description { get; }
-
-    public DirectiveCompletionDescription(string description)
-    {
-        if (description is null)
-        {
-            throw new ArgumentNullException(nameof(description));
-        }
-
-        Description = description;
-    }
+    public override string Description { get; } = description;
 }

src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Completion/MarkupTransitionCompletionDescription.cs

@@ -1,21 +1,9 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System;
-
 namespace Microsoft.CodeAnalysis.Razor.Completion;
 
-internal class MarkupTransitionCompletionDescription : CompletionDescription
+internal sealed class MarkupTransitionCompletionDescription(string description) : CompletionDescription
 {
-    public override string Description { get; }
-
-    public MarkupTransitionCompletionDescription(string description)
-    {
-        if (description is null)
-        {
-            throw new ArgumentNullException(nameof(description));
-        }
-
-        Description = description;
-    }
+    public override string Description { get; } = description;
 }

src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Completion/RazorCompletionItem.cs

@@ -114,4 +114,9 @@ public static RazorCompletionItem CreateAttribute(
         AttributeDescriptionInfo descriptionInfo,
         ImmutableArray<RazorCommitCharacter> commitCharacters, bool isSnippet)
         => new(RazorCompletionItemKind.Attribute, displayText, insertText, sortText: null, descriptionInfo, commitCharacters, isSnippet);
+
+    public static RazorCompletionItem CreateKeyword(
+        string displayText, string insertText,
+        ImmutableArray<RazorCommitCharacter> commitCharacters)
+        => new(RazorCompletionItemKind.CSharpRazorKeyword, displayText, insertText, sortText: null, new CSharpRazorKeywordCompletionDescription(displayText), commitCharacters, isSnippet: false);
 }

src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Completion/RazorCompletionItemKind.cs

@@ -5,6 +5,7 @@ namespace Microsoft.CodeAnalysis.Razor.Completion;
 
 internal enum RazorCompletionItemKind
 {
+    CSharpRazorKeyword,
     Directive,
     DirectiveAttribute,
     DirectiveAttributeParameter,

src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Completion/RazorCompletionItemResolver.cs

@@ -142,6 +142,15 @@ internal class RazorCompletionItemResolver : CompletionItemResolver
                             .ConfigureAwait(false);
                     }
 
+                    break;
+                }
+            case RazorCompletionItemKind.CSharpRazorKeyword:
+                {
+                    if (associatedRazorCompletion.DescriptionInfo is CSharpRazorKeywordCompletionDescription descriptionInfo)
+                    {
+                        completionItem.Documentation = descriptionInfo.Description;
+                    }
+
                     break;
                 }
         }

src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Completion/RazorCompletionListProvider.cs

@@ -276,6 +276,23 @@ internal static bool TryConvert(
                     completionItem = attributeCompletionItem;
                     return true;
                 }
+            case RazorCompletionItemKind.CSharpRazorKeyword:
+                {
+                    var csharpRazorKeywordCompletionItem = new VSInternalCompletionItem()
+                    {
+                        Label = razorCompletionItem.DisplayText,
+                        InsertText = razorCompletionItem.InsertText,
+                        FilterText = razorCompletionItem.DisplayText,
+                        SortText = razorCompletionItem.SortText,
+                        InsertTextFormat = insertTextFormat,
+                        Kind = CompletionItemKind.Keyword,
+                    };
+
+                    csharpRazorKeywordCompletionItem.UseCommitCharactersFrom(razorCompletionItem, clientCapabilities);
+
+                    completionItem = csharpRazorKeywordCompletionItem;
+                    return true;
+                }
         }
 
         completionItem = null;

src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Resources/SR.resx

@@ -230,4 +230,7 @@
     <value>{0} (and req'd attributes...)</value>
     <comment>The term "req'd" is an abbreviation for "required"</comment>
   </data>
+  <data name="KeywordDescription" xml:space="preserve">
+    <value>{0} Keyword</value>
+  </data>
 </root>