Refactor: Introduce object destruction

Search Terms

refactor, object destruction

Suggestion

A refactor that extract all property access expression to a object destruction or convert back

Use Cases

Examples

const item = {
  a: 1, b: 2
}

call(item.a, item.b)

to

const item = {
  a: 1, b: 2
}

const { a, b } = item

call(a, b)

Checklist

My suggestion meets these guidelines:

• This wouldn’t be a breaking change in existing TypeScript/JavaScript code
• This wouldn’t change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn’t a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
• This feature would agree with the rest of TypeScript’s Design Goals.

[dragomirtitian]

@Kingwl While this does sound nice in theory I believe there would issues around unions. Type gurads work differently on union types so not everything that can be done with a union could be done with the distructured constituents. For example:

let u!: { type: 'number'; payload: number } | { type: 'string', payload: string }

if(u.type === "number") {
    u.payload.toExponential // payload is number
} else {
    u.payload.big // payload is string
}


let { type, payload } = u

if(type === "number") {
    payload.toExponential // error payload is string | number
} else {
    payload.big // error payload is string | number
}

This is not a reason not to implement this, but great care should be taken not to offer this refactoring when resulting code would break because of type guards.

[Kingwl]

I start working on this one :XD