Optional destructured parameters do not work with default values

[jqyu]

TypeScript Version: 2.4.0

Code

The following code incorrectly type checks:

interface Attrs {
    foo?: number;
    bar?: number;
}

function unsafe({ foo, bar }: Attrs = {}): number {
    return foo * bar.toString().length + 1;
}

Expected behavior:
This should fail to type check since foo and bar may both be of type undefined

Actual behavior:

Match behaviour of omitting default value:

function failsToTypecheck({ foo, bar }: Attrs): number {
    return foo * bar.toString().length + 1;
}

Or behaviour of omitting destructuring:

function failsToTypecheck(attrs: Attrs = {}): number {
    return attrs.foo * attrs.bar.toString().length + 1;
}

[mhegazy]

@sandersn we talked about this one before, any thoughts here?

[whatisaphone]

Here's another example of this that I wrote up before searching for an existing issue:

interface Foo {
  readonly bar?: number;
}

function performFoo({ bar }: Foo = {}) {
  useBar(bar);  // `bar` should have type `number | undefined`, so this shouldn't compile.
}

function useBar(bar: number) {
  alert('The number is: ' + bar);
}

performFoo();

We've started using this pattern in our code, so I'm also interested in a fix for this.

[whatisaphone]

If someone takes up fixing this, here is another potentially useful test case:

interface Foo {
  readonly bar?: number;
}

function performFoo({ bar = null }: Foo = {}) {
  useBar(bar);  // `bar` should have type `number | null`, so this call shouldn't compile.
}

function useBar(bar: number | undefined) {
  alert('The number is: ' + bar);
}

performFoo();

[Lazarus535]

I fixed the issue in PR #21328
Update: Added testcases, signed CLA
Update2: Issue #17667 is not (totally) fixed by this. Only the part with the optionality (inclusion of undefined).