Regression in array destruction in TypeScript 3.3

[sergey-shandar]

TypeScript Version: 3.3.1 and 3.4.1

Search Terms:

Code

type ImmutableTuple2 = {
    readonly [0]: number
    readonly [1]: string
} & Iterable<number|string>

const f = <T>(_v: T, _c: (v: T) => void) => {}

const v: ImmutableTuple2 = [4, "hello"]

f(v, ([a, b]) => {
    const _a: number = a // a should be a `number` but it's `number`|`string` in TS 3.3
    const _b: string = b // b should be a `string` but it's `number`|`string` in TS 3.3
})

Expected behavior:
No compilation errors. (TypeScript 3.2)

Actual behavior:

TypeScript 3.3.1 and up

src/test.ts:11:11 - error TS2322: Type 'string | number' is not assignable to type 'number'.
  Type 'string' is not assignable to type 'number'.

11     const _a: number = a
             ~~

src/test.ts:12:11 - error TS2322: Type 'string | number' is not assignable to type 'string'.
  Type 'number' is not assignable to type 'string'.

12     const _b: string = b
             ~~


Found 2 errors

Playground Link:

Related Issues:

[sergey-shandar]

Simplified code

type ImmutableTuple2 = {
    readonly [0]: number
    readonly [1]: string
} & Iterable<number|string>

const f = ([a, b]: ImmutableTuple2) => {
    const _a: number = a // a should be a `number` but it's `number`|`string` in TS 3.3
    const _b: string = b // b should be a `string` but it's `number`|`string` in TS 3.3
}

[sergey-shandar]

Workaround # 1

const f = (ab: ImmutableTuple2) => {
    const _a: number = ab[0] // ok
    const _b: string = ab[1] // ok
}

Workaround # 2

const f = (ab: ImmutableTuple2) => {
    const [a, b] = ab
    const _a: number = a // ok
    const _b: string = b // ok
}

[sergey-shandar]

The bug is also in TypeScript 3.4.1.

[vladbarosan]

@ahejlsberg is there any expected release when this to be fixed ?

[ahejlsberg]

Starting with TypeScript 3.4 we have proper support for readonly arrays and tuples (see #29435). The original example can now be written:

const f = <T>(_v: T, _c: (v: T) => void) => {}

const v: readonly [number, string] = [4, "hello"]

f(v, ([a, b]) => {
    const _a: number = a;
    const _b: string = b;
})

We no longer recognize "pseudo-tuples" like ImmutableTuple2 and given the intrinsic support I don't think adding more complexity in this area is worth it. So, I'm closing this issue.