No, the problem is that

class C extends X {

when X turns out to be null must be an error along exactly these lines.
Everywhere else in the language where X is accepted as an expression
evaluated to a value, if X evaluates to null, this is the same thing as
placing null in that position. Consider:


const NULL = null; // C nostalgia

class C extends NULL {


It would be awful for this to be different than

class C extends null {


If you really want to write a class whose prototype.__proto__ is null,
imperatively make it so after the class declaration. We don't need to
compromise the consistency of the language to make this rare case less ugly.




On Sat, Feb 14, 2015 at 12:52 PM, Axel Rauschmayer <axel at rauschma.de> wrote:

> If I’m reading the latest spec draft correctly then
>
> ```js
> class C extends null {
> }
> ```
>
> produces the following result:
>
> 1. Constructor kind: derived
> 2. Prototype of `C`: `Function.prototype`
> 3. Prototype of `C.prototype`: `null`
>
> Neither #2 nor #3 seems very useful:
>
> * #2 means that a super-constructor call is allowed but throws an
> exception, because `Function.prototype` is not constructible. The default
> constructor will perform a super-constructor call. As a result, you are
> forced to explicitly return an object from the constructor if you don’t
> want an exception to be thrown.
>
> * #3 means that the constructor doesn’t even create objects whose
> prototype is `null`, but objects whose prototype is an object whose
> prototype is `null`.
>
> Therefore my question: is this useful for anything? Can’t `extends null`
> be turned into something useful? Even treating `extends null` as equivalent
> to a missing `extends` clause seems preferable.
>
> Thanks!
>
> Axel
>
> --
> Dr. Axel Rauschmayer
> axel at rauschma.de
> rauschma.de
>
>
>
>
> _______________________________________________
> es-discuss mailing list
> es-discuss at mozilla.org
> https://mail.mozilla.org/listinfo/es-discuss
>
>


-- 
    Cheers,
    --MarkM
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.mozilla.org/pipermail/es-discuss/attachments/20150214/cd5e60e3/attachment-0001.html>

No, the problem is that
```js
class C extends X {
```
when X turns out to be null must be an error along exactly these lines.
Everywhere else in the language where X is accepted as an expression
evaluated to a value, if X evaluates to null, this is the same thing as
placing null in that position. Consider:

```js
const NULL = null; // C nostalgia

class C extends NULL {
```

It would be awful for this to be different than
```js
class C extends null {
```

If you really want to write a class whose `prototype.__proto__` is null,
imperatively make it so after the class declaration. We don't need to
compromise the consistency of the language to make this rare case less ugly.