Attachment #640061 for bug #703537

Attachment #640061: Part 7 - Implement getOwnPropertyDescriptorTrap for bug #703537

View | Details | Raw Unified | Return to bug 703537
Collapse All | Expand All

(-)a/js/src/js.msg (+5 lines)

Line	Link Here

Lines 347-354 MSG_DEF(JSMSG_QUERY_INNERMOST_WITHOUT_LI	Link Here

347

MSG_DEF(JSMSG_DEBUG_VARIABLE_NOT_FOUND, 294, 0, JSEXN_TYPEERR, "variable not found in environment")

347

MSG_DEF(JSMSG_DEBUG_VARIABLE_NOT_FOUND, 294, 0, JSEXN_TYPEERR, "variable not found in environment")

348

MSG_DEF(JSMSG_PARAMETER_AFTER_REST,   295, 0, JSEXN_SYNTAXERR, "parameter after rest parameter")

348

MSG_DEF(JSMSG_PARAMETER_AFTER_REST,   295, 0, JSEXN_SYNTAXERR, "parameter after rest parameter")

349

MSG_DEF(JSMSG_NO_REST_NAME,           296, 0, JSEXN_SYNTAXERR, "no parameter name after ...")

349

MSG_DEF(JSMSG_NO_REST_NAME,           296, 0, JSEXN_SYNTAXERR, "no parameter name after ...")

350

MSG_DEF(JSMSG_ARGUMENTS_AND_REST,     297, 0, JSEXN_SYNTAXERR, "'arguments' object may not be used in conjunction with a rest parameter")

350

MSG_DEF(JSMSG_ARGUMENTS_AND_REST,     297, 0, JSEXN_SYNTAXERR, "'arguments' object may not be used in conjunction with a rest parameter")

351

MSG_DEF(JSMSG_FUNCTION_ARGUMENTS_AND_REST, 298, 0, JSEXN_ERR, "the 'arguments' property of a function with a rest parameter may not be used")

351

MSG_DEF(JSMSG_FUNCTION_ARGUMENTS_AND_REST, 298, 0, JSEXN_ERR, "the 'arguments' property of a function with a rest parameter may not be used")

352

MSG_DEF(JSMSG_REST_WITH_DEFAULT,      299, 0, JSEXN_SYNTAXERR, "rest parameter may not have a default")

352

MSG_DEF(JSMSG_REST_WITH_DEFAULT,      299, 0, JSEXN_SYNTAXERR, "rest parameter may not have a default")

353

MSG_DEF(JSMSG_NONDEFAULT_FORMAL_AFTER_DEFAULT, 300, 0, JSEXN_SYNTAXERR, "parameter(s) with default followed by parameter without default")

353

MSG_DEF(JSMSG_NONDEFAULT_FORMAL_AFTER_DEFAULT, 300, 0, JSEXN_SYNTAXERR, "parameter(s) with default followed by parameter without default")

354

MSG_DEF(JSMSG_YIELD_IN_DEFAULT,       301, 0, JSEXN_SYNTAXERR, "yield in default expression")

354

MSG_DEF(JSMSG_YIELD_IN_DEFAULT,       301, 0, JSEXN_SYNTAXERR, "yield in default expression")

355

MSG_DEF(JSMSG_CANT_REPORT_NC_AS_NE,   302, 0, JSEXN_TYPEERR, "can't report a non-configurable own property as non-existent")

356

MSG_DEF(JSMSG_CANT_REPORT_E_AS_NE,    303, 0, JSEXN_TYPEERR, "can't report an existing own property as non-existent on a non-extensible object")

357

MSG_DEF(JSMSG_CANT_REPORT_NEW,        304, 0, JSEXN_TYPEERR, "can't report a new property on a non-extensible object")

358

MSG_DEF(JSMSG_CANT_REPORT_INVALID,    305, 0, JSEXN_TYPEERR, "can't report an incompatible property descriptor")

359

MSG_DEF(JSMSG_CANT_REPORT_NE_AS_NC,   306, 0, JSEXN_TYPEERR, "can't report a non-existent property as non-configurable")





IndirectProxyHandler::getPropertyDescriptor(JSContext *cx, JSObject *proxy,
                                            jsid id, bool set,
                                            PropertyDescriptor *desc)
{
    return JS_GetPropertyDescriptorById(cx, GetProxyTargetObject(proxy), id,
                                        JSRESOLVE_QUALIFIED, desc);
}

bool
GetOwnPropertyDescriptor(JSContext *cx, JSObject *obj, jsid id, unsigned flags,
                         JSPropertyDescriptor *desc)
{
    // If obj is a proxy, we can do better than just guessing. This is
    // important for certain types of wrappers that wrap other wrappers.
    if (obj->isProxy())
        return Proxy::getOwnPropertyDescriptor(cx, obj, id,
                                               flags & JSRESOLVE_ASSIGNING,

    return GetIterator(cx, target, flags, vp);
}

static bool
GetTrap(JSContext *cx, JSObject *handler, PropertyName *name, Value *fvalp)
{
    JS_CHECK_RECURSION(cx, return false);

    // Direct proxies allow the handler object to be NULL
    if (!handler) {
        *fvalp = UndefinedValue();
        return true;
    }
    Rooted<PropertyName*> propname(cx, name);
    return handler->getProperty(cx, propname, fvalp);
}

static bool
GetFundamentalTrap(JSContext *cx, JSObject *handler, PropertyName *name, Value *fvalp)
{
    if (!GetTrap(cx, handler, name, fvalp))

    Value argv[2] = { *rval, v };
    return Trap(cx, handler, fval, 2, argv, rval);
}

static bool
ParsePropertyDescriptorObject(JSContext *cx, JSObject *obj, jsid id, const Value &v,
                              PropertyDescriptor *desc)
{
    if (v.isUndefined()) {
        // Indicate undefined by setting the obj field to NULL
        desc->obj = NULL;
        return true;
    }
    AutoPropDescArrayRooter descs(cx);
    PropDesc *d = descs.append();
    if (!d || !d->initialize(cx, v))
        return false;
    desc->obj = obj;
    desc->value = d->hasValue() ? d->value() : UndefinedValue();
    JS_ASSERT(!(d->attributes() & JSPROP_SHORTID));
    desc->attrs = d->attributes();

        if (!props.append(id))
            return false;
    }

    return true;
}

/* Derived class for all scripted proxy handlers. */
class ScriptedIndirectProxyHandler : public IndirectProxyHandler {
  public:
    ScriptedIndirectProxyHandler();
    virtual ~ScriptedIndirectProxyHandler();

    /* ES5 Harmony fundamental proxy traps. */
    virtual bool getPropertyDescriptor(JSContext *cx, JSObject *proxy, jsid id, bool set,
                                       PropertyDescriptor *desc);
    virtual bool getOwnPropertyDescriptor(JSContext *cx, JSObject *proxy, jsid id, bool set,
                                          PropertyDescriptor *desc);
    virtual bool defineProperty(JSContext *cx, JSObject *proxy, jsid id,
                                PropertyDescriptor *desc);

    virtual bool set(JSContext *cx, JSObject *proxy, JSObject *receiver, jsid id, bool strict,
                     Value *vp);
    virtual bool keys(JSContext *cx, JSObject *proxy, AutoIdVector &props);
    virtual bool iterate(JSContext *cx, JSObject *proxy, unsigned flags, Value *vp);

    virtual JSType typeOf(JSContext *cx, JSObject *proxy);
    virtual bool defaultValue(JSContext *cx, JSObject *obj, JSType hint, Value *vp);

    static ScriptedIndirectProxyHandler singleton;
};

static int sScriptedIndirectProxyHandlerFamily = 0;

ScriptedIndirectProxyHandler::ScriptedIndirectProxyHandler()
        : IndirectProxyHandler(&sScriptedIndirectProxyHandlerFamily)
{
}

ScriptedIndirectProxyHandler::~ScriptedIndirectProxyHandler()
{
}

static bool
ReturnedValueMustNotBePrimitive(JSContext *cx, JSObject *proxy, JSAtom *atom, const Value &v)
{
    if (v.isPrimitive()) {
        JSAutoByteString bytes;

static JSObject *
GetProxyHandlerObject(JSContext *cx, JSObject *proxy)
{
    JS_ASSERT(OperationInProgress(cx, proxy));
    return GetProxyPrivate(proxy).toObjectOrNull();
}

bool
ScriptedIndirectProxyHandler::getPropertyDescriptor(JSContext *cx,
                                                    JSObject *proxy_, jsid id_,
                                                    bool set,
                                                    PropertyDescriptor *desc)
{
    RootedObject proxy(cx, proxy_);
    RootedId id(cx, id_);
    RootedObject proxy(cx, proxy_);
    RootedObject handler(cx, GetProxyHandlerObject(cx, proxy));
    RootedValue fval(cx), value(cx);
    return GetFundamentalTrap(cx, handler, ATOM(getPropertyDescriptor), fval.address()) &&
           Trap1(cx, handler, fval, id, value.address()) &&
           ((value.get().isUndefined() && IndicatePropertyNotFound(cx, desc)) ||
            (ReturnedValueMustNotBePrimitive(cx, proxy, ATOM(getPropertyDescriptor), value) &&
             ParsePropertyDescriptorObject(cx, proxy, id, value, desc)));
}

bool
ScriptedIndirectProxyHandler::getOwnPropertyDescriptor(JSContext *cx,
                                                       JSObject *proxy_, jsid id_,
                                                       bool set,
                                                       PropertyDescriptor *desc)
{
    RootedId id(cx, id_);
    RootedObject proxy(cx, proxy_);
    RootedObject handler(cx, GetProxyHandlerObject(cx, proxy));
    RootedValue fval(cx), value(cx);
    return GetFundamentalTrap(cx, handler, ATOM(getOwnPropertyDescriptor), fval.address()) &&
           Trap1(cx, handler, fval, id, value.address()) &&
           ((value.get().isUndefined() && IndicatePropertyNotFound(cx, desc)) ||
            (ReturnedValueMustNotBePrimitive(cx, proxy, ATOM(getPropertyDescriptor), value) &&
             ParsePropertyDescriptorObject(cx, proxy, id, value, desc)));
}

bool
ScriptedIndirectProxyHandler::defineProperty(JSContext *cx, JSObject *proxy,
                                             jsid id_, PropertyDescriptor *desc)
{
    RootedObject handler(cx, GetProxyHandlerObject(cx, proxy));
    RootedValue fval(cx), value(cx);
    RootedId id(cx, id_);
    return GetFundamentalTrap(cx, handler, ATOM(defineProperty), fval.address()) &&
           NewPropertyDescriptorObject(cx, desc, value.address()) &&
           Trap2(cx, handler, fval, id, value, value.address());
}

bool
ScriptedIndirectProxyHandler::getOwnPropertyNames(JSContext *cx,
                                                  JSObject *proxy,
                                                  AutoIdVector &props)
{
    RootedObject handler(cx, GetProxyHandlerObject(cx, proxy));
    RootedValue fval(cx), value(cx);
    return GetFundamentalTrap(cx, handler, ATOM(getOwnPropertyNames), fval.address()) &&
           Trap(cx, handler, fval, 0, NULL, value.address()) &&
           ArrayToIdVector(cx, value, props);
}

bool
ScriptedIndirectProxyHandler::delete_(JSContext *cx, JSObject *proxy, jsid id,
                                      bool *bp)
{
    RootedObject handler(cx, GetProxyHandlerObject(cx, proxy));
    RootedValue fval(cx), value(cx);
    return GetFundamentalTrap(cx, handler, ATOM(delete), fval.address()) &&
           Trap1(cx, handler, fval, id, value.address()) &&
           ValueToBool(cx, value, bp);
}

bool
ScriptedIndirectProxyHandler::enumerate(JSContext *cx, JSObject *proxy,
                                        AutoIdVector &props)
{
    RootedObject handler(cx, GetProxyHandlerObject(cx, proxy));
    RootedValue fval(cx), value(cx);
    return GetFundamentalTrap(cx, handler, ATOM(enumerate), fval.address()) &&
           Trap(cx, handler, fval, 0, NULL, value.address()) &&
           ArrayToIdVector(cx, value, props);
}

bool
ScriptedIndirectProxyHandler::has(JSContext *cx, JSObject *proxy_, jsid id,
                                  bool *bp)
{
    RootedObject proxy(cx, proxy_);
    RootedObject handler(cx, GetProxyHandlerObject(cx, proxy));
    RootedValue fval(cx), value(cx);
    if (!GetDerivedTrap(cx, handler, ATOM(has), fval.address()))
        return false;
    if (!js_IsCallable(fval))
        return BaseProxyHandler::has(cx, proxy, id, bp);
    return Trap1(cx, handler, fval, id, value.address()) &&
           ValueToBool(cx, value, bp);
}

bool
ScriptedIndirectProxyHandler::hasOwn(JSContext *cx, JSObject *proxy_, jsid id,
                                     bool *bp)
{
    RootedObject proxy(cx, proxy_);
    RootedObject handler(cx, GetProxyHandlerObject(cx, proxy));
    RootedValue fval(cx), value(cx);
    if (!GetDerivedTrap(cx, handler, ATOM(hasOwn), fval.address()))
        return false;
    if (!js_IsCallable(fval))
        return BaseProxyHandler::hasOwn(cx, proxy, id, bp);
    return Trap1(cx, handler, fval, id, value.address()) &&
           ValueToBool(cx, value, bp);
}

bool
ScriptedIndirectProxyHandler::get(JSContext *cx, JSObject *proxy_,
                                  JSObject *receiver, jsid id_, Value *vp)
{
    RootedId id(cx, id_);
    RootedObject proxy(cx, proxy_);
    RootedObject handler(cx, GetProxyHandlerObject(cx, proxy));
    JSString *str = ToString(cx, IdToValue(id));
    if (!str)
        return false;
    RootedValue value(cx, StringValue(str));

    if (!GetDerivedTrap(cx, handler, ATOM(get), fval.address()))
        return false;
    if (!js_IsCallable(fval))
        return BaseProxyHandler::get(cx, proxy, receiver, id, vp);
    return Trap(cx, handler, fval, 2, argv, vp);
}

bool
ScriptedIndirectProxyHandler::set(JSContext *cx, JSObject *proxy_,
                                  JSObject *receiver, jsid id_, bool strict,
                                  Value *vp)
{
    RootedId id(cx, id_);
    RootedObject proxy(cx, proxy_);
    RootedObject handler(cx, GetProxyHandlerObject(cx, proxy));
    JSString *str = ToString(cx, IdToValue(id));
    if (!str)
        return false;
    RootedValue value(cx, StringValue(str));

    if (!GetDerivedTrap(cx, handler, ATOM(set), fval.address()))
        return false;
    if (!js_IsCallable(fval))
        return BaseProxyHandler::set(cx, proxy, receiver, id, strict, vp);
    return Trap(cx, handler, fval, 3, argv, value.address());
}

bool
ScriptedIndirectProxyHandler::keys(JSContext *cx, JSObject *proxy_,
                                   AutoIdVector &props)
{
    RootedObject proxy(cx, proxy_);
    RootedObject handler(cx, GetProxyHandlerObject(cx, proxy));
    RootedValue value(cx);
    if (!GetDerivedTrap(cx, handler, ATOM(keys), value.address()))
        return false;
    if (!js_IsCallable(value))
        return BaseProxyHandler::keys(cx, proxy, props);
    return Trap(cx, handler, value, 0, NULL, value.address()) &&
           ArrayToIdVector(cx, value, props);
}

bool
ScriptedIndirectProxyHandler::iterate(JSContext *cx, JSObject *proxy_,
                                      unsigned flags, Value *vp)
{
    RootedObject proxy(cx, proxy_);
    RootedObject handler(cx, GetProxyHandlerObject(cx, proxy));
    RootedValue value(cx);
    if (!GetDerivedTrap(cx, handler, ATOM(iterate), value.address()))
        return false;
    if (!js_IsCallable(value))
        return BaseProxyHandler::iterate(cx, proxy, flags, vp);
    return Trap(cx, handler, value, 0, NULL, vp) &&
           ReturnedValueMustNotBePrimitive(cx, proxy, ATOM(iterate), *vp);
}

JSType
ScriptedIndirectProxyHandler::typeOf(JSContext *cx, JSObject *proxy)
{
    /*
     * This function is only here to prevent a regression in
     * js1_8_5/extensions/scripted-proxies.js. It will be removed when the
     * direct proxy refactor is complete.
     */
    return BaseProxyHandler::typeOf(cx, proxy);
}

bool
ScriptedIndirectProxyHandler::defaultValue(JSContext *cx, JSObject *proxy,
                                           JSType hint, Value *vp)
{
    /*
     * This function is only here to prevent bug 757063. It will be removed when
     * the direct proxy refactor is complete.
     */
    return BaseProxyHandler::defaultValue(cx, proxy, hint, vp);
}

ScriptedIndirectProxyHandler ScriptedIndirectProxyHandler::singleton;

class ScriptedDirectProxyHandler : public DirectProxyHandler {
  public:
    ScriptedDirectProxyHandler();

    virtual ~ScriptedDirectProxyHandler();

    /* ES5 Harmony fundamental proxy traps. */
    virtual bool getOwnPropertyDescriptor(JSContext *cx, JSObject *proxy,
                                          jsid id, bool set,
                                          PropertyDescriptor *desc);

    static ScriptedDirectProxyHandler singleton;
};

const uint32_t HANDLER_EXTRA = 0;

inline JSObject *
GetProxyHandlerObject(const JSObject *obj)
{
    JS_ASSERT(IsProxy(obj));
    return GetProxyExtra(obj, HANDLER_EXTRA).toObjectOrNull();
}

/*
 * The information in a PropertyDescriptor is effectively a subset of that in
 * the corresponding PropDesc. This causes some problems, as PropertyDescriptor
 * misses some fields that are present in PropDesc, and which we need in order
 * to implement standard conforming behavior.
 *
 * In particular, the specification assumes that properties are represented as
 * JavaScript objects, which allows for the possibility of missing fields. To
 * keep track of missing fields, PropDesc contains several bit flags, which are
 * absent in PropertyDescriptor.
 *
 * 
 */

static inline bool
IsDataDescriptor(PropertyDescriptor *desc)
{
    /* 1. If Desc is undefined, then return false */
    if (!desc->obj) 
        return false;

    /*
     * 2. If both Desc.[[Value]] and Desc.[[Set]] are absent, then return false.
     */

    /*
     * We cannot distinguish here between a property descriptor in which the
     * value field is absent, or one in which the value field is undefined, so
     * instead, we define IsDataDescriptor as the logical negation of
     * IsAccessorDescriptor.
     */
    if ((desc->attrs & JSPROP_GETTER) || (desc->attrs & JSPROP_SETTER))
        return false;

    /* 3. Return true. */
    return true;
}

static inline bool
IsAccessorDescriptor(PropertyDescriptor *desc)
{
    /* 1. If Desc is undefined, then return false */
    if (!desc->obj) 
        return false;

    /* 2. If both Desc.[[Get] and Desc.[[Set]] are absent, then return false */
    if (!(desc->attrs & JSPROP_GETTER) && !(desc->attrs & JSPROP_SETTER))
        return false;

    /* 3. Return true. */
    return true;
}

static inline bool
IsGenericDescriptor(PropertyDescriptor *desc)
{
    /* 1. If Desc is undefined, then return false */
    if (!desc->obj) 
        return false;

    /*
     * 2. If IsAccessorDescriptor(Desc) and IsDataDescriptor(Desc) are both
     *    false, then return true.
     */

    /*
     * Due to the way we've devined IsDataDescriptor (see above), this test
     * always fails, and IsGenericDescriptor always returns true.
     */
    if (!IsDataDescriptor(desc) && !IsAccessorDescriptor(desc))
        return false;

    /* 3. Return true. */
    return true;
}

/* Aux 5. ValidateProperty(O, P, Desc) */
static inline bool
ValidateProperty(JSContext *cx, JSObject *proxy, jsid id,
                 PropertyDescriptor *desc, bool *bp)
{
    /*
     * 1. Let current be the result of calling the [[GetOwnProperty]] internal
     *    method of O with property name P.
     */
    AutoPropertyDescriptorRooter current(cx);
    if (!GetOwnPropertyDescriptor(cx, proxy, id, 0, &current))
        return false;

    /*
     * 2. Let extensible be the value of the [[Extensible]] internal property of
     *    O.
     */
    bool extensible = proxy->isExtensible();

    /* 3. If current is undefined and extensible is false, return false. */
    if (!current.obj && !extensible) {
        *bp = false;
        return true;
    }

    /* 4. If current is undefined and extensible is true, return true. */
    if (!current.obj && extensible) {
        *bp = true;
        return true;
    }

    /* 5. Return true, if every field in Desc is absent */

    /*
     * We cannot distinguish here between a property descriptor in which the
     * value field is absent, or one in which the value field is undefined, so
     * we are forced to ignore this step.
     */
    
    /*
     * 6. Return true if every field in Desc also occurs in current and the
     *    value of every field in Desc is the same value as the corresponding
     *    field in current when compared using the SameValue algorithm
     */
    if (desc->obj == current.obj && desc->attrs == current.attrs &&
        desc->getter == current.getter && desc->setter == current.setter) {
        bool same;
        if (!SameValue(cx, desc->value, current.value, &same))
            return false;
        if (same) {
            *bp = true;
            return true;
        }
    }

    /* 7 If the [[Configurable]] field of current is false then */
    if (current.attrs & JSPROP_PERMANENT) {
        /* a. Return false, if the [[Configurable]] field of Desc is true. */
        if (!(desc->attrs & JSPROP_PERMANENT)) {
            *bp = false;
            return true;
        }

        /*
         * b. Return false if the [[Enumerable]] field of Desc is present and
         *    [[Enumerable]] fields of current and Desc are the Boolean negation
         *    of each other.
         */ 
        if ((desc->attrs & JSPROP_ENUMERATE) !=
            (current.attrs & JSPROP_ENUMERATE)) {
            *bp = false;
            return true;
        }
    }

    /* 8. If IsGenericDescriptor(Desc) is true, return true */
    if (IsGenericDescriptor(desc)) {
        *bp = true;
        return true;
    }

    /*
     * 9. Else, if IsDataDescriptor(current) and IsDataDescriptor(desc) have
     *    different results, then
     */
   if ((IsDataDescriptor(desc) && !IsDataDescriptor(&current)) ||
        (!IsDataDescriptor(desc) && IsDataDescriptor(&current))) {
        /* a. Return false, if the [[Configurable]] field of current is false. */
        if (current.attrs & JSPROP_PERMANENT) {
            *bp = false;
            return true;
        }

        /* b. Return true */
        *bp = true;
        return true;
    }

    /*
     * 10. Else, if IsDataDescriptor(current) and IsDataDescriptor(desc) are
     *     both true,
     */
    if (IsDataDescriptor(desc) && IsDataDescriptor(&current)) {
        /* a. If the [[Configurable]] field of current is false, then */
        if (current.attrs & JSPROP_PERMANENT) {
            /*
             * i. Return false, if the [[Writable] field of current is false,
             *    and the [[Writable]] field of Desc is true.
             */
            if (!(desc->attrs & JSPROP_READONLY) &&
                (current.attrs & JSPROP_READONLY)) {
                *bp = true;
                return true;
            }
        
            /* ii. If the [[Writable]] field of current is false, then */
            if (current.attrs & JSPROP_READONLY) {
                /*
                 * 1. Return false, if the [[Value]] field of desc is present
                 *    and SameValue(Desc.[[Value]], current.[[Value]]) is
                 *    false.
                 */
                bool same;
                if (!SameValue(cx, desc->value, current.value, &same))
                    return false;
                if (!same) {
                    *bp = false;
                    return true;
                }
            }
        }

        /* b. Else, return true. */
        *bp = true;
        return true;
    }

    /* 12. Return true. */
    *bp = true;
    return true;
}

/* Aux. 6 IsSealed(O, P) */
static inline bool
IsSealed(JSContext* cx, JSObject *obj, jsid id, bool *bp)
{
    /* 1. Let desc be the result of calling O.[[GetOwnProperty]](P) */
    AutoPropertyDescriptorRooter desc(cx);
    if (!GetOwnPropertyDescriptor(cx, obj, id, 0, &desc))
        return false;

    /* 2. If desc is undefined, return false */
    if (!desc.obj) {
        *bp = false;
        return true;
    }

    /* 3. Return the boolean negation of desc.[[Configurable]] */
    *bp = desc.attrs & JSPROP_PERMANENT;
    return true;
}

static int sScriptedDirectProxyHandlerFamily = 0;

ScriptedDirectProxyHandler::ScriptedDirectProxyHandler()
        : DirectProxyHandler(&sScriptedDirectProxyHandlerFamily)
{
}

ScriptedDirectProxyHandler::~ScriptedDirectProxyHandler()
{
}

bool
ScriptedDirectProxyHandler::getOwnPropertyDescriptor(JSContext *cx,
                                                     JSObject *proxy, jsid id,
                                                     bool set,
                                                     PropertyDescriptor *desc)
{
    /* 1. Let handler be the value of the [[Handler]] internal property of O. */
    JSObject *handler = GetProxyHandlerObject(proxy);

    /* 2. Let target be the value of the [[Target]] internal property of O. */
    JSObject *target = GetProxyTargetObject(proxy);

    /*
     * 3. Let trap be the result of calling
     *    GetTrap(handler, "getOwnPropertyDescriptor")
     */
    AutoValueRooter fval(cx);
    if (!GetTrap(cx, handler, ATOM(getOwnPropertyDescriptor), fval.addr()))
        return false;

    /* 4. If trap is undefined */
    if (fval.value().isUndefined()) {
        /*
         * a. Return the result of calling the built-in function
         *    Reflect.getOwnPropertyDescriptor(target, P)
         */
        return DirectProxyHandler::getOwnPropertyDescriptor(cx, proxy, id, set,
                                                            desc);
    }

    /*
     * 5. Let trapResult be the result of calling the [[Call] internal method of
     * trap providing handler as the this value, target as the first agument and
     * P as the second argument.
     */
    JSString *name = ToString(cx, IdToValue(id));
    if (!name)
        return false;
    Value argv[] = {
        ObjectValue(*target),
        StringValue(name)
    };
    AutoValueRooter rval(cx);
    if (!Invoke(cx, ObjectOrNullValue(handler), fval.value(), 2, argv, rval.addr()))
        return false;

    /* 6. Let desc be NormalizeAndCompletePropertyDescriptor(trapResult) */

    /*
     * Due to how PropertyDescriptors are represented, we can neither normalize
     * or complete them, so we are forced to simply convert trapResult to a
     * PropertyDescriptor.
     */
    if (!ParsePropertyDescriptorObject(cx, proxy, id, rval.value(), desc))
        return false;

    /* 7. If desc is undefined */
    if (!desc->obj) {
        /*
         * a. If IsSealed(target, P), throw a TypeError (cannot report a
         *    non-configurable property as non-existent)
         */
        bool sealed;
        if (!IsSealed(cx, target, id, &sealed)) 
            return false;
        if (sealed) {
            JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL,
                                 JSMSG_CANT_REPORT_NC_AS_NE);
            return false;
        }

        /* 
         * b. If the [[Extensible]] attribute of target is false and
         *    target.[[HasOwn]](P) is true then,
         */
        if (!target->isExtensible()) {
            bool found;
            if (!getOwnPropertyDescriptor(cx, proxy, id, false, desc))
                return false;
            if (!desc->obj)
                return false;
            if (found) {
                /*
                 * i. Throw a TypeError (cannot report existing own property as
                 *    non-existent on a non-extensible object)
                 */
                JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL,
                                     JSMSG_CANT_REPORT_E_AS_NE);
                return false;
            }
        }
    }
    
    /* 8. Let isFixed be the result of calling target.[[HasOwn]].P */
    bool found;
    if (!getOwnPropertyDescriptor(cx, proxy, id, false, desc))
        return false;
    found = !!desc->obj;

    /*
     * 9. If the [[Extensible]] attribute of target is false and isFixed is
     *    false then,
     */
    if (!target->isExtensible() && !found) {
        /*
         * a. Throw a TypeError (cannot report a new own property on a
         *    non-extensible object)
         */
        JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL,
                             JSMSG_CANT_REPORT_NEW);
        return false;
    }

    /* 10. If isFixed is true, */
    if (found) {
        /*
         * a. Let valid be the result of calling
         *    ValidateProperty(target, P, desc)
         */
        bool valid;
        if (!ValidateProperty(cx, target, id, desc, &valid)) 
            return false;

        /*
         * b. If valid is false, throw a TypeError (cannot report incompatible
         *    property descriptor)
         */
        if (!valid) {
            JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL,
                                 JSMSG_CANT_REPORT_INVALID);
            return false;
        }
    }

    /* 11. If desc.[[Configurable]] is false and isFixed is false, */
    if (desc->attrs & JSPROP_PERMANENT && !found) {
        /*
         * a. Throw a TypeError (cannot report a non-configurable descriptor for
         *    a non-configurable descriptor for a non-existent property)
         */
        JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL,
                             JSMSG_CANT_REPORT_NE_AS_NC);
        return false;
    }

    /* 12. Return desc */
    return true;
}

ScriptedDirectProxyHandler ScriptedDirectProxyHandler::singleton;

class AutoPendingProxyOperation {
    JSRuntime               *rt;
    PendingProxyOperation   op;
  public:
    AutoPendingProxyOperation(JSContext *cx, JSObject *proxy)
        : rt(cx->runtime), op(cx, proxy)
    {

        proto = &vp[3].toObject();
        parent = proto->getParent();
    } else {
        JS_ASSERT(IsFunctionObject(vp[0]));
        proto = NULL;
    }
    if (!parent)
        parent = vp[0].toObject().getParent();
    JSObject *proxy = NewProxyObject(cx, &ScriptedIndirectProxyHandler::singleton, ObjectValue(*handler),
                                     proto, parent);
    if (!proxy)
        return false;

    vp->setObject(*proxy);
    return true;
}


        return false;
    JSObject *construct = NULL;
    if (argc > 2) {
        construct = ValueToCallable(cx, &vp[4]);
        if (!construct)
            return false;
    }

    JSObject *proxy = NewProxyObject(cx, &ScriptedIndirectProxyHandler::singleton,
                                     ObjectValue(*handler),
                                     proto, parent, call, construct);
    if (!proxy)
        return false;

    vp->setObject(*proxy);
    return true;
}

Return to bug 703537