TC39 meeting, October 1-3rd 2019

Not much significant change that we need to be worried about but lot of new proposals moved to stage 1. We have some reviewing work to do, as there is so much new stuff.

Normative Spec Changes

Remove ToUint32 from array literal evaluation

Summary: Spec bug, calcuation of array literals, including spreads, had their indices and lengths calcuated to a ToUint 32 operation. This was found the be incorrect, in the case of 2**32-1

SM impact: None. This is unlikely observable in implementations. Probably no action needed

Pull request

Conclusion: Consensus to merge

Prevent DFS invariants from being broken

Summary: An implementation of HostImportModuleDynamically, could, in theory, call Evaluate() in the same tick as the call to HostImportModuleDynamically. If that call to HostImportModuleDynamically was the direct result of another call to Evaluate(), this may eagerly evaluate a module that is already queued to be run at a later time.

SM impact: None. This is not observable in implementations, due to HTML doing this in the same tick already. Probably no action needed.

Pull request

Conclusion: Consensus to merge

Redefine CatchParameter as FormalParameter

Summary: Removes default value restriction for catch parameter. Was found in committee to have several unresolved issues, and was recommended to be moved to a proposal.

SM impact: None.

Pull request

Conclusion: No consensus for the PR. May be moved to a proposal.

Strengthening Atomics.wait and Atomics.notify (PR)

Summary: strengthens the synchronization between a waking thread and its wakees as though they were each a coinciding atomic write/read (respectively) to the same memory location.

SM impact: Needs a sanity check: I believe this was a spec bug, and is not observable in implementations.

Pull request

Conclusion: Consensus to merge

Reduce the amount of implementation-defined behavior in Array.prototype.sort

Summary: The issue is well detailed, and recommended reading. The intent is to make sort more consistent across implementation. However, it was raised by waldemar that the issue is self contradictory and needs further work.

SM impact: We would need to update our sorting algorithm.

Pull request

Consensus: Consensus on the intent, waiting on verification of correctness.

Revisit ECMA-402 casing conventions

Summary: Makes the recommendation that all Intl display names use camelCase everywhere.

SM impact: minor?

Pull Request)

Conclusion: consensus to merge

Proposals Seeking Advancement to Stage 4

globalThis to stage 4

Summary: globalThis has been implemented in at least 2 vendors.

SM impact: None. SM status: implemented.

RegExp Match Indices

Summary: Match Indices provide additional information about the start and end indices of captured substrings relative to the start of the input string.

SM status: Not implemented

Proposal

Conclusion: JSC will implement, then they will seek stage 4 in December

Proposals Seeking Advancement to Stage 3

for-in order for stage 3

Summary: Reflect.ownKeys is ordered, but for (a in b) {...} is not. However, engines tend to be consistent.

SM impact: Minor - We probably just need to run the tests. We might need to double check that our implementation conforms. Only known engine to not implement this behavior is JSC. SM status: Implemented, may beed to be double checked against the tests.

Conclusion: Stage 3

String.prototype.replaceAll for Stage 3

Summary: Updates both String.prototype.matchAll and String.prototype.replaceAll to throw for non-global RegExp.

SM impact: we will need to update our implementation of matchAll, and eventually implement replaceAll. SM status: matchall is implemented, replaceAll is not

Conclusion: Stage 3.

Promise.prototype.any for Stage 3

Summary: Introduce Promise.any which will resolve if any promise passed to it resolves. Current discussion revolves around resolving how errors will be reported. There was also some discussion about subclassing, which related back to the errors discussion. The issue raised was decided to be a stage three entry concern, property vs accessor.

SM status: Not implemented

Slides missing.
proposal

Conclusion: Consensus for Stage 3, pending reviews and spec text.

Intl.DisplayNames

Summary: Expose display name data through the Intl API. This would reduce download requirements for internationalization.

SM status: Not implemented

Conclusion: Stage 3.

Proposals Seeking Advancement to Stage 2

Map.upsert , previously Map.insertOrUpdate

Summary: Adding and updating values of a Map are tasks that developers often perform in conjunction. The proposal adds a method that will add a value to a map if the map does not already have something for that key, or else it will update the existing value on the key. Example: map.upsert(key, o => o, () => value).doThing();. There were potential performance concerns brought up, but it was seen as highly ergonomic, and standing on its own.

SM impact: we should carefully review this proposal.

No Slides
proposal

Conclusion: Consensus for stage 2.

Proposals Seeking Advancement to Stage 1

`Object.map` for Stage 1

Summary: A new method on objects is introduced to allow easy iteration over object entries, then map and reduce them. Example: Object.entries(obj).map([k, v] => { ... }) would become Object.map(obj, ([k, v], obj) => { ... });

SM impact: None, it seems unlikely that in its current form it will move forward.

Conclusion: The Proposal itself did not reach stage 1, but the problem of making object mapping more concise was determined to be a real issue, and the problem should be explored further in stage 1.

Records & Tuples for Stage 1

Summary: Introduce immutable data structures to JS, through the following syntax: const test = #{ key: value }; and let x = #[1, 1]. Testing loose equality would also be by property value rather than identify of the object, for example: assert(#{ a: 1 } == #{ a: 1 });assert(#[1] == #[1]);assert(Object.is(#{ a: 1 }, #{ a: 1 }));assert(Object.is(#[1], #[1]));

SM impact: We might want to keep an eye on this one, though no direct action is needed now.