Can not extend built in types

[mhegazy]

The ES6 designates some native objects as subclassable, e.g. Object, Boolean, Error, Map, Promise ..etc. The way these constructs are modeled in lib.d.ts makes is impossible to subclass, as they are defined as a pair of a var and an interface.

From the ES6 spec section19.5.1:

The Error constructor is designed to be subclassable. It may be used as the value of an extends clause of a class declaration. Subclass constructors that intended to inherit the specified Error behavior should include a super call to the Error constructor to initialize subclass instances.

Currently this would result in "A class can only extend another class" error:

class NotImplementedError extends Error {
    constructor() {
        super("Not Implemented");
    }
}

[metaweta]

This is a general problem for any js library that exposes functions that are meant to be subclassable. If my library exports the Foo constructor and expects to receive instances of subclasses of Foo (not just objects implementing a Foo-like interface), there's currently no way to allow that.

I would like to be able to say

class Error;

There would be no javascript emitted for such a statement, only an update of Typescript's symbol table.

For the general case, I'd like to be able to replace the body of any class declaration with a semicolon, allowing things like

class Foo<X, Y> extends Bar<X> implements Baz<Y>;

which would mean that the library already guarantees that Foo.prototype is an instance of Bar.prototype and implements the Baz interface.

[saschanaz]

@metaweta I think it may make some redundancies:

interface Foo {
}
class Foo; // Foo is now a class!
interface Bar extends Foo {
}
class Bar extends Foo; // Two `extends Foo`s. 

interface X {
}
class X extends Foo; // Hmm?
interface Y extends Foo {
}
class Y; // Hmm?

It still have some potentials as the subclassable interfaces will work as open-ended classes. #819

[mhegazy]

@metaweta your first case should be handled by an ambient class declaration. e.g.

// myLib.d.ts
declare class Error {
}
// no code emitted here for this. 

// myfile.ts
// Error is subclassable,
class MyError extends Error {
}

For the second case, I would file a different suggestion issue for it.

[mhegazy]

Here is the full list of "subclassable" objects from the ES6 spec. currently these are all defined as an interface/var pairs.

• Object
• Boolean
• Error
• NativeError
• Number
• Date
• String
• RegExp
• Array
• TypedArray(Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array, and DataView)
• Map
• Set
• WeakMap
• WeakSet
• ArrayBuffer
• DataView
• Promise

Problems:

• Once a type is defined as a class, there is no way to extend the member side (extending the static side can happen through a module).
• Existing extensions to the member side will not work as you can not redefine a class (breaking change)
• No way to model function calls on a class, e.g Object, String, Boolean, Date, Number, RegExp, Error, and Array. (again breaking change)

Possible solutions:

• Allow extending any type with a prototype property and a construct signature
• Allow extending instance side of a class (e.g. module Class.prototype {}, courtesy of @RyanCavanaugh )
• Allow defining call signatures on a class constructor

[metaweta]

@mhegazy Thanks, I was unaware of the ambient class declaration construct.