Refactor completion logic into standalone service.

- Migrated the completion item source provider and the legacy directive completion provider to use the new service.
- Cleaned up duplicate tests that were both verifying common completion functionality.
- Ensured that the legacy `RazorDirectiveCompletionProvider` did not result in additional Razor assembly loads when in C# scenarios.

#2530

Author: N. Taylor Mullen

src/Microsoft.VisualStudio.Editor.Razor/DefaultRazorCompletionFactsService.cs

@@ -0,0 +1,98 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.Composition;
+using System.Linq;
+using Microsoft.AspNetCore.Razor.Language;
+using Microsoft.AspNetCore.Razor.Language.Legacy;
+
+namespace Microsoft.VisualStudio.Editor.Razor
+{
+    [System.Composition.Shared]
+    [Export(typeof(RazorCompletionFactsService))]
+    internal class DefaultRazorCompletionFactsService : RazorCompletionFactsService
+    {
+        private static readonly IEnumerable<DirectiveDescriptor> DefaultDirectives = new[]
+        {
+            CSharpCodeParser.AddTagHelperDirectiveDescriptor,
+            CSharpCodeParser.RemoveTagHelperDirectiveDescriptor,
+            CSharpCodeParser.TagHelperPrefixDirectiveDescriptor,
+        };
+
+        public override IReadOnlyList<RazorCompletionItem> GetCompletionItems(RazorSyntaxTree syntaxTree, SourceSpan location)
+        {
+            var completionItems = new List<RazorCompletionItem>();
+
+            if (AtDirectiveCompletionPoint(syntaxTree, location))
+            {
+                var directiveCompletions = GetDirectiveCompletionItems(syntaxTree);
+                completionItems.AddRange(directiveCompletions);
+            }
+
+            return completionItems;
+        }
+
+        // Internal for testing
+        internal static List<RazorCompletionItem> GetDirectiveCompletionItems(RazorSyntaxTree syntaxTree)
+        {
+            var directives = syntaxTree.Options.Directives.Concat(DefaultDirectives);
+            var completionItems = new List<RazorCompletionItem>();
+            foreach (var directive in directives)
+            {
+                var completionDisplayText = directive.DisplayName ?? directive.Directive;
+                var completionItem = new RazorCompletionItem(
+                    completionDisplayText,
+                    directive.Directive,
+                    directive.Description,
+                    RazorCompletionItemKind.Directive);
+                completionItems.Add(completionItem);
+            }
+
+            return completionItems;
+        }
+
+        // Internal for testing
+        internal static bool AtDirectiveCompletionPoint(RazorSyntaxTree syntaxTree, SourceSpan location)
+        {
+            if (syntaxTree == null)
+            {
+                return false;
+            }
+
+            var change = new SourceChange(location, string.Empty);
+            var owner = syntaxTree.Root.LocateOwner(change);
+
+            if (owner == null)
+            {
+                return false;
+            }
+
+            if (owner.ChunkGenerator is ExpressionChunkGenerator &&
+                owner.Tokens.All(IsDirectiveCompletableToken) &&
+                // Do not provide IntelliSense for explicit expressions. Explicit expressions will usually look like:
+                // [@] [(] [DateTime.Now] [)]
+                owner.Parent?.Children.Count > 1 &&
+                owner.Parent.Children[1] == owner)
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        // Internal for testing
+        internal static bool IsDirectiveCompletableToken(IToken token)
+        {
+            if (!(token is CSharpToken csharpToken))
+            {
+                return false;
+            }
+
+            return csharpToken.Type == CSharpTokenType.Identifier ||
+                // Marker symbol
+                csharpToken.Type == CSharpTokenType.Unknown;
+        }
+    }
+}

src/Microsoft.VisualStudio.Editor.Razor/RazorCompletionFactsService.cs

@@ -0,0 +1,13 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System.Collections.Generic;
+using Microsoft.AspNetCore.Razor.Language;
+
+namespace Microsoft.VisualStudio.Editor.Razor
+{
+    internal abstract class RazorCompletionFactsService
+    {
+        public abstract IReadOnlyList<RazorCompletionItem> GetCompletionItems(RazorSyntaxTree syntaxTree, SourceSpan location);
+    }
+}

src/Microsoft.VisualStudio.Editor.Razor/RazorCompletionItem.cs

@@ -0,0 +1,45 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+
+namespace Microsoft.VisualStudio.Editor.Razor
+{
+    internal sealed class RazorCompletionItem
+    {
+        public RazorCompletionItem(
+            string displayText, 
+            string insertText, 
+            string description, 
+            RazorCompletionItemKind kind)
+        {
+            if (displayText == null)
+            {
+                throw new ArgumentNullException(nameof(displayText));
+            }
+
+            if (insertText == null)
+            {
+                throw new ArgumentNullException(nameof(insertText));
+            }
+
+            if (description == null)
+            {
+                throw new ArgumentNullException(nameof(description));
+            }
+
+            DisplayText = displayText;
+            InsertText = insertText;
+            Description = description;
+            Kind = kind;
+        }
+
+        public string DisplayText { get; }
+
+        public string InsertText { get; }
+
+        public string Description { get; }
+
+        public RazorCompletionItemKind Kind { get; }
+    }
+}

src/Microsoft.VisualStudio.Editor.Razor/RazorCompletionItemKind.cs

@@ -0,0 +1,10 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+namespace Microsoft.VisualStudio.Editor.Razor
+{
+    internal enum RazorCompletionItemKind
+    {
+        Directive
+    }
+}

src/Microsoft.VisualStudio.Editor.Razor/RazorDirectiveCompletionProvider.cs

@@ -36,12 +36,14 @@ internal class RazorDirectiveCompletionProvider : CompletionProvider
             CSharpCodeParser.TagHelperPrefixDirectiveDescriptor,
         };
         private readonly Lazy<RazorCodeDocumentProvider> _codeDocumentProvider;
+        private readonly Lazy<RazorCompletionFactsService> _completionFactsService;
         private readonly IAsyncCompletionBroker _asyncCompletionBroker;
         private readonly RazorTextBufferProvider _textBufferProvider;
 
         [ImportingConstructor]
         public RazorDirectiveCompletionProvider(
             [Import(typeof(RazorCodeDocumentProvider))] Lazy<RazorCodeDocumentProvider> codeDocumentProvider,
+            [Import(typeof(RazorCompletionFactsService))] Lazy<RazorCompletionFactsService> completionFactsService,
             IAsyncCompletionBroker asyncCompletionBroker,
             RazorTextBufferProvider textBufferProvider)
         {
@@ -50,6 +52,11 @@ public RazorDirectiveCompletionProvider(
                 throw new ArgumentNullException(nameof(codeDocumentProvider));
             }
 
+            if (completionFactsService == null)
+            {
+                throw new ArgumentNullException(nameof(completionFactsService));
+            }
+
             if (asyncCompletionBroker == null)
             {
                 throw new ArgumentNullException(nameof(asyncCompletionBroker));
@@ -61,6 +68,7 @@ public RazorDirectiveCompletionProvider(
             }
 
             _codeDocumentProvider = codeDocumentProvider;
+            _completionFactsService = completionFactsService;
             _asyncCompletionBroker = asyncCompletionBroker;
             _textBufferProvider = textBufferProvider;
         }
@@ -133,70 +141,41 @@ private Task AddCompletionItems(CompletionContext context)
                 return Task.CompletedTask;
             }
 
-            if (!AtDirectiveCompletionPoint(syntaxTree, context))
+            if (!TryGetRazorSnapshotPoint(context, out var razorSnapshotPoint))
             {
-                // Can't have a valid directive at the current location.
+                // Could not find associated Razor location.
                 return Task.CompletedTask;
             }
 
-            var completionItems = GetCompletionItems(syntaxTree);
-            context.AddItems(completionItems);
+            var location = new SourceSpan(razorSnapshotPoint.Position, 0);
+            var razorCompletionItems = _completionFactsService.Value.GetCompletionItems(syntaxTree, location);
 
-            return Task.CompletedTask;
-        }
-
-        // Internal virtual for testing
-        internal virtual IEnumerable<CompletionItem> GetCompletionItems(RazorSyntaxTree syntaxTree)
-        {
-            var directives = syntaxTree.Options.Directives.Concat(DefaultDirectives);
-            var completionItems = new List<CompletionItem>();
-            foreach (var directive in directives)
+            foreach (var razorCompletionItem in razorCompletionItems)
             {
-                var propertyDictionary = new Dictionary<string, string>(StringComparer.Ordinal);
+                if (razorCompletionItem.Kind != RazorCompletionItemKind.Directive)
+                {
+                    // Don't support any other types of completion kinds other than directives.
+                    continue;
+                }
 
-                if (!string.IsNullOrEmpty(directive.Description))
+                var propertyDictionary = new Dictionary<string, string>(StringComparer.Ordinal);
+                if (!string.IsNullOrEmpty(razorCompletionItem.Description))
                 {
-                    propertyDictionary[DescriptionKey] = directive.Description;
+                    propertyDictionary[DescriptionKey] = razorCompletionItem.Description;
                 }
 
                 var completionItem = CompletionItem.Create(
-                    directive.Directive,
+                    razorCompletionItem.InsertText,
                     // This groups all Razor directives together
                     sortText: "_RazorDirective_",
                     rules: CompletionItemRules.Create(formatOnCommit: false),
                     tags: ImmutableArray.Create(WellKnownTags.Intrinsic),
                     properties: propertyDictionary.ToImmutableDictionary());
-                completionItems.Add(completionItem);
-            }
-
-            return completionItems;
-        }
 
-        // Internal for testing
-        internal bool AtDirectiveCompletionPoint(RazorSyntaxTree syntaxTree, CompletionContext context)
-        {
-            if (TryGetRazorSnapshotPoint(context, out var razorSnapshotPoint))
-            {
-                var change = new SourceChange(razorSnapshotPoint.Position, 0, string.Empty);
-                var owner = syntaxTree.Root.LocateOwner(change);
-
-                if (owner == null)
-                {
-                    return false;
-                }
-
-                if (owner.ChunkGenerator is ExpressionChunkGenerator &&
-                    owner.Tokens.All(IsDirectiveCompletableSymbol) &&
-                    // Do not provide IntelliSense for explicit expressions. Explicit expressions will usually look like:
-                    // [@] [(] [DateTime.Now] [)]
-                    owner.Parent?.Children.Count > 1 &&
-                    owner.Parent.Children[1] == owner)
-                {
-                    return true;
-                }
+                context.AddItem(completionItem);
             }
 
-            return false;
+            return Task.CompletedTask;
         }
 
         protected virtual bool TryGetRazorSnapshotPoint(CompletionContext context, out SnapshotPoint snapshotPoint)