Inconsistent parenthesization requirements for single-argument additional constructors (with new)

[brianrourkeboll]

A single-argument additional constructor (i.e., a non-primary constructor declared with new) must have parentheses around its argument only if it is followed by another additional constructor.

Repro steps

1. Define a type with multiple additional constructors, one of which takes a single atomic argument pattern.
2. If the single-argument additional constructor is the last (or only) additional constructor, the argument does not need to be parenthesized; if any additional constructors follow it, the argument does need to be parenthesized.

This:

type T (x, y) =
    new (x) = T (x, 3)

can be simplified to

type T (x, y) =
    new x = T (x, 3)

Likewise:

type T (x, y) =
    new (x, y, z) = T (x, y)
    new (x) = T (x, 3)

can become

type T (x, y) =
    new (x, y, z) = T (x, y)
    new x = T (x, 3)

But if there's another constructor and it comes after the single-argument one:

type T (x, y) =
    new (x) = T (x, 3)
    new (x, y, _z) = T (x, y)

the parentheses must stay

> type T (x, y) =
-     new x = T (x, 3)
-     new (x, y, _z) = T (x, y);;

      new (x, y, _z) = T (x, y);;
  -------------------^

stdin(3,20): error FS0010: Unexpected symbol '=' in expression

The removal of the parentheses has a significant effect on the way the following additional constructors are parsed:

• AST with parens
• AST without parens
• AST diff

Expected behavior

Parentheses should either always be required for a single-argument additional constructor, or they should never be required.

Actual behavior

Parentheses are required for a single-argument additional constructor only if it is not the last additional constructor.

Known workarounds

N/A.

Related information

Provide any related information (optional):

.NET SDK 8.0.100-rc.2.23502.2 (and probably long before).