Probable bug: Can't infer an invariant generic on contravariant position when involving another generic

[devanshj]

Bug Report

🔎 Search Terms

invariant generic, contravariant inference
Maybe related or perhaps because of the same design limitation mentioned in #44999

🕗 Version & Regression Information

Tested with 4.3.5

⏯ Playground Link

Playground

💻 Code

declare const d: <T, U>(_: { v: T, m: (t: T) => U, f: (u: U) => void }) => void
declare const a: "a"
declare const b: "b"

d({
  v: a,
  m: t => t,
  f: u => {
    let test1: "a" = u // Type 'unknown' is not assignable to type '"a"'.
  }
})

d({
  v: a,
  m: (t: "a") => t,
  f: u => {
    let test2: "a" = u
  }
})

d({
  v: a,
  m: _ => b,
  f: u => {
    let test3: "b" = u // Type 'unknown' is not assignable to type '"b"'
  }
})

d({
  v: a,
  m: () => b,
  f: u => {
    let test4: "b" = u
  }
})

🙁 Actual behavior

In 1st and 3rd function call U gets inferred to unknown

🙂 Expected behavior

In 1st function call U should get inferred to "a" and in 3rd function call U should get inferred to "b".

Clearly the contravariant position of U in m seems to be a problem because if we annotate it (as done in 2nd call) or omit it (as done in 4th call) it gets inferred to what is expect and there are no error.

A real world use case:

declare const branch:
  <T, U extends T>(_: { test: T, if: (t: T) => t is U, then: (u: U) => void }) => void

declare const x: "a" | "b"

branch({
  test: x,
  if: (t): t is "a" => t === "a",
  then: u => {
    let test1: "a" = u // Type '"a" | "b"' is not assignable to type '"a"'
  }
})

branch({
  test: x,
  if: (t: "a" | "b"): t is "a" => t === "a",
  then: u => {
    let test2: "a" = u // compiles
  }
})

[RyanCavanaugh]

Inference can do multiple "rounds" based on parameters, but this isn't applied to object properties (since they are not bounded in size the way parameters are). See #30134

[devanshj]

Ah okay *goes and does a 👍🏻*

Unrelated: I always thought that the inference does "rounds" (especially when working with those T extends M<T> types) good to know that's actually how it happens :P

[DanielRosenwasser]

According to @Andarist this should be fixed in 4.7.

[devanshj]

#48538 does fix the issue, but partially. For example I'd expect this to compile too...

declare const branch:
  <T, U extends T>(_: { test: T, if: (t: T) => t is U, then: (u: U) => void }) => void

declare const is:
  <T, U extends T>(u: U) => (t: T) => t is U

declare const x: "a" | "b"

branch({
  test: x,
  if: is("a" as "a"),
  then: u => {
    let test: "a" = u // should compile, doesn't
  }
})

branch({
  test: x,
  if: (t): t is "a" => t === "a",
  then: u => {
    let test: "a" = u // should compile, does
  }
})


declare const pa:
  <T, U extends T>(t: T, p: (t: T) => t is U) => t is U

if (pa(x, is("a" as "a"))) {
  let test: "a" = x // should compile, does
}

So can we reopen this? Or should I submit a new issue? (And even if this is a design limitation then maybe it's a good idea to open an issue to track it)