Cleanup/perf in creating member maps. (#67997)

* Cleanup/perf in creating member maps.

* Simplify

* Better assert, and avoid empty arrays

* Remove type argument

* Remove unnecessary type arguments

* Fix

* Make static

* Add assert

Author: CyrusNajmabadi

src/Compilers/CSharp/Portable/Symbols/Source/SourceNamespaceSymbol.cs

@@ -249,19 +249,13 @@ private Dictionary<string, ImmutableArray<NamedTypeSymbol>> GetNameToTypeMembers
             {
                 // NOTE: This method depends on MakeNameToMembersMap() on creating a proper
                 // NOTE: type of the array, see comments in MakeNameToMembersMap() for details
-                Interlocked.CompareExchange(ref _nameToTypeMembersMap, getTypesFromMemberMap(GetNameToMembersMap()), null);
+                Interlocked.CompareExchange(
+                    ref _nameToTypeMembersMap,
+                    ImmutableArrayExtensions.GetTypesFromMemberMap<NamespaceOrTypeSymbol, NamedTypeSymbol>(GetNameToMembersMap(), StringOrdinalComparer.Instance),
+                    comparand: null);
             }
 
             return _nameToTypeMembersMap;
-
-            static Dictionary<string, ImmutableArray<NamedTypeSymbol>> getTypesFromMemberMap(Dictionary<string, ImmutableArray<NamespaceOrTypeSymbol>> map)
-            {
-#if DEBUG
-                return ImmutableArrayExtensions.GetTypesFromMemberMap<NamespaceOrTypeSymbol, NamedTypeSymbol, NamespaceSymbol>(map, StringOrdinalComparer.Instance);
-#else
-                return ImmutableArrayExtensions.GetTypesFromMemberMap<NamespaceOrTypeSymbol, NamedTypeSymbol>(map, StringOrdinalComparer.Instance);
-#endif
-            }
         }
 
         private Dictionary<string, ImmutableArray<NamespaceOrTypeSymbol>> MakeNameToMembersMap(BindingDiagnosticBag diagnostics)

src/Compilers/Core/Portable/Collections/ImmutableArrayExtensions.cs

@@ -15,6 +15,7 @@
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Collections;
 using Microsoft.CodeAnalysis.Shared.Collections;
+using Roslyn.Utilities;
 
 #if DEBUG
 using System.Linq;
@@ -907,107 +908,87 @@ internal static void AddToMultiValueDictionaryBuilder<K, T>(Dictionary<K, object
 
         internal static void CreateNameToMembersMap
             <TNamespaceOrTypeSymbol, TNamedTypeSymbol, TNamespaceSymbol>
-            (Dictionary<string, object> dictionary, Dictionary<String, ImmutableArray<TNamespaceOrTypeSymbol>> result)
+            (Dictionary<string, object> dictionary, Dictionary<string, ImmutableArray<TNamespaceOrTypeSymbol>> result)
             where TNamespaceOrTypeSymbol : class
             where TNamedTypeSymbol : class, TNamespaceOrTypeSymbol
             where TNamespaceSymbol : class, TNamespaceOrTypeSymbol
         {
-            foreach (var kvp in dictionary)
-            {
-                object value = kvp.Value;
-                ImmutableArray<TNamespaceOrTypeSymbol> members;
+            foreach (var (name, value) in dictionary)
+                result.Add(name, createMembers(value));
+
+            return;
 
-                var builder = value as ArrayBuilder<TNamespaceOrTypeSymbol>;
-                if (builder != null)
+            static ImmutableArray<TNamespaceOrTypeSymbol> createMembers(object value)
+            {
+                if (value is ArrayBuilder<TNamespaceOrTypeSymbol> builder)
                 {
                     Debug.Assert(builder.Count > 1);
-                    bool hasNamespaces = false;
-                    for (int i = 0; i < builder.Count; i++)
+                    foreach (var item in builder)
                     {
-                        if (builder[i] is TNamespaceSymbol)
-                        {
-                            hasNamespaces = true;
-                            break;
-                        }
+                        if (item is TNamespaceSymbol)
+                            return builder.ToImmutableAndFree();
                     }
 
-                    members = hasNamespaces
-                        ? builder.ToImmutable()
-                        : ImmutableArray<TNamespaceOrTypeSymbol>.CastUp(builder.ToDowncastedImmutable<TNamedTypeSymbol>());
-
-                    builder.Free();
+                    return ImmutableArray<TNamespaceOrTypeSymbol>.CastUp(builder.ToDowncastedImmutableAndFree<TNamedTypeSymbol>());
                 }
                 else
                 {
                     TNamespaceOrTypeSymbol symbol = (TNamespaceOrTypeSymbol)value;
-                    members = symbol is TNamespaceSymbol
-                        ? ImmutableArray.Create<TNamespaceOrTypeSymbol>(symbol)
-                        : ImmutableArray<TNamespaceOrTypeSymbol>.CastUp(ImmutableArray.Create<TNamedTypeSymbol>((TNamedTypeSymbol)symbol));
+                    return symbol is TNamespaceSymbol
+                        ? ImmutableArray.Create(symbol)
+                        : ImmutableArray<TNamespaceOrTypeSymbol>.CastUp(ImmutableArray.Create((TNamedTypeSymbol)symbol));
                 }
-
-                result.Add(kvp.Key, members);
             }
         }
 
-        internal static Dictionary<string, ImmutableArray<TNamedTypeSymbol>> GetTypesFromMemberMap
-            <TNamespaceOrTypeSymbol, TNamedTypeSymbol
-#if DEBUG
-             , TNamespaceSymbol
-#endif
-            >
+        internal static Dictionary<string, ImmutableArray<TNamedTypeSymbol>> GetTypesFromMemberMap<TNamespaceOrTypeSymbol, TNamedTypeSymbol>
             (Dictionary<string, ImmutableArray<TNamespaceOrTypeSymbol>> map, IEqualityComparer<string> comparer)
             where TNamespaceOrTypeSymbol : class
             where TNamedTypeSymbol : class, TNamespaceOrTypeSymbol
-#if DEBUG
-            where TNamespaceSymbol : class, TNamespaceOrTypeSymbol
-#endif
         {
             var dictionary = new Dictionary<string, ImmutableArray<TNamedTypeSymbol>>(comparer);
 
-            foreach (var kvp in map)
+            foreach (var (name, members) in map)
             {
-                ImmutableArray<TNamespaceOrTypeSymbol> members = kvp.Value;
+                var namedTypes = getOrCreateNamedTypes(members);
+                if (namedTypes.Length > 0)
+                    dictionary.Add(name, namedTypes);
+            }
 
-                bool hasType = false;
-                bool hasNamespace = false;
+            return dictionary;
 
-                foreach (var symbol in members)
-                {
-                    if (symbol is TNamedTypeSymbol)
-                    {
-                        hasType = true;
-                        if (hasNamespace)
-                        {
-                            break;
-                        }
-                    }
-                    else
-                    {
-#if DEBUG
-                        Debug.Assert(symbol is TNamespaceSymbol);
-#endif
-                        hasNamespace = true;
-                        if (hasType)
-                        {
-                            break;
-                        }
-                    }
-                }
+            static ImmutableArray<TNamedTypeSymbol> getOrCreateNamedTypes(ImmutableArray<TNamespaceOrTypeSymbol> members)
+            {
+                Debug.Assert(members.Length > 0);
+
+                // See if creator 'map' put a downcasted ImmutableArray<TNamedTypeSymbol> in it.  If so, we can just directly
+                // downcast to that and trivially reuse it.  If not, that means the array must have contained at least one
+                // TNamespaceSymbol and we'll need to filter that out.
+                var membersAsNamedTypes = members.As<TNamedTypeSymbol>();
+
+                if (!membersAsNamedTypes.IsDefault)
+                    return membersAsNamedTypes;
+
+                // Preallocate the right amount so we can avoid garbage reallocs.
+                var count = members.Count(static s => s is TNamedTypeSymbol);
 
-                if (hasType)
+                // Must have less items than in the original array.  Otherwise, the .As<TNamedTypeSymbol>() cast would
+                // have succeeded.
+                Debug.Assert(count < members.Length);
+
+                if (count == 0)
+                    return ImmutableArray<TNamedTypeSymbol>.Empty;
+
+                var builder = ArrayBuilder<TNamedTypeSymbol>.GetInstance(count);
+                foreach (var member in members)
                 {
-                    if (hasNamespace)
-                    {
-                        dictionary.Add(kvp.Key, members.OfType<TNamedTypeSymbol>().AsImmutable());
-                    }
-                    else
-                    {
-                        dictionary.Add(kvp.Key, members.As<TNamedTypeSymbol>());
-                    }
+                    if (member is TNamedTypeSymbol namedType)
+                        builder.Add(namedType);
                 }
-            }
 
-            return dictionary;
+                Debug.Assert(builder.Count == count);
+                return builder.ToImmutableAndFree();
+            }
         }
 
         internal static bool SequenceEqual<TElement, TArg>(this ImmutableArray<TElement> array1, ImmutableArray<TElement> array2, TArg arg, Func<TElement, TElement, TArg, bool> predicate)

src/Compilers/VisualBasic/Portable/Symbols/Source/SourceNamespaceSymbol.vb

@@ -186,17 +186,10 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols
 
                 ' NOTE: This method depends on MakeNameToMembersMap() on creating a proper 
                 ' NOTE: type of the array, see comments in MakeNameToMembersMap() for details
-
-                Dim dictionary As New Dictionary(Of String, ImmutableArray(Of NamedTypeSymbol))
-                Dim map As Dictionary(Of String, ImmutableArray(Of NamespaceOrTypeSymbol)) = Me.GetNameToMembersMap()
-
-#If DEBUG Then
-                dictionary = ImmutableArrayExtensions.GetTypesFromMemberMap(Of NamespaceOrTypeSymbol, NamedTypeSymbol, NamespaceSymbol)(map, CaseInsensitiveComparison.Comparer)
-#Else
-                dictionary = ImmutableArrayExtensions.GetTypesFromMemberMap(Of NamespaceOrTypeSymbol, NamedTypeSymbol)(map, CaseInsensitiveComparison.Comparer)
-#End If
-
-                Interlocked.CompareExchange(_nameToTypeMembersMap, dictionary, Nothing)
+                Interlocked.CompareExchange(
+                    _nameToTypeMembersMap,
+                    ImmutableArrayExtensions.GetTypesFromMemberMap(Of NamespaceOrTypeSymbol, NamedTypeSymbol)(Me.GetNameToMembersMap(), CaseInsensitiveComparison.Comparer),
+                    comparand:=Nothing)
             End If
 
             Return _nameToTypeMembersMap

src/Dependencies/PooledObjects/ArrayBuilder.cs

@@ -322,6 +322,13 @@ public ImmutableArray<U> ToDowncastedImmutable<U>()
             return tmp.ToImmutableAndFree();
         }
 
+        public ImmutableArray<U> ToDowncastedImmutableAndFree<U>() where U : T
+        {
+            var result = ToDowncastedImmutable<U>();
+            this.Free();
+            return result;
+        }
+
         /// <summary>
         /// Realizes the array and disposes the builder in one operation.
         /// </summary>