ES2015 & 2016 Features meta-issue

[samwgoldman]

Feel free to open an issue for any unchecked feature that doesn't already have one, but please try to keep discussion in a single issue if possible. Use cases (and test cases) are very welcome!

To report a bug with a completed feature, please open a new issue for the bug.

ES2015+

• let/const declarations (let/const #784)
• Regular expression u flag (Allow u flag on RegExp #2510)
• Regular expression y flag
• Binary literals (Support ES6 binary and octal literals #566)
• New octal literals (Support ES6 binary and octal literals #566)
• Arrow functions
• Default parameters (mostly supported, except using this: Flow error on using this.x as a default param in a class #1234)
• Rest parameters
• Spread operator
• super references
• Classes
• for-of loops
• Generators (ES6 Generators #534)
• Object literal property shorthand
• Object literal method shorthand
• Object literal computed properties (Support computed property keys #252)
• Template strings
• Tagged templates
• Tagged template fn strings param has a raw prop
• Tagged template fn strings and raw arrays are frozen
• Destructuring
• Default values in destructuring (Add support for destructuring parameters + default values #183)
• Unicode code point escapes
• Allow duplicate object literal properties (except proto)
• Modules
• new.target (new.target support #1152)
• Symbols (Add support for ES6 symbol types #810, Support typeof x === "symbol" #1015)
• export Foo from 'foo' (Is export something from 'something supported? #2403)
• object spread
• async/await
• async iterators (Implement async iteration proposal (stage 3) #1824)
• Shared memory and atomics (Add Shared Memory definitions #7811)
• String.prototype.matchAll (Add String.prototype.matchAll #7812)
• Promise.allSettled
• Lifting template literal restriction

Proposals

Stage 4

• String.prototype.replaceAll

Stage 3

• optional chaining (Support optional chaining #4303)
• BigInt (BigInt typechecking #7602)
• globalThis (Support globalThis proposal #7704)
• import.meta (Flow parser should support import.meta #6913)
• private instance methods and accessors
• nullish coalescing (Support 'Nullish coalescing' proposal #6257)
• class property initializers (Support ES7 class property initializers #850)
• numeric separators
• top-level await (Top-level await #7710)
• WeakRefs
• RegExp Match array offsets

Stage 2

• Promise.any
• function.sent
• throw expressions (Support for throw expressions #6605)
• Atomics.waitAsync
• new Set methods
• ArrayBuffer.prototype.transfer
• Temporal
• Array.isTemplateObject
• iterator helpers
• collection normalization
• class decorators
• method decorators

Stage 1

• do expressions (Support for Syntax Do Expression #2523)
• Emitter
• pattern matching (TC39 pattern matching syntax support #6353)
• pipeline operator (Support Pipeline Operator #5443)

Stage 0

• function bind operator (Support function bind syntax (stage 0) #1545)

[mroch]

this is super useful!

there are probably a bunch of new APIs that we need to add, too. for example, I just noticed that we don't have String.prototype.codePointAt (part of new unicode stuff)

[nmn]

Perhaps, add an ES7 section and mark async-await as done.

(BTW, I find it surprising that async-await is done before generators!)

[Globegitter]

It seems there is an issue with ES6 Class support. I am using atom/nuclide IDE and having the following code:

export default class Resource {
  constructor(req:string) {
    this.req = req * 2;
  }
}

assignment of property req Property req not found in Resource even though I am defining it here in the constructor.

[gabelevi]

@Globegitter, Flow wants you to declare class properties like so:

export default class Resource {
  req: number;
  constructor(req: number) {
    this.req = req * 2;
  }
}

Why do we require this? Well, if we don't make people declare properties then we can't detect things like

function getReq(resource: Resource): number {
  return resource.rep;
}

We do realize this is a little bit more work for the developer, but we're hoping the benefits outweigh the pain.

[Globegitter]

Aahh, I see, thanks @gabelevi For know I mostly want to use flow for its type inference with /* @flow weak */. The issue here is that I can not just put req; res; at the top, it does throw an 'Unexpected token;` issue.

Generally I do think this is an acceptable extra-effort, but why can flow not just get the information from the constructor itself? Is it that much more complex to see what this.req is assigned to and then look up the type in the constructor's parameter list?

As a side note kind of fitting to this, it would be great to see property initialiser support as mentioned here: http://babeljs.io/blog/2015/06/07/react-on-es6-plus/

[gabelevi]

I think at the moment that Flow requires type annotations for the class member properties you declare. So

req: any; res: any;

should work. I did recently change the parsing of that (7e5b2a9) in preparation for class property initializers. We absolutely are planning support for class property initializers. They solve so many problems! The one I hate the most is how you have to do

class Foo {
  constructor() {
    this.myCallBack = this.myCallBack.bind(this);
  }
  myCallBack() { ... }
}

but with class property initializers you can do

class Foo {
  myCallBack = () => { ... }
}

[Globegitter]

Thanks for the quick response that all sounds good :) And yep it really does solve a lot of issues.