extends dynamic Base class with generic throw an error

[cevek]

Throw error: Base constructor return type 'T' is not a class or interface type

interface BaseClass<T> {
    new (): T
}
function generateUserClass<T>(baseClass: BaseClass<T>){
    return class extends baseClass {
        name: string;
    }
}

Error: Type any is not constructor function type

function generateUserClass<T>(baseClass: any){
    return class extends baseClass {
        name: string;
    }
}

But if we specify generic it's work

function generateUserClass(baseClass: BaseClass<Foo>){
    return class extends baseClass {
        name: string;
    }
}

Throw error: Base constructor return type 'IUser & Base' is not a class or interface type

interface IUser {
    name: string;
}
interface IUserClass<T>{
    new (): IUser & T;
}
function genUserCls<T>(base: new ()=>T): IUserClass<T> {
    return null;
}
class Base{
    foo(){}
}
class User extends genUserCls(Base) {}

TS version: 1.8

[sandersn]

For the first example, on master, I get a different error:

interface I<T> {
    new(): T
}

function gen<T>(base: I<T>) {
    return class extends base {
                         ^^^^ Base constructor return type 'T' is not a class or interface type
        name: string;
    }
}

This error seems correct to me -- T is just a type variable, so we can't know if it's a class or not. However, adding a constraint doesn't make the error go away:

class Foo { }
function gen<T extends Foo>(base: I<T>) {
  return class extends base {
                       ^^^^ same error here
    name: string
  }
}

[mhegazy]

this is behaving as i would expect. you can only extend object types, in other words something that of a known structure. type arguments are not. the extend relationship involves checking that the structure of the derived class matches that of the base. without knowing what is the shape of the base, the compiler can not report these errors.

The request to allow classes to extend generic type arguments is tracked by #4890

[cevek]

Thanks, ahejlsberg example is working

interface Base{}
interface BaseClass<T> {
    new (): T
}

function generateUserClass<T extends Base>(baseClass: BaseClass<T>){
    class User extends (baseClass as BaseClass<Base>) {
        name: string;
    }
    return User as BaseClass<T & User>;
}

class Model{
    id: number;
}
var User = generateUserClass(Model);
var user = new User();
user.id;

[hszhsh]

'new User()' is ok, but you cannot create a class that extends User.