Forbid constructing tuples via "new"

[VSadov]

The following should work (or perhaps not):

new (int x1, int x2, ...., int x12) ( 1,2,...., 12);

It could be more complicated when constructor initializers are involved, like:
new (int x1, int x2, ...., int x12) ( 1,2,...., 12) { x1 = 1, x12 = 2};

If not, then new (int, int)(1, 2) should not work either.

[gafter]

I suggest that it should not work. That is, I do not suggest the object creation syntax should support tuple types. Instead we would give an error message that recommends using a tuple literal instead.

    var x = new (int x1, int x2)(3, 4);
    // error: cannot use 'new' with a tuple type. Use '(x1: 3, x2: 4)' instead

There are other contexts we might disallow tuple types (e.g. an is expression, since we cannot know if an object is of type (int x, int y) at runtime, when those names are absent, and since that syntax would conflict with pattern-matching on tuples).

@MadsTorgersen @dotnet/ldm @jcouv @AlekseyTs What do you think?

[jcouv]

I see no benefit to this syntax either.

[AlekseyTs]

I see no reason to disallow this.

[CyrusNajmabadi]

We let people write: new int?(4)

So i somewhat agree with @AlekseyTs, i don't see why this shouldn't be disallowed.

That said, i also ascribe to the: everything starts at -100 points. This seems to have pretty darn marginal value. Indeed, given how confusing it looks, i could argue it has anti-value. So i have no problem with it being disallowed.

[gafter]

One reason to disallow it is that ValueTuple<int, int, int, int, int, int, int, ValueTuple<int, int>> simply does not contain a constructor that accepts an argument list (int, int, int, int, int, int, int, int, int). This is the same reason we do not allow new int(3).

[VSadov]

Note that there is also a parameterless case -

new (int a, int b, int c)();

// same  as
default((int a, int b, int c));

It might need to be considered together with parameterized case.

[gafter]

See #347 (comment)

I think we've convinced ourselves in the C# design meeting that

new (byte, double) (1, 2);

is not going to be legal syntax. It won't be legal state a tuple type in a new expression. Instead, just use the tuple construction syntax.

(byte, double) x = (1, 2);

or

var x = ((byte)1, (double)2);

or

var x = ((byte, double)) (1, 2);

[mattwar]

Now Neal is quoting me!

[VSadov]

I have removed "Wont FIx" and made this a bug. I think "new" works currently with tuples <= 7 and not with bigger ones.
Regardless of the decision on this, the bug is actionable since we should either extend the support or disallow entirely.

[mattwar]

What is the bug exactly? That using tuple type syntax in object creation expression is not allowed?

[gafter]

I think the bug is that it is allowed (for sufficiently small tuples).

[VSadov]

Semantically new (int, int)(1, 2) is valid since (int, int) type does have a constructor taking two ints.
Perhaps we should prohibit this in the parser, which could be difficult, or introduce a rule that (int, int) syntax is not allowed to mean a type in object creation expressions.

[CyrusNajmabadi]

Perhaps we should prohibit this in the parser, which could be difficult

I don’t think this would be difficult TBH. We’d just need to update “ParseTypeCore” to take a Boolean saying if tuples were allowed. That would just go into ParseUnderlyingType, which would then ignore open parens.

       -- Cyrus

From: VSadov [mailto:notifications@github.com]
Sent: Monday, June 13, 2016 12:51 PM
To: dotnet/roslyn roslyn@noreply.github.com
Cc: Cyrus Najmabadi cyrusn@microsoft.com; Team mention team_mention@noreply.github.com
Subject: Re: [dotnet/roslyn] Add support for constructing tuples via "new" for 7+ elements (#10891)

Semantically new (int, int)(1, 2) is valid since (int, int) type does have a constructor taking two ints.
Perhaps we should prohibit this in the parser, which could be difficult, or introduce a rule that (int, int) syntax is not allowed to mean a type in object creation expressions.

—
You are receiving this because you are on a team that was mentioned.
Reply to this email directly, view it on GitHubhttps://github.com//issues/10891#issuecomment-225688544, or mute the threadhttps://github.com/notifications/unsubscribe/AEWmY8MbzLDx8H_fm4eSBWySXKjFeubOks5qLbS1gaJpZM4IQW-Y.

[jaredpar]

Didn't we decide in a recent LDM meeting that this should be allowed?

Bug seems out of date with more recent LDM discussions, wanted to get clarity on whether it was still relevant or not.

[VSadov]

As far as i know it is still supposed to be disallowed.

[gafter]

Part of the reason we decided to disallow this is that we are considering adding target-typed construction in the future

KeyValuePair<int, int> kvp;
kvp = new (1, 2);

We need to disallow new (T1, T2) to avoid a syntactic ambiguity.

[VSadov]

Also, allowing "new" with long tuples is a bit of work, while literals provide all the functionality needed with more concise syntax.
Basically why do extra work to just allow same thing be doable in two similar ways?