This seems like an awfully specific check - does it work on homomorphic mapped types in which all properties of the type being mapped are already optional? For example:

type Shapeify<T> = {
    [K in keyof T]: any;
}

interface MyInterface {
  something?: number;
}

class MyClass<T extends MyInterface> {
  doIt(data: Shapeify<T>) {}
}

class MySubClass extends MyClass<MyInterface> {}

function fn(arg: typeof MyClass) {};

fn(MySubClass);

The same question applies to if you used Readonly<T> or others.

I'm not sure what you're getting at. The only way we can be certain that all properties of the type that results from a mapping operation are optional is if the mapped type includes a ? in the template specification. That's what we're checking here.

As we discussed offline, that example doesn't apply because a constraint being all-optional (e.g. MyInterface) doesn't guarantee that T itself will be all-optional.

If you made isGenericMappedType a type predicate, you could avoid the type assertions.

No, because something for which isGenericMappedType returns false could still be a MappedType. We would need to introduce a new unique type representing generic mapped types, but it isn't worth the hassle.