ECMAScript compatibility tracking issue

This is a tracking issue for failed compat-table tests with links to each input, output, error and related issue (updated with v20200426).

These items are filtered out as “won’t fix”:

• new Function("features"): hard to implement
• Proxy: impossible to implement
• subclassing for built-ins: impossible to implement (except for Promise)
• typed arrays: won’t fix? (IE11 has typed array classes but doesn’t have Array methods, should be fixed?), #3064
• shared memory and atomics (ES2017): impossible to implement

---

ES2015

Optimisation

proper tail calls (tail call optimisation)

• direct recursion (in/out)
• mutual recursion (in/out)

Syntax

default function parameters

• arguments object interaction (in/out)

rest parameters

• function ‘length’ property (in/out)
• arguments object interaction (in/out)

spread syntax for iterable objects

• with sparse arrays, in array literals (in/out)
• with astral plane strings, in function calls (in/out)
• with astral plane strings, in array literals (in/out)
• spreading non-iterables is a runtime error (in/out)

object literal extensions

• computed accessors (compile error)

for…of loops

• with astral plane strings (in/out)
• iterator closing, break (in/out): https://github.com/google/closure-compiler/issues/2958
• iterator closing, throw (in/out): https://github.com/google/closure-compiler/issues/2958

octal and binary literals

• octal supported by Number() (in/out)
• binary supported by Number() (in/out)

template literals

• toString conversion (in/out)
• tagged template literals (in/out)
• passed array is frozen (in/out)
• TemplateStrings call site caching (in/out)
• TemplateStrings permanent caching (in/out)

RegExp “y” and “u” flags

• “y” flag (in/out)
• “y” flag, lastIndex (in/out)
• “u” flag (in/out)
• “u” flag, non-BMP Unicode characters (in/out)
• “u” flag, Unicode code point escapes (in/out)
• “u” flag, case folding (in/out)

destructuring, declarations

• with astral plane strings (in/out)
• iterator closing (in/out): https://github.com/google/closure-compiler/issues/2958

destructuring, assignment

• with astral plane strings (in/out)
• iterator closing (in/out): https://github.com/google/closure-compiler/issues/2958

destructuring, parameters

• with astral plane strings (in/out)
• iterator closing (in/out): https://github.com/google/closure-compiler/issues/2958

Unicode code point escapes

• in identifiers (in/out)

new.target

• in constructors (compile error)
• assignment is an early error (compile error)

Bindings

const

• temporal dead zone (in/out)
• temporal dead zone (strict mode) (in/out)

let

• temporal dead zone (in/out)
• temporal dead zone (strict mode) (in/out)

Functions

arrow functions

• no “prototype” property (in/out)
• lexical “super” binding in constructors (compile error)
• lexical “new.target” binding (compile error)

class

• class name is lexically scoped (compile error)
• computed names, temporal dead zone (in/out)
• methods aren’t enumerable (in/out)
• implicit strict mode (in/out)
• constructor requires new (in/out): https://github.com/google/closure-compiler/issues/2919
• extends null (in/out)
• new.target (compile error)

super

• constructor calls use correct “new.target” binding (compile error)

generators

• can’t use “this” with new (in/out)
• %GeneratorPrototype% (in/out)
• %GeneratorPrototype% prototype chain (in/out)
• %GeneratorPrototype%.constructor (in/out)
• yield *, astral plane strings (in/out)
• yield * on non-iterables is a runtime error (in/out)
• yield *, iterator closing via throw() (in/out)
• shorthand generators can’t be constructors (compile error)

Built ins

Map

• constructor requires new (in/out): https://github.com/google/closure-compiler/issues/2919
• iterator closing (in/out): https://github.com/google/closure-compiler/issues/2958
• Map iterator prototype chain (in/out)
• Map[Symbol.species] (in/out)

Set

• constructor requires new (in/out): https://github.com/google/closure-compiler/issues/2919
• iterator closing (in/out): https://github.com/google/closure-compiler/issues/2958
• Set iterator prototype chain (in/out)
• Set[Symbol.species] (in/out)

WeakMap

• constructor requires new (in/out): https://github.com/google/closure-compiler/issues/2919
• iterator closing (in/out): https://github.com/google/closure-compiler/issues/2958
• WeakMap.prototype isn’t an instance (in/out)

WeakSet

• constructor requires new (in/out): https://github.com/google/closure-compiler/issues/2919
• iterator closing (in/out): https://github.com/google/closure-compiler/issues/2958

Reflect

• Reflect.ownKeys, symbol keys (in/out)
• Reflect.construct sets new.target meta-property (compile error)
• Reflect.construct, Promise subclassing (in/out)

Promise

• Promise.prototype isn’t an instance (in/out)
• Promise[Symbol.species] (in/out)

Symbol

• typeof support (in/out)
• symbol keys are hidden to pre-ES6 code (in/out)
• symbols inherit from Symbol.prototype (in/out)
• cannot coerce to string or number (in/out)
• can convert with String() (in/out)
• Object(symbol) (in/out)
• JSON.stringify ignores symbol primitives (in/out)
• JSON.stringify ignores symbol objects (in/out)
• global symbol registry (in/out)

well-known symbols

• Symbol.hasInstance (in/out)
• Symbol.isConcatSpreadable (in/out)
• Symbol.iterator, arguments object (in/out)
• Symbol.species, existence (in/out)
• Symbol.species, Array.prototype.concat (in/out)
• Symbol.species, Array.prototype.filter (in/out)
• Symbol.species, Array.prototype.map (in/out)
• Symbol.species, Array.prototype.slice (in/out)
• Symbol.species, Array.prototype.splice (in/out)
• Symbol.species, RegExp.prototype[Symbol.split] (in/out)
• Symbol.species, Promise.prototype.then (in/out)
• Symbol.replace (in/out)
• Symbol.search (in/out)
• Symbol.split (in/out)
• Symbol.match (in/out)
• Symbol.match, RegExp constructor (in/out)
• Symbol.match, String.prototype.startsWith (in/out)
• Symbol.match, String.prototype.endsWith (in/out)
• Symbol.match, String.prototype.includes (in/out)
• Symbol.toPrimitive (in/out)
• Symbol.toStringTag (in/out)
• Symbol.toStringTag affects existing built-ins (in/out)
• Symbol.toStringTag, new built-ins (in/out)
• Symbol.toStringTag, misc. built-ins (in/out)
• Symbol.unscopables (compile error)

Built in extensions

Object static methods

• Object.getOwnPropertySymbols (in/out)

function “name” property

• function statements (in/out)
• function expressions (in/out)
• new Function (in/out)
• bound functions (in/out)
• variables (function) (in/out)
• object methods (function) (in/out)
• accessor properties (in/out)
• shorthand methods (in/out)
• symbol-keyed methods (in/out)
• class statements (in/out)
• class expressions (in/out)
• variables (class) (in/out)
• object methods (class) (in/out)
• class prototype methods (in/out)
• class static methods (in/out)
• isn’t writable, is configurable (in/out)

String static methods

• String.raw (in/out): https://github.com/google/closure-compiler/issues/3136

String.prototype methods

• String.prototype.normalize (in/out)
• String.prototype[Symbol.iterator] (in/out)
• String iterator prototype chain (in/out)

RegExp.prototype properties

• RegExp.prototype.flags (in/out)
• RegExp.prototype[Symbol.match] (in/out)
• RegExp.prototype[Symbol.replace] (in/out)
• RegExp.prototype[Symbol.split] (in/out)
• RegExp.prototype[Symbol.search] (in/out)
• RegExp[Symbol.species] (in/out)

Array static methods

• Array.from, iterator closing (in/out)
• Array[Symbol.species] (in/out)

Array.prototype methods

• Array iterator prototype chain (in/out)
• Array.prototype[Symbol.unscopables] (in/out)

Math methods

• Math.fround (in/out)
• Math.cbrt (in/out)

Date.prototype[Symbol.toPrimitive]

• Date.prototype[Symbol.toPrimitive] (in/out)

Misc

prototype of bound functions

• basic functions (in/out)
• generator functions (in/out)
• arrow functions (in/out)
• classes (in/out)
• subclasses (in/out)

Object static methods accept primitives

• Object.getPrototypeOf (in/out)
• Object.getOwnPropertyDescriptor (in/out)
• Object.getOwnPropertyNames (in/out)
• Object.seal (in/out)
• Object.freeze (in/out)
• Object.preventExtensions (in/out)
• Object.isSealed (in/out)
• Object.isFrozen (in/out)
• Object.isExtensible (in/out)
• Object.keys (in/out)

own property order

• Object.getOwnPropertyNames (in/out)
• Reflect.ownKeys, string key order (in/out)
• Reflect.ownKeys, symbol key order (in/out)

Updated identifier syntax

• var ⸯ; (in/out)
• var 𐋀; (compile error)

miscellaneous

• duplicate property names in strict mode (compile error)
• accessors aren’t constructors (in/out)
• RegExp constructor can alter flags (in/out)
• RegExp.prototype.toString generic and uses “flags” property (in/out)
• built-in prototypes are not instances (in/out)
• function ‘length’ is configurable (in/out)

Annex b

non-strict function semantics

• hoisted block-level function declaration (in/out)
• labeled function statements (compile error)
• function statements in if-statement clauses (compile error)

proto in object literals

• basic support (in/out)
• multiple proto is an error (in/out)
• not a computed property (in/out)
• not a shorthand property (in/out)
• not a shorthand method (in/out)

Object.prototype.proto

• absent from Object.create(null) (in/out)
• present in hasOwnProperty() (in/out)
• correct property descriptor (in/out)
• present in Object.getOwnPropertyNames() (in/out)

RegExp.prototype.compile

• returns this (in/out)

ES2016+

2016 features

Array.prototype.includes

• %TypedArray%.prototype.includes (in/out)

2016 misc

generator functions can’t be used with “new”

• generator functions can’t be used with “new” (in/out)

strict fn w/ non-strict non-simple params is error

• strict fn w/ non-strict non-simple params is error (in/out)

2017 features

Object static methods

• Object.getOwnPropertyDescriptors doesn’t provide undefined descriptors (in/out)

async functions

• no line break between async and function (in/out)
• no “prototype” property (in/out)
• cannot await in parameters (compile error)
• correct prototype chain (in/out)
• async function prototype, Symbol.toStringTag (in/out)
• async function constructor (in/out)

2017 misc

RegExp “u” flag, case folding

• RegExp “u” flag, case folding (in/out)

2017 annex b

Object.prototype getter/setter methods

• defineGetter, ToObject(this) (in/out)
• defineSetter, ToObject(this) (in/out)
• lookupGetter, ToObject(this) (in/out)
• lookupGetter, data properties can shadow accessors (in/out)
• lookupSetter, ToObject(this) (in/out)
• lookupSetter, data properties can shadow accessors (in/out)

assignments allowed in for-in head in non-strict mode

• assignments allowed in for-in head in non-strict mode (compile error)

2018 features

object rest/spread properties

• object rest properties (in/out): https://github.com/google/closure-compiler/issues/3139
• object spread properties (in/out): https://github.com/google/closure-compiler/issues/3139

s (dotAll) flag for regular expressions

• s (dotAll) flag for regular expressions (compile error)

RegExp named capture groups

• RegExp named capture groups (compile error)

RegExp Lookbehind Assertions

• RegExp Lookbehind Assertions (compile error)

RegExp Unicode Property Escapes

• RegExp Unicode Property Escapes (compile error)

2018 misc

Proxy “ownKeys” handler, duplicate keys for non-extensible targets

• Proxy “ownKeys” handler, duplicate keys for non-extensible targets (in/out)

template literal revision

• template literal revision (in/out)

2019 features

Array.prototype.{flat, flatMap}

• flat and flatMap in Array.prototype[@@unscopables] (in/out)

2019 misc

Symbol.prototype.description

• undefined description (in/out)

Function.prototype.toString revision

• functions created with the Function constructor (in/out)
• arrows (in/out)
• [native code] (in/out)
• class expression with implicit constructor (in/out)
• class expression with explicit constructor (in/out)
• unicode escape sequences in identifiers (in/out)
• methods and computed property names (in/out)

Well-formed JSON.stringify

• Well-formed JSON.stringify (in/out)

2020 features

BigInt

• basic functionality (compile error)
• constructor (compile error)
• BigInt.asUintN (in/out)
• BigInt.asIntN (in/out)
• BigInt64Array (compile error)
• BigUint64Array (compile error)
• DataView.prototype.getBigInt64 (compile error)
• DataView.prototype.getBigUint64 (compile error)

optional chaining operator (?.)

• optional property access (compile error)
• optional bracket access (compile error)
• optional method call (compile error)
• optional function call (compile error)

[brad4d]

FYI, I’ve just created a “supported features” page here https://github.com/google/closure-compiler/wiki/Supported-features

Hopefully it’s not too out of sync with this issue.

I added a link to this issue at the top of it.

Thanks @teppeis for your continuing efforts to maintain this information.

[brad4d]

@vxlydia is actively working on implementing ?? now, and will likely start working on optional chaining in January.

At the moment I expect we’ll have them available in ES_NEXT in 2020 Q1, and I hope to have ES_2020 LanguageMode available in Q2.