Reduce allocations in AbstractProjectExtensionProvider.FilterExtensions

src/Features/Core/Portable/CodeRefactorings/CodeRefactoringService.cs

@@ -80,7 +80,11 @@ static ImmutableArray<CodeRefactoringProvider> GetProjectRefactorings(TextDocume
         }
 
         static ProjectCodeRefactoringProvider.ExtensionInfo GetExtensionInfo(ExportCodeRefactoringProviderAttribute attribute)
-            => new(attribute.DocumentKinds, attribute.DocumentExtensions);
+        {
+            var kinds = EnumArrayConverter.FromStringArray<TextDocumentKind>(attribute.DocumentKinds);
+
+            return new(kinds, attribute.DocumentExtensions);
+        }
     }
 
     public async Task<bool> HasRefactoringsAsync(

src/Features/Core/Portable/Common/AbstractProjectExtensionProvider.cs

@@ -9,6 +9,7 @@
 using System.Runtime.CompilerServices;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.PooledObjects;
+using Microsoft.CodeAnalysis.Shared.Extensions;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis;
@@ -18,7 +19,7 @@ internal abstract class AbstractProjectExtensionProvider<TProvider, TExtension,
     where TExportAttribute : Attribute
     where TExtension : class
 {
-    public record class ExtensionInfo(string[] DocumentKinds, string[]? DocumentExtensions);
+    public record class ExtensionInfo(TextDocumentKind[] DocumentKinds, string[]? DocumentExtensions);
 
     // Following CWTs are used to cache completion providers from projects' references,
     // so we can avoid the slow path unless there's any change to the references.
@@ -87,48 +88,52 @@ public static ImmutableArray<TExtension> GetExtensions(TextDocument document, Fu
 
     public static ImmutableArray<TExtension> FilterExtensions(TextDocument document, ImmutableArray<TExtension> extensions, Func<TExportAttribute, ExtensionInfo> getExtensionInfoForFiltering)
     {
-        return extensions.WhereAsArray(ShouldIncludeExtension);
+        return extensions.WhereAsArray(ShouldIncludeExtension, (document, getExtensionInfoForFiltering));
 
-        bool ShouldIncludeExtension(TExtension extension)
+        static bool ShouldIncludeExtension(TExtension extension, (TextDocument, Func<TExportAttribute, ExtensionInfo>) args)
         {
+            var (document, getExtensionInfoForFiltering) = args;
             if (!s_extensionInfoMap.TryGetValue(extension, out var extensionInfo))
-            {
-                extensionInfo = s_extensionInfoMap.GetValue(extension,
-                    new ConditionalWeakTable<TExtension, ExtensionInfo?>.CreateValueCallback(ComputeExtensionInfo));
-            }
+                extensionInfo = GetOrCreateExtensionInfo(extension, getExtensionInfoForFiltering);
 
             if (extensionInfo == null)
                 return true;
 
-            if (!extensionInfo.DocumentKinds.Contains(document.Kind.ToString()))
+            if (Array.IndexOf(extensionInfo.DocumentKinds, document.Kind) < 0)
                 return false;
 
             if (document.FilePath != null &&
                 extensionInfo.DocumentExtensions != null &&
-                !extensionInfo.DocumentExtensions.Contains(PathUtilities.GetExtension(document.FilePath)))
+                Array.IndexOf(extensionInfo.DocumentExtensions, PathUtilities.GetExtension(document.FilePath)) < 0)
             {
                 return false;
             }
 
             return true;
         }
 
-        ExtensionInfo? ComputeExtensionInfo(TExtension extension)
+        static ExtensionInfo? GetOrCreateExtensionInfo(TExtension extension, Func<TExportAttribute, ExtensionInfo> getExtensionInfoForFiltering)
         {
-            TExportAttribute? attribute;
-            try
-            {
-                var typeInfo = extension.GetType().GetTypeInfo();
-                attribute = typeInfo.GetCustomAttribute<TExportAttribute>();
-            }
-            catch
+            return s_extensionInfoMap.GetValue(extension,
+                new ConditionalWeakTable<TExtension, ExtensionInfo?>.CreateValueCallback(ComputeExtensionInfo));
+
+            ExtensionInfo? ComputeExtensionInfo(TExtension extension)
             {
-                attribute = null;
-            }
+                TExportAttribute? attribute;
+                try
+                {
+                    var typeInfo = extension.GetType().GetTypeInfo();
+                    attribute = typeInfo.GetCustomAttribute<TExportAttribute>();
+                }
+                catch
+                {
+                    attribute = null;
+                }
 
-            if (attribute == null)
-                return null;
-            return getExtensionInfoForFiltering(attribute);
+                if (attribute == null)
+                    return null;
+                return getExtensionInfoForFiltering(attribute);
+            }
         }
     }
 

src/LanguageServer/Protocol/Features/CodeFixes/CodeFixService.cs

@@ -989,7 +989,11 @@ private ImmutableDictionary<DiagnosticId, ImmutableArray<CodeFixProvider>> Compu
         }
 
         private static ProjectCodeFixProvider.ExtensionInfo GetExtensionInfo(ExportCodeFixProviderAttribute attribute)
-                => new(attribute.DocumentKinds, attribute.DocumentExtensions);
+        {
+            var kinds = EnumArrayConverter.FromStringArray<TextDocumentKind>(attribute.DocumentKinds);
+
+            return new(kinds, attribute.DocumentExtensions);
+        }
 
         private sealed class FixerComparer : IComparer<CodeFixProvider>
         {

src/Workspaces/Core/Portable/CodeFixesAndRefactorings/EnumArrayConverter.cs

@@ -0,0 +1,28 @@
+// 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;
+
+namespace Microsoft.CodeAnalysis.CodeFixesAndRefactorings;
+
+internal class EnumArrayConverter
+{
+    public static TEnum[] FromStringArray<TEnum>(string[] strings) where TEnum : struct
+    {
+        if (!typeof(TEnum).IsEnum)
+            throw new ArgumentException("T must be an enumerated type");
+
+        var enums = new TEnum[strings.Length];
+        for (var i = 0; i < enums.Length; i++)
+        {
+            var s = strings[i];
+            if (!Enum.TryParse(s, out TEnum enumValue))
+                enumValue = default;
+
+            enums[i] = enumValue;
+        }
+
+        return enums;
+    }
+}