Support expression in extends clauses

Demo

Classes can extend arbitrary expressions, but Closure is throwing a warning on an unknown type.

const Mixin = (superclass) => class extends superclass {
  // ...
}

Note, the warning from the compiler service at least doesn’t have a line number:

JSC_TYPE_PARSE_ERROR: Bad type annotation. Unknown type superclass at line -1 beyond character 1

[ChadKillingsworth]

For background: http://justinfagnani.com/2015/12/21/real-mixins-with-javascript-classes/ Planned for use in Polymer 2.

[justinfagnani]

Yes, it just creates prototype chains.

I think this expansion is assuming a lot about the mixin function - that it only returns a class expression and does no other computation. In practice we have some utilities that will modify a mixin function so that it does things like de-duplicate multiple applications on a prototype chain (not reapply if it has already been applied), or cache and reuse the result of an application to a prototype chain. See DeDupe and Cache here: https://github.com/justinfagnani/mixwith.js

So I think it’d be better to type the mixin function itself somehow. To say that it takes a constructor of type S and returns a constructor of type M extends S…

Please my abuse of the type annotations below, and in general the level of crazy, but this is close to what I would want to type check mixins:

import {Mixin} from '../mixwith/mixwith.js';

/**
 * @template {HTMLElement} S
 * @param {function(new:S)} superclass
 * @return {M extends S}
 */
const AwesomeElement =  Mixin((superclass) => /** @typedef M */ class M extends superclass {
});

class MyElement extends AwesomeElement(HTMLElement) {
}

A few things that I knowingly fudge:

1. How do I specify that a template extends a type? @template {HTMLElement} S is my attempt to do Java’s <S extends HTMLElement>.
2. function(new:S) is my attempt to specify a first-class type, the metaclass of S
3. M extends S is a type operator that represents the type created by class M extends S{}
4. class M extends superclass: M doesn’t exist in the outer scope, so it needs some way to be pushed up. /** @typedef M */ is that 😕
5. I’m assuming that at the callsite for AwesomeElement(HTMLElement) the typechecker can calculate the result type and validate that AwesomeElement can extend HTMLElement (overrides are compatible).