Context sensitive inference fails with class instance #62380

class Foo<T> {
  constructor(public inner: T) {}
}

class BarClass<T> {
  constructor(public accessor: (state: T) => boolean) {}
}

{
  // This is my actual production use case, narrowed down.
  // `bars` is an array of class instances with a generic inferred from
  // context of previous function calls.
  class Container<C, F> {
    constructor(
      public ctx: C,
      public fooFactory: (ctx: C) => F,
      public bars: BarClass<F>[],
    ) {}
  }

  const container = new Container(
    42,
    ctx => new Foo({ answer: ctx }),
    [new BarClass(state => true)],
    //            ^?
    // state is unknown
  )
}

{
  // The problem exists with a singular instance of the class however.
  class Container<C, F> {
    constructor(
      public ctx: C,
      public fooFactory: (ctx: C) => F,
      public bar: BarClass<F>,
    ) {}
  }

  const containerWithoutAnnotation = new Container(
    42,
    ctx => new Foo({ answer: ctx }),
    new BarClass(state => true),
    //           ^?
    // state is unknown
  )

  const containerWithAnnotation = new Container(
    42,
    (ctx: number) => new Foo({ answer: ctx }), // an explicit type annotation on ctx here fixes the issue
    new BarClass(state => true), //               in all cases, but isn't practical for my API use case
    //           ^?
    // state is Foo<{ answer: number }>
  )
}

{
  // Having a factory function with no arguments doesn't help
  class Container<C, F> {
    constructor(
      public ctx: C,
      public fooFactory: (ctx: C) => F,
      public barFactory: () => BarClass<F>,
    ) {}
  }

  const container = new Container(
    42,
    ctx => new Foo({ answer: ctx }),
    () => new BarClass(state => true),
    //                 ^?
    // state is unknown
  )
}

{
  // A factory function with a dummy argument _does_ work
  class Container<C, F> {
    constructor(
      public ctx: C,
      public fooFactory: (ctx: C) => F,
      public barFactory: (dummy: never) => BarClass<F>,
    ) {}
  }

  const containerWithDummy = new Container(
    42,
    ctx => new Foo({ answer: ctx }),
    dummy => new BarClass(state => true),
    //                    ^?
    // state is Foo<{ answer: number }>
  )

  // however if the dummy argument isn't passed, it doesn't work
  const containerWithWrongArity = new Container(
    42,
    ctx => new Foo({ answer: ctx }),
    () => new BarClass(state => true),
    //                 ^?
    // state is unknown
  )
}

{
  type BarObject<T> = {
    accessor: (state: T) => boolean
  }

  // A regular object is inferred correctly.
  class Container<C, F> {
    constructor(
      public ctx: C,
      public fooFactory: (ctx: C) => F,
      public bar: BarObject<F>,
    ) {}
  }

  const container = new Container(
    42,
    ctx => new Foo({ answer: ctx }),
    { accessor: state => true },
    //          ^?
    // state is Foo<{ answer: number }>
  )
}