src/Compilers/CSharp/Test/Emit3/Semantics/CollectionExpressionTests_WithElement_ArraysAndSpans.cs - main - githubmirror/roslyn

src/Compilers/CSharp/Test/Emit3/Semantics/CollectionExpressionTests_WithElement_ArraysAndSpans.cs
831 строка29 KB
Cyrus Najmabadi
Add test-plan tests for `with(...)` elements. (#81922)
13 янв 2026, 23:16
13 янв 2026, 23:16ee3bf52
// Licensed to the .NET Foundation under one or more agreements.
// 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.Linq;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
using Microsoft.CodeAnalysis.Test.Utilities;
using Roslyn.Test.Utilities;
using Xunit;

namespace Microsoft.CodeAnalysis.CSharp.UnitTests;

[CompilerTrait(CompilerFeature.CollectionExpressions)]
public sealed class CollectionExpressionTests_WithElement_ArraysAndSpans : CSharpTestBase
{
    [Fact]
    public void WithElement_Array_Simple()
    {
        var source = """
            class C
            {
                void M()
                {
                    int[] array = [with(), 1, 2, 3];
                }
            }
            """;

        CreateCompilation(source).VerifyDiagnostics(
            // (5,24): error CS9336: Collection arguments are not supported for type 'int[]'.
            //         int[] array = [with(), 1, 2, 3];
            Diagnostic(ErrorCode.ERR_CollectionArgumentsNotSupportedForType, "with").WithArguments("int[]").WithLocation(5, 24));
    }

    [Fact]
    public void WithElement_Array_WithArguments()
    {
        var source = """
            class C
            {
                void M()
                {
                    int[] array = [with(capacity: 10), 1, 2, 3];
                }
            }
            """;

        CreateCompilation(source).VerifyDiagnostics(
            // (5,24): error CS9336: Collection arguments are not supported for type 'int[]'.
            //         int[] array = [with(capacity: 10), 1, 2, 3];
            Diagnostic(ErrorCode.ERR_CollectionArgumentsNotSupportedForType, "with").WithArguments("int[]").WithLocation(5, 24));
    }

    [Fact]
    public void WithElement_Array_Multidimensional()
    {
        var source = """
            class C
            {
                void M()
                {
                    int[,] array = [with()];
                }
            }
            """;

        CreateCompilation(source).VerifyDiagnostics(
            // (5,24): error CS9174: Cannot initialize type 'int[*,*]' with a collection expression because the type is not constructible.
            //         int[,] array = [with()];
            Diagnostic(ErrorCode.ERR_CollectionExpressionTargetTypeNotConstructible, "[with()]").WithArguments("int[*,*]").WithLocation(5, 24));
    }

    [Fact]
    public void WithElement_Array_Jagged()
    {
        var source = """
            class C
            {
                void M()
                {
                    int[][] array = [with(), new int[] { 1, 2 }];
                }
            }
            """;

        CreateCompilation(source).VerifyDiagnostics(
            // (5,26): error CS9336: Collection arguments are not supported for type 'int[][]'.
            //         int[][] array = [with(), new int[] { 1, 2 }];
            Diagnostic(ErrorCode.ERR_CollectionArgumentsNotSupportedForType, "with").WithArguments("int[][]").WithLocation(5, 26));
    }

    [Fact]
    public void WithElement_Array_Empty()
    {
        var source = """
            class C
            {
                void M()
                {
                    int[] array = [with()];
                }
            }
            """;

        CreateCompilation(source).VerifyDiagnostics(
            // (5,24): error CS9336: Collection arguments are not supported for type 'int[]'.
            //         int[] array = [with()];
            Diagnostic(ErrorCode.ERR_CollectionArgumentsNotSupportedForType, "with").WithArguments("int[]").WithLocation(5, 24));
    }

    [Fact]
    public void WithElement_Array_WithNamedArguments()
    {
        var source = """
            class C
            {
                void M()
                {
                    string[] array = [with(capacity: 5, name: "test"), "hello", "world"];
                }
            }
            """;

        CreateCompilation(source).VerifyDiagnostics(
            // (5,27): error CS9336: Collection arguments are not supported for type 'string[]'.
            //         string[] array = [with(capacity: 5, name: "test"), "hello", "world"];
            Diagnostic(ErrorCode.ERR_CollectionArgumentsNotSupportedForType, "with").WithArguments("string[]").WithLocation(5, 27));
    }

    [Fact]
    public void WithElement_Span_Simple()
    {
        var source = """
            using System;
            
            class C
            {
                void M()
                {
                    Span<int> span = [with(), 1, 2, 3];
                }
            }
            """;

        CreateCompilation(source, targetFramework: TargetFramework.Net80).VerifyDiagnostics(
            // (7,27): error CS9336: Collection arguments are not supported for type 'Span<int>'.
            //         Span<int> span = [with(), 1, 2, 3];
            Diagnostic(ErrorCode.ERR_CollectionArgumentsNotSupportedForType, "with").WithArguments("System.Span<int>").WithLocation(7, 27));
    }

    [Fact]
    public void WithElement_Span_WithArguments()
    {
        var source = """
            using System;
            
            class C
            {
                void M()
                {
                    Span<int> span = [with(capacity: 10), 1, 2, 3];
                }
            }
            """;

        CreateCompilation(source, targetFramework: TargetFramework.Net80).VerifyDiagnostics(
            // (7,27): error CS9336: Collection arguments are not supported for type 'Span<int>'.
            //         Span<int> span = [with(capacity: 10), 1, 2, 3];
            Diagnostic(ErrorCode.ERR_CollectionArgumentsNotSupportedForType, "with").WithArguments("System.Span<int>").WithLocation(7, 27));
    }

    [Fact]
    public void WithElement_Span_Empty()
    {
        var source = """
            using System;
            
            class C
            {
                void M()
                {
                    Span<int> span = [with()];
                }
            }
            """;

        CreateCompilation(source, targetFramework: TargetFramework.Net80).VerifyDiagnostics(
            // (7,27): error CS9336: Collection arguments are not supported for type 'Span<int>'.
            //         Span<int> span = [with()];
            Diagnostic(ErrorCode.ERR_CollectionArgumentsNotSupportedForType, "with").WithArguments("System.Span<int>").WithLocation(7, 27));
    }

    [Fact]
    public void WithElement_Span_WithNamedArguments()
    {
        var source = """
            using System;
            
            class C
            {
                void M()
                {
                    Span<string> span = [with(size: 10), "hello", "world"];
                }
            }
            """;

        CreateCompilation(source, targetFramework: TargetFramework.Net80).VerifyDiagnostics(
            // (7,30): error CS9336: Collection arguments are not supported for type 'Span<string>'.
            //         Span<string> span = [with(size: 10), "hello", "world"];
            Diagnostic(ErrorCode.ERR_CollectionArgumentsNotSupportedForType, "with").WithArguments("System.Span<string>").WithLocation(7, 30));
    }

    [Fact]
    public void WithElement_ReadOnlySpan_Simple()
    {
        var source = """
            using System;
            
            class C
            {
                void M()
                {
                    ReadOnlySpan<int> span = [with(), 1, 2, 3];
                }
            }
            """;

        CreateCompilation(source, targetFramework: TargetFramework.Net80).VerifyDiagnostics(
            // (7,35): error CS9336: Collection arguments are not supported for type 'ReadOnlySpan<int>'.
            //         ReadOnlySpan<int> span = [with(), 1, 2, 3];
            Diagnostic(ErrorCode.ERR_CollectionArgumentsNotSupportedForType, "with").WithArguments("System.ReadOnlySpan<int>").WithLocation(7, 35));
    }

    [Fact]
    public void WithElement_ReadOnlySpan_WithArguments()
    {
        var source = """
            using System;
            
            class C
            {
                void M()
                {
                    ReadOnlySpan<int> span = [with(capacity: 10), 1, 2, 3];
                }
            }
            """;

        CreateCompilation(source, targetFramework: TargetFramework.Net80).VerifyDiagnostics(
            // (7,35): error CS9336: Collection arguments are not supported for type 'ReadOnlySpan<int>'.
            //         ReadOnlySpan<int> span = [with(capacity: 10), 1, 2, 3];
            Diagnostic(ErrorCode.ERR_CollectionArgumentsNotSupportedForType, "with").WithArguments("System.ReadOnlySpan<int>").WithLocation(7, 35));
    }

    [Fact]
    public void WithElement_ReadOnlySpan_Empty()
    {
        var source = """
            using System;
            
            class C
            {
                void M()
                {
                    ReadOnlySpan<int> span = [with()];
                }
            }
            """;

        CreateCompilation(source, targetFramework: TargetFramework.Net80).VerifyDiagnostics(
            // (7,35): error CS9336: Collection arguments are not supported for type 'ReadOnlySpan<int>'.
            //         ReadOnlySpan<int> span = [with()];
            Diagnostic(ErrorCode.ERR_CollectionArgumentsNotSupportedForType, "with").WithArguments("System.ReadOnlySpan<int>").WithLocation(7, 35));
    }

    [Fact]
    public void WithElement_ReadOnlySpan_WithNamedArguments()
    {
        var source = """
            using System;
            
            class C
            {
                void M()
                {
                    ReadOnlySpan<char> span = [with(length: 5), 'a', 'b', 'c'];
                }
            }
            """;

        CreateCompilation(source, targetFramework: TargetFramework.Net80).VerifyDiagnostics(
            // (7,36): error CS9336: Collection arguments are not supported for type 'ReadOnlySpan<char>'.
            //         ReadOnlySpan<char> span = [with(length: 5), 'a', 'b', 'c'];
            Diagnostic(ErrorCode.ERR_CollectionArgumentsNotSupportedForType, "with").WithArguments("System.ReadOnlySpan<char>").WithLocation(7, 36));
    }

    [Fact]
    public void WithElement_Array_NestedInGeneric()
    {
        var source = """
            using System.Collections.Generic;
            
            class C
            {
                void M()
                {
                    List<int[]> list = [[with(), 1, 2, 3]];
                }
            }
            """;

        CreateCompilation(source).VerifyDiagnostics(
            // (7,30): error CS9336: Collection arguments are not supported for type 'int[]'.
            //         List<int[]> list = [[with(), 1, 2, 3]];
            Diagnostic(ErrorCode.ERR_CollectionArgumentsNotSupportedForType, "with").WithArguments("int[]").WithLocation(7, 30));
    }

    [Fact]
    public void WithElement_Span_NestedInGeneric()
    {
        var source = """
            using System;
            using System.Collections.Generic;
            
            class C
            {
                void M()
                {
                    List<Span<int>> list = [[with(), 1, 2, 3]];
                }
            }
            """;

        CreateCompilation(source, targetFramework: TargetFramework.Net80).VerifyDiagnostics(
            // (8,14): error CS9244: The type 'Span<int>' may not be a ref struct or a type parameter allowing ref structs in order to use it as parameter 'T' in the generic type or method 'List<T>'
            //         List<Span<int>> list = [[with(), 1, 2, 3]];
            Diagnostic(ErrorCode.ERR_NotRefStructConstraintNotSatisfied, "Span<int>").WithArguments("System.Collections.Generic.List<T>", "T", "System.Span<int>").WithLocation(8, 14),
            // (8,34): error CS9336: Collection arguments are not supported for type 'Span<int>'.
            //         List<Span<int>> list = [[with(), 1, 2, 3]];
            Diagnostic(ErrorCode.ERR_CollectionArgumentsNotSupportedForType, "with").WithArguments("System.Span<int>").WithLocation(8, 34));
    }

    [Fact]
    public void WithElement_ReadOnlySpan_NestedInGeneric()
    {
        var source = """
            using System;
            using System.Collections.Generic;
            
            class C
            {
                void M()
                {
                    List<ReadOnlySpan<int>> list = [[with(), 1, 2, 3]];
                }
            }
            """;

        CreateCompilation(source, targetFramework: TargetFramework.Net80).VerifyDiagnostics(
            // (8,14): error CS9244: The type 'ReadOnlySpan<int>' may not be a ref struct or a type parameter allowing ref structs in order to use it as parameter 'T' in the generic type or method 'List<T>'
            //         List<ReadOnlySpan<int>> list = [[with(), 1, 2, 3]];
            Diagnostic(ErrorCode.ERR_NotRefStructConstraintNotSatisfied, "ReadOnlySpan<int>").WithArguments("System.Collections.Generic.List<T>", "T", "System.ReadOnlySpan<int>").WithLocation(8, 14),
            // (8,42): error CS9336: Collection arguments are not supported for type 'ReadOnlySpan<int>'.
            //         List<ReadOnlySpan<int>> list = [[with(), 1, 2, 3]];
            Diagnostic(ErrorCode.ERR_CollectionArgumentsNotSupportedForType, "with").WithArguments("System.ReadOnlySpan<int>").WithLocation(8, 42));
    }

    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/77827")]
    public void WithElement_RefLikeElementType1()
    {
        var source = """
            using System;
            using System.Collections.Generic;
            
            class C
            {
                static void Main()
                {
                    IEnumerable<ReadOnlySpan<int>> list = [[1, 2, 3], [4, 5, 6]];

                    foreach (var span in list)
                    {
                        foreach (var item in span)
                        {
                            Console.Write(item + " ");
                        }
                    }
                }
            }
            """;

        CreateCompilation(source, targetFramework: TargetFramework.Net90).VerifyDiagnostics(
            // (8,47): error CS9404: Element type of an interface collection may not be a ref struct or a type parameter allowing ref structs
            //         IEnumerable<ReadOnlySpan<int>> list = [[1, 2, 3], [4, 5, 6]];
            Diagnostic(ErrorCode.ERR_CollectionRefLikeElementType, "[[1, 2, 3], [4, 5, 6]]").WithLocation(8, 47));
    }

    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/77827")]
    public void WithElement_RefLikeElementType2()
    {
        var source = """
            using System.Collections.Generic;
            
            class C
            {
                static void Goo<T>(T t1) where T : allows ref struct
                {
                    IEnumerable<T> list = [t1];
                }
            }
            """;

        CreateCompilation(source, targetFramework: TargetFramework.Net90).VerifyDiagnostics(
            // (7,31): error CS9404: Element type of an interface collection may not be a ref struct or a type parameter allowing ref structs
            //         IEnumerable<T> list = [t1];
            Diagnostic(ErrorCode.ERR_CollectionRefLikeElementType, "[t1]").WithLocation(7, 31));
    }

    [Fact]
    public void WithElement_Array_AsMethodParameter()
    {
        var source = """
            class C
            {
                void Method(int[] array) { }
                
                void M()
                {
                    Method([with(capacity: 10), 1, 2, 3]);
                }
            }
            """;

        CreateCompilation(source).VerifyDiagnostics(
            // (7,17): error CS9336: Collection arguments are not supported for type 'int[]'.
            //         Method([with(capacity: 10), 1, 2, 3]);
            Diagnostic(ErrorCode.ERR_CollectionArgumentsNotSupportedForType, "with").WithArguments("int[]").WithLocation(7, 17));
    }

    [Fact]
    public void WithElement_Span_AsMethodParameter()
    {
        var source = """
            using System;
            
            class C
            {
                void Method(Span<int> span) { }
                
                void M()
                {
                    Method([with(capacity: 10), 1, 2, 3]);
                }
            }
            """;

        CreateCompilation(source, targetFramework: TargetFramework.Net80).VerifyDiagnostics(
            // (9,17): error CS9336: Collection arguments are not supported for type 'Span<int>'.
            //         Method([with(capacity: 10), 1, 2, 3]);
            Diagnostic(ErrorCode.ERR_CollectionArgumentsNotSupportedForType, "with").WithArguments("System.Span<int>").WithLocation(9, 17));
    }

    [Fact]
    public void WithElement_ReadOnlySpan_AsMethodParameter()
    {
        var source = """
            using System;
            
            class C
            {
                void Method(ReadOnlySpan<int> span) { }
                
                void M()
                {
                    Method([with(capacity: 10), 1, 2, 3]);
                }
            }
            """;

        CreateCompilation(source, targetFramework: TargetFramework.Net80).VerifyDiagnostics(
            // (9,17): error CS9336: Collection arguments are not supported for type 'ReadOnlySpan<int>'.
            //         Method([with(capacity: 10), 1, 2, 3]);
            Diagnostic(ErrorCode.ERR_CollectionArgumentsNotSupportedForType, "with").WithArguments("System.ReadOnlySpan<int>").WithLocation(9, 17));
    }

    [Fact]
    public void WithElement_Array_AsReturnValue()
    {
        var source = """
            class C
            {
                int[] Method()
                {
                    return [with(), 1, 2, 3];
                }
            }
            """;

        CreateCompilation(source).VerifyDiagnostics(
            // (5,17): error CS9336: Collection arguments are not supported for type 'int[]'.
            //         return [with(), 1, 2, 3];
            Diagnostic(ErrorCode.ERR_CollectionArgumentsNotSupportedForType, "with").WithArguments("int[]").WithLocation(5, 17));
    }

    [Fact]
    public void WithElement_Span_AsReturnValue()
    {
        var source = """
            using System;
            
            class C
            {
                Span<int> Method()
                {
                    return [with(), 1, 2, 3];
                }
            }
            """;

        CreateCompilation(source, targetFramework: TargetFramework.Net80).VerifyDiagnostics(
            // (7,17): error CS9401: 'with(...)' elements are not supported for type 'Span<int>'
            //         return [with(), 1, 2, 3];
            Diagnostic(ErrorCode.ERR_CollectionArgumentsNotSupportedForType, "with").WithArguments("System.Span<int>").WithLocation(7, 17));
    }

    [Fact]
    public void WithElement_ReadOnlySpan_AsReturnValue()
    {
        var source = """
            using System;
            
            class C
            {
                ReadOnlySpan<int> Method()
                {
                    return [with(), 1, 2, 3];
                }
            }
            """;

        CreateCompilation(source, targetFramework: TargetFramework.Net80).VerifyDiagnostics(
            // (7,17): error CS9336: Collection arguments are not supported for type 'ReadOnlySpan<int>'.
            //         return [with(), 1, 2, 3];
            Diagnostic(ErrorCode.ERR_CollectionArgumentsNotSupportedForType, "with").WithArguments("System.ReadOnlySpan<int>").WithLocation(7, 17));
    }

    [Fact]
    public void WithElement_Array_WithRefOutInParameters()
    {
        var source = """
            class C
            {
                void M()
                {
                    int x = 10;
                    int[] array = [with(ref x), 1, 2, 3];
                }
            }
            """;

        CreateCompilation(source).VerifyDiagnostics(
            // (6,24): error CS9401: 'with(...)' elements are not supported for type 'int[]'
            //         int[] array = [with(ref x), 1, 2, 3];
            Diagnostic(ErrorCode.ERR_CollectionArgumentsNotSupportedForType, "with").WithArguments("int[]").WithLocation(6, 24));
    }

    [Fact]
    public void WithElement_Span_WithRefOutInParameters()
    {
        var source = """
            using System;
            
            class C
            {
                void M()
                {
                    int x = 10;
                    Span<int> span = [with(in x), 1, 2, 3];
                }
            }
            """;

        var compilation = CreateCompilation(source, targetFramework: TargetFramework.Net80).VerifyDiagnostics(
            // (8,27): error CS9401: 'with(...)' elements are not supported for type 'Span<int>'
            //         Span<int> span = [with(in x), 1, 2, 3];
            Diagnostic(ErrorCode.ERR_CollectionArgumentsNotSupportedForType, "with").WithArguments("System.Span<int>").WithLocation(8, 27));
        var tree = compilation.SyntaxTrees.Single();
        var root = tree.GetRoot();
        compilation.VerifyOperationTree(root.DescendantNodes().OfType<CollectionExpressionSyntax>().Single(), """
            ICollectionExpressionOperation (3 elements, ConstructMethod: null) (OperationKind.CollectionExpression, Type: System.Span<System.Int32>, IsInvalid) (Syntax: '[with(in x), 1, 2, 3]')
              ConstructArguments(1):
                  ILocalReferenceOperation: x (OperationKind.LocalReference, Type: System.Int32) (Syntax: 'x')
              Elements(3):
                  ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 1) (Syntax: '1')
                  ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 2) (Syntax: '2')
                  ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 3) (Syntax: '3')
            """);
    }

    [Fact(Skip = "https://github.com/dotnet/roslyn/issues/80518")]
    public void WithElement_ReadOnlySpan_WithOutVar()
    {
        var source = """
            using System;
            
            class C
            {
                void M()
                {
                    ReadOnlySpan<int> span = [with(out var x), x, x + 1];
                }
            }
            """;

        CreateCompilation(source, targetFramework: TargetFramework.Net80).VerifyDiagnostics();
    }

    [Fact]
    public void WithElement_Array_WithParamsArguments()
    {
        var source = """
            class C
            {
                void M()
                {
                    int[] array = [with(1, 2, 3, 4, 5), 6, 7, 8];
                }
            }
            """;

        CreateCompilation(source).VerifyDiagnostics(
            // (5,24): error CS9336: Collection arguments are not supported for type 'int[]'.
            //         int[] array = [with(1, 2, 3, 4, 5), 6, 7, 8];
            Diagnostic(ErrorCode.ERR_CollectionArgumentsNotSupportedForType, "with").WithArguments("int[]").WithLocation(5, 24));
    }

    [Fact]
    public void WithElement_Array_WithDynamicArguments()
    {
        var source = """
            class C
            {
                void M()
                {
                    dynamic d = 42;
                    int[] array = [with(d), 1, 2, 3];
                }
            }
            """;

        CreateCompilation(source).VerifyDiagnostics(
            // (6,29): error CS9337: Collection arguments cannot be dynamic
            //         int[] array = [with(d), 1, 2, 3];
            Diagnostic(ErrorCode.ERR_CollectionArgumentsDynamicBinding, "d").WithLocation(6, 29));
    }

    [Fact]
    public void WithElement_Span_WithDynamicArguments()
    {
        var source = """
            using System;
            
            class C
            {
                void M()
                {
                    dynamic d = 42;
                    Span<int> span = [with(capacity: d), 1, 2, 3];
                }
            }
            """;

        CreateCompilation(source, targetFramework: TargetFramework.Net80).VerifyDiagnostics(
            // (8,42): error CS9337: Collection arguments cannot be dynamic
            //         Span<int> span = [with(capacity: d), 1, 2, 3];
            Diagnostic(ErrorCode.ERR_CollectionArgumentsDynamicBinding, "d").WithLocation(8, 42));
    }

    [Fact]
    public void WithElement_Array_ImplicitlyTyped()
    {
        var source = """
            class C
            {
                void M()
                {
                    var array = [with(), 1, 2, 3] as int[];
                }
            }
            """;

        CreateCompilation(source).VerifyDiagnostics(
            // (5,21): error CS9176: There is no target type for the collection expression.
            //         var array = [with(), 1, 2, 3] as int[];
            Diagnostic(ErrorCode.ERR_CollectionExpressionNoTargetType, "[with(), 1, 2, 3]").WithLocation(5, 21));
    }

    [Fact]
    public void WithElement_Span_ImplicitlyTyped()
    {
        var source = """
            using System;
            
            class C
            {
                void M()
                {
                    var span = [with(), 1, 2, 3] as Span<int>;
                }
            }
            """;

        CreateCompilation(source, targetFramework: TargetFramework.Net80).VerifyDiagnostics(
            // (7,20): error CS9176: There is no target type for the collection expression.
            //         var span = [with(), 1, 2, 3] as Span<int>;
            Diagnostic(ErrorCode.ERR_CollectionExpressionNoTargetType, "[with(), 1, 2, 3]").WithLocation(7, 20));
    }

    [Fact]
    public void WithElement_ReadOnlySpan_ImplicitlyTyped()
    {
        var source = """
            using System;
            
            class C
            {
                void M()
                {
                    var span = [with(), 1, 2, 3] as ReadOnlySpan<int>;
                }
            }
            """;

        CreateCompilation(source, targetFramework: TargetFramework.Net80).VerifyDiagnostics(
            // (7,20): error CS9176: There is no target type for the collection expression.
            //         var span = [with(), 1, 2, 3] as ReadOnlySpan<int>;
            Diagnostic(ErrorCode.ERR_CollectionExpressionNoTargetType, "[with(), 1, 2, 3]").WithLocation(7, 20));
    }

    [Fact]
    public void WithElement_Array_WithGenericType()
    {
        var source = """
            class C<T>
            {
                void M()
                {
                    T[] array = [with()];
                }
            }
            """;

        CreateCompilation(source).VerifyDiagnostics(
            // (5,22): error CS9336: Collection arguments are not supported for type 'T[]'.
            //         T[] array = [with()];
            Diagnostic(ErrorCode.ERR_CollectionArgumentsNotSupportedForType, "with").WithArguments("T[]").WithLocation(5, 22));
    }

    [Fact]
    public void WithElement_Span_WithGenericType()
    {
        var source = """
            using System;
            
            class C<T>
            {
                void M()
                {
                    Span<T> span = [with()];
                }
            }
            """;

        CreateCompilation(source, targetFramework: TargetFramework.Net80).VerifyDiagnostics(
            // (7,25): error CS9336: Collection arguments are not supported for type 'Span<T>'.
            //         Span<T> span = [with()];
            Diagnostic(ErrorCode.ERR_CollectionArgumentsNotSupportedForType, "with").WithArguments("System.Span<T>").WithLocation(7, 25));
    }

    [Fact]
    public void WithElement_ReadOnlySpan_WithGenericType()
    {
        var source = """
            using System;
            
            class C<T>
            {
                void M()
                {
                    ReadOnlySpan<T> span = [with()];
                }
            }
            """;

        CreateCompilation(source, targetFramework: TargetFramework.Net80).VerifyDiagnostics(
            // (7,33): error CS9336: Collection arguments are not supported for type 'ReadOnlySpan<T>'.
            //         ReadOnlySpan<T> span = [with()];
            Diagnostic(ErrorCode.ERR_CollectionArgumentsNotSupportedForType, "with").WithArguments("System.ReadOnlySpan<T>").WithLocation(7, 33));
    }

    [Theory]
    [InlineData("string[]")]
    [InlineData("System.ReadOnlySpan<string>")]
    public void WithElement_GetSymbolInfo(string type)
    {
        var source = $$"""
            class C
            {
                static void Main()
                {
                    string s = "";
                    {{type}} list = [with(), s];
                }
            }
            """;

        var compilation = CreateCompilation(source, targetFramework: TargetFramework.Net100).VerifyDiagnostics(
            // (6,45): error CS9401: 'with(...)' elements are not supported for type 'ReadOnlySpan<string>'
            //         System.ReadOnlySpan<string> list = [with(), s];
            Diagnostic(ErrorCode.ERR_CollectionArgumentsNotSupportedForType, "with").WithArguments(type));
        var tree = compilation.SyntaxTrees.Single();
        var semanticModel = compilation.GetSemanticModel(tree);
        var withElement = tree.GetRoot().DescendantNodes().OfType<WithElementSyntax>().Single();

        var symbol = semanticModel.GetSymbolInfo(withElement);
        Assert.Null(symbol.Symbol);
        Assert.Empty(symbol.CandidateSymbols);
    }
}