Editorial: Add support for Abstract Closures to CreateBuiltinFunction

[ExE-Boss]

Part of #1894.

I’ve also converted Object.fromEntries to use it, as it’s the only built‑in anonymous function that has no internal slots apart from CreateListIteratorRecord, but built‑in iterators are being converted to use Abstract Closures in #2045.

Depends on:

• Normative: Set function name and length in CreateBuiltinFunction #2116 (merged)

---

Preview (#sec-createbuiltinfunction, #sec-object.fromentries)

[bakkot]

Thanks for getting this started! A couple of comments from a first pass.

[jmdyck]

It still gives the impression that only the built-ins created via closure get length and name properties, but I gather that PR #2116 will take care of that.

Otherwise, looks okay to me.

[syg]

lgtm with one comment

[syg]

I feel like this is lacking clarity a bit for the case with _algorithm_ is an Abstract Closure. Since the definition of ACs explicitly talk about invoking them, perhaps we should have a sentence here that in the case algorithm is an AC, it is invoked with the same arguments in the same order that the built-in function objects was called with, and its return value returned.

[jmdyck]

Theoretically, algorithm (whether or not it's an AC) is never invoked, it merely specifies the behavior that the new function must exhibit.

[syg]

Fair enough, it is not invoked in the sense of an actual JS function invocation. There's no term we use for the "meta invocation" that's spec-internal calling of an AC. The high order bit for me here was to say something about forwarding of arguments. Perhaps nobody else finds this under-specified and considers "performs the action described" to include the argument forwarding?

[jmdyck]

Actually, when I said "invoked", I did mean it in your sense of "meta invocation": algorithm is never meta-invoked. When the new function object is called, it doesn't forward arguments to algorithm, because algorithm isn't in the picture.

E.g., you can imagine that the implementation uses algorithm as a template/blueprint for building the function, and then discards it once the function is created (i.e., by the time this step finishes). algorithm's parameters are a template for the function's parameters, so when the function is called, it will handle its arguments in a way that is consistent with how algorithm handles its parameters.

That's how I read it, anyway.

[syg]

That's a fine mental model, I'd still like a sentence about it, like "the function object handles parameters in a way consistent with how algorithm handles parameters"

[bakkot]

Perhaps "performs the action described by algorithm using the provided arguments as the values of the corresponding parameters specified by algorithm"?

That doesn't describe how to deal with the case that the function is called with the wrong number of arguments, but that's covered by these paragraphs in ECMAScript Standard Built-in Objects:

Unless otherwise specified in the description of a particular function, if a built-in function or constructor is given fewer arguments than the function is specified to require, the function or constructor shall behave exactly as if it had been given sufficient additional arguments, each such argument being the undefined value. Such missing arguments are considered to be “not present” and may be identified in that manner by specification algorithms. In the description of a particular function, the terms “this value” and “NewTarget” have the meanings given in 10.3.

Unless otherwise specified in the description of a particular function, if a built-in function or constructor described is given more arguments than the function is specified to allow, the extra arguments are evaluated by the call and then ignored by the function. However, an implementation may define implementation specific behaviour relating to such arguments as long as the behaviour is not the throwing of a TypeError exception that is predicated simply on the presence of an extra argument.

[syg]

This wording sgtm.

[michaelficarra]

LGTM otherwise.

[bakkot]

Suggested change

	1. Let _func_ be a new built-in function object that, when called, performs the action described by _behaviour_. The new function object has internal slots whose names are the elements of _internalSlotsList_, and an [[InitialName]] internal slot.
	1. Let _func_ be a new built-in function object that, when called, performs the action described by _behaviour_ using the provided arguments as the values of the corresponding parameters specified by _behaviour_. The new function object has internal slots whose names are the elements of _internalSlotsList_, and an [[InitialName]] internal slot.

per discussion.

Edit: pushed a commit doing this.