Cannot define a union type with a new signature type

[tinganho]

This currently gives me parse error:

class A {

}

function test(x: string | new() => A) {
                          ~~~~~~~~~~ parse error    
}

Though this works:

function test(x: new() => A) {

}

[RyanCavanaugh]

Due to parsing precedence, you have to write

function test(x: string | (new() => A)) {
}

[tinganho]

Ok thanks, shouldn't it give me some kind of feedback on that?

[RyanCavanaugh]

Parser errors are best-effort because the fact that there's a parser error means we're really not sure what's going on or what the intended code was. The earliest error is "type expected", which is nearly (?) correct. I'm not sure what specifically we could do; maybe @CyrusNajmabadi has some ideas.

[CyrusNajmabadi]

we could technically parse a wider range of values when parsing the union type. We could then report an error afterwards with more detail. I wouldn't have a problem with that at all.

[CyrusNajmabadi]

Note: it's necessary for precedence that we disallow this. Otherwise there's far too much ambiguity. For example, it would then get very tricky to have a rule to properly parse this:

a: string | new() => B | C

So it's better to use precedence to outright disallow call/construct signatures when parsing a union/intersection type and give the escape hatch of parenthesizing things if that's what you actually want.

[DanielRosenwasser]

I'd say that it's advantageous to users to disallow this, since we force writers to be explicit for future readers.

But yes, I think parsing this and reporting an error would be helpful, such as:

A function or constructor type literal must be explicitly parenthesized in a union or intersection type.

or the following two separately:

A function type literal must be explicitly parenthesized in a union or intersection type.

A constructor type literal must be explicitly parenthesized in a union or intersection type.

[benliddicott]

Maybe just add: "(Tip: Do you need parentheses?)"

[jbondc]

Hit this recently with intersection types. Patch (was a bit tricky) uses this message :
Invalid type. To avoid ambiguity, add parentheses: '(new() => void)'