Destructuring all but one key dynamically via rest creates an unusable type by omitting all of its keys

[branson-dyer]

🔎 Search Terms

"Destructuring", "Omit<Partial, "keyof type> not assignable to Partial",

🕗 Version & Regression Information

• This is the behavior in every version I tried, and I reviewed the FAQ for entries about destructuring and Omit and found a somewhat related thing under 'Add a Key Constraint to Omit' but that isn't the change necessitated here

⏯ Playground Link

https://www.typescriptlang.org/play/?#code/JYOwLgpgTgZghgYwgAgJLmvJyDeAoZZABgC5kQBXAWwCNoBuA5AexAjIGcwpQBzRwmADuzMjWbMANhDghGAXzx4YFEAjDBWyACoQuAHgAmcMHG0BPAA4QAfAApjpso7NWIAGmSQuAaQjmyAGt-ZhhkFwtrAEpcJmkwZEs4KA04SQAREzgyAAVk1MkjLMjbZABecKyBZARWLhrJVggAdWAwAAtmCjA-c3LkO2CA5CHQytMSmLKbWMJCWpB6nGQAbSGAXTIAfU8AOn3mDuhM02R5fqSU4DSTuGrCS4Lb-sP246qAegAqL5LkAHIAPJUNr6PJXNJFCZuGyeUZhCIw-7IYAcciHZBwDgcYC8EBwGjSLzMLxuAHggpQ1zWGz-XZMP7-eHjakQZGo9EJLE4vEEolgElgMn-ACiAA8EJIKIYIPpmYjrHCQgjikj6XMdMKuDwQLxkAAfcjUOhQA3IDjmWhSdlokAY7m4-GElAC0nWAFsABu0DpTA1jO1fBtnMx2MdfJdguFXp9ux+HyY8mqkqarQ6XR6-js3kz5ii1SgEDAFCgIES+WuGSqeEUeF0BnQkFgiFsdmWpGQABYAEyeJpkABEHULEAHnmEomQ8EkHBQ8k8A6aA-zQA

💻 Code

interface Interface {
  0: number;
  one: string;
  two: boolean;
}

function Test<dataType>(data: dataType, testKey: keyof dataType) {
  let partialData: Partial<dataType> = data;
  const cloneWithoutKey = (key: keyof dataType) => {
    const { [key]: _, ...otherData } = partialData;
    partialData = otherData;/**Type 'Omit<Partial<dataType>, keyof dataType>' is not assignable to type 'Partial<dataType>'.
  Type 'keyof dataType' is not assignable to type 'Exclude<keyof dataType, keyof dataType>'.
    Type 'string | number | symbol' is not assignable to type 'never'.
      Type 'string' is not assignable to type 'never'.**/
  };
  cloneWithoutKey(testKey);
  return partialData;
}

Test<Interface>({ 0: 42, one: "three", two: false }, "one");

🙁 Actual behavior

otherData resolves to never and is not assignable to partial data

🙂 Expected behavior

the rest parameter should be resolved to a partial of the datatype

Additional information about the issue

No response

[RyanCavanaugh]

Omit<T, keyof T> isn't technically wrong here but I agree Partial<T> has much better ergonomics here and better matches the intent (especially since it's distributive). Putting up a PR to see if this breaks anything interesting.

[jcalz]

There's two issues here.

TS can't do much when it comes to reasoning about generics and conditional types, see #43846 & #28884 for examples. This is going to be a design limitation or missing feature. It would be nice if Omit<T, K> were always assignable to Partial<T> for generic T.

The other is that destructuring with union-typed keys is going to indeed omit more keys from the type of the rest element than will actually occur at runtime. We can rewrite your code to be non-generic as:

function Test(data: Interface, testKey: keyof Interface) {
  let partialData: Partial<Interface> = data;
  const cloneWithoutKey = (key: keyof Interface) => {
    const { [key]: _, ...otherData } = partialData;
    otherData;
    // ^? const otherData: {}
    partialData = otherData;
  }
  cloneWithoutKey(testKey);
  return partialData;
}

There's no error there but presumably you expect otherData to be of some union of all the ways you can omit a single key from a type, like Omit<Interface, "0"> | Omit<Interface, "one"> | Omit<Interface,"two">. This doesn't happen and that's probably also either a design limitation or working as intended. TypeScript doesn't distribute this way as it would cause it to have to synthesize quite complex types, which is similar to why union-typed computed properties tend to get widened all the way to string when constructing an object, see #13948. I can't imagine this will ever be changed. Really you want testKey to be generic K extends keyof Interface and not a union.