Error inheriting class B from class A that contains a method that takes a parameter of type B and returns this when decorated with multiple mixins

[AlmostBearded]

Bug Report

I'm sorry for the long title but the issue is not easy to translate into words. Let me start a minimal code example.

type Constructor<T = {}> = new (...args: any[]) => T;

class A {
  foo(b: B): this {
    return this;
  }
}

function MixinA<T extends Constructor<A>>(Base: T) {
  return class MixinA extends Base {};
}

function MixinB<T extends Constructor<A>>(Base: T) {
  return class MixinB extends Base {};
}

class B extends MixinB(MixinA(A)) {}  // ERROR 

The error that's being given is: Type 'B' recursively references itself as a base type

In my opinion this error doesn't make sense or am I mistaken? The error disappears when I
a) remove the use of class B from the foo method
b) remove the this return type from the foo method
c) Only decorate class A with 1 mixin. For some reason the error disappears when only one mixin is used.
d) change the required mixin constructor type to any: function MixinA<T extends Constructor<any>>(...) {...}

The first 2 options are not viable as they are incompatible with my use case and option d looses type safety within the mixin implementations.

🔎 Search Terms

mixins recursively references itself

🕗 Version & Regression Information

When testing in the playground it seems like this error occurred between versions 3.6.2 and 3.7.5

⏯ Playground Link

Playground link with relevant code

💻 Code

type Constructor<T = {}> = new (...args: any[]) => T;

class A {
  foo(b: B): this {
    return this;
  }
}

function MixinA<T extends Constructor<A>>(Base: T) {
  return class MixinA extends Base {};
}

function MixinB<T extends Constructor<A>>(Base: T) {
  return class MixinB extends Base {};
}

class B extends MixinB(MixinA(A)) {}  // ERROR 

🙁 Actual behavior

Error Type 'B' recursively references itself as a base type. ts(2310)

🙂 Expected behavior

No error

[RyanCavanaugh]

This is a true type circularity, but one that we are normally able to handle, so it's weird that this is happening