[automated] Merge branch 'main' => 'release/dev18.0'

.github/workflows/main-merge.yml

@@ -1,18 +1,31 @@
-# Merges any changes from release/prerelease to main (e.g. servicing changes)
+# See https://github.com/dotnet/arcade/blob/e52018a/Documentation/Maestro/New-Inter-Branch-Merge-Approach.md
 
-name: Flow main to release/dev18.0
+name: Inter-branch merge
 on:
   schedule:
-    # once a day at 13:00 UTC to cleanup old runs
-    - cron: '0 13 * * *'
+    # Create a merge every 3 hours (works only for merges from `main`, others would need a `push` trigger).
+    - cron: '0 */3 * * *'
   workflow_dispatch:
+    inputs:
+      configuration_file_branch:
+        description: 'Branch to use for configuration file'
+        required: true
+        default: 'main'
 
 permissions:
   contents: write
   pull-requests: write
 
 jobs:
-  check-script:
+  # The config does not support multiple flows from the same source branch,
+  # so we need to run separately for each duplicate source branch (https://github.com/dotnet/arcade/issues/15586).
+  merge:
     uses: dotnet/arcade/.github/workflows/inter-branch-merge-base.yml@main
     with:
-      configuration_file_path: '.config/branch-merge.json'
+      configuration_file_path: 'eng/config/branch-merge.jsonc'
+      configuration_file_branch: ${{ inputs.configuration_file_branch || 'main' }}
+  merge-2:
+    uses: dotnet/arcade/.github/workflows/inter-branch-merge-base.yml@main
+    with:
+      configuration_file_path: 'eng/config/branch-merge-2.jsonc'
+      configuration_file_branch: ${{ inputs.configuration_file_branch || 'main' }}

eng/Version.Details.xml

@@ -8,9 +8,9 @@
       <SourceBuild RepoName="source-build-externals" ManagedOnly="true" />
     </Dependency>
     <!-- Intermediate is necessary for source build. -->
-    <Dependency Name="Microsoft.SourceBuild.Intermediate.source-build-reference-packages" Version="10.0.611901">
+    <Dependency Name="Microsoft.SourceBuild.Intermediate.source-build-reference-packages" Version="10.0.615303">
       <Uri>https://github.com/dotnet/source-build-reference-packages</Uri>
-      <Sha>d794781cc75921b4ebbefe2eabdb0d6cd1713005</Sha>
+      <Sha>964c28e59a72516a64d4c8ff06b797703c5cdbfd</Sha>
       <SourceBuild RepoName="source-build-reference-packages" ManagedOnly="true" />
     </Dependency>
     <Dependency Name="System.CommandLine" Version="2.0.0-beta4.24528.1">

eng/config/PublishData.json

@@ -178,6 +178,16 @@
       "insertionCreateDraftPR": true
     },
     "main": {
+      "nugetKind": [
+        "Shipping",
+        "NonShipping"
+      ],
+      "vsBranch": "main",
+      "vsMajorVersion": 17,
+      "insertionCreateDraftPR": true,
+      "insertionTitlePrefix": "[d17.14 P3]"
+    },
+    "main-vs-deps": {
       "nugetKind": [
         "Shipping",
         "NonShipping"

eng/config/branch-merge-2.jsonc

@@ -0,0 +1,10 @@
+// Used by .github/workflows/main-merge.yml
+{
+    "merge-flow-configurations": {
+        // Merge any main changes to main-vs-deps.
+        "main": {
+            "MergeToBranch": "main-vs-deps",
+            "ExtraSwitches": "-QuietComments"
+        }
+    }
+}

.config/branch-merge.json → eng/config/branch-merge.jsonc

@@ -1,3 +1,4 @@
+// Used by .github/workflows/main-merge.yml
 {
     "merge-flow-configurations": {
         // Merge any main changes to release/dev18.0.
@@ -6,4 +7,4 @@
             "ExtraSwitches": "-QuietComments"
         }
     }
-}
+}

src/Analyzers/CSharp/Analyzers/UseCollectionInitializer/CSharpUseCollectionInitializerAnalyzer.cs

@@ -48,8 +48,11 @@ protected override bool HasExistingInvalidInitializerForCollection()
     protected override bool AnalyzeMatchesAndCollectionConstructorForCollectionExpression(
         ArrayBuilder<CollectionMatch<SyntaxNode>> preMatches,
         ArrayBuilder<CollectionMatch<SyntaxNode>> postMatches,
+        out bool mayChangeSemantics,
         CancellationToken cancellationToken)
     {
+        mayChangeSemantics = false;
+
         // Constructor wasn't called with any arguments.  Nothing to validate.
         var argumentList = _objectCreationExpression.ArgumentList;
         if (argumentList is null || argumentList.Arguments.Count == 0)
@@ -63,20 +66,21 @@ protected override bool AnalyzeMatchesAndCollectionConstructorForCollectionExpre
         if (this.SemanticModel.GetSymbolInfo(_objectCreationExpression, cancellationToken).Symbol is not IMethodSymbol
             {
                 MethodKind: MethodKind.Constructor,
-                Parameters.Length: 1,
+                Parameters: [var firstParameter],
             } constructor)
         {
             return false;
         }
 
-        var ienumerableOfTType = this.SemanticModel.Compilation.IEnumerableOfTType();
-        var firstParameter = constructor.Parameters[0];
-        if (Equals(firstParameter.Type.OriginalDefinition, ienumerableOfTType) ||
-            firstParameter.Type.AllInterfaces.Any(i => Equals(i.OriginalDefinition, ienumerableOfTType)))
+        if (CanSpreadFirstParameter(constructor.ContainingType, firstParameter))
         {
             // Took a single argument that implements IEnumerable<T>.  We handle this by spreading that argument as the
             // first thing added to the collection.
             preMatches.Add(new(argumentList.Arguments[0].Expression, UseSpread: true));
+
+            // Can't be certain that spreading the elements will be the same as passing to the constructor.  So pass
+            // that uncertainty up to the caller so they can inform the user.
+            mayChangeSemantics = true;
             return true;
         }
         else if (firstParameter is { Type.SpecialType: SpecialType.System_Int32, Name: "capacity" })
@@ -195,5 +199,36 @@ protected override bool AnalyzeMatchesAndCollectionConstructorForCollectionExpre
         }
 
         return false;
+
+        bool CanSpreadFirstParameter(INamedTypeSymbol constructedType, IParameterSymbol firstParameter)
+        {
+            var compilation = this.SemanticModel.Compilation;
+
+            var ienumerableOfTType = compilation.IEnumerableOfTType();
+            if (!Equals(firstParameter.Type.OriginalDefinition, ienumerableOfTType) &&
+                !firstParameter.Type.AllInterfaces.Any(i => Equals(i.OriginalDefinition, ienumerableOfTType)))
+            {
+                return false;
+            }
+
+            // Looks like something passed to the constructor call that we could potentially spread instead. e.g. `new
+            // HashSet(someList)` can become `[.. someList]`.  However, check for certain cases we know where this is
+            // wrong and we can't do this.
+
+            // BlockingCollection<T> and Collection<T> both take ownership of the collection passed to them.  So adds to
+            // them will add through to the original collection.  They do not take the original collection and add their
+            // elements to itself.
+
+            var collectionType = compilation.CollectionOfTType();
+            var blockingCollectionType = compilation.BlockingCollectionOfTType();
+            if (constructedType.GetBaseTypesAndThis().Any(
+                    t => Equals(collectionType, t.OriginalDefinition) ||
+                         Equals(blockingCollectionType, t.OriginalDefinition)))
+            {
+                return false;
+            }
+
+            return true;
+        }
     }
 }

src/Analyzers/CSharp/Tests/UseCollectionInitializer/UseCollectionInitializerTests.cs

@@ -7,6 +7,7 @@
 using Microsoft.CodeAnalysis.CSharp.UseCollectionInitializer;
 using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
 using Microsoft.CodeAnalysis.Test.Utilities;
+using Microsoft.CodeAnalysis.Testing;
 using Roslyn.Test.Utilities;
 using Xunit;
 
@@ -1826,4 +1827,42 @@ void M(List<int>? list1)
             LanguageVersion = LanguageVersion.CSharp12,
         }.RunAsync();
     }
+
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/77416")]
+    public async Task TestNoCollectionExpressionForBlockingCollection()
+    {
+        await new VerifyCS.Test
+        {
+            TestCode = """
+                using System;
+                using System.Collections.Concurrent;
+
+                class A
+                {
+                    public void Main(ConcurrentQueue<int> queue)
+                    {
+                        BlockingCollection<int> bc = [|new|](queue);
+                        [|bc.Add(|]42);
+                    }
+                }
+                """,
+            FixedCode = """
+                using System;
+                using System.Collections.Concurrent;
+
+                class A
+                {
+                    public void Main(ConcurrentQueue<int> queue)
+                    {
+                        BlockingCollection<int> bc = new(queue)
+                        {
+                            42
+                        };
+                    }
+                }
+                """,
+            LanguageVersion = LanguageVersion.CSharp13,
+            ReferenceAssemblies = ReferenceAssemblies.Net.Net90,
+        }.RunAsync();
+    }
 }

src/Analyzers/Core/Analyzers/UseCollectionInitializer/AbstractObjectCreationExpressionAnalyzer.cs

@@ -37,7 +37,8 @@ internal abstract class AbstractObjectCreationExpressionAnalyzer<
 {
     public readonly record struct AnalysisResult(
         ImmutableArray<TMatch> PreMatches,
-        ImmutableArray<TMatch> PostMatches);
+        ImmutableArray<TMatch> PostMatches,
+        bool ChangesSemantics);
 
     protected UpdateExpressionState<TExpressionSyntax, TStatementSyntax> State;
 
@@ -48,7 +49,7 @@ public readonly record struct AnalysisResult(
     protected SemanticModel SemanticModel => this.State.SemanticModel;
 
     protected abstract bool ShouldAnalyze(CancellationToken cancellationToken);
-    protected abstract bool TryAddMatches(ArrayBuilder<TMatch> preMatches, ArrayBuilder<TMatch> postMatches, CancellationToken cancellationToken);
+    protected abstract bool TryAddMatches(ArrayBuilder<TMatch> preMatches, ArrayBuilder<TMatch> postMatches, out bool changesSemantics, CancellationToken cancellationToken);
     protected abstract bool IsInitializerOfLocalDeclarationStatement(
         TLocalDeclarationStatementSyntax localDeclarationStatement, TObjectCreationExpressionSyntax rootExpression, [NotNullWhen(true)] out TVariableDeclaratorSyntax? variableDeclarator);
 
@@ -87,10 +88,10 @@ protected AnalysisResult AnalyzeWorker(CancellationToken cancellationToken)
 
         using var _1 = ArrayBuilder<TMatch>.GetInstance(out var preMatches);
         using var _2 = ArrayBuilder<TMatch>.GetInstance(out var postMatches);
-        if (!TryAddMatches(preMatches, postMatches, cancellationToken))
+        if (!TryAddMatches(preMatches, postMatches, out var mayChangeSemantics, cancellationToken))
             return default;
 
-        return new(preMatches.ToImmutableAndClear(), postMatches.ToImmutableAndClear());
+        return new(preMatches.ToImmutableAndClear(), postMatches.ToImmutableAndClear(), mayChangeSemantics);
     }
 
     protected UpdateExpressionState<TExpressionSyntax, TStatementSyntax>? TryInitializeState(

src/Analyzers/Core/Analyzers/UseCollectionInitializer/AbstractUseCollectionInitializerAnalyzer.cs

@@ -50,7 +50,10 @@ internal abstract class AbstractUseCollectionInitializerAnalyzer<
     protected abstract bool IsComplexElementInitializer(SyntaxNode expression);
     protected abstract bool HasExistingInvalidInitializerForCollection();
     protected abstract bool AnalyzeMatchesAndCollectionConstructorForCollectionExpression(
-        ArrayBuilder<CollectionMatch<SyntaxNode>> preMatches, ArrayBuilder<CollectionMatch<SyntaxNode>> postMatches, CancellationToken cancellationToken);
+        ArrayBuilder<CollectionMatch<SyntaxNode>> preMatches,
+        ArrayBuilder<CollectionMatch<SyntaxNode>> postMatches,
+        out bool mayChangeSemantics,
+        CancellationToken cancellationToken);
 
     protected abstract IUpdateExpressionSyntaxHelper<TExpressionSyntax, TStatementSyntax> SyntaxHelper { get; }
 
@@ -66,7 +69,7 @@ public AnalysisResult Analyze(
             return default;
 
         this.Initialize(state.Value, objectCreationExpression, analyzeForCollectionExpression);
-        var (preMatches, postMatches) = this.AnalyzeWorker(cancellationToken);
+        var (preMatches, postMatches, mayChangeSemantics) = this.AnalyzeWorker(cancellationToken);
 
         // If analysis failed entirely, immediately bail out.
         if (preMatches.IsDefault || postMatches.IsDefault)
@@ -81,15 +84,19 @@ public AnalysisResult Analyze(
         // other words, we don't want to suggest changing `new List<int>()` to `new List<int>() { }` as that's just
         // noise.  So convert empty results to an invalid result here.
         if (analyzeForCollectionExpression)
-            return new(preMatches, postMatches);
+            return new(preMatches, postMatches, mayChangeSemantics);
 
         // Downgrade an empty result to a failure for the normal collection-initializer case.
-        return postMatches.IsEmpty ? default : new(preMatches, postMatches);
+        return postMatches.IsEmpty ? default : new(preMatches, postMatches, mayChangeSemantics);
     }
 
     protected sealed override bool TryAddMatches(
-        ArrayBuilder<CollectionMatch<SyntaxNode>> preMatches, ArrayBuilder<CollectionMatch<SyntaxNode>> postMatches, CancellationToken cancellationToken)
+        ArrayBuilder<CollectionMatch<SyntaxNode>> preMatches,
+        ArrayBuilder<CollectionMatch<SyntaxNode>> postMatches,
+        out bool mayChangeSemantics,
+        CancellationToken cancellationToken)
     {
+        mayChangeSemantics = false;
         var seenInvocation = false;
         var seenIndexAssignment = false;
 
@@ -127,7 +134,10 @@ protected sealed override bool TryAddMatches(
         }
 
         if (_analyzeForCollectionExpression)
-            return AnalyzeMatchesAndCollectionConstructorForCollectionExpression(preMatches, postMatches, cancellationToken);
+        {
+            return AnalyzeMatchesAndCollectionConstructorForCollectionExpression(
+                preMatches, postMatches, out mayChangeSemantics, cancellationToken);
+        }
 
         return true;
     }

src/Analyzers/Core/Analyzers/UseCollectionInitializer/AbstractUseCollectionInitializerDiagnosticAnalyzer.cs

@@ -68,10 +68,7 @@ public override DiagnosticAnalyzerCategory GetAnalyzerCategory()
         isUnnecessary: true);
 
     protected AbstractUseCollectionInitializerDiagnosticAnalyzer()
-        : base(
-            [
-                (s_descriptor, CodeStyleOptions2.PreferCollectionInitializer)
-            ])
+        : base([(s_descriptor, CodeStyleOptions2.PreferCollectionInitializer)])
     {
     }
 
@@ -117,9 +114,9 @@ private void OnCompilationStart(CompilationStartAnalysisContext context)
         // as a non-local diagnostic and would not participate in lightbulb for computing code fixes.
         var expressionType = context.Compilation.ExpressionOfTType();
         context.RegisterCodeBlockStartAction<TSyntaxKind>(blockStartContext =>
-                blockStartContext.RegisterSyntaxNodeAction(
-                    nodeContext => AnalyzeNode(nodeContext, ienumerableType, expressionType),
-                    matchKindsArray));
+            blockStartContext.RegisterSyntaxNodeAction(
+                nodeContext => AnalyzeNode(nodeContext, ienumerableType, expressionType),
+                matchKindsArray));
     }
 
     private void AnalyzeNode(
@@ -206,13 +203,13 @@ private void AnalyzeNode(
             if (!preferInitializerOption.Value)
                 return null;
 
-            var (_, matches) = analyzer.Analyze(semanticModel, syntaxFacts, objectCreationExpression, analyzeForCollectionExpression: false, cancellationToken);
+            var (_, matches, changesSemantics) = analyzer.Analyze(semanticModel, syntaxFacts, objectCreationExpression, analyzeForCollectionExpression: false, cancellationToken);
 
             // If analysis failed, we can't change this, no matter what.
             if (matches.IsDefault)
                 return null;
 
-            return (matches, shouldUseCollectionExpression: false, changesSemantics: false);
+            return (matches, shouldUseCollectionExpression: false, changesSemantics);
         }
 
         (ImmutableArray<CollectionMatch<SyntaxNode>> matches, bool shouldUseCollectionExpression, bool changesSemantics)? GetCollectionExpressionMatches()
@@ -224,18 +221,18 @@ private void AnalyzeNode(
             if (!this.AreCollectionExpressionsSupported(context.Compilation))
                 return null;
 
-            var (preMatches, postMatches) = analyzer.Analyze(semanticModel, syntaxFacts, objectCreationExpression, analyzeForCollectionExpression: true, cancellationToken);
+            var (preMatches, postMatches, changesSemantics1) = analyzer.Analyze(semanticModel, syntaxFacts, objectCreationExpression, analyzeForCollectionExpression: true, cancellationToken);
 
             // If analysis failed, we can't change this, no matter what.
             if (preMatches.IsDefault || postMatches.IsDefault)
                 return null;
 
             // Check if it would actually be legal to use a collection expression here though.
             var allowSemanticsChange = preferExpressionOption.Value == CollectionExpressionPreference.WhenTypesLooselyMatch;
-            if (!CanUseCollectionExpression(semanticModel, objectCreationExpression, expressionType, preMatches, allowSemanticsChange, cancellationToken, out var changesSemantics))
+            if (!CanUseCollectionExpression(semanticModel, objectCreationExpression, expressionType, preMatches, allowSemanticsChange, cancellationToken, out var changesSemantics2))
                 return null;
 
-            return (preMatches.Concat(postMatches), shouldUseCollectionExpression: true, changesSemantics);
+            return (preMatches.Concat(postMatches), shouldUseCollectionExpression: true, changesSemantics1 || changesSemantics2);
         }
     }
 

src/Analyzers/Core/Analyzers/UseObjectInitializer/UseNamedMemberInitializerAnalyzer.cs

@@ -69,8 +69,10 @@ protected sealed override bool ShouldAnalyze(CancellationToken cancellationToken
     protected sealed override bool TryAddMatches(
         ArrayBuilder<Match<TExpressionSyntax, TStatementSyntax, TMemberAccessExpressionSyntax, TAssignmentStatementSyntax>> preMatches,
         ArrayBuilder<Match<TExpressionSyntax, TStatementSyntax, TMemberAccessExpressionSyntax, TAssignmentStatementSyntax>> postMatches,
+        out bool changesSemantics,
         CancellationToken cancellationToken)
     {
+        changesSemantics = false;
         using var _1 = PooledHashSet<string>.GetInstance(out var seenNames);
 
         var initializer = this.SyntaxFacts.GetInitializerOfBaseObjectCreationExpression(_objectCreationExpression);

src/Analyzers/Core/CodeFixes/UseCollectionInitializer/AbstractUseCollectionInitializerCodeFixProvider.cs

@@ -76,7 +76,7 @@ protected sealed override async Task FixAsync(
         using var analyzer = GetAnalyzer();
 
         var useCollectionExpression = properties.ContainsKey(UseCollectionInitializerHelpers.UseCollectionExpressionName) is true;
-        var (preMatches, postMatches) = analyzer.Analyze(
+        var (preMatches, postMatches, _) = analyzer.Analyze(
             semanticModel, syntaxFacts, objectCreation, useCollectionExpression, cancellationToken);
 
         if (preMatches.IsDefault || postMatches.IsDefault)

src/Analyzers/VisualBasic/Analyzers/UseCollectionInitializer/VisualBasicCollectionInitializerAnalyzer.vb

@@ -41,6 +41,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.UseCollectionInitializer
         Protected Overrides Function AnalyzeMatchesAndCollectionConstructorForCollectionExpression(
                 preMatches As ArrayBuilder(Of CollectionMatch(Of SyntaxNode)),
                 postMatches As ArrayBuilder(Of CollectionMatch(Of SyntaxNode)),
+                ByRef changesSemantics As Boolean,
                 cancellationToken As CancellationToken) As Boolean
             ' Only called for collection expressions, which VB does not support
             Throw ExceptionUtilities.Unreachable()