Commenting on this same region:
```
print(points[0].x); // 0 to start
points[0].x = 1;
print(points[0].x); // still 0
points[0] = {x: 1, y: 2};
print(points[0].x); // now 1
```
There's no reason why we couldn't extend the grammar to handle this
case, in the same way that `a.f()` has different semantics than `f =
a.f; f();`. That is, use the [Reference Specification Type] to treat
field assignment differently, so that the semantics of:
```
points[0].x = 1;
```
are the same as:
```
points[0] = { x: 1, y: points[0].y }
```
For my own education, here's a rough draft of how the [runtime
semantics of assignment] might look:
AssignmentExpression[In, Yield] : LeftHandSideExpression[?Yield] =
AssignmentExpression[?In, ?Yield]
1. Let *lref* be the result of evaluating *LeftHandSideExpression*
2. ReturnIfAbrupt(*lref*)
3. If Type(*lref*) is Reference, then
a. Let *baseref* be GetBaseReference(*lref*)
b. If *baseref* is a reference to a value type, then
i. Let *name* be GetReferencedName(*lref*)
ii. Let *oldval* be GetValue(*baseref*)
iii. Let *rref* be the result of evaluating *AssignmentExpression*
iv. ReturnIfAbrupt(*rref*)
v. Let *rval* be GetValue(*rref*)
vi. Let *newval* be a value type identical to *oldval* except
that field *name* is set to *rval*
vii. Let *status* be PutValue(*baseref*, *newval*)
viii. ReturnIfAbrupt(*status*)
ix. Return *rval*
etc
Note that in step 3a I need to get a *reference to* the base value,
rather than using GetValue(*lref*). So the Reference specification
type would have to cover two levels of indirection rather than one.
--scott
[Reference Specification Type]:
https://people.mozilla.org/~jorendorff/es6-draft.html#sec-reference-specification-type)
[runtime semantics of assignment]:
https://people.mozilla.org/~jorendorff/es6-draft.html#sec-assignment-operators-runtime-semantics-evaluation
_______________________________________________
es-discuss mailing list
es-discuss@mozilla.org
https://mail.mozilla.org/listinfo/es-discuss
