.net 9 ReadOnlySpan params cause issues with my analyzer

[Dimension4]

I'm trying to update our code base from .net 8 to 9, but for some reason my analyzer is reporting code snippets that were previously fine. Basically, the analyzer checks if Task<> objects are handled, for example:

Task.Run(Foo); // diagnostic, returned Task is not used
_ = Task.Run(Foo); // ok, we explicitly assigned the Task

Previously, the following code was fine:

_ = Task.WhenAll(Task.FromResult(0), Task.FromResult(1));

but after upgrading to .net 9, the analyzer complains that both Task.FromResult Tasks aren't used, despite them clearly being passed in as arguments. Now I've noticed that Task.WhenAll changed from params Task<TResult>[] to params ReadOnlySpan<TResult>, so I assume that's the problem. However, I can't find a IOperation implementation that describes this case. The .net 8 version that used params Task<TResult>[] produced a IArrayInitializerOperation that I could listen for and handle that way, but that seems to no longer cover this case. However, when debugging this specific code snippet in the test project of the analyzer, I'm still receiving an IArrayInitializerOperation for this part, despite the driver using C# 13 and me explicitly referencing the .net 9 assemblies, so my tests still pass.

My analyzer registers for IInvocationOperation actions and, if the method returns a Task, checks the parent operation like so:

    private static bool ReturnedTaskIsUsed(IOperation operation) => operation.Parent switch
    {
        IAwaitOperation => // await SomeTask(); await await SomeNestedTask()
            !IsTaskOfTask(operation.Type!, operation.SemanticModel!.Compilation) || ReturnedTaskIsUsed(operation.Parent),
        IConversionOperation
            or IReturnOperation // return Task.Run(...)
            or ISymbolInitializerOperation // var x = Task.Run(...)
            or IAssignmentOperation // x = Task.Run(...)
            or IInvocationOperation // Task.Run(...).Wait()
            or IArgumentOperation // ProcessTask(Task.Run(...))
            or IMemberReferenceOperation // Task.Run(...).Result
            or IArrayInitializerOperation // new [] { Task.Run(...), Task.Run(...) }       <---- this is where I end up in the debugger
            or IConditionalOperation // x == condition ? Task.Run(...) : Task.Completed
            or IConditionalAccessOperation // Task.Run(...)?.Wait()
            or ITupleOperation => // (1, Task.Run(...))
            true,
        _ => false
    };

I use this snippet to invoke the analyzer in my test:

    void MyTest() =>
        Assert<MyAnalyzer>("""
          namespace Foo
          {
              class Bar
              {
                  async Task Meth()
                  {
                      _= Task.WhenAll(Task.FromResult(0), Task.FromResult(1));
                  }
              }
          }
          """);

    async Task Assert<T>(string source) where T : DiagnosticAnalyzer, new()
    {
        var test = new CSharpAnalyzerTest<T, DefaultVerifier>
        {
            ReferenceAssemblies = ReferenceAssemblies.Net.Net90,
            TestCode = source
        };

        await test.RunAsync();
    }

I've also updated all nuget packages to the latest version, these are (most of) the packages used in the test project:

    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Analyzer.Testing" Version="1.1.2"/>
    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.CodeFix.Testing" Version="1.1.2"/>
    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="4.12.0"/>
    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0"/>

I've checked with the debugger and the referenced assemblies are from .net 9.0, the C# version is 13, but the operation I get for Task.FromResult(0) is IArrayInitializerOperation, which my analyzer handles.

What am I missing? Why is the diagnostic reported in a normal .net 9 project but not in my analyzer test project?

[333fred]

Your test probably doesn't have the right language version. I see that you've checked that, but I would double check that again. Verify that the program was parsed with C# 13, and that the compilation options are C# 13.

[Dimension4]

Hmm I see both params overloads are still there. I've checked the method symbol of Task.WhenAll and it picked the array overload. The method symbol is located in System.Runtime, Version=9.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a though, according to the debugger.

[333fred]

The test csporj itself uses .net 9 and I set the language version to 13 there as well if that affects something somehow.

That is not related. You need to set the options of the CSharpAnalyzerTest you are creating.

[Dimension4]

I've changed the test to use

    private const string DefaultUsings =
        """
        using System;
        using System.Collections.Generic;
        using System.Runtime.CompilerServices;
        using System.Runtime.InteropServices;
        using System.Threading.Tasks;

        """;

    public static async Task Assert<T>(string source) where T : DiagnosticAnalyzer, new() =>
        await new Driver<T>(DefaultUsings + source).RunAsync();

    private class Driver<T> : CSharpAnalyzerTest<T, DefaultVerifier> where T : DiagnosticAnalyzer, new()
    {
        protected override CompilationOptions CreateCompilationOptions() =>
            new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary, allowUnsafe: true);

        protected override ParseOptions CreateParseOptions() =>
            new CSharpParseOptions(LanguageVersion.CSharp13, DocumentationMode.Diagnose);

        public Driver(string source)
        {
            ReferenceAssemblies = ReferenceAssemblies.Net.Net90;
            TestCode = source;
        }
    }

which is mostly copy & pasted from the base class, but it doesn't change anything. Did I forget to configure something?

[333fred]

@sharwell this appears to be because the reference assemblies shipped with the test SDK are not the final .NET 9 assemblies: instead, they're from p1. We need to seriously consider deprecating the built-in way to control reference assemblies in the test SDK, and instead just use Basic.Reference.Assemblies.

[Dimension4]

I should've taken a closer look at the file paths when checking the reference assemblies. This is how I do it now:

    public static async Task Assert<T>(string source) where T : DiagnosticAnalyzer, new()
    {
        var tester = new CSharpAnalyzerTest<T, DefaultVerifier>
        {
            TestCode = DefaultUsings + source,
            ReferenceAssemblies = new ReferenceAssemblies("net9.0", new PackageIdentity("Microsoft.NETCore.App.Ref", "9.0.0"), Path.Combine("ref", "net9.0")),
        };

        await tester.RunAsync();
    }

which successfully reproduces the diagnostic.

Thank you!

@333fred I don't have to open a bug for the reference assemblies since you're already aware of it, right?

[333fred]

Opened dotnet/roslyn-sdk#1211.