Building

dotnet · CyrusNajmabadi · Jul 28, 2023 · Jul 24, 2023 · Jul 24, 2023 · Jul 24, 2023
commit e96f92674fb542988b8e72e50004b80cedaa9534
@@ -43,7 +43,7 @@ protected override StatementSyntax GetNewStatement(
             StatementSyntax statement,
             BaseObjectCreationExpressionSyntax objectCreation,
             bool useCollectionExpression,
-            ImmutableArray<StatementSyntax> matches)
+            ImmutableArray<Match<StatementSyntax>> matches)
         {
             return statement.ReplaceNode(
                 objectCreation,
@@ -53,7 +53,7 @@ protected override StatementSyntax GetNewStatement(
         private static ExpressionSyntax GetNewObjectCreation(
             BaseObjectCreationExpressionSyntax objectCreation,
             bool useCollectionExpression,
-            ImmutableArray<StatementSyntax> matches)
+            ImmutableArray<Match<StatementSyntax>> matches)
         {
             var expressions = CreateExpressions(objectCreation, matches);
             return useCollectionExpression
@@ -63,7 +63,7 @@ private static ExpressionSyntax GetNewObjectCreation(
 
         private static CollectionExpressionSyntax CreateCollectionExpression(
             BaseObjectCreationExpressionSyntax objectCreation,
-            ImmutableArray<StatementSyntax> matches,
+            ImmutableArray<Match<StatementSyntax>> matches,
             SeparatedSyntaxList<ExpressionSyntax> expressions)
         {
             using var _ = ArrayBuilder<SyntaxNodeOrToken>.GetInstance(out var nodesAndTokens);
@@ -78,7 +78,7 @@ private static CollectionExpressionSyntax CreateCollectionExpression(
                 else
                 {
                     var expression = (ExpressionSyntax)nodeOrToken.AsNode()!;
-                    nodesAndTokens.Add(matches[expressionIndex] is ForEachStatementSyntax
+                    nodesAndTokens.Add(matches[expressionIndex].UseSpread
                         ? SpreadElement(expression)
                         : ExpressionElement(expression));
                     expressionIndex++;
@@ -90,15 +90,15 @@ private static CollectionExpressionSyntax CreateCollectionExpression(
 
         private static SeparatedSyntaxList<ExpressionSyntax> CreateExpressions(
             BaseObjectCreationExpressionSyntax objectCreation,
-            ImmutableArray<StatementSyntax> matches)
+            ImmutableArray<Match<StatementSyntax>> matches)
         {
             using var _ = ArrayBuilder<SyntaxNodeOrToken>.GetInstance(out var nodesAndTokens);
 
             UseInitializerHelpers.AddExistingItems(objectCreation, nodesAndTokens);
 
             for (var i = 0; i < matches.Length; i++)
             {
-                var statement = matches[i];
+                var statement = matches[i].Statement;
 
                 var trivia = statement.GetLeadingTrivia();
                 var newTrivia = i == 0 ? trivia.WithoutLeadingBlankLines() : trivia;

@@ -17,6 +17,10 @@
 
 namespace Microsoft.CodeAnalysis.UseCollectionInitializer
 {
+    internal readonly record struct Match<TStatementSyntax>(
+        TStatementSyntax Statement,
+        bool UseSpread) where TStatementSyntax : SyntaxNode;
+
     internal abstract partial class AbstractUseCollectionInitializerDiagnosticAnalyzer<
         TSyntaxKind,
         TExpressionSyntax,
@@ -128,7 +132,7 @@ private void AnalyzeNode(SyntaxNodeAnalysisContext context, INamedTypeSymbol ien
             if (matches.IsDefaultOrEmpty)
                 return;
 
-            var nodes = ImmutableArray.Create<SyntaxNode>(containingStatement).AddRange(matches);
+            var nodes = ImmutableArray.Create<SyntaxNode>(containingStatement).AddRange(matches.Select(static m => m.Statement));
             var syntaxFacts = GetSyntaxFacts();
             if (syntaxFacts.ContainsInterleavedDirective(nodes, cancellationToken))
                 return;
@@ -146,7 +150,7 @@ private void AnalyzeNode(SyntaxNodeAnalysisContext context, INamedTypeSymbol ien
 
             return;
 
-            (ImmutableArray<TStatementSyntax> matches, bool shouldUseCollectionExpression) GetMatches()
+            (ImmutableArray<Match<TStatementSyntax>> matches, bool shouldUseCollectionExpression) GetMatches()
             {
                 // Analyze the surrounding statements. First, try a broader set of statements if the language supports
                 // collection expressions. 
@@ -190,13 +194,13 @@ bool AreCollectionExpressionsSupported()
 
         private void FadeOutCode(
             SyntaxNodeAnalysisContext context,
-            ImmutableArray<TStatementSyntax> matches,
+            ImmutableArray<Match<TStatementSyntax>> matches,
             ImmutableArray<Location> locations)
         {
             var syntaxTree = context.Node.SyntaxTree;
             var syntaxFacts = GetSyntaxFacts();
 
-            foreach (var match in matches)
+            foreach (var (match, _) in matches)
             {
                 if (match is TExpressionStatementSyntax)
                 {

@@ -2,6 +2,7 @@
 // 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.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
@@ -25,7 +26,7 @@ internal sealed class UseCollectionInitializerAnalyzer<
             TStatementSyntax,
             TObjectCreationExpressionSyntax,
             TVariableDeclaratorSyntax,
-            TStatementSyntax>
+            Match<TStatementSyntax>>
         where TExpressionSyntax : SyntaxNode
         where TStatementSyntax : SyntaxNode
         where TObjectCreationExpressionSyntax : TExpressionSyntax
@@ -38,7 +39,7 @@ internal sealed class UseCollectionInitializerAnalyzer<
         private static readonly ObjectPool<UseCollectionInitializerAnalyzer<TExpressionSyntax, TStatementSyntax, TObjectCreationExpressionSyntax, TMemberAccessExpressionSyntax, TInvocationExpressionSyntax, TExpressionStatementSyntax, TForeachStatementSyntax, TVariableDeclaratorSyntax>> s_pool
             = SharedPools.Default<UseCollectionInitializerAnalyzer<TExpressionSyntax, TStatementSyntax, TObjectCreationExpressionSyntax, TMemberAccessExpressionSyntax, TInvocationExpressionSyntax, TExpressionStatementSyntax, TForeachStatementSyntax, TVariableDeclaratorSyntax>>();
 
-        public static ImmutableArray<TStatementSyntax> Analyze(
+        public static ImmutableArray<Match<TStatementSyntax>> Analyze(
             SemanticModel semanticModel,
             ISyntaxFacts syntaxFacts,
             TObjectCreationExpressionSyntax objectCreationExpression,
@@ -58,7 +59,7 @@ public static ImmutableArray<TStatementSyntax> Analyze(
             }
         }
 
-        protected override void AddMatches(ArrayBuilder<TStatementSyntax> matches)
+        protected override void AddMatches(ArrayBuilder<Match<TStatementSyntax>> matches)
         {
             // If containing statement is inside a block (e.g. method), than we need to iterate through its child statements.
             // If containing statement is in top-level code, than we need to iterate through child statements of containing compilation unit.
@@ -107,20 +108,42 @@ protected override void AddMatches(ArrayBuilder<TStatementSyntax> matches)
 
                 if (extractedChild is TExpressionStatementSyntax expressionStatement)
                 {
-                    TExpressionSyntax? instance = null;
-                    if (!seenIndexAssignment && TryAnalyzeAddInvocation(expressionStatement, requiredArgumentName: null, out instance))
-                        seenInvocation = true;
-
-                    if (!seenInvocation && !_analyzeForCollectionExpression && TryAnalyzeIndexAssignment(expressionStatement, out instance))
-                        seenIndexAssignment = true;
-
-                    if (instance == null)
-                        return;
+                    if (!seenIndexAssignment)
+                    {
+                        // Look for a call to Add or AddRange
+                        if (TryAnalyzeInvocation(
+                                expressionStatement,
+                                addName: WellKnownMemberNames.CollectionInitializerAddMethodName,
+                                requiredArgumentName: null,
+                                out var instance) &&
+                            ValuePatternMatches(instance))
+                        {
+                            seenInvocation = true;
+                            matches.Add(new Match<TStatementSyntax>(expressionStatement, UseSpread: false));
+                        }
+                        else if (
+                            _analyzeForCollectionExpression &&
+                            TryAnalyzeInvocation(
+                                expressionStatement,
+                                addName: nameof(List<int>.AddRange),
+                                requiredArgumentName: null,
+                                out instance))
+                        {
+                            seenInvocation = true;
+                            matches.Add(new Match<TStatementSyntax>(expressionStatement, UseSpread: true));
+                        }
+                    }
 
-                    if (!ValuePatternMatches(instance))
-                        return;
+                    if (!seenInvocation && !_analyzeForCollectionExpression)
+                    {
+                        if (TryAnalyzeIndexAssignment(expressionStatement, out var instance))
+                        {
+                            seenIndexAssignment = true;
+                            matches.Add(new Match<TStatementSyntax>(expressionStatement, UseSpread: false));
+                        }
+                    }
 
-                    matches.Add(expressionStatement);
+                    return;
                 }
                 else if (extractedChild is TForeachStatementSyntax foreachStatement)
                 {
@@ -134,14 +157,13 @@ protected override void AddMatches(ArrayBuilder<TStatementSyntax> matches)
                         return;
 
                     if (foreachStatements.ToImmutableArray() is not [TExpressionStatementSyntax childExpressionStatement] ||
-                        !TryAnalyzeAddInvocation(childExpressionStatement, identifier.Text, out var instance) ||
-                        instance is null ||
+                        !TryAnalyzeInvocation(childExpressionStatement, addName: WellKnownMemberNames.CollectionInitializerAddMethodName, identifier.Text, out var instance) ||
                         !ValuePatternMatches(instance))
                     {
                         return;
                     }
 
-                    matches.Add(foreachStatement);
+                    matches.Add(new Match<TStatementSyntax>(foreachStatement, UseSpread: true));
                 }
                 else
                 {
@@ -211,8 +233,9 @@ private bool TryAnalyzeIndexAssignment(
             return instance != null;
         }
 
-        private bool TryAnalyzeAddInvocation(
+        private bool TryAnalyzeInvocation(
             TExpressionStatementSyntax statement,
+            string addName,
             string? requiredArgumentName,
             [NotNullWhen(true)] out TExpressionSyntax? instance)
         {
@@ -271,7 +294,7 @@ private bool TryAnalyzeAddInvocation(
             _syntaxFacts.GetPartsOfMemberAccessExpression(memberAccess, out var localInstance, out var memberName);
             _syntaxFacts.GetNameAndArityOfSimpleName(memberName, out var name, out var arity);
 
-            if (arity != 0 || !Equals(name, WellKnownMemberNames.CollectionInitializerAddMethodName))
+            if (arity != 0 || !Equals(name, addName))
                 return false;
 
             instance = localInstance as TExpressionSyntax;

@@ -39,7 +39,7 @@ public static ImmutableArray<Match<TExpressionSyntax, TStatementSyntax, TMemberA
             CancellationToken cancellationToken)
         {
             var analyzer = s_pool.Allocate();
-            analyzer.Initialize(semanticModel, syntaxFacts, objectCreationExpression, areCollectionExpressionsSupported: false, cancellationToken);
+            analyzer.Initialize(semanticModel, syntaxFacts, objectCreationExpression, analyzeForCollectionExpression: false, cancellationToken);
             try
             {
                 return analyzer.AnalyzeWorker();

@@ -45,7 +45,7 @@ public override ImmutableArray<string> FixableDiagnosticIds
             => ImmutableArray.Create(IDEDiagnosticIds.UseCollectionInitializerDiagnosticId);
 
         protected abstract TStatementSyntax GetNewStatement(
-            TStatementSyntax statement, TObjectCreationExpressionSyntax objectCreation, bool useCollectionExpression, ImmutableArray<TStatementSyntax> matches);
+            TStatementSyntax statement, TObjectCreationExpressionSyntax objectCreation, bool useCollectionExpression, ImmutableArray<Match<TStatementSyntax>> matches);
 
         protected override bool IncludeDiagnosticDuringFixAll(Diagnostic diagnostic)
             => !diagnostic.Descriptor.ImmutableCustomTags().Contains(WellKnownDiagnosticTags.Unnecessary);
@@ -93,20 +93,20 @@ protected override async Task FixAllAsync(
                 var matches = UseCollectionInitializerAnalyzer<TExpressionSyntax, TStatementSyntax, TObjectCreationExpressionSyntax, TMemberAccessExpressionSyntax, TInvocationExpressionSyntax, TExpressionStatementSyntax, TForeachStatementSyntax, TVariableDeclaratorSyntax>.Analyze(
                     semanticModel, syntaxFacts, objectCreation, useCollectionExpression, cancellationToken);
 
-                if (matches == null || matches.Value.Length == 0)
+                if (matches.IsDefaultOrEmpty)
                     continue;
 
                 var statement = objectCreation.FirstAncestorOrSelf<TStatementSyntax>();
                 Contract.ThrowIfNull(statement);
 
-                var newStatement = GetNewStatement(statement, objectCreation, useCollectionExpression, matches.Value)
+                var newStatement = GetNewStatement(statement, objectCreation, useCollectionExpression, matches)
                     .WithAdditionalAnnotations(Formatter.Annotation);
 
                 var subEditor = new SyntaxEditor(currentRoot, document.Project.Solution.Services);
 
                 subEditor.ReplaceNode(statement, newStatement);
                 foreach (var match in matches)
-                    subEditor.RemoveNode(match, SyntaxRemoveOptions.KeepUnbalancedDirectives);
+                    subEditor.RemoveNode(match.Statement, SyntaxRemoveOptions.KeepUnbalancedDirectives);
 
                 document = document.WithSyntaxRoot(subEditor.GetChangedRoot());
                 semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);

@@ -86,15 +86,13 @@ protected override async Task FixAllAsync(
                 var matches = UseNamedMemberInitializerAnalyzer<TExpressionSyntax, TStatementSyntax, TObjectCreationExpressionSyntax, TMemberAccessExpressionSyntax, TAssignmentStatementSyntax, TVariableDeclaratorSyntax>.Analyze(
                     semanticModel, syntaxFacts, objectCreation, cancellationToken);
 
-                if (matches == null || matches.Value.Length == 0)
-                {
+                if (matches.IsDefaultOrEmpty)
                     continue;
-                }
 
                 var statement = objectCreation.FirstAncestorOrSelf<TStatementSyntax>();
                 Contract.ThrowIfNull(statement);
 
-                var newStatement = GetNewStatement(statement, objectCreation, matches.Value)
+                var newStatement = GetNewStatement(statement, objectCreation, matches)
                     .WithAdditionalAnnotations(Formatter.Annotation);
 
                 var subEditor = new SyntaxEditor(currentRoot, document.Project.Solution.Services);

@@ -34,7 +34,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.UseCollectionInitializer
                 statement As StatementSyntax,
                 objectCreation As ObjectCreationExpressionSyntax,
                 useCollectionExpression As Boolean,
-                matches As ImmutableArray(Of StatementSyntax)) As StatementSyntax
+                matches As ImmutableArray(Of Match(Of StatementSyntax))) As StatementSyntax
             Contract.ThrowIfTrue(useCollectionExpression, "VB does not support collection expressions")
             Dim newStatement = statement.ReplaceNode(
                 objectCreation,
@@ -45,7 +45,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.UseCollectionInitializer
             totalTrivia.Add(SyntaxFactory.ElasticMarker)
 
             For Each match In matches
-                For Each trivia In match.GetLeadingTrivia()
+                For Each trivia In match.Statement.GetLeadingTrivia()
                     If trivia.Kind = SyntaxKind.CommentTrivia Then
                         totalTrivia.Add(trivia)
                         totalTrivia.Add(SyntaxFactory.ElasticMarker)
@@ -58,7 +58,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.UseCollectionInitializer
 
         Private Shared Function GetNewObjectCreation(
                 objectCreation As ObjectCreationExpressionSyntax,
-                matches As ImmutableArray(Of StatementSyntax)) As ObjectCreationExpressionSyntax
+                matches As ImmutableArray(Of Match(Of StatementSyntax))) As ObjectCreationExpressionSyntax
 
             Return UseInitializerHelpers.GetNewObjectCreation(
                 objectCreation,
@@ -68,13 +68,13 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.UseCollectionInitializer
 
         Private Shared Function CreateCollectionInitializer(
                 objectCreation As ObjectCreationExpressionSyntax,
-                matches As ImmutableArray(Of StatementSyntax)) As CollectionInitializerSyntax
+                matches As ImmutableArray(Of Match(Of StatementSyntax))) As CollectionInitializerSyntax
             Dim nodesAndTokens = ArrayBuilder(Of SyntaxNodeOrToken).GetInstance()
 
             AddExistingItems(objectCreation, nodesAndTokens)
 
             For i = 0 To matches.Length - 1
-                Dim expressionStatement = DirectCast(matches(i), ExpressionStatementSyntax)
+                Dim expressionStatement = DirectCast(matches(i).Statement, ExpressionStatementSyntax)
 
                 Dim newExpression As ExpressionSyntax
                 Dim invocationExpression = DirectCast(expressionStatement.Expression, InvocationExpressionSyntax)