Error in generated binding for variadic argument of type that needs rooting

[mbrubeck]

The following WebIDL (where Touch is as defined in #7204):

partial interface Document {
      TouchList createTouchList(Touch... touches);
};

causes this compile error:

DocumentBinding.rs:2184:61: 2184:64 error: no method named `r` found for type `collections::vec::Vec<dom::bindings::js::Root<dom::touch::Touch>>` in the current scope
DocumentBinding.rs:2184     let result: Root<TouchList> = this.CreateTouchList(arg0.r());
                                                                                    ^~~

The generated trait method signature is:

    fn CreateTouchList(&self, touches: Vec<&Touch>) -> Root<TouchList>;

and the generated binding is:

unsafe extern fn createTouchList(cx: *mut JSContext, _obj: HandleObject, this: *const Document, args: *const JSJitMethodCallArgs) -> bool {
    let this = &*this;
    let args = &*args;
    let argc = args._base.argc_;
    let arg0: Vec<Root<Touch>> = if 0 < argc {
        let mut vector: Vec<Root<Touch>> = Vec::with_capacity((argc - 0) as usize);
        for variadicArg in 0..argc {
            let slot: Root<Touch> = if args.get(variadicArg).get().is_object() {
                match native_from_handlevalue(args.get(variadicArg)) {
                    Ok(val) => val,
                    Err(()) => {
                        throw_type_error(cx, "value does not implement interface Touch.");
                        return false;
                    }
                }
            } else {
                throw_type_error(cx, "Value is not an object.");
                return false;
            };
            vector.push(slot);
        }
        vector
    } else {
        Vec::new()
    };
    let result: Root<TouchList> = this.CreateTouchList(arg0.r());

    (result).to_jsval(cx, args.rval());
    return true;
}

[Ms2ger]

This is probably because CGPerSignatureCall.getArguments doesn't check whether the argument is variadic. I suspect adding that check would fix this (but note the duplicated code in CGProxySpecialOperation.getArguments).

[nox]

I would rather make it pass &[&T] instead of just removing that .r() call, no?

[Ms2ger]

I guess a Vec<Root<T>> is useless anyway. We could go either way.

[nox]

Sounds like making the proper thing (&[&T]) is more complex than just removing the .r() call, for now.

[nox]

Especially because I think the RootedVec::new() then needs to be moved outside the block that defines arg0, so that it doesn't end up moved.

[nox]

So I managed to get the code to compile:

unsafe extern fn passVariadicInterface(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> bool {
    let this = &*this;
    let args = &*args;
    let argc = args._base.argc_;
    let arg0: _ = if 0 < argc {
        let mut vector = RootedVec::new();
        *vector = Vec::with_capacity((argc - 0) as usize);

        for variadicArg in 0..argc {
            let slot: *const Blob = if args.get(variadicArg).get().is_object() {
                match native_from_handlevalue(args.get(variadicArg)) {
                    Ok(val) => val,
                    Err(()) => {
                        throw_type_error(cx, "value does not implement interface Blob.");
                        return false;
                    }
                }
            } else {
                throw_type_error(cx, "Value is not an object.");
                return false;
            };
            vector.push(JS::from_ref(&*slot));
        }
        vector
    } else {
        RootedVec::new()
    };
    let result: () = this.PassVariadicInterface(arg0.r());

    (result).to_jsval(cx, args.rval());
    return true;
}

But I'm pretty sure this will fail at runtime when the RootedVec is dropped. Will write a test.

[nox]

Yes, this panics.