Editorial: support built-in async functions

[michaelficarra]

This adds support for built-in async functions, as needed by the async iterator helpers and Array.fromAsync proposals.

[jmdyck]

This says that a built-in function is exotic (and synchronous) unless otherwise specified. So then a built-in would be ordinary (i.e., an ECMAScript function object) only if specified to be so. But, of course, none of them are, because the spec explicitly says that built-ins can be ordinary or exotic.

[bakkot]

@jmdyck I don't understand this comment. I think I'm missing some assumption. Can you rephrase?

[jmdyck]

• 10.3 "Built-in Function Objects" says that built-in functions may be implemented as either ECMAScript function objects or as exotic function objects.

• 10.2 "ECMAScript Function Objects" says that an ECMAScript function object has the [[Call]] internal method defined in 10.2.1.

• 10.3 "Built-in Function Objects" says (in the status quo) that a built-in function that isn't implemented as an ECMAScript function object must have the [[Call]] internal method defined in 10.3.1.

So, in the status quo, a built-in's [[Call]] can be either 10.2.1 or 10.3.1, and the spec leaves the choice to the implementation.

• This PR replaces the third point with a sentence that says a built-in function object must use 10.3.1 "unless otherwise specified".

• But for all of the existing built-in functions, the spec never specifies whether to use 10.3.1 or 10.2.1 (because it's leaving that choice to the implementation), so it is never "otherwise specified", so the "unless otherwise specified" clause never holds.

So this new sentence implies that all existing built-in functions must use 10.3.1.

[jmdyck]

(And I know that, at some point, the idea was floated to get rid of the 10.2.1 possibility for built-ins, but that's clearly not what this PR is trying to accomplish. That would presumably be a separate PR.)

[michaelficarra]

This is not an observable difference. I am okay with it. Besides, we wanted to eliminate all the implications (and explicit statements) that "built-ins can be ECMAScript code, too" because it doesn't matter.

[michaelficarra]

Resolution from editor call is to change the definition of ordinary object to explicitly allow these [[Call]] and [[Construct]] methods so they're all considered ordinary for now. We'll do this in a separate PR.

[michaelficarra]

Resolved in #2969.

[jmdyck]

#2969 expands the definition of "ordinary function" to include all built-in functions (however implemented). But I don't think that resolves this, because my concern doesn't hinge on the definition of "ordinary function". If you look at my response to bakkot above, it all still holds in a post-2969 spec (except that "exotic" in the first point now becomes "non-ECMAScript").

(Yes, it was during discussion of this concern that the editors call decided to expand the definition of "ordinary", but maybe that was just to deal with the discovery that built-ins could be exotic?)

[jmdyck]

I think PR #3007 would be a basis for resolving my concern.

[jmdyck]

PR #3007 was superseded by PR #3145, which (among other things) established that all built-in functions had 10.3.1 [[Call]] semantics, thus resolving this discussion.

[syg]

lgtm % question and nits

[syg]

What's the verbiage for describing an async AC? "Let c be a new async Abstract Closure"? Or "Async Abstract Closure" with capital A?

[bakkot]

I would say "async Abstract Closure", I think; the idea is what we will say "async function" or "async method" for the built-in function case (as in proposal-iterator-helpers).

We don't actually have any async ACs at the moment so it's not established yet.

[bakkot]

Per plenary, built-in async functions will continue to have Function.prototype as their prototype.

[jmdyck]

Roughly speaking, the status quo says that a function is ordinary if its [[Call]] conforms to either 10.2.1 or 10.3.1. This PR defines a distinct [[Call]] for built-in async function objects, which implies that these objects are not ordinary. Is that intentional, or do you need to tweak the definition of ordinary to include them?

[syg]

Recording my thoughts here for the record. While being able to specify built-ins as async functions in spec text significantly aids spec authors and many readers, I've found that it simultaneously really hinders understanding by implementers that work in a non-self hosting implementation, like V8.

For non-self hosting implementations, the implementer would need to do a manual transform to some kind of state machine. This manual transformation process increases the likelihood of bugs and subtle non-interop (like getting the number of Promise ticks wrong or something).

There are possible paths forward. The long-term solution is for V8 to be build something so that async functions can be written as straightline code as well. The spec can also include the transformed version and offer an alternate formulation of async builtins.

[js-choi]

Once tc39/proposal-array-from-async#50’s reviews are finished and it is merged, Array.fromAsync will be ready to make a pull request against this pull request for formal Stage 3 reviews, as per tc39/proposal-array-from-async#14 (comment). [Edit: Now in #3581.]

However, this pull request now seems to have merge conflicts with the main ecma262 branch.

Should I write the new Array.fromAsync pull request against this pull request as it is now, or should I wait until this pull request’s conflicts are resolved?

[michaelficarra]

@js-choi Rebased.

[ExE-Boss]

This shouldn’t be present, as the presence/absence of [[Construct]] is used to differentiate constructors from non‑constructors and it’s observable, and all existing and future async‑like built‑in functions lack it.

[jmdyck]

I think it's fairly clear that "built-in async functions" are a subset of "built-in functions". However, there are a few things that make it less clear:

• CreateBuiltinFunction has a dichotomy between creating "a new built-in async function object" vs "a new built-in function object". The latter could instead be "a new built-in sync function object" (or whatever you want to call it, I don't think there's a precedent).

• 10.3.1 [[Call]] and 10.3.2 [[Construct]] say they are for "a built-in function object F". Similarly, 10.3.3 BuiltinCallOrConstruct says that its parameter _F_ is "a built-in function object". But presumably these are only for synchronous built-ins.

• The new section 10.4 Built-in Async Function Objects is a sibling of 10.3 Built-in Function Objects. You could instead make it a subsection. At the same time, it might be helpful to factor out the sync-specific parts of 10.3 and put them in a complementary subsection. That is, something like this:

10.3 Built-in Function Objects
     10.3.1 CreateBuiltinFunction
     10.3.2 Built-in Sync Function Objects
            10.3.2.1 [[Call]]
            10.3.2.2 [[Construct]]
            10.3.2.3 BuiltinCallOrConstruct
     10.3.3 Built-in Async Function Objects
            10.3.3.1 [[Call]]

[jmdyck]

Rather than leaving it vaguely open-ended like this, wouldn't it help the reader more to say that [[Call]] must conform to one of two explicit possibilities?

[jmdyck]

What is this change for? AFAICT, the current spec has no built-in that specifies an alternative [[Construct]], and this PR isn't adding one, so is this change for the benefit of a future PR? If so, maybe defer this change to that.

[jmdyck]

The corresponding step in BuiltinCallOrConstruct wraps the result of evaluating in an <emu-meta> element. Does that apply here too?

[jmdyck]

Presumably you will need to add this to the possible definitions of [[Call]] for an ordinary object as defined in 6.1.7.2.