Narrowing types with private functions with `this` return type fails

Bug Report

I found that a generic type may be evaluated as incompatible while in fact it should be compatible. In my particular case I have a few generic types / classes that have a type argument constrained to MyClass.
I also have a conditional type with a generic argument that is "less" constrained to a union type of MyClass and a different class that has a generic.

// Conditional type with a generic constrained to either MyClass or something else
type ConditionalType<T extends MyClass | string> =
  T extends MyClass ? MyGenericType<T> : T;

In the given constellation I get the following error:

Type 'MyClass & T' does not satisfy the constraint 'MyClass'.
  Property 'fn' is missing in type 'MyClass & T' but required in type 'MyClass'.(2344)

I found that these prerequisites have to be met to reproduce the error:

1. The class (MyClass) that we constrain the generics arguments to has a function that returns a this type.
   Edit: Or no type annotation, no matter what the inferred type is. Other return type annotations, e.g. : string work.
2. This function is either protected or private.

🔎 Search Terms

this type, generic, conditional types

🕗 Version & Regression Information

• This is the behavior in every version I tried, and I reviewed the FAQ for entries about: seems to me that none apply.

⏯ Playground Link

Playground link with relevant code

💻 Code

// The class to constrain to in the generic types
class MyClass {
  constructor(public name: string) {}

  protected fn(): this {
    return this;
  }
}

// A generic type with a type argument constrained to MyClass
type MyGenericType<T extends MyClass> = T;

// Conditional type with a generic constrained to either MyClass or something else
type ConditionalType<T extends MyClass | string> =
  T extends MyClass ? MyGenericType<T> : T;

🙁 Actual behavior

Although the condition in the mapped type constrains the given type to extend MyClass it is not compatible as the type here evaluates to MyClass & T.

🙂 Expected behavior

I would expect that the condition in the type narrows the type as given in the condition.