DELPROP: exposed property deletion algorithm ("delete" operator)

Background

Properties are deleted in ECMAScript code with the delete operator, e.g.:

delete foo.bar;

This involves:

• A property accessor reference (E5 Section 11.2.1)
• delete semantics (E5 Section 11.4.1)
• A call to [[Delete]]

The property accessor coercions are the same as for GetValue:

• The base reference is checked with CheckObjectCoercible()
• The property name is coerced to a string

The delete expression will then:

• Coerce the base value to an object
• Call the [[Delete]] algorithm

Note that if the base value is not an object, a temporary object will be created by coercion. Since a deletion always operates on the "own properties" of an object, the deletion can only have side effects (error throwing) side effects. Any other effects will be lost with the temporary object. This is discussed in more detail below, for the deletion algorithm.

Notes:

• [[Delete]] only checks for the property P in the original object O, and does not follow the prototype chain
• In particular, an inherited property P which would prevent a [[Put]] does not affect the outcome of [[Delete]]

First draft

Starting from the property accessor, then applying delete (and skipping any unused steps):

1. Call CheckObjectCoercible for the base value. In practice, throw a TypeError if the base value is null or undefined.
2. Coerce property name to string using ToString().
3. Coerce base value to object using ToObject() and call [[Delete]] with the coerced object, the coerced key, and a "Throw" flag set if the property reference is contained in strict mode code.

More formally, suppose O is the base value, P is the property name value, and currStrict is true if the property deletion expression occurred in strict code:

1. If O is null or undefined, throw a TypeError
2. P = ToString(P)
3. O = ToObject(O)
4. Call O.[[Delete]](P, currStrict), and return its result

Avoiding object coercion

We want to avoid the object coercion; let's first make it more explicit:

1. If O is null or undefined, throw a TypeError
2. P = ToString(P)
3. If O is an object, call [[Delete]](O, P, currStrict), and return its result
4. Else O is primitive: a. O = ToObject(O) (create temporary object) b. Call O.[[Delete]](P, currStrict), and return its result

Avoiding temporary objects

Note that a [[Delete]] only operates on the "own properties" of the target object. When the base value is not an object, the deletion operates only on the temporary object. Since the temporary object is immediately discarded, there are only two possible user visible effects:

• The return value of [[Delete]], which is:
  • true, if the property does not exist
  • true, if the property exists and could be deleted
  • false, if the property exists, cannot be deleted, and Throw is false (if Throw is true, an error is thrown instead)
• Errors thrown by [[Delete]], which happens if:
  • The (own) property exists, the property is non-configurable, and the Throw flag is set, i.e. we're evaluating delete in strict code

The coerced temporary object can be:

• a Boolean instance: no own properties
• a Number instance: no own properties
• a String instance: has length and array indices (inside string length) as own properties, all non-configurable

Given these, the algorithm can be changed to avoid creation of temporaries entirely:

1. If O is null or undefined, throw a TypeError
2. P = ToString(P)
3. If O is an object, call [[Delete]](O, P, currStrict) and return its result
4. Else O is primitive: a. If O is a boolean, return true b. If O is a number, return true c. If O is a string: 1. If P is length or an array index inside the O string length: a. If currStrict is true, throw a TypeError b. Else, return false 2. Else, return true d. Return true (This step should never be reached, as the checks above are comprehensive.)

Step 4 can be simplified a bit:

1. If O is null or undefined, throw a TypeError
2. P = ToString(P)
3. If O is an object, call [[Delete]](O, P, currStrict) and return its result
4. If O is a string: a. If P is length or an array index inside the O string length: 1. If currStrict is true, throw a TypeError 2. Else, return false
5. Return true

Fast path for array indices

It would be straightforward to add a fast path for array indices, but there is no fast path in the current implementation for array index deletion. The index is always string coerced and interned.