Allow non-inherited static class members.

Search Terms

inheritance inherit static class extendStatics

Suggestion

Provide a way to mark static class members as non-inherited. This is particularly meaningful for factory methods.

Use Cases

Static factory methods are often useful because they can be used for async construction of an object. They also can be useful for providing alternative constructor implementations (effectively) since TypeScript doesn't support constructor overloads (without a bunch of conditional ugliness in the constructor). Unfortunately, while the constructor for a subclass isn't inherited by the superclass, all static members are which means you cannot have a factory method like create or from in both the subclass and the superclass. One of them gets the name, the other doesn't.

Looking at the emitted code, there is explicit code for emitting static class extension. It would be nice if there were a way to tell the compiler to not emit static extension for a particular static method.

Examples

class Point1 {
    public constructor(private readonly x: number) { }
}
class Point2 extends Point1 {
    public constructor(x: number, private readonly y: number) { super(x) }
    public static from = (point1: Point1, y) => new Point2(point1.x, y)
}
class Point3 extends Point2 {
    public constructor(x: number, y: number, private readonly z: number) { super(x, y) }
    public static from = (point2: Point2, z) => new Point3(point2.x, point2.y, z)
}

The above code currently fails to compile. It would be nice if I could somehow annotate the from method on Point2 such that it was not inherited. Currently, if I rename them to from1 and from2 then a user calling Point3.from1(...) will get back a Point2 instead of the expected Point3. When I am authoring a Point2 factory method, I want to tell the compiler, "It doesn't make sense to call this static method from the context of a derived class".

Checklist

My suggestion meets these guidelines:

• This wouldn't be a breaking change in existing TypeScript/JavaScript code
• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.

Start by reviewing the compiler logic that emits static class extension and the type-checking behavior for inherited static members. Use the Point1, Point2, and Point3 examples as reproduction cases; done requires an agreed annotation or language design, correct type checking, and tests covering the resulting inheritance behavior.