Forced to call super leading to undefined is not a constructor

[jeffrose]

TypeScript Version: 2.7.1

Search Terms:
super constructor undefined

Code

tsconfig.json

{
  "compilerOptions": {
    "declaration": true,
    "downlevelIteration": true,
    "experimentalDecorators": true,
    "lib": [ "esnext", "dom" ],
    "module": "es2015",
    "moduleResolution": "node",
    "noUnusedLocals": true,
    "noUnusedParameters": true,
    "removeComments": true,
    "skipLibCheck": true,
    "sourceMap": true,
    "target": "es5"
  }
}

type Constructor<T = {}> = new( ...args: any[] ) => T;
class Null extends null { }

interface MyInterface {
  myMixinMethod(): void;
  myClassMethod(): void;
}

const MyMixin = <T extends Constructor>( superclass: T ) => class extends superclass {
 myMixinMethod(): void {
    console.log( 'Called my mixin method' );
  }
};

abstract class AbstractMyClass extends MyMixin( Null ) implements MyInterface {
 abstract myClassMethod(): void;
}

class MyClass extends AbstractMyClass {
  constructor( public myProperty: string ){
    // If super() is not called, it throws the error below
    // [ts] Constructors for derived classes must contain a 'super' call.
    super();
  }
  myClassMethod(): void {
    console.log( 'Called my class method' );
  }
}

// If super() is called in MyClass, it throws the error below
// TypeError: undefined is not a constructor (evaluating '_super.call(this)')
const myClass = new MyClass( 'myValue' );

Expected behavior:
It should not require the super() call since parent class lacks a constructor.

Actual behavior:
It requires a call to super() which results in the error undefined is not a constructor.

Related Issues:

Can you get a JavaScript example that works for you at runtime? I tried with just this:

class Null extends null {}

class MyClass extends Null {
  constructor() {
    super();
  }
}

new MyClass();

And it doesn't work at runtime with or without super();. So TypeScript may be correctly telling you that you have an impossible situation...
I can't find any way to even construct a Null. And if Null can't be constructed, a subclass can't either.

[jeffrose]

@Andy-MS It looks like you are correct. The same catch-22 exists in vanilla JavaScript.

Prior to the introduction of class I've done...

function Null(){}
Null.prototype = Object.create( null );

There doesn't seem to be a way to duplicate this using the class syntax since you cannot extend classes that extend null.

By the way, why not use Object as the supertype? This has an empty constructor.

[jeffrose]

It's more secure to inherit from null since modifications to Object.prototype would affect your class.

[jeffrose]

I tried a few more patterns in JavaScript and only one of them actually seemed to work, i.e. give you a clean object from which to inherit that is not tied to Object.prototype.

// Given this class
class Null {}

// This does not work
Null.prototype = Object.create( null );

// This does not work in JavaScript and causes the same error above in TypeScript
Object.setPrototypeOf( Null, Object.create( null ) );

// This works in JavaScript but results in an error in TypeScript
// [ts] Property '__proto__' does not exist on type 'Null'.
Null.prototype.__proto__ = Object.create( null );

You could use Object.setPrototypeOf(Null.prototype, null);.

[jeffrose]

Both Object.setPrototypeOf( Null.prototype, null ) and Object.setPrototypeOf( Null.prototype, Object.create( null ) ) seem to work. Offhand, I don't know if the Object.create is better for this scenario or not. Either way it seems to resolve my issue.

While I think this is what extends null should be doing, it looks like it's not a TypeScript problem to solve.

The Object.create(null) will just insert an additional object into the prototype chain. So instead of Null.prototype -> null you get Null.prototype -> {} -> null.

[jeffrose]

Since this seems to be reproducible in JavaScript, there's no reason to keep the issue open.