Experiment with array creation. (part2)

src/Analyzers/CSharp/CodeFixes/InlineDeclaration/CSharpInlineDeclarationCodeFixProvider.cs

@@ -70,14 +70,7 @@ protected override async Task FixAllAsync(
         await editor.ApplyExpressionLevelSemanticEditsAsync(
             document,
             originalNodes,
-            t =>
-            {
-                using var _ = ArrayBuilder<SyntaxNode>.GetInstance(capacity: 2, out var additionalNodesToTrack);
-                additionalNodesToTrack.Add(t.identifier);
-                additionalNodesToTrack.Add(t.declarator);
-
-                return (t.invocationOrCreation, additionalNodesToTrack.ToImmutable());
-            },
+            static t => (t.invocationOrCreation, ImmutableArray.Create<SyntaxNode>(t.identifier, t.declarator)),
             (_, _, _) => true,
             (semanticModel, currentRoot, t, currentNode)
                 => ReplaceIdentifierWithInlineDeclaration(

src/Analyzers/CSharp/CodeFixes/UseImplicitOrExplicitType/UseExplicitTypeCodeFixProvider.cs

@@ -205,7 +205,7 @@ private static ExpressionSyntax GenerateTupleDeclaration(ITypeSymbol typeSymbol,
 
         return TupleExpression(
             OpenParenToken.WithTrailingTrivia(),
-            SeparatedList(builder.ToImmutable(), separatorBuilder.ToImmutableAndFree()),
+            SeparatedList(builder, separatorBuilder),
             CloseParenToken)
             .WithTrailingTrivia(parensDesignation.GetTrailingTrivia());
     }

src/Analyzers/Core/CodeFixes/AddParameter/AbstractAddParameterCodeFixProvider.cs

@@ -13,6 +13,7 @@
 using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.LanguageService;
 using Microsoft.CodeAnalysis.PooledObjects;
+using Microsoft.CodeAnalysis.Shared.Collections;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Roslyn.Utilities;
 
@@ -244,7 +245,7 @@ private void RegisterFixForMethodOverloads(
 
         ImmutableArray<CodeAction> NestByOverload()
         {
-            using var _ = ArrayBuilder<CodeAction>.GetInstance(codeFixData.Length, out var builder);
+            var builder = new FixedSizeArrayBuilder<CodeAction>(codeFixData.Length);
             foreach (var data in codeFixData)
             {
                 // We create the mandatory data.CreateChangedSolutionNonCascading fix first.
@@ -276,12 +277,12 @@ ImmutableArray<CodeAction> NestByOverload()
                 builder.Add(codeAction);
             }
 
-            return builder.ToImmutableAndClear();
+            return builder.MoveToImmutable();
         }
 
         ImmutableArray<CodeAction> NestByCascading()
         {
-            using var _ = ArrayBuilder<CodeAction>.GetInstance(capacity: 2, out var builder);
+            using var builder = TemporaryArray<CodeAction>.Empty;
 
             var nonCascadingActions = codeFixData.SelectAsArray(data =>
             {
@@ -312,7 +313,7 @@ ImmutableArray<CodeAction> NestByCascading()
                 builder.Add(CodeAction.Create(nestedCascadingTitle, cascadingActions, isInlinable: false));
             }
 
-            return builder.ToImmutable();
+            return builder.ToImmutableAndClear();
         }
     }
 
@@ -321,7 +322,7 @@ private ImmutableArray<CodeFixData> PrepareCreationOfCodeActions(
         SeparatedSyntaxList<TArgumentSyntax> arguments,
         ImmutableArray<ArgumentInsertPositionData<TArgumentSyntax>> methodsAndArgumentsToAdd)
     {
-        using var _ = ArrayBuilder<CodeFixData>.GetInstance(methodsAndArgumentsToAdd.Length, out var builder);
+        var builder = new FixedSizeArrayBuilder<CodeFixData>(methodsAndArgumentsToAdd.Length);
 
         // Order by the furthest argument index to the nearest argument index.  The ones with
         // larger argument indexes mean that we matched more earlier arguments (and thus are
@@ -343,7 +344,7 @@ private ImmutableArray<CodeFixData> PrepareCreationOfCodeActions(
             builder.Add(codeFixData);
         }
 
-        return builder.ToImmutable();
+        return builder.MoveToImmutable();
     }
 
     private static string GetCodeFixTitle(string resourceString, IMethodSymbol methodToUpdate, bool includeParameters)

src/Features/Core/Portable/CodeFixes/Suppression/AbstractSuppressionCodeFixProvider.RemoveSuppressionCodeAction.BatchFixer.cs

@@ -158,14 +158,14 @@ public override async Task<CodeAction> TryGetMergedFixAsync(
 
             private static async Task<ImmutableArray<SyntaxNode>> GetAttributeNodesToFixAsync(ImmutableArray<AttributeRemoveAction> attributeRemoveFixes, CancellationToken cancellationToken)
             {
-                using var _ = ArrayBuilder<SyntaxNode>.GetInstance(attributeRemoveFixes.Length, out var builder);
+                var builder = new FixedSizeArrayBuilder<SyntaxNode>(attributeRemoveFixes.Length);
                 foreach (var attributeRemoveFix in attributeRemoveFixes)
                 {
                     var attributeToRemove = await attributeRemoveFix.GetAttributeToRemoveAsync(cancellationToken).ConfigureAwait(false);
                     builder.Add(attributeToRemove);
                 }
 
-                return builder.ToImmutableAndClear();
+                return builder.MoveToImmutable();
             }
         }
     }

src/Features/Core/Portable/CodeRefactorings/SyncNamespace/AbstractChangeNamespaceService.cs

@@ -403,11 +403,11 @@ private static ImmutableArray<string> GetAllNamespaceImportsForDeclaringDocument
     private static ImmutableArray<SyntaxNode> CreateImports(Document document, ImmutableArray<string> names, bool withFormatterAnnotation)
     {
         var generator = SyntaxGenerator.GetGenerator(document);
-        using var _ = ArrayBuilder<SyntaxNode>.GetInstance(names.Length, out var builder);
+        var builder = new FixedSizeArrayBuilder<SyntaxNode>(names.Length);
         for (var i = 0; i < names.Length; ++i)
             builder.Add(CreateImport(generator, names[i], withFormatterAnnotation));
 
-        return builder.ToImmutableAndClear();
+        return builder.MoveToImmutable();
     }
 
     private static SyntaxNode CreateImport(SyntaxGenerator syntaxGenerator, string name, bool withFormatterAnnotation)

src/Features/Core/Portable/Completion/Providers/ImportCompletionProvider/ImportCompletionItem.cs

@@ -11,6 +11,7 @@
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Tags;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.Completion.Providers;
 
@@ -97,7 +98,7 @@ public static CompletionItem CreateAttributeItemWithoutSuffix(CompletionItem att
         var attributeItems = attributeItem.GetProperties();
 
         // Remember the full type name so we can get the symbol when description is displayed.
-        using var _ = ArrayBuilder<KeyValuePair<string, string>>.GetInstance(attributeItems.Length + 1, out var builder);
+        var builder = new FixedSizeArrayBuilder<KeyValuePair<string, string>>(attributeItems.Length + 1);
         builder.AddRange(attributeItems);
         builder.Add(new KeyValuePair<string, string>(AttributeFullName, attributeItem.DisplayText));
 
@@ -107,7 +108,7 @@ public static CompletionItem CreateAttributeItemWithoutSuffix(CompletionItem att
         var item = CompletionItem.CreateInternal(
              displayText: attributeNameWithoutSuffix,
              sortText: sortTextBuilder.ToStringAndFree(),
-             properties: builder.ToImmutable(),
+             properties: builder.MoveToImmutable(),
              tags: attributeItem.Tags,
              rules: attributeItem.Rules,
              displayTextPrefix: attributeItem.DisplayTextPrefix,
@@ -219,12 +220,8 @@ private static (ISymbol? symbol, int overloadCount) GetSymbolAndOverloadCount(Co
     public static CompletionItem MarkItemToAlwaysFullyQualify(CompletionItem item)
     {
         var itemProperties = item.GetProperties();
-
-        using var _ = ArrayBuilder<KeyValuePair<string, string>>.GetInstance(itemProperties.Length + 1, out var builder);
-        builder.AddRange(itemProperties);
-        builder.Add(new KeyValuePair<string, string>(AlwaysFullyQualifyKey, AlwaysFullyQualifyKey));
-
-        return item.WithProperties(builder.ToImmutable());
+        ImmutableArray<KeyValuePair<string, string>> properties = [.. itemProperties, KeyValuePairUtil.Create(AlwaysFullyQualifyKey, AlwaysFullyQualifyKey)];
+        return item.WithProperties(properties);
     }
 
     public static bool ShouldAlwaysFullyQualify(CompletionItem item) => item.TryGetProperty(AlwaysFullyQualifyKey, out var _);

src/Features/Core/Portable/DocumentHighlighting/AbstractDocumentHighlightsService.cs

@@ -263,13 +263,11 @@ private static async Task<ImmutableArray<DocumentHighlights>> CreateSpansAsync(
             await AddLocationSpanAsync(location, solution, spanSet, tagMap, HighlightSpanKind.Reference, cancellationToken).ConfigureAwait(false);
         }
 
-        using var _1 = ArrayBuilder<DocumentHighlights>.GetInstance(tagMap.Count, out var list);
+        var list = new FixedSizeArrayBuilder<DocumentHighlights>(tagMap.Count);
         foreach (var kvp in tagMap)
-        {
             list.Add(new DocumentHighlights(kvp.Key, [.. kvp.Value]));
-        }
 
-        return list.ToImmutableAndClear();
+        return list.MoveToImmutable();
     }
 
     private static bool ShouldIncludeDefinition(ISymbol symbol)

src/Features/Core/Portable/ExtractMethod/MethodExtractor.Analyzer.cs

@@ -440,11 +440,10 @@ private ImmutableArray<VariableInfo> MarkVariableInfoToUseAsReturnValueIfPossibl
 
         private static ImmutableArray<VariableInfo> GetMethodParameters(Dictionary<ISymbol, VariableInfo> variableInfoMap)
         {
-            using var _ = ArrayBuilder<VariableInfo>.GetInstance(variableInfoMap.Count, out var list);
+            var list = new FixedSizeArrayBuilder<VariableInfo>(variableInfoMap.Count);
             list.AddRange(variableInfoMap.Values);
-
             list.Sort();
-            return list.ToImmutable();
+            return list.MoveToImmutable();
         }
 
         /// <param name="bestEffort">When false, variables whose data flow is not understood

src/Features/Core/Portable/ImplementInterface/ImplementHelpers.cs

@@ -36,11 +36,7 @@ public static ImmutableArray<ISymbol> GetDelegatableMembers(
 
         var parameters = GetNonCapturedPrimaryConstructorParameters(fields, properties);
 
-        using var _1 = ArrayBuilder<ISymbol>.GetInstance(fields.Length + properties.Length + parameters.Length, out var result);
-        result.AddRange(fields);
-        result.AddRange(properties);
-        result.AddRange(parameters);
-        return result.ToImmutableAndClear();
+        return [.. fields, .. properties, .. parameters];
 
         ImmutableArray<IParameterSymbol> GetNonCapturedPrimaryConstructorParameters(
             ImmutableArray<IFieldSymbol> fields,

src/Features/Core/Portable/Structure/BlockStructureServiceWithProviders.cs

@@ -74,11 +74,11 @@ private static BlockStructure GetBlockStructure(
 
     private static BlockStructure CreateBlockStructure(in BlockStructureContext context)
     {
-        using var _ = ArrayBuilder<BlockSpan>.GetInstance(context.Spans.Count, out var updatedSpans);
+        var updatedSpans = new FixedSizeArrayBuilder<BlockSpan>(context.Spans.Count);
         foreach (var span in context.Spans)
             updatedSpans.Add(UpdateBlockSpan(span, context.Options));
 
-        return new BlockStructure(updatedSpans.ToImmutableAndClear());
+        return new BlockStructure(updatedSpans.MoveToImmutable());
     }
 
     private static BlockSpan UpdateBlockSpan(BlockSpan blockSpan, in BlockStructureOptions options)

src/Features/Core/Portable/Wrapping/ChainedExpression/AbstractChainedExpressionWrapper.cs

@@ -230,11 +230,11 @@ pieces[index] is var piece &&
     private static ImmutableArray<SyntaxNodeOrToken> GetSubRange(
         ArrayBuilder<SyntaxNodeOrToken> pieces, int start, int end)
     {
-        using var _ = ArrayBuilder<SyntaxNodeOrToken>.GetInstance(end - start, out var result);
+        var result = new FixedSizeArrayBuilder<SyntaxNodeOrToken>(end - start);
         for (var i = start; i < end; i++)
             result.Add(pieces[i]);
 
-        return result.ToImmutableAndClear();
+        return result.MoveToImmutable();
     }
 
     private bool IsDecomposableChainPart(SyntaxNode? node)

src/Features/LanguageServer/Protocol/Features/Diagnostics/DocumentAnalysisExecutor.cs

@@ -395,14 +395,14 @@ private static async Task<ImmutableArray<DiagnosticData>> RemapDiagnosticLocatio
             }
 
             // Round tripping the diagnostics should ensure they get correctly remapped.
-            using var _ = ArrayBuilder<DiagnosticData>.GetInstance(diagnostics.Length, out var builder);
+            var builder = new FixedSizeArrayBuilder<DiagnosticData>(diagnostics.Length);
             foreach (var diagnosticData in diagnostics)
             {
                 var diagnostic = await diagnosticData.ToDiagnosticAsync(textDocument.Project, cancellationToken).ConfigureAwait(false);
                 builder.Add(DiagnosticData.Create(diagnostic, textDocument));
             }
 
-            return builder.ToImmutableAndClear();
+            return builder.MoveToImmutable();
         }
     }
 }

src/Features/LanguageServer/Protocol/Features/UnifiedSuggestions/UnifiedSuggestedActionsSource.cs

@@ -148,7 +148,7 @@ async Task<IUnifiedSuggestedAction> GetUnifiedSuggestedActionAsync(Solution orig
             {
                 if (action.NestedActions.Length > 0)
                 {
-                    using var _ = ArrayBuilder<IUnifiedSuggestedAction>.GetInstance(action.NestedActions.Length, out var unifiedNestedActions);
+                    var unifiedNestedActions = new FixedSizeArrayBuilder<IUnifiedSuggestedAction>(action.NestedActions.Length);
                     foreach (var nestedAction in action.NestedActions)
                     {
                         var unifiedNestedAction = await GetUnifiedSuggestedActionAsync(originalSolution, nestedAction, fix).ConfigureAwait(false);
@@ -158,7 +158,7 @@ async Task<IUnifiedSuggestedAction> GetUnifiedSuggestedActionAsync(Solution orig
                     var set = new UnifiedSuggestedActionSet(
                         originalSolution,
                         categoryName: null,
-                        actions: unifiedNestedActions.ToImmutableAndClear(),
+                        actions: unifiedNestedActions.MoveToImmutable(),
                         title: null,
                         priority: action.Priority,
                         applicableToSpan: fix.PrimaryDiagnostic.Location.SourceSpan);
@@ -454,14 +454,14 @@ public static async Task<ImmutableArray<UnifiedSuggestedActionSet>> GetFilterAnd
 
             var filteredRefactorings = FilterOnAnyThread(refactorings, selection, filterOutsideSelection);
 
-            using var _ = ArrayBuilder<UnifiedSuggestedActionSet>.GetInstance(filteredRefactorings.Length, out var orderedRefactorings);
+            var orderedRefactorings = new FixedSizeArrayBuilder<UnifiedSuggestedActionSet>(filteredRefactorings.Length);
             foreach (var refactoring in filteredRefactorings)
             {
                 var orderedRefactoring = await OrganizeRefactoringsAsync(workspace, document, selection, refactoring, cancellationToken).ConfigureAwait(false);
                 orderedRefactorings.Add(orderedRefactoring);
             }
 
-            return orderedRefactorings.ToImmutableAndClear();
+            return orderedRefactorings.MoveToImmutable();
         }
 
         private static ImmutableArray<CodeRefactoring> FilterOnAnyThread(
@@ -546,7 +546,7 @@ async Task<IUnifiedSuggestedAction> GetUnifiedSuggestedActionSetAsync(CodeAction
             {
                 if (codeAction.NestedActions.Length > 0)
                 {
-                    using var _1 = ArrayBuilder<IUnifiedSuggestedAction>.GetInstance(codeAction.NestedActions.Length, out var nestedActions);
+                    var nestedActions = new FixedSizeArrayBuilder<IUnifiedSuggestedAction>(codeAction.NestedActions.Length);
                     foreach (var nestedAction in codeAction.NestedActions)
                     {
                         var unifiedAction = await GetUnifiedSuggestedActionSetAsync(nestedAction, applicableToSpan, selection, cancellationToken).ConfigureAwait(false);
@@ -556,7 +556,7 @@ async Task<IUnifiedSuggestedAction> GetUnifiedSuggestedActionSetAsync(CodeAction
                     var set = new UnifiedSuggestedActionSet(
                         originalSolution,
                         categoryName: null,
-                        actions: nestedActions.ToImmutableAndClear(),
+                        actions: nestedActions.MoveToImmutable(),
                         title: null,
                         priority: codeAction.Priority,
                         applicableToSpan: applicableToSpan);

src/Features/LanguageServer/Protocol/Handler/InlayHint/InlayHintHandler.cs

@@ -50,14 +50,14 @@ public TextDocumentIdentifier GetTextDocumentIdentifier(InlayHintParams request)
             var options = _optionsService.GetInlineHintsOptions(document.Project.Language);
             var hints = await inlineHintService.GetInlineHintsAsync(document, textSpan, options, displayAllOverride: false, cancellationToken).ConfigureAwait(false);
 
-            using var _ = ArrayBuilder<LSP.InlayHint>.GetInstance(hints.Length, out var inlayHints);
             var syntaxVersion = await document.GetSyntaxVersionAsync(cancellationToken).ConfigureAwait(false);
             var inlayHintCache = context.GetRequiredLspService<InlayHintCache>();
 
             // Store the members in the resolve cache so that when we get a resolve request for a particular
             // member we can re-use the inline hint.
             var resultId = inlayHintCache.UpdateCache(new InlayHintCache.InlayHintCacheEntry(hints, syntaxVersion));
 
+            var inlayHints = new LSP.InlayHint[hints.Length];
             for (var i = 0; i < hints.Length; i++)
             {
                 var hint = hints[i];
@@ -88,10 +88,10 @@ public TextDocumentIdentifier GetTextDocumentIdentifier(InlayHintParams request)
                     Data = new InlayHintResolveData(resultId, i, request.TextDocument)
                 };
 
-                inlayHints.Add(inlayHint);
+                inlayHints[i] = inlayHint;
             }
 
-            return inlayHints.ToArray();
+            return inlayHints;
         }
 
         /// <summary>