Attachment #8450035 for bug #945566

Attachment #8450035: proxyConstructOnly.patch for bug #945566

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





load(libdir + "asserts.js");

// Throw a TypeError if Proxy is not called as a constructor
assertThrowsInstanceOf(function () { Proxy({}, {}); }, TypeError);

// Throw a TypeError if Proxy is called with less than two arguments
assertThrowsInstanceOf(function () { Proxy(); }, TypeError);
assertThrowsInstanceOf(function () { new Proxy(); }, TypeError);
assertThrowsInstanceOf(function () { Proxy({}); }, TypeError);
assertThrowsInstanceOf(function () { new Proxy({}); }, TypeError);

// Throw a TypeError if the first argument is not a non-null object
assertThrowsInstanceOf(function () { Proxy(0, {}); }, TypeError);
assertThrowsInstanceOf(function () { new Proxy(0, {}); }, TypeError);
assertThrowsInstanceOf(function () { Proxy(null, {}); }, TypeError);
assertThrowsInstanceOf(function () { new Proxy(null, {}); }, TypeError);

// Throw a TypeError if the second argument is not a non-null object
assertThrowsInstanceOf(function () { Proxy({}, 0); }, TypeError);
assertThrowsInstanceOf(function () { new Proxy({}, 0); }, TypeError);
assertThrowsInstanceOf(function () { Proxy({}, null); }, TypeError);
assertThrowsInstanceOf(function () { new Proxy({}, null); }, TypeError);

// Result of the call should be an object
assertEq(typeof Proxy({}, {}), 'object');
assertEq(typeof new Proxy({}, {}), 'object');






    setSlot(HANDLER_SLOT, PrivateValue(handler));
    setCrossCompartmentSlot(PRIVATE_SLOT, priv);
    setSlot(EXTRA_SLOT + 0, UndefinedValue());
    setSlot(EXTRA_SLOT + 1, UndefinedValue());
}

static bool
NewScriptedProxy(JSContext *cx, CallArgs &args)
{
    CallArgs args = CallArgsFromVp(argc, vp);
    if (args.length() < 2) {
        JS_ReportErrorNumber(cx, js_GetErrorMessage, nullptr, JSMSG_MORE_ARGS_NEEDED,
                             "Proxy", "1", "s");
        return false;
    }
    RootedObject target(cx, NonNullObject(cx, args[0]));
    if (!target)
        return false;

    if (!proxy)
        return false;
    proxy->setExtra(ScriptedDirectProxyHandler::HANDLER_EXTRA, ObjectValue(*handler));
    args.rval().setObject(*proxy);
    return true;
}

static bool
proxy(JSContext *cx, unsigned argc, jsval *vp)
{
    CallArgs args = CallArgsFromVp(argc, vp);

    if (!args.isConstructing()) {
        JS_ReportErrorNumber(cx, js_GetErrorMessage, nullptr, JSMSG_NOT_FUNCTION, "Proxy");
        return false;
    }

    return NewScriptedProxy(cx, args);
}

static bool
RevokeProxy(JSContext *cx, unsigned argc, Value *vp)
{
    CallReceiver rec = CallReceiverFromVp(vp);

    RootedFunction func(cx, &rec.callee().as<JSFunction>());
    RootedObject p(cx, func->getExtendedSlot(ScriptedDirectProxyHandler::REVOKE_SLOT).toObjectOrNull());

    if (p) {


    rec.rval().setUndefined();
    return true;
}

static bool
proxy_revocable(JSContext *cx, unsigned argc, Value *vp)
{
    CallArgs args = CallArgsFromVp(argc, vp);

    if (!NewScriptedProxy(cx, args))
        return false;

    RootedValue proxyVal(cx, args.rval());
    MOZ_ASSERT(proxyVal.toObject().is<ProxyObject>());

    RootedObject revoker(cx, NewFunctionWithReserved(cx, RevokeProxy, 0, 0, cx->global(),
    "RevokeProxy"));
    if (!revoker) {





        return results[i++];
    }
    var ret = { next: next }
    ret[std_iterator] = iterator;
    return ret;
}

function* yield_results(expected) {
    return yield* new Proxy(results(expected), {});
}

function collect_results(iter) {
    var ret = [];
    var result;
    do {
        result = iter.next();
        ret.push(result);

Return to bug 945566