Support collection expressions for non-copyable analyzer

eng/Versions.props

@@ -70,7 +70,7 @@
     <!-- Versions for tests and general utility execution. -->
     <!-- This version is for utility and executable assemblies. The version here should not overlap with any of the surface
          area versions. -->
-    <MicrosoftCodeAnalysisVersionForTests>4.8.0</MicrosoftCodeAnalysisVersionForTests>
+    <MicrosoftCodeAnalysisVersionForTests>4.9.0-3.final</MicrosoftCodeAnalysisVersionForTests>
     <MicrosoftCodeAnalysisVersionForExecution>4.6.0-1.final</MicrosoftCodeAnalysisVersionForExecution>
     <MicrosoftCodeAnalysisCSharpCodeStyleVersion>4.6.0</MicrosoftCodeAnalysisCSharpCodeStyleVersion>
     <MicrosoftCodeAnalysisVisualBasicCodeStyleVersion>4.6.0</MicrosoftCodeAnalysisVisualBasicCodeStyleVersion>

src/Roslyn.Diagnostics.Analyzers/Core/AbstractDoNotCopyValue.cs

@@ -10,6 +10,7 @@
 using System.Linq;
 using Analyzer.Utilities;
 using Analyzer.Utilities.Extensions;
+using Analyzer.Utilities.Lightup;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.FlowAnalysis;
@@ -1437,6 +1438,9 @@ when SymbolEqualityComparer.Default.Equals(taskType, Cache.ValueTaskT) || Symbol
                     case OperationKind.Throw:
                         return RefKind.None;
 
+                    case OperationKindEx.CollectionExpression:
+                        return RefKind.None;
+
                     default:
                         return RefKind.RefReadOnly;
                 }

src/Roslyn.Diagnostics.Analyzers/UnitTests/DoNotCopyValueTests.cs

@@ -1400,5 +1400,123 @@ End Structure
                 // /0/Test0.vb(38,22): warning RS0042: Auto-property 'Private Property Property3 As CannotCopy' cannot have non-copyable type 'CannotCopy'
                 VerifyVB.Diagnostic(AbstractDoNotCopyValue.NoAutoPropertyRule).WithLocation(1).WithArguments("CannotCopy", "Private Property Property3 As CannotCopy"));
         }
+
+        [Fact]
+        public async Task AllowCopyFromCollectionExpression()
+        {
+            var source = """
+                using System;
+                using System.Collections;
+                using System.Collections.Generic;
+                using System.Runtime.CompilerServices;
+
+                [NonCopyable]
+                [CollectionBuilder(typeof(MyCollection), nameof(Create))]
+                partial struct MyCollection : IEnumerable<int>
+                {
+                    public IEnumerator<int> GetEnumerator() => null;
+                    IEnumerator IEnumerable.GetEnumerator() => null;
+
+                    public static MyCollection Create(ReadOnlySpan<int> r) => throw null;
+                }
+
+                class C
+                {
+                    void M()
+                    {
+                        MyCollection m = [1, 2, 3];
+                        m = [];
+                    }
+                }
+
+                internal sealed class NonCopyableAttribute : System.Attribute { }
+
+                namespace System.Runtime.CompilerServices
+                {
+                    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface, Inherited = false)]
+                    internal sealed class CollectionBuilderAttribute : Attribute
+                    {
+                        public CollectionBuilderAttribute(Type builderType, string methodName)
+                        {
+                            BuilderType = builderType;
+                            MethodName = methodName;
+                        }
+
+                        public Type BuilderType { get; }
+
+                        public string MethodName { get; }
+                    }
+                }
+                """;
+
+            await new VerifyCS.Test
+            {
+                TestCode = source,
+                LanguageVersion = Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp12,
+            }.RunAsync();
+        }
+
+        [Fact]
+        public async Task DoNotAllowCopyInCollectionExpressionElement()
+        {
+            var source = """
+                using System;
+                using System.Collections;
+                using System.Collections.Generic;
+                using System.Runtime.CompilerServices;
+
+                [NonCopyable]
+                struct S
+                {
+                }
+
+                [CollectionBuilder(typeof(MyCollection), nameof(Create))]
+                partial struct MyCollection : IEnumerable<S>
+                {
+                    public IEnumerator<S> GetEnumerator() => throw null;
+                    IEnumerator IEnumerable.GetEnumerator() => throw null;
+
+                    public static MyCollection Create(ReadOnlySpan<S> r) => throw null;
+                }
+
+                class C
+                {
+                    void M()
+                    {
+                        S s = new();
+                        MyCollection m = [{|#0:s|}, new S()];
+                    }
+                }
+
+                internal sealed class NonCopyableAttribute : System.Attribute { }
+
+                namespace System.Runtime.CompilerServices
+                {
+                    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface, Inherited = false)]
+                    internal sealed class CollectionBuilderAttribute : Attribute
+                    {
+                        public CollectionBuilderAttribute(Type builderType, string methodName)
+                        {
+                            BuilderType = builderType;
+                            MethodName = methodName;
+                        }
+
+                        public Type BuilderType { get; }
+
+                        public string MethodName { get; }
+                    }
+                }
+                """;
+
+            await new VerifyCS.Test
+            {
+                TestCode = source,
+                LanguageVersion = Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp12,
+                ExpectedDiagnostics = {
+                    // /0/Test0.cs(25,27): warning RS0042: Unsupported use of non-copyable type 'S' in 'LocalReference' operation
+                    VerifyCS.Diagnostic(AbstractDoNotCopyValue.UnsupportedUseRule).WithLocation(0).WithArguments("S", "LocalReference")
+                }
+            }.RunAsync();
+        }
     }
 }

src/Utilities/Compiler/Lightup/OperationKindEx.cs

@@ -12,6 +12,7 @@ internal static class OperationKindEx
         public const OperationKind ImplicitIndexerReference = (OperationKind)0x7b;
         public const OperationKind Utf8String = (OperationKind)0x7c;
         public const OperationKind Attribute = (OperationKind)0x7d;
+        public const OperationKind CollectionExpression = (OperationKind)0x7f;
     }
 }