TS is overly picky when declaring a class constructor type

TypeScript Version: 3.4.0-dev.20190202

Search Terms: class, extend, constructor, any[]

Code

type ClassConstructor = new(...args: any[]) => {}

function mixin<C extends ClassConstructor>(Class: C) {
  return class extends Class {}
}

Expected behavior:

I should be able to replace ...args: any[] with ...args: unknown[], or any other signature.

Actual behavior:

Error: Type 'C' is not a constructor function type. [2507]

Playground Link: https://www.typescriptlang.org/play/index.html#src=type ClassConstructor %3D new(...args%3A unknown[]) %3D> {} function mixin<C extends ClassConstructor>(Class%3A C) { return class extends Class {} }

[RyanCavanaugh]

Agree, unknown[] should be an acceptable substitute. Accepting PRs for an easy fix.

[dragomirtitian]

@RyanCavanaugh I can look into that, but this problem seems much bigger than mixins and would have implications broadly. Rest parameters of type unknown[] are generally not compatible with arbitrary parameter types even if we are talking about a constraint. This currently fails under strictFunctionTypes

function test<T extends (...a: unknown[]) => unknown>(fn:T) : T{
      fn(""); // this passes "" can be assigned to unknown 
      return fn;
}
test(function (a: number) {   // error here under strictFunctionTypes
})

I’m not 100% sure it is necessarily a great idea to make the code above error free . It seems to be weaker as far as type safety goes. As we see in the code above the callback passed in accepts a number but it’s called inside test with a string. I think the current behavior is better, don’t let a function with a number parameter be assigned to a function with an unknown parameter, the implementing function can’t handle unknown.

While this is no worse than if we use any[], unknown[] would give a false sense of type-safety when no safety actually exists. Except for obeying the no-any tslint rule not sure why unknown is better in this instance. At least any would function as a ‘💀💀 careful unsafe 💀💀’ warning, at least that’s the way I see any 😃