Move more instances to IDisposable ArrayBuilder.

src/Dependencies/CodeAnalysis.Debugging/CustomDebugInfoReader.cs

@@ -123,13 +123,13 @@ public static ImmutableArray<short> DecodeUsingRecord(ImmutableArray<byte> bytes
             var offset = 0;
             var numCounts = ReadInt16(bytes, ref offset);
 
-            var builder = ArrayBuilder<short>.GetInstance(numCounts);
+            using var builder = ArrayBuilder<short>.GetInstance(numCounts);
             for (var i = 0; i < numCounts; i++)
             {
                 builder.Add(ReadInt16(bytes, ref offset));
             }
 
-            return builder.ToImmutableAndFree();
+            return builder.ToImmutable();
         }
 
         /// <summary>
@@ -172,7 +172,7 @@ public static ImmutableArray<StateMachineHoistedLocalScope> DecodeStateMachineHo
 
             var bucketCount = ReadInt32(bytes, ref offset);
 
-            var builder = ArrayBuilder<StateMachineHoistedLocalScope>.GetInstance(bucketCount);
+            using var builder = ArrayBuilder<StateMachineHoistedLocalScope>.GetInstance(bucketCount);
             for (var i = 0; i < bucketCount; i++)
             {
                 var startOffset = ReadInt32(bytes, ref offset);
@@ -191,7 +191,7 @@ public static ImmutableArray<StateMachineHoistedLocalScope> DecodeStateMachineHo
                 builder.Add(new StateMachineHoistedLocalScope(startOffset, endOffset));
             }
 
-            return builder.ToImmutableAndFree();
+            return builder.ToImmutable();
         }
 
         /// <summary>
@@ -234,13 +234,13 @@ public static ImmutableArray<DynamicLocalInfo> DecodeDynamicLocalsRecord(Immutab
         {
             const int FlagBytesCount = 64;
 
-            var flagsBuilder = ArrayBuilder<bool>.GetInstance(FlagBytesCount);
-            var pooledNameBuilder = PooledStringBuilder.GetInstance();
+            using var flagsBuilder = ArrayBuilder<bool>.GetInstance(FlagBytesCount);
+            using var pooledNameBuilder = PooledStringBuilder.GetInstance();
             var nameBuilder = pooledNameBuilder.Builder;
 
             var offset = 0;
             var bucketCount = ReadInt32(bytes, ref offset);
-            var builder = ArrayBuilder<DynamicLocalInfo>.GetInstance(bucketCount);
+            using var builder = ArrayBuilder<DynamicLocalInfo>.GetInstance(bucketCount);
 
             for (var i = 0; i < bucketCount; i++)
             {
@@ -281,9 +281,7 @@ public static ImmutableArray<DynamicLocalInfo> DecodeDynamicLocalsRecord(Immutab
                 nameBuilder.Clear();
             }
 
-            flagsBuilder.Free();
-            pooledNameBuilder.Free();
-            return builder.ToImmutableAndFree();
+            return builder.ToImmutable();
         }
 
         /// <summary>
@@ -293,18 +291,18 @@ public static ImmutableArray<TupleElementNamesInfo> DecodeTupleElementNamesRecor
         {
             var offset = 0;
             var n = ReadInt32(bytes, ref offset);
-            var builder = ArrayBuilder<TupleElementNamesInfo>.GetInstance(n);
+            using var builder = ArrayBuilder<TupleElementNamesInfo>.GetInstance(n);
             for (var i = 0; i < n; i++)
             {
                 builder.Add(DecodeTupleElementNamesInfo(bytes, ref offset));
             }
-            return builder.ToImmutableAndFree();
+            return builder.ToImmutable();
         }
 
         private static TupleElementNamesInfo DecodeTupleElementNamesInfo(ImmutableArray<byte> bytes, ref int offset)
         {
             var n = ReadInt32(bytes, ref offset);
-            var builder = ArrayBuilder<string>.GetInstance(n);
+            using var builder = ArrayBuilder<string>.GetInstance(n);
             for (var i = 0; i < n; i++)
             {
                 var value = ReadUtf8String(bytes, ref offset);
@@ -314,7 +312,7 @@ private static TupleElementNamesInfo DecodeTupleElementNamesInfo(ImmutableArray<
             var scopeStart = ReadInt32(bytes, ref offset);
             var scopeEnd = ReadInt32(bytes, ref offset);
             var localName = ReadUtf8String(bytes, ref offset);
-            return new TupleElementNamesInfo(builder.ToImmutableAndFree(), slotIndex, localName, scopeStart, scopeEnd);
+            return new TupleElementNamesInfo(builder.ToImmutable(), slotIndex, localName, scopeStart, scopeEnd);
         }
 
         /// <summary>
@@ -427,8 +425,8 @@ private static void SkipRecord(byte[] bytes, ref int offset, int size)
             var importStrings = getMethodImportStrings(methodToken, arg);
             Debug.Assert(!importStrings.IsDefault);
 
-            var resultBuilder = ArrayBuilder<ImmutableArray<string>>.GetInstance(groupSizes.Length);
-            var groupBuilder = ArrayBuilder<string>.GetInstance();
+            using var resultBuilder = ArrayBuilder<ImmutableArray<string>>.GetInstance(groupSizes.Length);
+            using var groupBuilder = ArrayBuilder<string>.GetInstance();
             var pos = 0;
 
             foreach (var groupSize in groupSizes)
@@ -469,19 +467,17 @@ private static void SkipRecord(byte[] bytes, ref int offset, int size)
                     groupBuilder.Add(importString);
                 }
 
-                externAliasStrings = groupBuilder.ToImmutableAndFree();
+                externAliasStrings = groupBuilder.ToImmutable();
             }
             else
             {
-                groupBuilder.Free();
-
                 if (pos < importStrings.Length)
                 {
                     throw new InvalidOperationException(string.Format("Group size indicates fewer imports than there are import strings (method {0}).", FormatMethodToken(methodToken)));
                 }
             }
 
-            return resultBuilder.ToImmutableAndFree();
+            return resultBuilder.ToImmutable();
         }
 
         /// <summary>

src/Dependencies/PooledObjects/PooledStringBuilder.cs

 // Copyright (c) Microsoft.  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.Diagnostics;
 using System.Text;
 
@@ -13,7 +14,7 @@ namespace Microsoft.CodeAnalysis.PooledObjects
     ///        ... sb.ToString() ...
     ///        inst.Free();
     /// </summary>
-    internal class PooledStringBuilder
+    internal class PooledStringBuilder : IDisposable
     {
         public readonly StringBuilder Builder = new StringBuilder();
         private readonly ObjectPool<PooledStringBuilder> _pool;
@@ -90,6 +91,8 @@ public static PooledStringBuilder GetInstance()
             return builder;
         }
 
+        public void Dispose() => Free();
+
         public static implicit operator StringBuilder(PooledStringBuilder obj)
         {
             return obj.Builder;

src/Features/CSharp/Portable/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionCodeFixProvider.cs

@@ -41,45 +41,38 @@ public override Task RegisterCodeFixesAsync(CodeFixContext context)
         protected override async Task FixAllAsync(Document document, ImmutableArray<Diagnostic> diagnostics, SyntaxEditor editor, CancellationToken cancellationToken)
         {
             var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
-            var spans = ArrayBuilder<TextSpan>.GetInstance(diagnostics.Length);
-            try
+            using var spans = ArrayBuilder<TextSpan>.GetInstance(diagnostics.Length);
+            foreach (var diagnostic in diagnostics)
             {
-                foreach (var diagnostic in diagnostics)
-                {
-                    cancellationToken.ThrowIfCancellationRequested();
+                cancellationToken.ThrowIfCancellationRequested();
 
-                    var span = diagnostic.AdditionalLocations[0].SourceSpan;
-                    if (spans.Any((s, nodeSpan) => s.Contains(nodeSpan), span))
-                    {
-                        // Skip nested switch expressions in case of a fix-all operation.
-                        continue;
-                    }
+                var span = diagnostic.AdditionalLocations[0].SourceSpan;
+                if (spans.Any((s, nodeSpan) => s.Contains(nodeSpan), span))
+                {
+                    // Skip nested switch expressions in case of a fix-all operation.
+                    continue;
+                }
 
-                    spans.Add(span);
+                spans.Add(span);
 
-                    var properties = diagnostic.Properties;
-                    var nodeToGenerate = (SyntaxKind)int.Parse(properties[Constants.NodeToGenerateKey]);
-                    var shouldRemoveNextStatement = bool.Parse(properties[Constants.ShouldRemoveNextStatementKey]);
+                var properties = diagnostic.Properties;
+                var nodeToGenerate = (SyntaxKind)int.Parse(properties[Constants.NodeToGenerateKey]);
+                var shouldRemoveNextStatement = bool.Parse(properties[Constants.ShouldRemoveNextStatementKey]);
 
-                    var switchStatement = (SwitchStatementSyntax)editor.OriginalRoot.FindNode(span);
-                    editor.ReplaceNode(switchStatement,
-                        Rewriter.Rewrite(switchStatement, semanticModel, editor,
-                            nodeToGenerate, shouldMoveNextStatementToSwitchExpression: shouldRemoveNextStatement)
-                        .WithAdditionalAnnotations(Formatter.Annotation));
+                var switchStatement = (SwitchStatementSyntax)editor.OriginalRoot.FindNode(span);
+                editor.ReplaceNode(switchStatement,
+                    Rewriter.Rewrite(switchStatement, semanticModel, editor,
+                        nodeToGenerate, shouldMoveNextStatementToSwitchExpression: shouldRemoveNextStatement)
+                    .WithAdditionalAnnotations(Formatter.Annotation));
 
-                    if (shouldRemoveNextStatement)
-                    {
-                        // Already morphed into the top-level switch expression.
-                        var nextStatement = switchStatement.GetNextStatement();
-                        Debug.Assert(nextStatement.IsKind(SyntaxKind.ThrowStatement, SyntaxKind.ReturnStatement));
-                        editor.RemoveNode(nextStatement);
-                    }
+                if (shouldRemoveNextStatement)
+                {
+                    // Already morphed into the top-level switch expression.
+                    var nextStatement = switchStatement.GetNextStatement();
+                    Debug.Assert(nextStatement.IsKind(SyntaxKind.ThrowStatement, SyntaxKind.ReturnStatement));
+                    editor.RemoveNode(nextStatement);
                 }
             }
-            finally
-            {
-                spans.Free();
-            }
         }
 
         private sealed class MyCodeAction : CodeAction.DocumentChangeAction

src/Features/CSharp/Portable/InlineDeclaration/CSharpInlineDeclarationCodeFixProvider.cs

@@ -73,11 +73,11 @@ public override Task RegisterCodeFixesAsync(CodeFixContext context)
                 originalNodes,
                 t =>
                 {
-                    var additionalNodesToTrack = ArrayBuilder<SyntaxNode>.GetInstance(2);
+                    using var additionalNodesToTrack = ArrayBuilder<SyntaxNode>.GetInstance(2);
                     additionalNodesToTrack.Add(t.identifier);
                     additionalNodesToTrack.Add(t.declarator);
 
-                    return (t.invocationOrCreation, additionalNodesToTrack.ToImmutableAndFree());
+                    return (t.invocationOrCreation, additionalNodesToTrack.ToImmutable());
                 },
                 (_1, _2, _3) => true,
                 (semanticModel, currentRoot, t, currentNode)

src/Features/CSharp/Portable/TypeStyle/UseExplicitTypeCodeFixProvider.cs

@@ -120,7 +120,7 @@ private static ExpressionSyntax GenerateTupleDeclaration(ITypeSymbol typeSymbol,
             var elements = ((INamedTypeSymbol)typeSymbol).TupleElements;
             Debug.Assert(elements.Length == parensDesignation.Variables.Count);
 
-            var builder = ArrayBuilder<SyntaxNode>.GetInstance(elements.Length);
+            using var builder = ArrayBuilder<SyntaxNode>.GetInstance(elements.Length);
             for (var i = 0; i < elements.Length; i++)
             {
                 var designation = parensDesignation.Variables[i];
@@ -151,7 +151,7 @@ private static ExpressionSyntax GenerateTupleDeclaration(ITypeSymbol typeSymbol,
 
             return SyntaxFactory.TupleExpression(
                 SyntaxFactory.Token(SyntaxKind.OpenParenToken).WithTrailingTrivia(),
-                SyntaxFactory.SeparatedList(builder.ToImmutableAndFree(), separatorBuilder.ToImmutableAndFree()),
+                SyntaxFactory.SeparatedList(builder.ToImmutable(), separatorBuilder.ToImmutableAndFree()),
                 SyntaxFactory.Token(SyntaxKind.CloseParenToken))
                 .WithTrailingTrivia(parensDesignation.GetTrailingTrivia());
         }

src/Features/Core/Portable/AddParameter/AbstractAddParameterCodeFixProvider.cs

@@ -230,7 +230,7 @@ private static int NonParamsParameterCount(IMethodSymbol method)
 
             ImmutableArray<CodeAction> NestByOverload()
             {
-                var builder = ArrayBuilder<CodeAction>.GetInstance(codeFixData.Length);
+                using var builder = ArrayBuilder<CodeAction>.GetInstance(codeFixData.Length);
                 foreach (var data in codeFixData)
                 {
                     // We create the mandatory data.CreateChangedSolutionNonCascading fix first.
@@ -259,12 +259,12 @@ ImmutableArray<CodeAction> NestByOverload()
                     builder.Add(codeAction);
                 }
 
-                return builder.ToImmutableAndFree();
+                return builder.ToImmutable();
             }
 
             ImmutableArray<CodeAction> NestByCascading()
             {
-                var builder = ArrayBuilder<CodeAction>.GetInstance(2);
+                using var builder = ArrayBuilder<CodeAction>.GetInstance(2);
 
                 var nonCascadingActions = ImmutableArray.CreateRange<CodeFixData, CodeAction>(codeFixData, data =>
                 {
@@ -294,7 +294,7 @@ ImmutableArray<CodeAction> NestByCascading()
                     builder.Add(new CodeAction.CodeActionWithNestedActions(nestedCascadingTitle, cascadingActions, isInlinable: false));
                 }
 
-                return builder.ToImmutableAndFree();
+                return builder.ToImmutable();
             }
         }
 
@@ -303,7 +303,7 @@ ImmutableArray<CodeAction> NestByCascading()
             SeparatedSyntaxList<TArgumentSyntax> arguments,
             ImmutableArray<ArgumentInsertPositionData<TArgumentSyntax>> methodsAndArgumentsToAdd)
         {
-            var builder = ArrayBuilder<CodeFixData>.GetInstance(methodsAndArgumentsToAdd.Length);
+            using var builder = ArrayBuilder<CodeFixData>.GetInstance(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
@@ -325,7 +325,7 @@ ImmutableArray<CodeAction> NestByCascading()
                 builder.Add(codeFixData);
             }
 
-            return builder.ToImmutableAndFree();
+            return builder.ToImmutable();
         }
 
         private static string GetCodeFixTitle(string resourceString, IMethodSymbol methodToUpdate, bool includeParameters)

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

@@ -162,14 +162,14 @@ public BatchFixer(AbstractSuppressionCodeFixProvider suppressionFixProvider)
 
                 private static async Task<ImmutableArray<SyntaxNode>> GetAttributeNodesToFixAsync(ImmutableArray<AttributeRemoveAction> attributeRemoveFixes, CancellationToken cancellationToken)
                 {
-                    var builder = ArrayBuilder<SyntaxNode>.GetInstance(attributeRemoveFixes.Length);
+                    using var builder = ArrayBuilder<SyntaxNode>.GetInstance(attributeRemoveFixes.Length);
                     foreach (var attributeRemoveFix in attributeRemoveFixes)
                     {
                         var attributeToRemove = await attributeRemoveFix.GetAttributeToRemoveAsync(cancellationToken).ConfigureAwait(false);
                         builder.Add(attributeToRemove);
                     }
 
-                    return builder.ToImmutableAndFree();
+                    return builder.ToImmutable();
                 }
             }
         }

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

@@ -208,40 +208,32 @@ await ChangeNamespaceInSingleDocumentAsync(solutionAfterNamespaceChange, documen
             // will return false. We use span of namespace declaration found in each document to decide if they are identical.            
 
             var documents = ids.SelectAsArray(id => solution.GetDocument(id));
-            var containers = ArrayBuilder<(DocumentId, SyntaxNode)>.GetInstance(ids.Length);
-            var spanForContainers = PooledHashSet<TextSpan>.GetInstance();
+            using var containers = ArrayBuilder<(DocumentId, SyntaxNode)>.GetInstance(ids.Length);
+            using var spanForContainers = PooledHashSet<TextSpan>.GetInstance();
 
-            try
+            foreach (var document in documents)
             {
-                foreach (var document in documents)
-                {
-                    var container = await TryGetApplicableContainerFromSpanAsync(document, span, cancellationToken).ConfigureAwait(false);
-
-                    if (container is TNamespaceDeclarationSyntax)
-                    {
-                        spanForContainers.Add(container.Span);
-                    }
-                    else if (container is TCompilationUnitSyntax)
-                    {
-                        // In case there's no namespace declaration in the document, we used an empty span as key, 
-                        // since a valid namespace declaration node can't have zero length.
-                        spanForContainers.Add(default);
-                    }
-                    else
-                    {
-                        return default;
-                    }
+                var container = await TryGetApplicableContainerFromSpanAsync(document, span, cancellationToken).ConfigureAwait(false);
 
-                    containers.Add((document.Id, container));
+                if (container is TNamespaceDeclarationSyntax)
+                {
+                    spanForContainers.Add(container.Span);
+                }
+                else if (container is TCompilationUnitSyntax)
+                {
+                    // In case there's no namespace declaration in the document, we used an empty span as key, 
+                    // since a valid namespace declaration node can't have zero length.
+                    spanForContainers.Add(default);
+                }
+                else
+                {
+                    return default;
                 }
 
-                return spanForContainers.Count == 1 ? containers.ToImmutable() : default;
-            }
-            finally
-            {
-                containers.Free();
-                spanForContainers.Free();
+                containers.Add((document.Id, container));
             }
+
+            return spanForContainers.Count == 1 ? containers.ToImmutable() : default;
         }
 
         /// <summary>
@@ -342,13 +334,13 @@ private static ImmutableArray<string> GetAllNamespaceImportsForDeclaringDocument
         private ImmutableArray<SyntaxNode> CreateImports(Document document, ImmutableArray<string> names, bool withFormatterAnnotation)
         {
             var generator = SyntaxGenerator.GetGenerator(document);
-            var builder = ArrayBuilder<SyntaxNode>.GetInstance(names.Length);
+            using var builder = ArrayBuilder<SyntaxNode>.GetInstance(names.Length);
             for (var i = 0; i < names.Length; ++i)
             {
                 builder.Add(CreateImport(generator, names[i], withFormatterAnnotation));
             }
 
-            return builder.ToImmutableAndFree();
+            return builder.ToImmutable();
         }
 
         private static SyntaxNode CreateImport(SyntaxGenerator syntaxGenerator, string name, bool withFormatterAnnotation)

src/Features/Core/Portable/Diagnostics/DiagnosticHelper.cs

@@ -145,13 +145,13 @@ private LocalizableStringWithArguments(ObjectReader reader)
                 }
                 else
                 {
-                    var argumentsBuilder = ArrayBuilder<string>.GetInstance(length);
+                    using var argumentsBuilder = ArrayBuilder<string>.GetInstance(length);
                     for (var i = 0; i < length; i++)
                     {
                         argumentsBuilder.Add(reader.ReadString());
                     }
 
-                    _formatArguments = argumentsBuilder.ToArrayAndFree();
+                    _formatArguments = argumentsBuilder.ToArray();
                 }
             }
 

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

@@ -288,19 +288,19 @@ private static bool ShouldConsiderSymbol(ISymbol symbol)
                 await AddLocationSpan(location, solution, spanSet, tagMap, HighlightSpanKind.Reference, cancellationToken).ConfigureAwait(false);
             }
 
-            var list = ArrayBuilder<DocumentHighlights>.GetInstance(tagMap.Count);
+            using var list = ArrayBuilder<DocumentHighlights>.GetInstance(tagMap.Count);
             foreach (var kvp in tagMap)
             {
-                var spans = ArrayBuilder<HighlightSpan>.GetInstance(kvp.Value.Count);
+                using var spans = ArrayBuilder<HighlightSpan>.GetInstance(kvp.Value.Count);
                 foreach (var span in kvp.Value)
                 {
                     spans.Add(span);
                 }
 
-                list.Add(new DocumentHighlights(kvp.Key, spans.ToImmutableAndFree()));
+                list.Add(new DocumentHighlights(kvp.Key, spans.ToImmutable()));
             }
 
-            return list.ToImmutableAndFree();
+            return list.ToImmutable();
         }
 
         private static bool ShouldIncludeDefinition(ISymbol symbol)

src/Features/Core/Portable/EditAndContinue/EditSession.cs

@@ -226,7 +226,7 @@ private async Task<ImmutableArray<ActiveStatementExceptionRegions>> GetBaseActiv
             {
                 var baseActiveStatements = await BaseActiveStatements.GetValueAsync(cancellationToken).ConfigureAwait(false);
                 var instructionMap = baseActiveStatements.InstructionMap;
-                var builder = ArrayBuilder<ActiveStatementExceptionRegions>.GetInstance(instructionMap.Count);
+                using var builder = ArrayBuilder<ActiveStatementExceptionRegions>.GetInstance(instructionMap.Count);
                 builder.Count = instructionMap.Count;
 
                 foreach (var activeStatement in instructionMap.Values)
@@ -241,7 +241,7 @@ private async Task<ImmutableArray<ActiveStatementExceptionRegions>> GetBaseActiv
                     builder[activeStatement.Ordinal] = new ActiveStatementExceptionRegions(exceptionRegions, isCovered);
                 }
 
-                return builder.ToImmutableAndFree();
+                return builder.ToImmutable();
             }
             catch (Exception e) when (FatalError.ReportWithoutCrashUnlessCanceled(e))
             {

src/Features/Core/Portable/GenerateMember/GenerateParameterizedMember/AbstractGenerateDeconstructMethodService.State.cs

@@ -91,14 +91,14 @@ internal new class State :
                 }
 
                 var tupleElements = ((INamedTypeSymbol)targetType).TupleElements;
-                var builder = ArrayBuilder<IParameterSymbol>.GetInstance(tupleElements.Length);
+                using var builder = ArrayBuilder<IParameterSymbol>.GetInstance(tupleElements.Length);
                 foreach (var element in tupleElements)
                 {
                     builder.Add(CodeGenerationSymbolFactory.CreateParameterSymbol(
                         attributes: default, RefKind.Out, isParams: false, element.Type, element.Name));
                 }
 
-                return builder.ToImmutableAndFree();
+                return builder.ToImmutable();
             }
         }
     }

src/Features/Core/Portable/Shared/Naming/IdentifierNameParts.cs

@@ -69,13 +69,13 @@ private static string RemovePrefixesAndSuffixes(ISymbol symbol, ImmutableArray<N
 
         private static ImmutableArray<string> CreateWords(ArrayBuilder<TextSpan> parts, string name)
         {
-            var result = ArrayBuilder<string>.GetInstance(parts.Count);
+            using var result = ArrayBuilder<string>.GetInstance(parts.Count);
             foreach (var part in parts)
             {
                 result.Add(name.Substring(part.Start, part.Length));
             }
 
-            return result.ToImmutableAndFree();
+            return result.ToImmutable();
         }
     }
 }

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

@@ -234,13 +234,13 @@ private bool IsToken(int tokenKind, ArrayBuilder<SyntaxNodeOrToken> pieces, int
         private ImmutableArray<SyntaxNodeOrToken> GetSubRange(
             ArrayBuilder<SyntaxNodeOrToken> pieces, int start, int end)
         {
-            var result = ArrayBuilder<SyntaxNodeOrToken>.GetInstance(end - start);
+            using var result = ArrayBuilder<SyntaxNodeOrToken>.GetInstance(end - start);
             for (var i = start; i < end; i++)
             {
                 result.Add(pieces[i]);
             }
 
-            return result.ToImmutableAndFree();
+            return result.ToImmutable();
         }
 
         private bool IsDecomposableChainPart(SyntaxNode node)