Hi @sandydoo, could you mention real-life use case where you have to wrap args into proxy?

I'm trying to migrate ember-google-maps to Octane. I was hoping I could avoid converting this.args into a POJO every time a map component has to be updated. The goal is to filter/modify the arguments passed to the map component before sending them on to Google Maps. It works quite well, aside from accusing me of calling getOwnPropertyDescriptor...

It seems nobody else has run into this problem, so I’m going to close this issue as “likely too esoteric and niche” 😆.

For anyone reading this, here’s the TL;DR: don’t wrap this.args in a proxy.

Hi @sandydoo, may it help you? glimmerjs/glimmer-vm#1304

So, the reason we put that assertion there at all was just to discourage people from attempting strange things like dynamically defining properties on args. It doesn't seem like your use case is all that strange, and I do think it should be supported and work in general.

What's odd to me is that you're triggering getOwnPropertyDescriptor just using Reflect.get? That's really strange, because that would be super non-performant. I don't think the spec would require that. Is something else attempting to get the property descriptor? Like, is some code you don't control trying to do Object.getOwnPropertyDescriptor on your proxy, which is then forwarding it to the args proxy?

In either case, I think we could relax this restriction.

I don't think the spec would require that. Is something else attempting to get the property descriptor? Like, is some code you don't control trying to do Object.getOwnPropertyDescriptor on your proxy, which is then forwarding it to the args proxy?

The thing is, you can replicate the behaviour like so:

let firstProxy = new Proxy(Object.create(null), {
  get() {
    console.log('checking the first proxy');
    return;
  },

  getOwnPropertyDescriptor() {
    console.log('I should not be called');
    return;
  },
});

let secondProxy = new Proxy(firstProxy, {
  get() {
    return Reflect.get(...arguments);
  },
});

secondProxy.undefinedProp;

Safari, Firefox...they both end up calling getOwnPropertyDescriptor.

The repro I made is essentially the same. If you run through the debugger step-by-step, you’ll notice how we suddenly jump to getOwnPropertyDescriptor in Ember’s proxy handler right before we’re supposed to return from my proxy’s get handler. The getOwnPropertyDescriptor on my proxy is never run.

That's really strange, because that would be super non-performant.

🤷 Could be fun to see what happens if you then give it some value in getOwnPropertyDescriptor...

So, the reason we put that assertion there at all was just to discourage people from attempting strange things like dynamically defining properties on args.

Ah, that makes sense.

Hi @sandydoo, may it help you? glimmerjs/glimmer-vm#1304

@lifeart, thanks for keeping an eye out ❤️

Huh, really interesting... it must be something that the proxy is doing for some reason. I'll have to read the spec on that at some point.

I think we can remove that assertion for now though, and instead just return a blank/default property descriptor if the property doesn't exist.

Huh, really interesting... it must be something that the proxy is doing for some reason. I'll have to read the spec on that at some point.

Alright, alright, you got me curious 🤣 Now I have to look!

Here’s the relevant bit:

Because proxy objects permit the implementation of internal methods to be provided by arbitrary ECMAScript code, it is possible to define a proxy object whose handler methods violates the invariants defined in 6.1.7.3. Some of the internal method invariants defined in 6.1.7.3 are essential integrity invariants. These invariants are explicitly enforced by the proxy object internal methods specified in this section. An ECMAScript implementation must be robust in the presence of all possible invariant violations. — https://262.ecma-international.org/11.0/#sec-proxy-object-internal-methods-and-internal-slots

And here’s what Proxy actually does in the get handler. There’s our call to GetOwnProperty!

https://262.ecma-international.org/11.0/#sec-proxy-object-internal-methods-and-internal-slots-get-p-receiver

9.5.8 [[Get]] ( P, Receiver )

When the [[Get]] internal method of a Proxy exotic object O is called with property key P and ECMAScript language value Receiver, the following steps are taken:

    Assert: IsPropertyKey(P) is true.
    Let handler be O.[[ProxyHandler]].
    If handler is null, throw a TypeError exception.
    Assert: Type(handler) is Object.
    Let target be O.[[ProxyTarget]].
    Let trap be ? GetMethod(handler, "get").
    If trap is undefined, then
        Return ? target.[[Get]](P, Receiver).
    Let trapResult be ? Call(trap, handler, « target, P, Receiver »).
    Let targetDesc be ? target.[[GetOwnProperty]](P).
    If targetDesc is not undefined and targetDesc.[[Configurable]] is false, then
        If IsDataDescriptor(targetDesc) is true and targetDesc.[[Writable]] is false, then
            If SameValue(trapResult, targetDesc.[[Value]]) is false, throw a TypeError exception.
        If IsAccessorDescriptor(targetDesc) is true and targetDesc.[[Get]] is undefined, then
            If trapResult is not undefined, throw a TypeError exception.
    Return trapResult.

And here are those “invariants”:

https://262.ecma-international.org/11.0/#sec-invariants-of-the-essential-internal-methods

[[Get]] ( P, Receiver )
If P was previously observed as a non-configurable, non-writable own data property of the target with value V, then [[Get]] must return the SameValue as V.
If P was previously observed as a non-configurable own accessor property of the target whose [[Get]] attribute is undefined, the [[Get]] operation must return undefined.

[[GetOwnProperty]] ( P )
If P is described as a non-configurable, non-writable own data property, all future calls to [[GetOwnProperty]] ( P ) must return Property Descritor whose [[Value]] is SameValue as P's [[Value]] attribute.

Well, I guess you pay a price for that flexibility 🤷 Now I’m curious what could happen if Proxy could break these “essential integrity invariants”... What a rabbit hole 🙄

i also had this issue. simple workaround if possible: dont set args as the proxy target.

const origArgs = context.args;
    return new Proxy({}, {
      get(target: any, p: string | symbol, receiver: any): any {
        if (p in origArgs) {
          return origArgs[p];
        }
        return defaultArgs[p];
      }
    });