{ a: string } can not be assigned to Partial<Omit<P, "a"> & { a: string }>

[vipcxj]

Bug Report

🔎 Search Terms

extends, Partial

🕗 Version & Regression Information

4.2.4

⏯ Playground Link

Playground link with relevant code

💻 Code

// We can quickly address your report if:
//  - The code sample is short. Nearly all TypeScript bugs can be demonstrated in 20-30 lines of code!
//  - It doesn't use external libraries. These are often issues with the type definitions rather than TypeScript bugs.
//  - The incorrectness of the behavior is readily apparent from reading the sample.
// Reports are slower to investigate if:
//  - We have to pare too much extraneous code.
//  - We have to clone a large repo and validate that the problem isn't elsewhere.
//  - The sample is confusing or doesn't clearly demonstrate what's wrong.

type FunctionType<T> = {
  func(arg: Partial<T>): any;
};

type StringType = {
  str: string;
};

type T = { str: "abc" }
type A = T & StringType;
type B = Omit<T, "str"> & StringType;
const a: Partial<A> = { str: "" }; // not ok.
const b: Partial<B> = { str: "" }; // ok.

function example<T extends Record<string, any>>(ft: FunctionType<Omit<T, "str"> & StringType>) {
  ft.func({ str: "" }); // not ok.
}

according #43125, { a: "string" } can not be assigned to Partial<P> which P extends { a: string } because P.a may extends from string. So I make 2 new version:

1. T & { a: string }
2. Omit<T, "a"> & { a: string }.

But still not work.

🙁 Actual behavior

At least { a: string } should be assigned to Partial<Omit<P, "a"> & { a: string }>

🙂 Expected behavior

It not work.

[jcalz]

Reminds me of #28884, where the compiler doesn't currently perform the kind of analysis needed to verify such assignability for types depending on unresolved generics type parameters like P.

[amcasey]

Another issue with strange (but mostly explained?) Omit behavior: #43717

[RyanCavanaugh]

The type system doesn't take Omit as a first-class operation; it's a series of mapped types and conditional types under the hood that aren't resolvable on a generic type in a way that would produce a type that we could identify as a valid assignment target of that expression. There's not much we can do here apart from possibly special-casing, but that's a future endeavor.

[jchook]

Thanks for the explanation.

Is that why I cannot "fill in" the omitted properties of Omit<T, K> to get T again?

For example:

interface MyType {
  path: string
  params: Record<string, string>
}

function getMyTypeCreator<T extends MyType>(initial: Omit<T, 'params'>) {
  return (params: T['params']): T => ({
    ...initial,
    params,
  })
  // Error: Type 'Omit<T, "params"> & { params: T["params"]; }' is not assignable to type 'T'.
  // 'Omit<T, "params"> & { params: T["params"]; }' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint 'MyType'.(2322)
}

[RyanCavanaugh]

Exactly, yes