Syntax suggestion: Ignore last void parameters

[teintinu]

class X<T>
{
 f(t: T) { return { a: t }; }
}


var x: X<number>;
var t1 = x.f(5);
t1.a = 5; // Should not error: t1 should have type {a: number}, instead has type {a: T}

var x2: X<void>; 
var t2a = x.f(void 0); // It works but void 0 it's unnecessary
var t2b = x.f(); // SUGGESTION: ignore syntax check of last argument if it's type is void
t2b.a = void 0; // Should not error: t2 should have type {a: void}, instead has type {a: T}

test case: tests/cases/compiler/genericObjectLitReturnType.ts

maybe the solution is the same for #3356

[weswigham]

Would I be correct in saying that the type signature T|void should be equivalent to T?? (Any type which contains the void type is optional as a parameter) This equality is true in the closure compiler type system (but it uses undefined rather than void for the type name).

[teintinu]

Not always Wesley Wigham (@weswigham), just in last arguments of functions.

class X<T, U>
{
 f(t: T|void, u: U) { ... }
}

t: T it's mandatory because is not the last function argument and we can't lose u: U. My suggestion it's only for last argument. However, the rule can be "last void parameters" because, if X<void,void>, f function can be invoked with f() lossless

I don't understand when you say T|undefined (rather than T|void) equality is true in the closure compiler, can you send me a sample?

Thanks

[weswigham]

Oh, sorry, I was (completely) mistaken - The equality's not true for optional function arguments, only optional record type members. :S (Optional function arguments in closure are denoted with an =, while optional members use ?, hence my mixup.)

[RyanCavanaugh]

Chatting with Dan Quirk (@danquirk), our proposal (roughly) is that at a call expression, we treat the unprovided required arguments as if they were of type void, then check that those are assignable to the parameter types (modulo any). Leave assignability/subtyping of function types unchanged.

[teintinu]

Yes Ryan Cavanaugh (@RyanCavanaugh), just for call expressions. I don't know how works typescript checker then I can't say if it's better don't throw error if last parameter is void and missing or if it's treat the unprovided required arguments as if they were of type void. But it's what you say, just in call expression leaving assignability/subtyping of function types unchanged.

If I can help you just tell what to do.
Thanks.

[RyanCavanaugh]

Approved. Should be useful for Promise<void>.