Out variable declaration with underscore as the name behaves inconsistently

[poke]

Triggered by this question on Stack Overflow, we noticed a few inconsistencies when using the new C#7 out variable declaration with an underscore as the variable name (the one used for the discard functionality).

As expected, the following code does not compile since the _ makes the out variable be discarded:

string s = "123";
int.TryParse(s, out _);
Console.WriteLine(_);

However, assigning to _ works for some reason:

string s = "123";
int.TryParse(s, out _);
_ = 2;

Similarly, if you actually declare the underscore as an inline out variable, you get the same result, even though it should be a real variable now:

string s = "123";
int.TryParse(s, out var _);
Console.WriteLine(_); // does not compile
_ = 2; // does compile

There seems to be something weird going on with the syntax parsing there, since the _ is recognized as a discard regardless of whether it’s an actual discard or a variable declaration. And then the behavior to be able to assign something to _ is just odd; the name shouldn’t be available for anything, not even assigning to it.

(I’ve tested this with the most current version of Visual Studio 2017 15.0.0+26228.9)

[pawchen]

Is this by design?

out var _ means out _, if you have a function that has multiple out parameters, out _ can be used multiple times regardless of the type of the parameters. So my understanding is that, _ can be assigned by anything as long as it's recognized as discard.

The following code compiles

_ = 2;
_ = "wat";
_ = GetSomething();
_ = new Something();

This looks meaningless, but C# 7 adds tupple, so it's possible to

var (a, _, _) = GetSomeTuple();

(int, int, string) GetSomeTuple() => (0, 1, "wat");

[poke]

Huh? Is _ to discard stuff a general language construct now? Is this really an intended change and is this documented somewhere? According to the language specification, _ is a valid identifier, so the following should work according to spec:

var _ = "foo";
Console.WriteLine(_);

This works in both C#6 and C#7. The following fails in C#6 though but compiles fine in C#7:

_ = "asd"; // CS0103 on C#6
Console.WriteLine(_);

That behavior would appear normal and desired to me. An underscore, while being a poor choice for a variable name, is still a valid variable name. And unless I declare that, it shouldn’t work.

For the discarding functionality in out variables and for tuple destructuring, I would expect this to be a special syntax feature that does not actually do anything to a “real” name _.

[hvdijk]

The following fails in C#6 though but compiles fine in C#7:

The first line works in C#7, the second doesn't, because you never declared a variable named _.

It's the same as when var was introduced: when a variable is named var, that variable is used. Otherwise, var acts as a new keyword. That's what's going on with _ too. _ = ""; _ = 1; works and discards two values. var _ = ""; _ = 1; doesn't, the _ = 1; here acts as an attempted assignment to the existing variable, and the type mismatch is diagnosed.

The design notes from Nov 15 (#16674) mention what has been done to avoid errors for existing uses of _.

[gafter]

Yes, _ is a general discard construct now. You can assign anything to it.

[poke]

Interesting, I did not know that this was the spec’ed intention. Thank you @hvdijk and @gafter!

[jcouv]

For reference, here's the feature design doc: https://github.com/dotnet/roslyn/blob/master/docs/features/discards.md