proposal: Object Members

[Ranando King]

> The proposal commingles static and instance private properties.  In the
first example, you could read or write this#.field2, and it would work.
How would you encode the generic expression a#.[b]?

That's not quite right. I added some details about how all this works a few
hours after you wrote this message. Here's the gist:
The `static` keyword would cause `field2` to be placed in the
`[[PrivateValues]]` record of the function. The `protected` keyword would
cause a key/value pair resembling `"field2": Symbol("field2")` to be placed
in the `[[DeclarationInfo]]` record of the function. Since you used `this`,
I will assume it is an instance of `ExampleFn`. The expression
`this#.field2` within `ExampleFn` would translate into

`this.[[PrivateValues]][this.[[DeclarationInfo]].field2] ->
this.[[PrivateValues]][undefined] -> TypeError`

assuming that the prototype of `ExampleFn` contained no definition for
field2. Since the `static` field belongs to the function it is declared in,
it can only be accessed via the function object itself, i.e.
`ExampleFn#.field2` or `this.constructor#.field2` or the array-notation
equivalents. I can't say that I'm understanding what you're looking for
with `a#.[b]` That looks like a syntax error to me. If you're trying to
understand how `a#[b]` works, it would be exactly the same. The best way to
understand how it works is to look at this equation for the `#` operator.

<lParam>#<rParam> ===
<lParam>.[[PrivateValues]][<lParam>.[[DeclarationInfo]]<rParam>]

In the case of `a#[b]`, the result would be:

a.[[PrivateValues]][a.[[DeclarationInfo]] [b] ]

I get that all the square braces can make that hard to read, so here's the
step by step:

   1. Throw a type error if a is not an object
   2. Let D be the [[DeclarationInfo]] record of object.
   3. if D is not in the lexical scope chain of the current function, throw
   a TypeError
   4. Let N be the value for the key matching b in D, or undefined if no
   such key exists.
   5. Let P be the [[PrivateValues]] record of object a
   6. If N is not a key of P, Throw a TypeError
   7. return P[N]

> Worse, the proposal commingles all private properties across all
classes.  There's nothing in the proposed code stopping you from reading
and writing private properties defined by class A on instances of an
unrelated class B.

That's not right either. The example desugaring does indeed throw all maps
into the same WeakMap. I'll work on that to make a better example. However,
to get a better understanding of how I see the implementation, you should
read the implementation details section. There's a much better description
there. Besides, the 7 step description I just wrote for you should help you
realize that:

   - If the function you're in doesn't know the names of the private fields
   of your object, you get a TypeError.
   - If the object you're accessing doesn't recognize the name of the field
   you're trying to access, you get a TypeError.

So there really is no way to apply the private field names of `class A`
onto an instance of `class B`.

I'll spend some time tonight re-tooling my example desugaring and a few
other details I thought of while writing this in the proposal. Hopefully,
that'll prevent more confusion.


On Fri, Jul 27, 2018 at 7:55 PM Waldemar Horwat <waldemar at google.com> wrote:

> On 07/26/2018 01:55 PM, Ranando King wrote:
> > I've just finished updating my proposal with an [Existing proposals](
> https://github.com/rdking/proposal-object-members/blob/master/README.md#existing-proposals)
> section that lists the major differences.
>
> Reading the proposal, I'm not yet sure what it's supposed to do.  Some
> things I've noticed:
>
> - The proposal commingles static and instance private properties.  In the
> first example, you could read or write this#.field2, and it would work.
> How would you encode the generic expression a#.[b]?
>
> - Worse, the proposal commingles all private properties across all
> classes.  There's nothing in the proposed code stopping you from reading
> and writing private properties defined by class A on instances of an
> unrelated class B.
>
>      Waldemar
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.mozilla.org/pipermail/es-discuss/attachments/20180727/f1779f44/attachment.html>