Can't access to static member of generic class from a decorator.

[lilezek]

Stack overflow url of this issue: https://stackoverflow.com/questions/45347630/accessing-static-member-of-generic-class-from-a-decorator

TypeScript Version: nightly (2.5.0-dev.20170725)

Code

@Decorator
class Entity {
    public static member: string[] = [];
}

function Decorator<T extends { new(...args: any[]): Entity; }>(constructor: T) {
  return class extends constructor {
    constructor(...args: any[]) {
      super(...args);
      // Do some things
      constructor.member.map((v) => {
        // Do things with the elements of the static array.
      });
    }
  };
}

Expected behavior:

I would expect to be able to access the static member from the Decorator.

Actual behavior:

Member is not part of type T.

[ghost]

You can't access that property because you never declared it in the type bound for T. You would have to declare T extends { member: string[]; new(...args: any[]): Entity; }.

[lilezek]

Well, as this is labeled as question, I'm going to make a question about what I want to achieve.

Is it possible to have a generic type T extended from Entity, where I can access static elements from Entity without explicitly have to write twice the Entity's structure or doing any casting?

People are suggesting things at https://stackoverflow.com/questions/45347630/accessing-static-member-of-generic-class-from-a-decorator but all suggestions are casting or writing twice the structure.

[lilezek]

Another example of what I think that it shouldn't be mandatory to do:

function decorator<T extends typeof Entity>(C: T) {
  return class extends (C as typeof Entity) { // Why is this cast necessary?
    constructor(...args: {}[]) {
      super(...args);
      C.member.forEach((v) => {
        // ...
      });
    }
    x = 1;
    y = 2;
    static z = 3;
  } as {} as T; 
}

This code is from StackOverflow example, where a cast from C to typeof Entity seems mandatory in order to the compiler to work. Isn't C, which is of type T, which is an extension of typeof Entity, enough to be extended as a new anonymous class?

[ghost]

If your decorator is only going to apply to exactly one class, you could just use C: typeof Entity.
If you're using the decorator on many different classes, wouldn't it make sense to declare an interface for what they should all have in common?
As for the cast, see #17504.

[aluanhaddad]

@lilezek thanks to @andy-ms's explanation, I realized I was mistaken in my answer in SO. To get this to work, Entitys constructor must have the signature new (...args: any[]) => any.

That is

class Entity {
  constructor(...args: any[]) {} // the ... is also required.
}

Any type that is used to refine the constraint also must contain the signature new (...args: any[]) => any. For example:

function decorator<T extends
  typeof Entity
  & {
    new(...args: any[]): any,
    prototype: {p: number}
  }
>(C: T) {
  return class extends C {};
}

will work but the following will fail

function decorator<T extends
  typeof Entity
  & {new(...args: any[]): any}
  & {prototype: {p: number}}
>(C: T) {
  return class extends C {};
}

[mhegazy]

Automatically closing this issue for housekeeping purposes. The issue labels indicate that it is unactionable at the moment or has already been addressed.