Bug 1259877 - Update miscellaneous code to use js::Call instead of js::Invoke. r=till

--HG--
extra : rebase_source : 7881073ec02d63777da5275a64885823e3ba8ebf

js/src/asmjs/WasmModule.cpp

@@ -1421,8 +1421,16 @@ Module::callImport(JSContext* cx, uint32_t importIndex, unsigned argc, const Val
 
     const Import& import = imports()[importIndex];
 
+    InvokeArgs args(cx);
+    if (!args.init(argc))
+        return false;
+
+    for (size_t i = 0; i < argc; i++)
+        args[i].set(argv[i]);
+
     RootedValue fval(cx, ObjectValue(*importToExit(import).fun));
-    if (!Invoke(cx, UndefinedValue(), fval, argc, argv, rval))
+    RootedValue thisv(cx, UndefinedValue());
+    if (!Call(cx, fval, thisv, args, rval))
         return false;
 
     ImportExit& exit = importToExit(import);

js/src/builtin/Intl.cpp

@@ -473,17 +473,15 @@ IntlInitialize(JSContext* cx, HandleObject obj, Handle<PropertyName*> initialize
     MOZ_ASSERT(initializerValue.isObject());
     MOZ_ASSERT(initializerValue.toObject().is<JSFunction>());
 
-    InvokeArgs args(cx);
-    if (!args.init(3))
-        return false;
+    FixedInvokeArgs<3> args(cx);
 
-    args.setCallee(initializerValue);
-    args.setThis(NullValue());
     args[0].setObject(*obj);
     args[1].set(locales);
     args[2].set(options);
 
-    return Invoke(cx, args);
+    RootedValue thisv(cx, NullValue());
+    RootedValue ignored(cx);
+    return js::Call(cx, initializerValue, thisv, args, &ignored);
 }
 
 static bool
@@ -552,18 +550,15 @@ GetInternals(JSContext* cx, HandleObject obj)
     MOZ_ASSERT(getInternalsValue.isObject());
     MOZ_ASSERT(getInternalsValue.toObject().is<JSFunction>());
 
-    InvokeArgs args(cx);
-    if (!args.init(1))
-        return nullptr;
+    FixedInvokeArgs<1> args(cx);
 
-    args.setCallee(getInternalsValue);
-    args.setThis(NullValue());
     args[0].setObject(*obj);
 
-    if (!Invoke(cx, args))
+    RootedValue v(cx, NullValue());
+    if (!js::Call(cx, getInternalsValue, v, args, &v))
         return nullptr;
 
-    return &args.rval().toObject();
+    return &v.toObject();
 }
 
 static bool

js/src/builtin/Object.cpp

@@ -434,10 +434,16 @@ js::WatchHandler(JSContext* cx, JSObject* obj_, jsid id_, JS::Value old,
     if (resolving.alreadyStarted())
         return true;
 
-    JSObject* callable = (JSObject*)closure;
-    Value argv[] = { IdToValue(id), old, *nvp };
+    FixedInvokeArgs<3> args(cx);
+
+    args[0].set(IdToValue(id));
+    args[1].set(old);
+    args[2].set(*nvp);
+
+    RootedValue callable(cx, ObjectValue(*static_cast<JSObject*>(closure)));
+    RootedValue thisv(cx, ObjectValue(*obj));
     RootedValue rv(cx);
-    if (!Invoke(cx, ObjectValue(*obj), ObjectOrNullValue(callable), ArrayLength(argv), argv, &rv))
+    if (!Call(cx, callable, thisv, args, &rv))
         return false;
 
     *nvp = rv;

js/src/builtin/TypedObject.cpp

@@ -114,16 +114,12 @@ ConvertAndCopyTo(JSContext* cx,
                  HandleAtom name,
                  HandleValue val)
 {
-    RootedFunction func(
-        cx, SelfHostedFunction(cx, cx->names().ConvertAndCopyTo));
+    RootedFunction func(cx, SelfHostedFunction(cx, cx->names().ConvertAndCopyTo));
     if (!func)
         return false;
 
-    InvokeArgs args(cx);
-    if (!args.init(5))
-        return false;
+    FixedInvokeArgs<5> args(cx);
 
-    args.setCallee(ObjectValue(*func));
     args[0].setObject(*typeObj);
     args[1].setObject(*typedObj);
     args[2].setInt32(offset);
@@ -133,7 +129,9 @@ ConvertAndCopyTo(JSContext* cx,
         args[3].setNull();
     args[4].set(val);
 
-    return Invoke(cx, args);
+    RootedValue fval(cx, ObjectValue(*func));
+    RootedValue dummy(cx); // ignored by ConvertAndCopyTo
+    return js::Call(cx, fval, dummy, args, &dummy);
 }
 
 static bool
@@ -158,20 +156,14 @@ Reify(JSContext* cx,
     if (!func)
         return false;
 
-    InvokeArgs args(cx);
-    if (!args.init(3))
-        return false;
+    FixedInvokeArgs<3> args(cx);
 
-    args.setCallee(ObjectValue(*func));
     args[0].setObject(*type);
     args[1].setObject(*typedObj);
     args[2].setInt32(offset);
 
-    if (!Invoke(cx, args))
-        return false;
-
-    to.set(args.rval());
-    return true;
+    RootedValue fval(cx, ObjectValue(*func));
+    return js::Call(cx, fval, UndefinedHandleValue, args, to);
 }
 
 // Extracts the `prototype` property from `obj`, throwing if it is

js/src/jsarray.cpp

@@ -934,16 +934,16 @@ ArraySpeciesCreate(JSContext* cx, HandleObject origArray, uint32_t length, Mutab
 
     FixedInvokeArgs<2> args(cx);
 
-    args.setCallee(ObjectValue(*create));
-    args.setThis(UndefinedValue());
     args[0].setObject(*origArray);
     args[1].set(NumberValue(length));
 
-    if (!Invoke(cx, args))
+    RootedValue callee(cx, ObjectValue(*create));
+    RootedValue rval(cx);
+    if (!Call(cx, callee, UndefinedHandleValue, args, &rval))
         return false;
 
-    MOZ_ASSERT(args.rval().isObject());
-    arr.set(&args.rval().toObject());
+    MOZ_ASSERT(rval.isObject());
+    arr.set(&rval.toObject());
     return true;
 }
 

js/src/jsfun.cpp

@@ -1148,22 +1148,35 @@ js::fun_call(JSContext* cx, unsigned argc, Value* vp)
 {
     CallArgs args = CallArgsFromVp(argc, vp);
 
-    HandleValue fval = args.thisv();
-    if (!IsCallable(fval)) {
+    HandleValue func = args.thisv();
+
+    // We don't need to do this -- Call would do it for us -- but the error
+    // message is *much* better if we do this here.  (Without this,
+    // JSDVG_SEARCH_STACK tries to decompile |func| as if it were |this| in
+    // the scripted caller's frame -- so for example
+    //
+    //   Function.prototype.call.call({});
+    //
+    // would identify |{}| as |this| as being the result of evaluating
+    // |Function.prototype.call| and would conclude, "Function.prototype.call
+    // is not a function".  Grotesque.)
+    if (!IsCallable(func)) {
         ReportIncompatibleMethod(cx, args, &JSFunction::class_);
         return false;
     }
 
-    args.setCallee(fval);
-    args.setThis(args.get(0));
+    size_t argCount = args.length();
+    if (argCount > 0)
+        argCount--; // strip off provided |this|
 
-    if (args.length() > 0) {
-        for (size_t i = 0; i < args.length() - 1; i++)
-            args[i].set(args[i + 1]);
-        args = CallArgsFromVp(args.length() - 1, vp);
-    }
+    InvokeArgs iargs(cx);
+    if (!iargs.init(argCount))
+        return false;
 
-    return InternalInvoke(cx, args);
+    for (size_t i = 0; i < argCount; i++)
+        iargs[i].set(args[i + 1]);
+
+    return Call(cx, func, args.get(0), iargs, args.rval());
 }
 
 // ES5 15.3.4.3
@@ -1173,6 +1186,10 @@ js::fun_apply(JSContext* cx, unsigned argc, Value* vp)
     CallArgs args = CallArgsFromVp(argc, vp);
 
     // Step 1.
+    //
+    // Note that we must check callability here, not at actual call time,
+    // because extracting argument values from the provided arraylike might
+    // have side effects or throw an exception.
     HandleValue fval = args.thisv();
     if (!IsCallable(fval)) {
         ReportIncompatibleMethod(cx, args, &JSFunction::class_);
@@ -1196,9 +1213,6 @@ js::fun_apply(JSContext* cx, unsigned argc, Value* vp)
         if (!args2.init(iter.numActualArgs()))
             return false;
 
-        args2.setCallee(fval);
-        args2.setThis(args[0]);
-
         // Steps 7-8.
         iter.unaliasedForEachActual(cx, CopyTo(args2.array()));
     } else {
@@ -1225,21 +1239,13 @@ js::fun_apply(JSContext* cx, unsigned argc, Value* vp)
         if (!args2.init(length))
             return false;
 
-        // Push fval, obj, and aobj's elements as args.
-        args2.setCallee(fval);
-        args2.setThis(args[0]);
-
         // Steps 7-8.
         if (!GetElements(cx, aobj, length, args2.array()))
             return false;
     }
 
     // Step 9.
-    if (!Invoke(cx, args2))
-        return false;
-
-    args.rval().set(args2.rval());
-    return true;
+    return Call(cx, fval, args[0], args2, args.rval());
 }
 
 bool

js/src/jsiter.cpp

@@ -497,9 +497,16 @@ GetCustomIterator(JSContext* cx, HandleObject obj, unsigned flags, MutableHandle
         ++sCustomIteratorCount;
 
     /* Otherwise call it and return that object. */
-    Value arg = BooleanValue((flags & JSITER_FOREACH) == 0);
-    if (!Invoke(cx, ObjectValue(*obj), rval, 1, &arg, &rval))
-        return false;
+    {
+        FixedInvokeArgs<1> args(cx);
+
+        args[0].setBoolean((flags & JSITER_FOREACH) == 0);
+
+        RootedValue thisv(cx, ObjectValue(*obj));
+        if (!js::Call(cx, rval, thisv, args, &rval))
+            return false;
+    }
+
     if (rval.isPrimitive()) {
         // Ignore the stack when throwing. We can't tell whether we were
         // supposed to skip over a new.target or not.
@@ -1404,7 +1411,12 @@ js::IteratorMore(JSContext* cx, HandleObject iterobj, MutableHandleValue rval)
     if (!GetProperty(cx, iterobj, iterobj, cx->names().next, rval))
         return false;
 
-    if (!Invoke(cx, ObjectValue(*iterobj), rval, 0, nullptr, rval)) {
+    // Call the .next method.  Fall through to the error-handling cases in the
+    // unlikely event that either one of the fallible operations performed
+    // during the call process fails.
+    FixedInvokeArgs<0> args(cx);
+    RootedValue iterval(cx, ObjectValue(*iterobj));
+    if (!js::Call(cx, rval, iterval, args, rval)) {
         // Check for StopIteration.
         if (!cx->isExceptionPending())
             return false;
@@ -1416,7 +1428,6 @@ js::IteratorMore(JSContext* cx, HandleObject iterobj, MutableHandleValue rval)
 
         cx->clearPendingException();
         rval.setMagic(JS_NO_ITER_VALUE);
-        return true;
     }
 
     return true;

js/src/jsobj.cpp

@@ -3949,14 +3949,13 @@ js::SpeciesConstructor(JSContext* cx, HandleObject obj, HandleValue defaultCtor,
     RootedValue func(cx);
     if (!GlobalObject::getSelfHostedFunction(cx, cx->global(), shName, shName, 2, &func))
         return false;
-    InvokeArgs args(cx);
-    if (!args.init(2))
-        return false;
-    args.setCallee(func);
-    args.setThis(UndefinedValue());
+
+    FixedInvokeArgs<2> args(cx);
+
     args[0].setObject(*obj);
     args[1].set(defaultCtor);
-    if (!Invoke(cx, args))
+
+    if (!Call(cx, func, UndefinedHandleValue, args, pctor))
         return false;
 
     pctor.set(args.rval());

js/src/jsstr.cpp

@@ -3826,15 +3826,13 @@ CallIsStringOptimizable(JSContext* cx, const char* name, bool* result)
     if (!GlobalObject::getSelfHostedFunction(cx, cx->global(), propName, propName, 0, &funcVal))
         return false;
 
-    InvokeArgs args(cx);
-    if (!args.init(0))
-        return false;
-    args.setCallee(funcVal);
-    args.setThis(UndefinedValue());
-    if (!Invoke(cx, args))
+    FixedInvokeArgs<0> args(cx);
+
+    RootedValue rval(cx);
+    if (!Call(cx, funcVal, UndefinedHandleValue, args, &rval))
         return false;
 
-    *result = args.rval().toBoolean();
+    *result = rval.toBoolean();
     return true;
 }
 #endif

js/src/proxy/DirectProxyHandler.cpp

@@ -74,7 +74,12 @@ DirectProxyHandler::call(JSContext* cx, HandleObject proxy, const CallArgs& args
 {
     assertEnteredPolicy(cx, proxy, JSID_VOID, CALL);
     RootedValue target(cx, proxy->as<ProxyObject>().private_());
-    return Invoke(cx, args.thisv(), target, args.length(), args.array(), args.rval());
+
+    InvokeArgs iargs(cx);
+    if (!FillArgumentsFromArraylike(cx, iargs, args))
+        return false;
+
+    return js::Call(cx, target, args.thisv(), iargs, args.rval());
 }
 
 bool

js/src/shell/js.cpp

@@ -3364,9 +3364,13 @@ InvokeInterruptCallbackWrapper(JSContext* cx, unsigned argc, Value* vp)
         return false;
 
     JS::AutoSaveExceptionState savedExc(cx);
-    Value argv[1] = { BooleanValue(interruptRv) };
+
+    FixedInvokeArgs<1> iargs(cx);
+
+    iargs[0].setBoolean(interruptRv);
+
     RootedValue rv(cx);
-    if (!Invoke(cx, UndefinedValue(), args[0], 1, argv, &rv))
+    if (!js::Call(cx, args[0], UndefinedHandleValue, iargs, &rv))
         return false;
 
     args.rval().setUndefined();

js/src/vm/GeneratorObject.cpp

@@ -214,14 +214,10 @@ LegacyGeneratorObject::close(JSContext* cx, HandleObject obj)
     MOZ_ASSERT(closeValue.isObject());
     MOZ_ASSERT(closeValue.toObject().is<JSFunction>());
 
-    InvokeArgs args(cx);
-    if (!args.init(0))
-        return false;
+    FixedInvokeArgs<0> args(cx);
 
-    args.setCallee(closeValue);
-    args.setThis(ObjectValue(*genObj));
-
-    return Invoke(cx, args);
+    RootedValue v(cx, ObjectValue(*genObj));
+    return Call(cx, closeValue, v, args, &v);
 }
 
 const Class LegacyGeneratorObject::class_ = {

js/src/vm/Interpreter.h

@@ -72,17 +72,6 @@ Invoke(JSContext* cx, const AnyInvokeArgs& args)
     return InternalCallOrConstruct(cx, args, NO_CONSTRUCT);
 }
 
-/*
- * Similar to InternalCallOrConstruct, but for use in places that really
- * shouldn't use such an internal method directly (and won't, later in this
- * patch stack).
- */
-inline bool
-InternalInvoke(JSContext* cx, const CallArgs& args)
-{
-    return InternalCallOrConstruct(cx, args, NO_CONSTRUCT);
-}
-
 // DEPRECATED.  TO BE REMOVED.  DO NOT ADD NEW USES.
 extern bool
 Invoke(JSContext* cx, const Value& thisv, const Value& fval, unsigned argc, const Value* argv,

js/src/vm/SelfHosting.cpp

@@ -1712,17 +1712,10 @@ CallSelfHostedNonGenericMethod(JSContext* cx, const CallArgs& args)
     if (!args2.init(args.length() - 1))
         return false;
 
-    args2.setCallee(selfHostedFun);
-    args2.setThis(args.thisv());
-
     for (size_t i = 0; i < args.length() - 1; i++)
         args2[i].set(args[i]);
 
-    if (!Invoke(cx, args2))
-        return false;
-
-    args.rval().set(args2.rval());
-    return true;
+    return js::Call(cx, selfHostedFun, args.thisv(), args2, args.rval());
 }
 
 bool