Destructured argument default value is not type checked

[asfernandes]

TypeScript Version: 2.4.1

Code

function test(n: number,
	{
		method = 'z'
	}: {
		method?: 'x' | 'y',
	} = {
		method: 'y'
	})
{
	console.log('test', n, method);
}

test(1);
test(2, {});

Expected behavior:

Compile error: z is not a possible value for method's type.

Actual behavior:

Prints:
test 1 y
test 2 z

This might not be a bug since method is correctly typed inside the body of test. A simple example:

function test({ x = 1 }: { x?: string }) {
    x.toUpperCase(); // Error
}
test({ x: 1 }); // Error

This declares that callers of test must provide a string value for x (or no value), and internal to test, x will be 1 if no value was supplied.

[asfernandes]

It's not allowed for standard parameters:

function test2(x: string = 1) {  // Error
    x.toUpperCase();
}
test2();

I don't see why it should for the case I pointed.

[asfernandes]

This is also not allowed:

function test(n: number,
	{
		method = 'z'
	}: {
		method?: 'x' | 'y',
	} = {
		method: 'z'  // <--- error here
	})
{
	console.log('test', n, method);
}

[sandersn]

This was intentionally broken in #10577, although the intent there was to correctly handle unannotated declarations like let { x = true } = { x: cond ? false : undefined }. The conflict between the default-initialiser and parent-initialiser is resolved by just returning a union type.

However, in the case that there's a parent type annotation, the annotation should outrank the type of both initialisers. I think that should be fairly simple to implement.