VSCode infers all return types as nullable

[Tabonx]

Hi everyone,

I'm seeing an issue in VSCode where it always shows my return types as nullable, even when I don't expect them to be.

Here's a simplified example:

public class TestObject
{
    public string Id { get; set; } = string.Empty;
}

public interface ITestInterface
{
    Task<TestObject> GetAsync(string id, CancellationToken cancellationToken);
}

When I call this:

var test = await testInterface.GetAsync("testId", cancellationToken);

and hover over test, VSCode shows:

(local variable) TestObject? test

but I feel it should just be:

(local variable) TestObject test

If I add a null check like this:

var test = await testInterface.GetAsync("testId", cancellationToken);

if (test is null)
{
    return;
}

test.Id = "";

the hover over test in the if condition shows:

(local variable) TestObject? test
'test' may be null here.

and the hover over test when I assign test.Id = "" shows:

(local variable) TestObject? test
'test' is not null here.

Why does VSCode always show the question mark in the hover? It feels misleading since my method's return type is not nullable.

Thanks!

[RikkiGibson]

What's happening here is: a var of reference type, is always nullable. We did this because we found cases where people wanted to assign a possible null value to the var later on, and we didn't want to introduce a separate form for that purpose like var?, because it disrupts the simplicity of "just declaring something as var".

One common case we were seeing was the "linked list traversal" case, e.g. if we inferred a non-nullable reference type for node, then we would give a "nuisance warning" on node = node.Next.

for (var node = head; node != null; node = node.Next)
{
    Visit(node);
}

See also https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/statements/declarations#implicitly-typed-local-variables

We made a change very recently to try and improve clarity when hovering on the declaration: dotnet/roslyn#79649

[Tabonx]

Thank you for the explanation. I understand why var is always considered nullable, but it still feels counterintuitive. I am new to C# after years of working with Swift, where I think this is handled much better.

My colleagues use Rider, where the IDE correctly infers nullability. For example, if an interface specifies that the return value is non-nullable, Rider will indicate that null checks are unnecessary, even when using var instead of explicitly declaring the type.

Is there a way to make VS Code behave similarly to Rider? Ideally, var would still be nullable by default when creating new objects, but it would match the nullability specified by the interface when that information is available.