simplify

src/Features/Core/Portable/Wrapping/BinaryExpression/AbstractBinaryExpressionWrapper.cs

@@ -99,9 +99,9 @@ internal abstract partial class AbstractBinaryExpressionWrapper<TBinaryExpressio
         private ImmutableArray<SyntaxNodeOrToken> GetExpressionsAndOperators(
             PrecedenceKind precedence, TBinaryExpressionSyntax binaryExpr)
         {
-            var result = ArrayBuilder<SyntaxNodeOrToken>.GetInstance();
+            using var _ = ArrayBuilder<SyntaxNodeOrToken>.GetInstance(out var result);
             AddExpressionsAndOperators(precedence, binaryExpr, result);
-            return result.ToImmutableAndFree();
+            return result.ToImmutable();
         }
 
         private void AddExpressionsAndOperators(

src/Features/Core/Portable/Wrapping/BinaryExpression/BinaryExpressionCodeActionComputer.cs

@@ -83,7 +83,7 @@ private Task<WrapItemsAction> GetUnwrapCodeActionAsync()
 
             private ImmutableArray<Edit> GetWrapEdits(bool align)
             {
-                var result = ArrayBuilder<Edit>.GetInstance();
+                using var _ = ArrayBuilder<Edit>.GetInstance(out var result);
                 var indentationTrivia = align ? _indentAndAlignTrivia : _smartIndentTrivia;
 
                 for (var i = 1; i < _exprsAndOperators.Length; i += 2)
@@ -114,12 +114,12 @@ private ImmutableArray<Edit> GetWrapEdits(bool align)
                     }
                 }
 
-                return result.ToImmutableAndFree();
+                return result.ToImmutable();
             }
 
             private ImmutableArray<Edit> GetUnwrapEdits()
             {
-                var result = ArrayBuilder<Edit>.GetInstance();
+                using var _ = ArrayBuilder<Edit>.GetInstance(out var result);
 
                 for (var i = 0; i < _exprsAndOperators.Length - 1; i++)
                 {
@@ -128,7 +128,7 @@ private ImmutableArray<Edit> GetUnwrapEdits()
                         NoTrivia, _exprsAndOperators[i + 1]));
                 }
 
-                return result.ToImmutableAndFree();
+                return result.ToImmutable();
             }
         }
     }

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

@@ -123,7 +123,7 @@ private ImmutableArray<ImmutableArray<SyntaxNodeOrToken>> GetChainChunks(SyntaxN
             // nodes and tokens we want to treat as individual elements.  i.e. an 
             // element that would be kept together.  For example, the arg-list of an
             // invocation is an element we do not want to ever break-up/wrap. 
-            using var _ = ArrayBuilder<SyntaxNodeOrToken>.GetInstance(out var pieces);
+            using var _1 = ArrayBuilder<SyntaxNodeOrToken>.GetInstance(out var pieces);
             Decompose(node, pieces);
 
             // Now that we have the pieces, find 'chunks' similar to the form:
@@ -134,9 +134,9 @@ private ImmutableArray<ImmutableArray<SyntaxNodeOrToken>> GetChainChunks(SyntaxN
             // 
             // Here 'remainder' is everything up to the next <c>. Name (...)</c> chunk.
 
-            var chunks = ArrayBuilder<ImmutableArray<SyntaxNodeOrToken>>.GetInstance();
+            using var _2 = ArrayBuilder<ImmutableArray<SyntaxNodeOrToken>>.GetInstance(out var chunks);
             BreakPiecesIntoChunks(pieces, chunks);
-            return chunks.ToImmutableAndFree();
+            return chunks.ToImmutable();
         }
 
         private void BreakPiecesIntoChunks(

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

@@ -92,13 +92,13 @@ private class CallExpressionCodeActionComputer :
 
             protected override async Task<ImmutableArray<WrappingGroup>> ComputeWrappingGroupsAsync()
             {
-                var actions = ArrayBuilder<WrapItemsAction>.GetInstance();
+                using var _ = ArrayBuilder<WrapItemsAction>.GetInstance(out var actions);
 
                 await AddWrapCodeActionAsync(actions).ConfigureAwait(false);
                 await AddUnwrapCodeActionAsync(actions).ConfigureAwait(false);
                 await AddWrapLongCodeActionAsync(actions).ConfigureAwait(false);
 
-                return ImmutableArray.Create(new WrappingGroup(isInlinable: true, actions.ToImmutableAndFree()));
+                return ImmutableArray.Create(new WrappingGroup(isInlinable: true, actions.ToImmutable()));
             }
 
             // Pass 0 as the wrapping column as we effectively always want to wrap each chunk
@@ -120,7 +120,7 @@ private async Task AddWrapLongCodeActionAsync(ArrayBuilder<WrapItemsAction> acti
 
             private ImmutableArray<Edit> GetWrapEdits(int wrappingColumn, bool align)
             {
-                var result = ArrayBuilder<Edit>.GetInstance();
+                using var _ = ArrayBuilder<Edit>.GetInstance(out var result);
 
                 // First, normalize the first chunk.
                 var firstChunk = _chunks[0];
@@ -160,7 +160,7 @@ private ImmutableArray<Edit> GetWrapEdits(int wrappingColumn, bool align)
                     position += NormalizedWidth(chunk);
                 }
 
-                return result.ToImmutableAndFree();
+                return result.ToImmutable();
             }
 
             private static int NormalizedWidth(ImmutableArray<SyntaxNodeOrToken> chunk)
@@ -168,14 +168,14 @@ private static int NormalizedWidth(ImmutableArray<SyntaxNodeOrToken> chunk)
 
             private ImmutableArray<Edit> GetUnwrapEdits()
             {
-                var result = ArrayBuilder<Edit>.GetInstance();
+                using var _ = ArrayBuilder<Edit>.GetInstance(out var result);
 
                 // Flatten all the chunks into one long list.  Then delete all the spaces
                 // between each piece in that full list.
                 var flattened = _chunks.SelectMany(c => c).ToImmutableArray();
                 DeleteAllSpacesInChunk(result, flattened);
 
-                return result.ToImmutableAndFree();
+                return result.ToImmutable();
             }
 
             private static void DeleteAllSpacesInChunk(

src/Features/Core/Portable/Wrapping/SeparatedSyntaxList/SeparatedSyntaxListCodeActionComputer.cs

@@ -100,9 +100,9 @@ private SyntaxTrivia GetIndentationTrivia(WrappingStyle wrappingStyle)
 
             protected override async Task<ImmutableArray<WrappingGroup>> ComputeWrappingGroupsAsync()
             {
-                var result = ArrayBuilder<WrappingGroup>.GetInstance();
+                using var _ = ArrayBuilder<WrappingGroup>.GetInstance(out var result);
                 await AddWrappingGroupsAsync(result).ConfigureAwait(false);
-                return result.ToImmutableAndFree();
+                return result.ToImmutable();
             }
 
             private async Task AddWrappingGroupsAsync(ArrayBuilder<WrappingGroup> result)
@@ -116,7 +116,7 @@ private async Task AddWrappingGroupsAsync(ArrayBuilder<WrappingGroup> result)
 
             private async Task<WrappingGroup> GetUnwrapGroupAsync()
             {
-                var unwrapActions = ArrayBuilder<WrapItemsAction>.GetInstance();
+                using var _ = ArrayBuilder<WrapItemsAction>.GetInstance(out var unwrapActions);
 
                 var parentTitle = Wrapper.Unwrap_list;
 
@@ -129,7 +129,7 @@ private async Task<WrappingGroup> GetUnwrapGroupAsync()
 
                 // The 'unwrap' title strings are unique and do not collide with any other code
                 // actions we're computing.  So they can be inlined if possible.
-                return new WrappingGroup(isInlinable: true, unwrapActions.ToImmutableAndFree());
+                return new WrappingGroup(isInlinable: true, unwrapActions.ToImmutable());
             }
 
             private async Task<WrapItemsAction> GetUnwrapAllCodeActionAsync(string parentTitle, WrappingStyle wrappingStyle)
@@ -144,7 +144,7 @@ private async Task<WrapItemsAction> GetUnwrapAllCodeActionAsync(string parentTit
 
             private ImmutableArray<Edit> GetUnwrapAllEdits(WrappingStyle wrappingStyle)
             {
-                var result = ArrayBuilder<Edit>.GetInstance();
+                using var _ = ArrayBuilder<Edit>.GetInstance(out var result);
 
                 AddTextChangeBetweenOpenAndFirstItem(wrappingStyle, result);
 
@@ -155,7 +155,7 @@ private ImmutableArray<Edit> GetUnwrapAllEdits(WrappingStyle wrappingStyle)
                 }
 
                 result.Add(Edit.DeleteBetween(_listItems.Last(), _listSyntax.GetLastToken()));
-                return result.ToImmutableAndFree();
+                return result.ToImmutable();
             }
 
             #endregion
@@ -165,7 +165,7 @@ private ImmutableArray<Edit> GetUnwrapAllEdits(WrappingStyle wrappingStyle)
             private async Task<WrappingGroup> GetWrapLongGroupAsync()
             {
                 var parentTitle = Wrapper.Wrap_long_list;
-                var codeActions = ArrayBuilder<WrapItemsAction>.GetInstance();
+                using var _ = ArrayBuilder<WrapItemsAction>.GetInstance(out var codeActions);
 
                 // MethodName(int a, int b, int c,
                 //            int d, int e, int f,
@@ -198,7 +198,7 @@ private async Task<WrappingGroup> GetWrapLongGroupAsync()
                 // We can't in-line these nested actions because the parent title is necessary to
                 // determine which situation each child action applies to.
 
-                return new WrappingGroup(isInlinable: false, codeActions.ToImmutableAndFree());
+                return new WrappingGroup(isInlinable: false, codeActions.ToImmutable());
             }
 
             private async Task<WrapItemsAction> GetWrapLongLineCodeActionAsync(
@@ -215,7 +215,7 @@ private async Task<WrappingGroup> GetWrapLongGroupAsync()
             private ImmutableArray<Edit> GetWrapLongLinesEdits(
                 WrappingStyle wrappingStyle, SyntaxTrivia indentationTrivia)
             {
-                var result = ArrayBuilder<Edit>.GetInstance();
+                using var _ = ArrayBuilder<Edit>.GetInstance(out var result);
 
                 AddTextChangeBetweenOpenAndFirstItem(wrappingStyle, result);
 
@@ -258,7 +258,7 @@ private async Task<WrappingGroup> GetWrapLongGroupAsync()
                     currentOffset += nextToken.Span.Length;
                 }
 
-                return result.ToImmutableAndFree();
+                return result.ToImmutable();
             }
 
             #endregion
@@ -269,7 +269,7 @@ private async Task<WrappingGroup> GetWrapEveryGroupAsync()
             {
                 var parentTitle = Wrapper.Wrap_every_item;
 
-                var codeActions = ArrayBuilder<WrapItemsAction>.GetInstance();
+                using var _ = ArrayBuilder<WrapItemsAction>.GetInstance(out var codeActions);
 
                 // MethodName(int a,
                 //            int b,
@@ -295,7 +295,7 @@ private async Task<WrappingGroup> GetWrapEveryGroupAsync()
 
                 // See comment in GetWrapLongTopLevelCodeActionAsync for explanation of why we're
                 // not inlinable.
-                return new WrappingGroup(isInlinable: false, codeActions.ToImmutableAndFree());
+                return new WrappingGroup(isInlinable: false, codeActions.ToImmutable());
             }
 
             private async Task<WrapItemsAction> GetWrapEveryNestedCodeActionAsync(
@@ -321,7 +321,7 @@ private string GetNestedCodeActionTitle(WrappingStyle wrappingStyle)
             private ImmutableArray<Edit> GetWrapEachEdits(
                 WrappingStyle wrappingStyle, SyntaxTrivia indentationTrivia)
             {
-                var result = ArrayBuilder<Edit>.GetInstance();
+                using var _ = ArrayBuilder<Edit>.GetInstance(out var result);
 
                 AddTextChangeBetweenOpenAndFirstItem(wrappingStyle, result);
 
@@ -345,7 +345,7 @@ private string GetNestedCodeActionTitle(WrappingStyle wrappingStyle)
                 // last item.  Delete whatever is between it and the close token of the list.
                 result.Add(Edit.DeleteBetween(_listItems.Last(), _listSyntax.GetLastToken()));
 
-                return result.ToImmutableAndFree();
+                return result.ToImmutable();
             }
 
             #endregion