"When variable type is apparent" doesn't apply to array initialization

[davkean]

This the same bug I filed #23907, but it stated that it was fixed.

Version Used:
Version 15.8.0 Preview 1.0 [27628.0.d15.8]

Steps to Reproduce:

public class Foo
{
    public void Method()
    {
        var files = new string[0];
    }

}

Expected Behavior:

No message

Actual Behavior:

Message IDE0008 Use explicit type instead of 'var' ConsoleApp300 C:\Users\davkean\Source\Repos\ConsoleApp300\ConsoleApp300\Program.cs 6 Active

[davkean]

tag @jcouv as you originally fixed this.

[sharwell]

This is by design. See #24114.

[jcouv]

Specifically, the preference for explicit types on built-in types dominates the preference for var when type is apparent.

[davkean]

The design is broken: #23714.

[sharwell]

@davkean The design may not match your expectations, but we have no intention of making a universally-configurable system that meets all possible expectations (attempting to do so would doom the entire system to failing for everyone under an impossible testing burden). Some expectations will be broken for each user, but the majority styles are accommodated to a degree deemed reasonably possible.

[davkean]

"When type is apparent" is one of the options but it doesn't work.

[sharwell]

Do you have a suggestion for different wording that would more accurately reflect the behavior? For example:

When type is apparent, except in cases where the type is a built-in type

Alternately, is there a way to present the three options such that it's clear the set of three items is ordered?

[Neme12]

The current set of options is:

csharp_style_var_for_built_in_types		true/fale
csharp_style_var_when_type_is_apparent	true/false
csharp_style_var_elsewhere				true/false

I believe having these options instead would make sense and only increase the number o possible combinations from 8 to 9 while solving this issue:

csharp_style_var_for_built_in_types		always/never/when_type_is_apparent
csharp_style_var_elsewhere				always/never/when_type_is_apparent

[davkean]

Yes that makes sense. I'm trying to understand under what circumstances someone would choose the following (which is effectively what options are enforcing now):

csharp_style_var_for_built_in_types		never
csharp_style_var_elsewhere				when_type_is_apparent

I've never seen that style anywhere. Whereas the style I want enforced both project-system and CoreFx/CoreCLR enforce.

[sharwell]

It covers things like this: https://github.com/benaadams/corefx/blob/a29b8b80468c1694d8125f9d76e8c335c3b6ed5f/src/System.Collections/tests/Generic/List/List.Generic.Tests.netcoreapp.cs#L23

[Neme12]

Unfortunately my proposal can't be done in a backwards compatible way because it removes 2 combinations that are currently possible. I created a table mapping current options to the proposed ones:

built_in_types	when_type_is_apparent	elsewhere	|	built_in_types	elsewhere

false		false			false		|	never		never
false		false			true		|	NOT AVAILABLE
false		true			false		|	never		when_type_is_apparent
false		true			true		|	never		always
true		false			false		|	always		never
true		false			true		|	NOT AVAILABLE
true		true			false		|	always		when_type_is_apparent
true		true			true		|	always		always

It would no longer be possible to prefer explicit type when type is apparent but var when it is not apparent. This does seem like a bizarre preference, but even if it was OK to remove this, I don't know how it could be done with editrconfig to map these.

On the other hand, this proposal would add 3 new possible preferences:

	built_in_types			elsewhere

1.	when_type_is_apparent	never
2.	when_type_is_apparent	always
3.	when_type_is_apparent	when_type_is_apparent

where number 3 is the desired one, 2 seems somewhat reasonable and 1 does not.

[Neme12]

@sharwell

It covers things like this:

I don't think so. I would expect 0 to be classified as "not apparent". var would only be suggested if you type var i = new int()

[Neme12]

At least it was my understanding that "apparent" means "the type is explicitly spelled out inside the expression". Maybe I'm wrong.

[davkean]

@Neme12 That makes sense, I was grouping the following together when I filed #23714, but I like your idea better.

var i = new int[];
var i = 0;

[sharwell]

Reopening to see if the proposal from @Neme12 could provide a suitable replacement for current behavior without being overwhelming.

[sharwell]

@Neme12 The analysis provided comparing the two sets of options is good, but currently misses some of the behaviors. I'm specifically interested in understanding the following cases:

Setting	Explicit type was used	var was used
always	❌	✔️
never	✔️	❌
when_type_is_apparent	❓	✔️

The current options can represent "allow when type is apparent, and disallow otherwise". I'm concerned the new options would subtly change that to "require when type is apparent, and disallow otherwise".

[JimBobSquarePants]

Observed behavior indicates that this seems to only trigger for built in types.

With the following config:

csharp_style_var_for_built_in_types = false:warning
csharp_style_var_elsewhere = false:warning
csharp_style_var_when_type_is_apparent = true:warning

Array initialization of a built in type triggers IDE0008 .

var buffer = new byte[n];

However custom types do not trigger the error.

var buffer = new MyCustomType[n];

[sharwell]

I reviewed #26531 (comment) and #26531 (comment) again today with @mavasani. I believe my original concerns can now be addressed by setting the severity for the diagnostic ID instead of setting it as part of the code style configuration. For example, the "allow when apparent, disallow otherwise" setting could be:

csharp_style_var_for_built_in_types = never
csharp_style_var_elsewhere = when_type_is_apparent
# IDE0007: Use implicit type
dotnet_diagnostic.IDE0007.severity = hidden
# IDE0008: Use explicit type
dotnet_diagnostic.IDE0008.severity = warning