TestBindingBinding.rs

/* THIS FILE IS AUTOGENERATED - DO NOT EDIT */

#![allow(unreachable_code,non_camel_case_types,non_upper_case_globals,unused_parens,unused_imports,unused_variables,unused_unsafe,unused_mut,unused_assignments,dead_code)]
use dom::bindings;
use dom::bindings::callback::wrap_call_this_object;
use dom::bindings::callback::{CallSetup,ExceptionHandling};
use dom::bindings::callback::{CallbackContainer,CallbackInterface,CallbackFunction};
use dom::bindings::codegen::Bindings::*;
use dom::bindings::codegen::{PrototypeList, RegisterBindings, UnionTypes};
use dom::bindings::conversions::DOM_OBJECT_SLOT;
use dom::bindings::conversions::IDLInterface;
use dom::bindings::conversions::StringificationBehavior;
use dom::bindings::conversions::jsid_to_str;
use dom::bindings::conversions::{FromJSValConvertible, ToJSValConvertible};
use dom::bindings::conversions::{native_from_reflector, native_from_handlevalue, native_from_handleobject};
use dom::bindings::error::Error::JSFailed;
use dom::bindings::error::throw_dom_exception;
use dom::bindings::error::throw_type_error;
use dom::bindings::error::{Fallible, Error, ErrorResult};
use dom::bindings::global::GlobalRef;
use dom::bindings::global::global_object_for_js_object;
use dom::bindings::js::{JS, Root, RootedReference};
use dom::bindings::js::{OptionalRootedReference};
use dom::bindings::num::Finite;
use dom::bindings::proxyhandler;
use dom::bindings::proxyhandler::{fill_property_descriptor, get_expando_object};
use dom::bindings::proxyhandler::{get_property_descriptor};
use dom::bindings::str::ByteString;
use dom::bindings::str::USVString;
use dom::bindings::trace::{JSTraceable, RootedTraceable};
use dom::bindings::utils::ARRAY_VALUES_STRING;
use dom::bindings::utils::ConstantSpec;
use dom::bindings::utils::ConstantVal::{IntVal, UintVal};
use dom::bindings::utils::NonNullJSNative;
use dom::bindings::utils::finalize_global;
use dom::bindings::utils::get_dictionary_property;
use dom::bindings::utils::has_property_on_prototype;
use dom::bindings::utils::is_platform_object;
use dom::bindings::utils::throwing_constructor;
use dom::bindings::utils::{DOMClass};
use dom::bindings::utils::{DOMJSClass, JSCLASS_DOM_GLOBAL};
use dom::bindings::utils::{NativeProperties, NativePropertyHooks};
use dom::bindings::utils::{Reflectable};
use dom::bindings::utils::{create_dom_global, do_create_interface_objects};
use dom::bindings::utils::{find_enum_string_index, get_array_index_from_id};
use dom::bindings::utils::{get_property_on_prototype, get_proto_or_iface_array};
use dom::types::Blob;
use dom::types::Event;
use dom::types::HTMLElement;
use dom::types::TestBinding;
use js;
use js::glue::{CallJitMethodOp, CallJitGetterOp, CallJitSetterOp, CreateProxyHandler};
use js::glue::{GetProxyPrivate, NewProxyObject, ProxyTraps};
use js::glue::{RUST_FUNCTION_VALUE_TO_JITINFO};
use js::glue::{RUST_JS_NumberValue, RUST_JSID_IS_STRING};
use js::jsapi::GetGlobalForObjectCrossCompartment;
use js::jsapi::{JSAutoCompartment, JSAutoRequest};
use js::jsapi::{JSClass, FreeOp, JSFreeOp, JSFunctionSpec, MutableHandleValue, HandleObject, HandleValue, RootedObject, RootedValue, jsid};
use js::jsapi::{JSJitGetterCallArgs, JSJitSetterCallArgs, JSJitMethodCallArgs, CallArgs};
use js::jsapi::{JSNativeWrapper, JSNative, JSObject, JSPropertyDescriptor};
use js::jsapi::{JSPropertySpec};
use js::jsapi::{JSString, JSTracer, JSJitInfo, JSJitInfo_OpType, JSJitInfo_AliasSet};
use js::jsapi::{JS_CallFunctionValue, JS_GetClass, JS_GetGlobalForObject};
use js::jsapi::{JS_GetObjectPrototype, JS_GetProperty, JS_GetPropertyById};
use js::jsapi::{JS_GetPropertyDescriptorById, JS_GetReservedSlot};
use js::jsapi::{JS_HasProperty, JS_HasPropertyById, JS_IsExceptionPending};
use js::jsapi::{JS_NewObjectWithGivenProto, IsCallable, JS_SetProperty, JS_SetPrototype};
use js::jsapi::{JS_SetReservedSlot, JS_WrapValue, JSContext};
use js::jsapi::{MutableHandle, Handle, HandleId, JSType, JSValueType};
use js::jsapi::{SymbolCode, ObjectOpResult, HandleValueArray};
use js::jsval::JSVal;
use js::jsval::{NullValue, UndefinedValue};
use js::jsval::{ObjectValue, ObjectOrNullValue, PrivateValue};
use js::{JSCLASS_GLOBAL_SLOT_COUNT, JSCLASS_IS_DOMJSCLASS, JSCLASS_IMPLEMENTS_BARRIERS};
use js::{JSCLASS_IS_GLOBAL, JSCLASS_RESERVED_SLOTS_SHIFT};
use js::{JSCLASS_RESERVED_SLOTS_MASK};
use js::{JSPROP_ENUMERATE, JSPROP_SHARED};
use js::{JS_ARGV, JS_CALLEE, JS_THIS_OBJECT};
use libc;
use std::borrow::ToOwned;
use std::boxed;
use std::cmp;
use std::default::Default;
use std::ffi::CString;
use std::iter::repeat;
use std::mem;
use std::num;
use std::ptr;
use std::rc;
use std::rc::Rc;
use std::str;
use util::str::DOMString;

#[repr(usize)]
#[derive(PartialEq, Copy, Clone)]
#[jstraceable]
pub enum TestEnum {
    _empty,
    Foo,
    Bar
}
pub mod TestEnumValues {
    use dom::bindings::conversions::ToJSValConvertible;
    use js::jsapi::JSContext;
    use js::jsval::JSVal;

    pub const strings: &'static [&'static str] = &[
        "",
        "foo",
        "bar",
    ];

    impl ToJSValConvertible for super::TestEnum {
        fn to_jsval(&self, cx: *mut JSContext) -> JSVal {
            strings[*self as usize].to_jsval(cx)
        }
    }
} // mod TestEnumValues

#[no_move]
pub struct TestDictionary {
    pub anyValue: HandleValue,
    pub booleanValue: Option<bool>,
    pub byteValue: Option<i8>,
    pub doubleValue: Option<Finite<f64>>,
    pub enumValue: Option<TestEnum>,
    pub floatValue: Option<Finite<f32>>,
    pub interfaceValue: Option<Root<Blob>>,
    pub longLongValue: Option<i64>,
    pub longValue: Option<i32>,
    pub objectValue: Option<*mut JSObject>,
    pub octetValue: Option<u8>,
    pub shortValue: Option<i16>,
    pub stringValue: Option<DOMString>,
    pub unrestrictedDoubleValue: Option<f64>,
    pub unrestrictedFloatValue: Option<f32>,
    pub unsignedLongLongValue: Option<u64>,
    pub unsignedLongValue: Option<u32>,
    pub unsignedShortValue: Option<u16>,
    pub usvstringValue: Option<USVString>,
}
impl TestDictionary {
    pub fn empty() -> TestDictionary {
        TestDictionary::new(ptr::null_mut(), NullValue()).unwrap()
    }
    pub fn new(cx: *mut JSContext, val: JSVal) -> Result<TestDictionary, ()> {
        let object = if val.is_null_or_undefined() {
            RootedObject::new(cx, ptr::null_mut())
        } else if val.is_object() {
            RootedObject::new(cx, val.to_object())
        } else {
            throw_type_error(cx, "Value not an object.");
            return Err(());
        };
        Ok(TestDictionary {
            anyValue: {
            let mut rval = RootedValue::new(cx, UndefinedValue());
            match try!(get_dictionary_property(cx, object.handle(), "anyValue", rval.handle_mut())) {
                Some(value) => {
                    value
                },
                None => {
                    HandleValue::undefined()
                },
            }
            },
            booleanValue: {
            let mut rval = RootedValue::new(cx, UndefinedValue());
            match try!(get_dictionary_property(cx, object.handle(), "booleanValue", rval.handle_mut())) {
                Some(value) => {
                    Some(match FromJSValConvertible::from_jsval(cx, value, ()) {
                        Ok(v) => v,
                        Err(_) => { return Err(()); }
                    })
                },
                None => {
                    None
                },
            }
            },
            byteValue: {
            let mut rval = RootedValue::new(cx, UndefinedValue());
            match try!(get_dictionary_property(cx, object.handle(), "byteValue", rval.handle_mut())) {
                Some(value) => {
                    Some(match FromJSValConvertible::from_jsval(cx, value, ()) {
                        Ok(v) => v,
                        Err(_) => { return Err(()); }
                    })
                },
                None => {
                    None
                },
            }
            },
            doubleValue: {
            let mut rval = RootedValue::new(cx, UndefinedValue());
            match try!(get_dictionary_property(cx, object.handle(), "doubleValue", rval.handle_mut())) {
                Some(value) => {
                    Some(match FromJSValConvertible::from_jsval(cx, value, ()) {
                        Ok(v) => v,
                        Err(_) => { return Err(()); }
                    })
                },
                None => {
                    None
                },
            }
            },
            enumValue: {
            let mut rval = RootedValue::new(cx, UndefinedValue());
            match try!(get_dictionary_property(cx, object.handle(), "enumValue", rval.handle_mut())) {
                Some(value) => {
                    Some(match find_enum_string_index(cx, value, TestEnumValues::strings) {
                        Err(_) => { return Err(()); },
                        Ok(None) => { return Err(()); },
                        Ok(Some(index)) => {
                            //XXXjdm need some range checks up in here.
                            unsafe { mem::transmute(index) }
                        },
                    })
                },
                None => {
                    None
                },
            }
            },
            floatValue: {
            let mut rval = RootedValue::new(cx, UndefinedValue());
            match try!(get_dictionary_property(cx, object.handle(), "floatValue", rval.handle_mut())) {
                Some(value) => {
                    Some(match FromJSValConvertible::from_jsval(cx, value, ()) {
                        Ok(v) => v,
                        Err(_) => { return Err(()); }
                    })
                },
                None => {
                    None
                },
            }
            },
            interfaceValue: {
            let mut rval = RootedValue::new(cx, UndefinedValue());
            match try!(get_dictionary_property(cx, object.handle(), "interfaceValue", rval.handle_mut())) {
                Some(value) => {
                    Some(if value.get().is_object() {
                        match native_from_handlevalue(value) {
                            Ok(val) => val,
                            Err(()) => {
                                return Err(());
                            }
                        }
                    } else {
                        return Err(());
                    })
                },
                None => {
                    None
                },
            }
            },
            longLongValue: {
            let mut rval = RootedValue::new(cx, UndefinedValue());
            match try!(get_dictionary_property(cx, object.handle(), "longLongValue", rval.handle_mut())) {
                Some(value) => {
                    Some(match FromJSValConvertible::from_jsval(cx, value, ()) {
                        Ok(v) => v,
                        Err(_) => { return Err(()); }
                    })
                },
                None => {
                    None
                },
            }
            },
            longValue: {
            let mut rval = RootedValue::new(cx, UndefinedValue());
            match try!(get_dictionary_property(cx, object.handle(), "longValue", rval.handle_mut())) {
                Some(value) => {
                    Some(match FromJSValConvertible::from_jsval(cx, value, ()) {
                        Ok(v) => v,
                        Err(_) => { return Err(()); }
                    })
                },
                None => {
                    None
                },
            }
            },
            objectValue: {
            let mut rval = RootedValue::new(cx, UndefinedValue());
            match try!(get_dictionary_property(cx, object.handle(), "objectValue", rval.handle_mut())) {
                Some(value) => {
                    Some(if value.get().is_object() {
                        value.get().to_object()
                    } else {
                        return Err(());
                    })
                },
                None => {
                    None
                },
            }
            },
            octetValue: {
            let mut rval = RootedValue::new(cx, UndefinedValue());
            match try!(get_dictionary_property(cx, object.handle(), "octetValue", rval.handle_mut())) {
                Some(value) => {
                    Some(match FromJSValConvertible::from_jsval(cx, value, ()) {
                        Ok(v) => v,
                        Err(_) => { return Err(()); }
                    })
                },
                None => {
                    None
                },
            }
            },
            shortValue: {
            let mut rval = RootedValue::new(cx, UndefinedValue());
            match try!(get_dictionary_property(cx, object.handle(), "shortValue", rval.handle_mut())) {
                Some(value) => {
                    Some(match FromJSValConvertible::from_jsval(cx, value, ()) {
                        Ok(v) => v,
                        Err(_) => { return Err(()); }
                    })
                },
                None => {
                    None
                },
            }
            },
            stringValue: {
            let mut rval = RootedValue::new(cx, UndefinedValue());
            match try!(get_dictionary_property(cx, object.handle(), "stringValue", rval.handle_mut())) {
                Some(value) => {
                    Some(match FromJSValConvertible::from_jsval(cx, value, StringificationBehavior::Default) {
                        Ok(strval) => strval,
                        Err(_) => { return Err(()); },
                    })
                },
                None => {
                    None
                },
            }
            },
            unrestrictedDoubleValue: {
            let mut rval = RootedValue::new(cx, UndefinedValue());
            match try!(get_dictionary_property(cx, object.handle(), "unrestrictedDoubleValue", rval.handle_mut())) {
                Some(value) => {
                    Some(match FromJSValConvertible::from_jsval(cx, value, ()) {
                        Ok(v) => v,
                        Err(_) => { return Err(()); }
                    })
                },
                None => {
                    None
                },
            }
            },
            unrestrictedFloatValue: {
            let mut rval = RootedValue::new(cx, UndefinedValue());
            match try!(get_dictionary_property(cx, object.handle(), "unrestrictedFloatValue", rval.handle_mut())) {
                Some(value) => {
                    Some(match FromJSValConvertible::from_jsval(cx, value, ()) {
                        Ok(v) => v,
                        Err(_) => { return Err(()); }
                    })
                },
                None => {
                    None
                },
            }
            },
            unsignedLongLongValue: {
            let mut rval = RootedValue::new(cx, UndefinedValue());
            match try!(get_dictionary_property(cx, object.handle(), "unsignedLongLongValue", rval.handle_mut())) {
                Some(value) => {
                    Some(match FromJSValConvertible::from_jsval(cx, value, ()) {
                        Ok(v) => v,
                        Err(_) => { return Err(()); }
                    })
                },
                None => {
                    None
                },
            }
            },
            unsignedLongValue: {
            let mut rval = RootedValue::new(cx, UndefinedValue());
            match try!(get_dictionary_property(cx, object.handle(), "unsignedLongValue", rval.handle_mut())) {
                Some(value) => {
                    Some(match FromJSValConvertible::from_jsval(cx, value, ()) {
                        Ok(v) => v,
                        Err(_) => { return Err(()); }
                    })
                },
                None => {
                    None
                },
            }
            },
            unsignedShortValue: {
            let mut rval = RootedValue::new(cx, UndefinedValue());
            match try!(get_dictionary_property(cx, object.handle(), "unsignedShortValue", rval.handle_mut())) {
                Some(value) => {
                    Some(match FromJSValConvertible::from_jsval(cx, value, ()) {
                        Ok(v) => v,
                        Err(_) => { return Err(()); }
                    })
                },
                None => {
                    None
                },
            }
            },
            usvstringValue: {
            let mut rval = RootedValue::new(cx, UndefinedValue());
            match try!(get_dictionary_property(cx, object.handle(), "usvstringValue", rval.handle_mut())) {
                Some(value) => {
                    Some(match FromJSValConvertible::from_jsval(cx, value, ()) {
                        Ok(strval) => strval,
                        Err(_) => { return Err(()); },
                    })
                },
                None => {
                    None
                },
            }
            },
        })
    }
}

#[no_move]
pub struct TestDictionaryDefaults {
    pub anyValue: HandleValue,
    pub booleanValue: bool,
    pub byteValue: i8,
    pub enumValue: TestEnum,
    pub longLongValue: i64,
    pub longValue: i32,
    pub nullableBooleanValue: Option<bool>,
    pub nullableByteValue: Option<i8>,
    pub nullableLongLongValue: Option<i64>,
    pub nullableLongValue: Option<i32>,
    pub nullableObjectValue: *mut JSObject,
    pub nullableOctetValue: Option<u8>,
    pub nullableShortValue: Option<i16>,
    pub nullableStringValue: Option<DOMString>,
    pub nullableUnsignedLongLongValue: Option<u64>,
    pub nullableUnsignedLongValue: Option<u32>,
    pub nullableUnsignedShortValue: Option<u16>,
    pub nullableUsvstringValue: Option<USVString>,
    pub octetValue: u8,
    pub shortValue: i16,
    pub stringValue: DOMString,
    pub unsignedLongLongValue: u64,
    pub unsignedLongValue: u32,
    pub unsignedShortValue: u16,
    pub usvstringValue: USVString,
}
impl TestDictionaryDefaults {
    pub fn empty() -> TestDictionaryDefaults {
        TestDictionaryDefaults::new(ptr::null_mut(), NullValue()).unwrap()
    }
    pub fn new(cx: *mut JSContext, val: JSVal) -> Result<TestDictionaryDefaults, ()> {
        let object = if val.is_null_or_undefined() {
            RootedObject::new(cx, ptr::null_mut())
        } else if val.is_object() {
            RootedObject::new(cx, val.to_object())
        } else {
            throw_type_error(cx, "Value not an object.");
            return Err(());
        };
        Ok(TestDictionaryDefaults {
            anyValue: {
            let mut rval = RootedValue::new(cx, UndefinedValue());
            match try!(get_dictionary_property(cx, object.handle(), "anyValue", rval.handle_mut())) {
                Some(value) => {
                    value
                },
                None => {
                    HandleValue::null()
                },
            }
            },
            booleanValue: {
            let mut rval = RootedValue::new(cx, UndefinedValue());
            match try!(get_dictionary_property(cx, object.handle(), "booleanValue", rval.handle_mut())) {
                Some(value) => {
                    match FromJSValConvertible::from_jsval(cx, value, ()) {
                        Ok(v) => v,
                        Err(_) => { return Err(()); }
                    }
                },
                None => {
                    false
                },
            }
            },
            byteValue: {
            let mut rval = RootedValue::new(cx, UndefinedValue());
            match try!(get_dictionary_property(cx, object.handle(), "byteValue", rval.handle_mut())) {
                Some(value) => {
                    match FromJSValConvertible::from_jsval(cx, value, ()) {
                        Ok(v) => v,
                        Err(_) => { return Err(()); }
                    }
                },
                None => {
                    7
                },
            }
            },
            enumValue: {
            let mut rval = RootedValue::new(cx, UndefinedValue());
            match try!(get_dictionary_property(cx, object.handle(), "enumValue", rval.handle_mut())) {
                Some(value) => {
                    match find_enum_string_index(cx, value, TestEnumValues::strings) {
                        Err(_) => { return Err(()); },
                        Ok(None) => { return Err(()); },
                        Ok(Some(index)) => {
                            //XXXjdm need some range checks up in here.
                            unsafe { mem::transmute(index) }
                        },
                    }
                },
                None => {
                    TestEnum::Bar
                },
            }
            },
            longLongValue: {
            let mut rval = RootedValue::new(cx, UndefinedValue());
            match try!(get_dictionary_property(cx, object.handle(), "longLongValue", rval.handle_mut())) {
                Some(value) => {
                    match FromJSValConvertible::from_jsval(cx, value, ()) {
                        Ok(v) => v,
                        Err(_) => { return Err(()); }
                    }
                },
                None => {
                    7
                },
            }
            },
            longValue: {
            let mut rval = RootedValue::new(cx, UndefinedValue());
            match try!(get_dictionary_property(cx, object.handle(), "longValue", rval.handle_mut())) {
                Some(value) => {
                    match FromJSValConvertible::from_jsval(cx, value, ()) {
                        Ok(v) => v,
                        Err(_) => { return Err(()); }
                    }
                },
                None => {
                    7
                },
            }
            },
            nullableBooleanValue: {
            let mut rval = RootedValue::new(cx, UndefinedValue());
            match try!(get_dictionary_property(cx, object.handle(), "nullableBooleanValue", rval.handle_mut())) {
                Some(value) => {
                    match FromJSValConvertible::from_jsval(cx, value, ()) {
                        Ok(v) => v,
                        Err(_) => { return Err(()); }
                    }
                },
                None => {
                    Some(false)
                },
            }
            },
            nullableByteValue: {
            let mut rval = RootedValue::new(cx, UndefinedValue());
            match try!(get_dictionary_property(cx, object.handle(), "nullableByteValue", rval.handle_mut())) {
                Some(value) => {
                    match FromJSValConvertible::from_jsval(cx, value, ()) {
                        Ok(v) => v,
                        Err(_) => { return Err(()); }
                    }
                },
                None => {
                    Some(7)
                },
            }
            },
            nullableLongLongValue: {
            let mut rval = RootedValue::new(cx, UndefinedValue());
            match try!(get_dictionary_property(cx, object.handle(), "nullableLongLongValue", rval.handle_mut())) {
                Some(value) => {
                    match FromJSValConvertible::from_jsval(cx, value, ()) {
                        Ok(v) => v,
                        Err(_) => { return Err(()); }
                    }
                },
                None => {
                    Some(7)
                },
            }
            },
            nullableLongValue: {
            let mut rval = RootedValue::new(cx, UndefinedValue());
            match try!(get_dictionary_property(cx, object.handle(), "nullableLongValue", rval.handle_mut())) {
                Some(value) => {
                    match FromJSValConvertible::from_jsval(cx, value, ()) {
                        Ok(v) => v,
                        Err(_) => { return Err(()); }
                    }
                },
                None => {
                    Some(7)
                },
            }
            },
            nullableObjectValue: {
            let mut rval = RootedValue::new(cx, UndefinedValue());
            match try!(get_dictionary_property(cx, object.handle(), "nullableObjectValue", rval.handle_mut())) {
                Some(value) => {
                    if value.get().is_object() {
                        value.get().to_object()
                    } else if value.get().is_null_or_undefined() {
                        ptr::null_mut()
                    } else {
                        return Err(());
                    }
                },
                None => {
                    ptr::null_mut()
                },
            }
            },
            nullableOctetValue: {
            let mut rval = RootedValue::new(cx, UndefinedValue());
            match try!(get_dictionary_property(cx, object.handle(), "nullableOctetValue", rval.handle_mut())) {
                Some(value) => {
                    match FromJSValConvertible::from_jsval(cx, value, ()) {
                        Ok(v) => v,
                        Err(_) => { return Err(()); }
                    }
                },
                None => {
                    Some(7)
                },
            }
            },
            nullableShortValue: {
            let mut rval = RootedValue::new(cx, UndefinedValue());
            match try!(get_dictionary_property(cx, object.handle(), "nullableShortValue", rval.handle_mut())) {
                Some(value) => {
                    match FromJSValConvertible::from_jsval(cx, value, ()) {
                        Ok(v) => v,
                        Err(_) => { return Err(()); }
                    }
                },
                None => {
                    Some(7)
                },
            }
            },
            nullableStringValue: {
            let mut rval = RootedValue::new(cx, UndefinedValue());
            match try!(get_dictionary_property(cx, object.handle(), "nullableStringValue", rval.handle_mut())) {
                Some(value) => {
                    match FromJSValConvertible::from_jsval(cx, value, ()) {
                        Ok(strval) => strval,
                        Err(_) => { return Err(()); },
                    }
                },
                None => {
                    Some("foo".to_owned())
                },
            }
            },
            nullableUnsignedLongLongValue: {
            let mut rval = RootedValue::new(cx, UndefinedValue());
            match try!(get_dictionary_property(cx, object.handle(), "nullableUnsignedLongLongValue", rval.handle_mut())) {
                Some(value) => {
                    match FromJSValConvertible::from_jsval(cx, value, ()) {
                        Ok(v) => v,
                        Err(_) => { return Err(()); }
                    }
                },
                None => {
                    Some(7)
                },
            }
            },
            nullableUnsignedLongValue: {
            let mut rval = RootedValue::new(cx, UndefinedValue());
            match try!(get_dictionary_property(cx, object.handle(), "nullableUnsignedLongValue", rval.handle_mut())) {
                Some(value) => {
                    match FromJSValConvertible::from_jsval(cx, value, ()) {
                        Ok(v) => v,
                        Err(_) => { return Err(()); }
                    }
                },
                None => {
                    Some(7)
                },
            }
            },
            nullableUnsignedShortValue: {
            let mut rval = RootedValue::new(cx, UndefinedValue());
            match try!(get_dictionary_property(cx, object.handle(), "nullableUnsignedShortValue", rval.handle_mut())) {
                Some(value) => {
                    match FromJSValConvertible::from_jsval(cx, value, ()) {
                        Ok(v) => v,
                        Err(_) => { return Err(()); }
                    }
                },
                None => {
                    Some(7)
                },
            }
            },
            nullableUsvstringValue: {
            let mut rval = RootedValue::new(cx, UndefinedValue());
            match try!(get_dictionary_property(cx, object.handle(), "nullableUsvstringValue", rval.handle_mut())) {
                Some(value) => {
                    match FromJSValConvertible::from_jsval(cx, value, ()) {
                        Ok(strval) => strval,
                        Err(_) => { return Err(()); },
                    }
                },
                None => {
                    Some(USVString("foo".to_owned()))
                },
            }
            },
            octetValue: {
            let mut rval = RootedValue::new(cx, UndefinedValue());
            match try!(get_dictionary_property(cx, object.handle(), "octetValue", rval.handle_mut())) {
                Some(value) => {
                    match FromJSValConvertible::from_jsval(cx, value, ()) {
                        Ok(v) => v,
                        Err(_) => { return Err(()); }
                    }
                },
                None => {
                    7
                },
            }
            },
            shortValue: {
            let mut rval = RootedValue::new(cx, UndefinedValue());
            match try!(get_dictionary_property(cx, object.handle(), "shortValue", rval.handle_mut())) {
                Some(value) => {
                    match FromJSValConvertible::from_jsval(cx, value, ()) {
                        Ok(v) => v,
                        Err(_) => { return Err(()); }
                    }
                },
                None => {
                    7
                },
            }
            },
            stringValue: {
            let mut rval = RootedValue::new(cx, UndefinedValue());
            match try!(get_dictionary_property(cx, object.handle(), "stringValue", rval.handle_mut())) {
                Some(value) => {
                    match FromJSValConvertible::from_jsval(cx, value, StringificationBehavior::Default) {
                        Ok(strval) => strval,
                        Err(_) => { return Err(()); },
                    }
                },
                None => {
                    "foo".to_owned()
                },
            }
            },
            unsignedLongLongValue: {
            let mut rval = RootedValue::new(cx, UndefinedValue());
            match try!(get_dictionary_property(cx, object.handle(), "unsignedLongLongValue", rval.handle_mut())) {
                Some(value) => {
                    match FromJSValConvertible::from_jsval(cx, value, ()) {
                        Ok(v) => v,
                        Err(_) => { return Err(()); }
                    }
                },
                None => {
                    7
                },
            }
            },
            unsignedLongValue: {
            let mut rval = RootedValue::new(cx, UndefinedValue());
            match try!(get_dictionary_property(cx, object.handle(), "unsignedLongValue", rval.handle_mut())) {
                Some(value) => {
                    match FromJSValConvertible::from_jsval(cx, value, ()) {
                        Ok(v) => v,
                        Err(_) => { return Err(()); }
                    }
                },
                None => {
                    7
                },
            }
            },
            unsignedShortValue: {
            let mut rval = RootedValue::new(cx, UndefinedValue());
            match try!(get_dictionary_property(cx, object.handle(), "unsignedShortValue", rval.handle_mut())) {
                Some(value) => {
                    match FromJSValConvertible::from_jsval(cx, value, ()) {
                        Ok(v) => v,
                        Err(_) => { return Err(()); }
                    }
                },
                None => {
                    7
                },
            }
            },
            usvstringValue: {
            let mut rval = RootedValue::new(cx, UndefinedValue());
            match try!(get_dictionary_property(cx, object.handle(), "usvstringValue", rval.handle_mut())) {
                Some(value) => {
                    match FromJSValConvertible::from_jsval(cx, value, ()) {
                        Ok(strval) => strval,
                        Err(_) => { return Err(()); },
                    }
                },
                None => {
                    USVString("foo".to_owned())
                },
            }
            },
        })
    }
}

pub fn GetProtoObject(cx: *mut JSContext, global: HandleObject, receiver: HandleObject) -> *mut JSObject {
    unsafe {
        /* Get the interface prototype object for this class.  This will create the
           object as needed. */

        /* global and receiver are usually the same, but they can be different
           too. For example a sandbox often has an xray wrapper for a window as the
           prototype of the sandbox's global. In that case receiver is the xray
           wrapper and global is the sandbox's global.
         */

        assert!(((*JS_GetClass(global.get())).flags & JSCLASS_DOM_GLOBAL) != 0);

        /* Check to see whether the interface objects are already installed */
        let proto_or_iface_array = get_proto_or_iface_array(global.get());
        let cached_object: *mut JSObject = *proto_or_iface_array.offset(PrototypeList::ID::TestBinding as isize);
        if cached_object.is_null() {
            let tmp: *mut JSObject = CreateInterfaceObjects(cx, global, receiver);
            assert!(!tmp.is_null());
            *proto_or_iface_array.offset(PrototypeList::ID::TestBinding as isize) = tmp;
            tmp
        } else {
            cached_object
        }
    }
}

unsafe extern fn get_booleanAttribute(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: JSJitGetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let result: bool = this.BooleanAttribute();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}

unsafe extern fn set_booleanAttribute(cx: *mut JSContext, obj: HandleObject, this: *const TestBinding, args: JSJitSetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let arg0: bool = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.SetBooleanAttribute(arg0);

        return 1;
    }
}


const booleanAttribute_getterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: get_booleanAttribute as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Getter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_BOOLEAN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

const booleanAttribute_setterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: set_booleanAttribute as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Setter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn get_byteAttribute(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: JSJitGetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let result: i8 = this.ByteAttribute();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}

unsafe extern fn set_byteAttribute(cx: *mut JSContext, obj: HandleObject, this: *const TestBinding, args: JSJitSetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let arg0: i8 = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.SetByteAttribute(arg0);

        return 1;
    }
}


const byteAttribute_getterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: get_byteAttribute as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Getter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_INT32 as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

const byteAttribute_setterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: set_byteAttribute as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Setter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn get_octetAttribute(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: JSJitGetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let result: u8 = this.OctetAttribute();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}

unsafe extern fn set_octetAttribute(cx: *mut JSContext, obj: HandleObject, this: *const TestBinding, args: JSJitSetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let arg0: u8 = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.SetOctetAttribute(arg0);

        return 1;
    }
}


const octetAttribute_getterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: get_octetAttribute as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Getter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_INT32 as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

const octetAttribute_setterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: set_octetAttribute as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Setter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn get_shortAttribute(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: JSJitGetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let result: i16 = this.ShortAttribute();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}

unsafe extern fn set_shortAttribute(cx: *mut JSContext, obj: HandleObject, this: *const TestBinding, args: JSJitSetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let arg0: i16 = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.SetShortAttribute(arg0);

        return 1;
    }
}


const shortAttribute_getterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: get_shortAttribute as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Getter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_INT32 as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

const shortAttribute_setterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: set_shortAttribute as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Setter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn get_unsignedShortAttribute(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: JSJitGetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let result: u16 = this.UnsignedShortAttribute();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}

unsafe extern fn set_unsignedShortAttribute(cx: *mut JSContext, obj: HandleObject, this: *const TestBinding, args: JSJitSetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let arg0: u16 = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.SetUnsignedShortAttribute(arg0);

        return 1;
    }
}


const unsignedShortAttribute_getterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: get_unsignedShortAttribute as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Getter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_INT32 as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

const unsignedShortAttribute_setterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: set_unsignedShortAttribute as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Setter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn get_longAttribute(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: JSJitGetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let result: i32 = this.LongAttribute();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}

unsafe extern fn set_longAttribute(cx: *mut JSContext, obj: HandleObject, this: *const TestBinding, args: JSJitSetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let arg0: i32 = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.SetLongAttribute(arg0);

        return 1;
    }
}


const longAttribute_getterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: get_longAttribute as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Getter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_INT32 as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

const longAttribute_setterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: set_longAttribute as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Setter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn get_unsignedLongAttribute(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: JSJitGetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let result: u32 = this.UnsignedLongAttribute();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}

unsafe extern fn set_unsignedLongAttribute(cx: *mut JSContext, obj: HandleObject, this: *const TestBinding, args: JSJitSetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let arg0: u32 = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.SetUnsignedLongAttribute(arg0);

        return 1;
    }
}


const unsignedLongAttribute_getterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: get_unsignedLongAttribute as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Getter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_DOUBLE as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

const unsignedLongAttribute_setterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: set_unsignedLongAttribute as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Setter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn get_longLongAttribute(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: JSJitGetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let result: i64 = this.LongLongAttribute();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}

unsafe extern fn set_longLongAttribute(cx: *mut JSContext, obj: HandleObject, this: *const TestBinding, args: JSJitSetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let arg0: i64 = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.SetLongLongAttribute(arg0);

        return 1;
    }
}


const longLongAttribute_getterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: get_longLongAttribute as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Getter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_DOUBLE as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

const longLongAttribute_setterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: set_longLongAttribute as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Setter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn get_unsignedLongLongAttribute(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: JSJitGetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let result: u64 = this.UnsignedLongLongAttribute();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}

unsafe extern fn set_unsignedLongLongAttribute(cx: *mut JSContext, obj: HandleObject, this: *const TestBinding, args: JSJitSetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let arg0: u64 = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.SetUnsignedLongLongAttribute(arg0);

        return 1;
    }
}


const unsignedLongLongAttribute_getterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: get_unsignedLongLongAttribute as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Getter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_DOUBLE as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

const unsignedLongLongAttribute_setterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: set_unsignedLongLongAttribute as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Setter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn get_unrestrictedFloatAttribute(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: JSJitGetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let result: f32 = this.UnrestrictedFloatAttribute();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}

unsafe extern fn set_unrestrictedFloatAttribute(cx: *mut JSContext, obj: HandleObject, this: *const TestBinding, args: JSJitSetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let arg0: f32 = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.SetUnrestrictedFloatAttribute(arg0);

        return 1;
    }
}


const unrestrictedFloatAttribute_getterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: get_unrestrictedFloatAttribute as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Getter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_DOUBLE as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

const unrestrictedFloatAttribute_setterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: set_unrestrictedFloatAttribute as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Setter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn get_floatAttribute(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: JSJitGetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let result: Finite<f32> = this.FloatAttribute();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}

unsafe extern fn set_floatAttribute(cx: *mut JSContext, obj: HandleObject, this: *const TestBinding, args: JSJitSetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let arg0: Finite<f32> = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.SetFloatAttribute(arg0);

        return 1;
    }
}


const floatAttribute_getterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: get_floatAttribute as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Getter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_DOUBLE as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

const floatAttribute_setterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: set_floatAttribute as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Setter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn get_unrestrictedDoubleAttribute(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: JSJitGetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let result: f64 = this.UnrestrictedDoubleAttribute();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}

unsafe extern fn set_unrestrictedDoubleAttribute(cx: *mut JSContext, obj: HandleObject, this: *const TestBinding, args: JSJitSetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let arg0: f64 = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.SetUnrestrictedDoubleAttribute(arg0);

        return 1;
    }
}


const unrestrictedDoubleAttribute_getterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: get_unrestrictedDoubleAttribute as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Getter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_DOUBLE as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

const unrestrictedDoubleAttribute_setterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: set_unrestrictedDoubleAttribute as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Setter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn get_doubleAttribute(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: JSJitGetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let result: Finite<f64> = this.DoubleAttribute();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}

unsafe extern fn set_doubleAttribute(cx: *mut JSContext, obj: HandleObject, this: *const TestBinding, args: JSJitSetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let arg0: Finite<f64> = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.SetDoubleAttribute(arg0);

        return 1;
    }
}


const doubleAttribute_getterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: get_doubleAttribute as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Getter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_DOUBLE as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

const doubleAttribute_setterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: set_doubleAttribute as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Setter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn get_stringAttribute(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: JSJitGetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let result: DOMString = this.StringAttribute();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}

unsafe extern fn set_stringAttribute(cx: *mut JSContext, obj: HandleObject, this: *const TestBinding, args: JSJitSetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let arg0: DOMString = match FromJSValConvertible::from_jsval(cx, args.get(0), StringificationBehavior::Default) {
            Ok(strval) => strval,
            Err(_) => { return false as u8; },
        };
        let result: () = this.SetStringAttribute(arg0);

        return 1;
    }
}


const stringAttribute_getterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: get_stringAttribute as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Getter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_STRING as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

const stringAttribute_setterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: set_stringAttribute as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Setter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn get_usvstringAttribute(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: JSJitGetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let result: USVString = this.UsvstringAttribute();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}

unsafe extern fn set_usvstringAttribute(cx: *mut JSContext, obj: HandleObject, this: *const TestBinding, args: JSJitSetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let arg0: USVString = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(strval) => strval,
            Err(_) => { return false as u8; },
        };
        let result: () = this.SetUsvstringAttribute(arg0);

        return 1;
    }
}


const usvstringAttribute_getterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: get_usvstringAttribute as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Getter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_STRING as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

const usvstringAttribute_setterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: set_usvstringAttribute as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Setter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn get_byteStringAttribute(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: JSJitGetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let result: ByteString = this.ByteStringAttribute();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}

unsafe extern fn set_byteStringAttribute(cx: *mut JSContext, obj: HandleObject, this: *const TestBinding, args: JSJitSetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let arg0: ByteString = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(strval) => strval,
            Err(_) => { return false as u8; },
        };
        let result: () = this.SetByteStringAttribute(arg0);

        return 1;
    }
}


const byteStringAttribute_getterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: get_byteStringAttribute as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Getter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_STRING as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

const byteStringAttribute_setterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: set_byteStringAttribute as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Setter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn get_enumAttribute(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: JSJitGetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let result: TestEnum = this.EnumAttribute();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}

unsafe extern fn set_enumAttribute(cx: *mut JSContext, obj: HandleObject, this: *const TestBinding, args: JSJitSetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let arg0: TestEnum = match find_enum_string_index(cx, args.get(0), TestEnumValues::strings) {
            Err(_) => { return false as u8; },
            Ok(None) => { return 1; },
            Ok(Some(index)) => {
                //XXXjdm need some range checks up in here.
                unsafe { mem::transmute(index) }
            },
        };
        let result: () = this.SetEnumAttribute(arg0);

        return 1;
    }
}


const enumAttribute_getterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: get_enumAttribute as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Getter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_STRING as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

const enumAttribute_setterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: set_enumAttribute as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Setter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn get_interfaceAttribute(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: JSJitGetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let result: Root<Blob> = this.InterfaceAttribute();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}

unsafe extern fn set_interfaceAttribute(cx: *mut JSContext, obj: HandleObject, this: *const TestBinding, args: JSJitSetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let arg0: Root<Blob> = if args.get(0).get().is_object() {
            match native_from_handlevalue(args.get(0)) {
                Ok(val) => val,
                Err(()) => {
                    throw_type_error(cx, "value does not implement interface Blob.");
                    return false as u8;
                }
            }
        } else {
            throw_type_error(cx, "Value is not an object.");
            return false as u8;
        };
        let result: () = this.SetInterfaceAttribute(arg0.r());

        return 1;
    }
}


const interfaceAttribute_getterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: get_interfaceAttribute as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Getter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_OBJECT as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

const interfaceAttribute_setterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: set_interfaceAttribute as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Setter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn get_unionAttribute(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: JSJitGetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let result: UnionTypes::HTMLElementOrLong = this.UnionAttribute();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}

unsafe extern fn set_unionAttribute(cx: *mut JSContext, obj: HandleObject, this: *const TestBinding, args: JSJitSetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let arg0: UnionTypes::HTMLElementOrLong = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(value) => value,
            Err(()) => { return false as u8; },
        };
        let result: () = this.SetUnionAttribute(arg0);

        return 1;
    }
}


const unionAttribute_getterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: get_unionAttribute as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Getter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNKNOWN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

const unionAttribute_setterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: set_unionAttribute as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Setter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn get_union2Attribute(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: JSJitGetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let result: UnionTypes::EventOrString = this.Union2Attribute();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}

unsafe extern fn set_union2Attribute(cx: *mut JSContext, obj: HandleObject, this: *const TestBinding, args: JSJitSetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let arg0: UnionTypes::EventOrString = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(value) => value,
            Err(()) => { return false as u8; },
        };
        let result: () = this.SetUnion2Attribute(arg0);

        return 1;
    }
}


const union2Attribute_getterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: get_union2Attribute as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Getter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNKNOWN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

const union2Attribute_setterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: set_union2Attribute as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Setter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn get_arrayAttribute(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: JSJitGetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let result: *mut JSObject = this.ArrayAttribute(cx);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const arrayAttribute_getterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: get_arrayAttribute as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Getter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_OBJECT as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn get_anyAttribute(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: JSJitGetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let result: JSVal = this.AnyAttribute(cx);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}

unsafe extern fn set_anyAttribute(cx: *mut JSContext, obj: HandleObject, this: *const TestBinding, args: JSJitSetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let arg0: HandleValue = args.get(0);
        let result: () = this.SetAnyAttribute(cx, arg0);

        return 1;
    }
}


const anyAttribute_getterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: get_anyAttribute as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Getter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNKNOWN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

const anyAttribute_setterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: set_anyAttribute as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Setter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn get_objectAttribute(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: JSJitGetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let result: *mut JSObject = this.ObjectAttribute(cx);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}

unsafe extern fn set_objectAttribute(cx: *mut JSContext, obj: HandleObject, this: *const TestBinding, args: JSJitSetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let arg0: *mut JSObject = if args.get(0).get().is_object() {
            args.get(0).get().to_object()
        } else {
            throw_type_error(cx, "Value is not an object.");
            return false as u8;
        };
        let result: () = this.SetObjectAttribute(cx, arg0);

        return 1;
    }
}


const objectAttribute_getterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: get_objectAttribute as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Getter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_OBJECT as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

const objectAttribute_setterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: set_objectAttribute as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Setter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn get_booleanAttributeNullable(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: JSJitGetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let result: Option<bool> = this.GetBooleanAttributeNullable();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}

unsafe extern fn set_booleanAttributeNullable(cx: *mut JSContext, obj: HandleObject, this: *const TestBinding, args: JSJitSetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let arg0: Option<bool> = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.SetBooleanAttributeNullable(arg0);

        return 1;
    }
}


const booleanAttributeNullable_getterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: get_booleanAttributeNullable as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Getter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNKNOWN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

const booleanAttributeNullable_setterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: set_booleanAttributeNullable as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Setter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn get_byteAttributeNullable(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: JSJitGetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let result: Option<i8> = this.GetByteAttributeNullable();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}

unsafe extern fn set_byteAttributeNullable(cx: *mut JSContext, obj: HandleObject, this: *const TestBinding, args: JSJitSetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let arg0: Option<i8> = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.SetByteAttributeNullable(arg0);

        return 1;
    }
}


const byteAttributeNullable_getterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: get_byteAttributeNullable as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Getter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNKNOWN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

const byteAttributeNullable_setterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: set_byteAttributeNullable as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Setter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn get_octetAttributeNullable(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: JSJitGetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let result: Option<u8> = this.GetOctetAttributeNullable();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}

unsafe extern fn set_octetAttributeNullable(cx: *mut JSContext, obj: HandleObject, this: *const TestBinding, args: JSJitSetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let arg0: Option<u8> = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.SetOctetAttributeNullable(arg0);

        return 1;
    }
}


const octetAttributeNullable_getterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: get_octetAttributeNullable as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Getter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNKNOWN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

const octetAttributeNullable_setterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: set_octetAttributeNullable as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Setter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn get_shortAttributeNullable(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: JSJitGetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let result: Option<i16> = this.GetShortAttributeNullable();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}

unsafe extern fn set_shortAttributeNullable(cx: *mut JSContext, obj: HandleObject, this: *const TestBinding, args: JSJitSetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let arg0: Option<i16> = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.SetShortAttributeNullable(arg0);

        return 1;
    }
}


const shortAttributeNullable_getterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: get_shortAttributeNullable as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Getter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNKNOWN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

const shortAttributeNullable_setterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: set_shortAttributeNullable as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Setter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn get_unsignedShortAttributeNullable(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: JSJitGetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let result: Option<u16> = this.GetUnsignedShortAttributeNullable();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}

unsafe extern fn set_unsignedShortAttributeNullable(cx: *mut JSContext, obj: HandleObject, this: *const TestBinding, args: JSJitSetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let arg0: Option<u16> = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.SetUnsignedShortAttributeNullable(arg0);

        return 1;
    }
}


const unsignedShortAttributeNullable_getterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: get_unsignedShortAttributeNullable as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Getter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNKNOWN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

const unsignedShortAttributeNullable_setterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: set_unsignedShortAttributeNullable as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Setter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn get_longAttributeNullable(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: JSJitGetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let result: Option<i32> = this.GetLongAttributeNullable();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}

unsafe extern fn set_longAttributeNullable(cx: *mut JSContext, obj: HandleObject, this: *const TestBinding, args: JSJitSetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let arg0: Option<i32> = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.SetLongAttributeNullable(arg0);

        return 1;
    }
}


const longAttributeNullable_getterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: get_longAttributeNullable as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Getter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNKNOWN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

const longAttributeNullable_setterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: set_longAttributeNullable as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Setter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn get_unsignedLongAttributeNullable(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: JSJitGetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let result: Option<u32> = this.GetUnsignedLongAttributeNullable();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}

unsafe extern fn set_unsignedLongAttributeNullable(cx: *mut JSContext, obj: HandleObject, this: *const TestBinding, args: JSJitSetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let arg0: Option<u32> = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.SetUnsignedLongAttributeNullable(arg0);

        return 1;
    }
}


const unsignedLongAttributeNullable_getterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: get_unsignedLongAttributeNullable as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Getter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNKNOWN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

const unsignedLongAttributeNullable_setterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: set_unsignedLongAttributeNullable as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Setter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn get_longLongAttributeNullable(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: JSJitGetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let result: Option<i64> = this.GetLongLongAttributeNullable();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}

unsafe extern fn set_longLongAttributeNullable(cx: *mut JSContext, obj: HandleObject, this: *const TestBinding, args: JSJitSetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let arg0: Option<i64> = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.SetLongLongAttributeNullable(arg0);

        return 1;
    }
}


const longLongAttributeNullable_getterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: get_longLongAttributeNullable as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Getter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNKNOWN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

const longLongAttributeNullable_setterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: set_longLongAttributeNullable as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Setter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn get_unsignedLongLongAttributeNullable(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: JSJitGetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let result: Option<u64> = this.GetUnsignedLongLongAttributeNullable();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}

unsafe extern fn set_unsignedLongLongAttributeNullable(cx: *mut JSContext, obj: HandleObject, this: *const TestBinding, args: JSJitSetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let arg0: Option<u64> = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.SetUnsignedLongLongAttributeNullable(arg0);

        return 1;
    }
}


const unsignedLongLongAttributeNullable_getterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: get_unsignedLongLongAttributeNullable as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Getter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNKNOWN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

const unsignedLongLongAttributeNullable_setterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: set_unsignedLongLongAttributeNullable as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Setter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn get_unrestrictedFloatAttributeNullable(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: JSJitGetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let result: Option<f32> = this.GetUnrestrictedFloatAttributeNullable();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}

unsafe extern fn set_unrestrictedFloatAttributeNullable(cx: *mut JSContext, obj: HandleObject, this: *const TestBinding, args: JSJitSetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let arg0: Option<f32> = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.SetUnrestrictedFloatAttributeNullable(arg0);

        return 1;
    }
}


const unrestrictedFloatAttributeNullable_getterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: get_unrestrictedFloatAttributeNullable as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Getter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNKNOWN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

const unrestrictedFloatAttributeNullable_setterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: set_unrestrictedFloatAttributeNullable as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Setter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn get_floatAttributeNullable(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: JSJitGetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let result: Option<Finite<f32>> = this.GetFloatAttributeNullable();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}

unsafe extern fn set_floatAttributeNullable(cx: *mut JSContext, obj: HandleObject, this: *const TestBinding, args: JSJitSetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let arg0: Option<Finite<f32>> = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.SetFloatAttributeNullable(arg0);

        return 1;
    }
}


const floatAttributeNullable_getterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: get_floatAttributeNullable as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Getter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNKNOWN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

const floatAttributeNullable_setterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: set_floatAttributeNullable as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Setter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn get_unrestrictedDoubleAttributeNullable(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: JSJitGetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let result: Option<f64> = this.GetUnrestrictedDoubleAttributeNullable();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}

unsafe extern fn set_unrestrictedDoubleAttributeNullable(cx: *mut JSContext, obj: HandleObject, this: *const TestBinding, args: JSJitSetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let arg0: Option<f64> = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.SetUnrestrictedDoubleAttributeNullable(arg0);

        return 1;
    }
}


const unrestrictedDoubleAttributeNullable_getterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: get_unrestrictedDoubleAttributeNullable as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Getter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNKNOWN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

const unrestrictedDoubleAttributeNullable_setterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: set_unrestrictedDoubleAttributeNullable as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Setter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn get_doubleAttributeNullable(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: JSJitGetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let result: Option<Finite<f64>> = this.GetDoubleAttributeNullable();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}

unsafe extern fn set_doubleAttributeNullable(cx: *mut JSContext, obj: HandleObject, this: *const TestBinding, args: JSJitSetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let arg0: Option<Finite<f64>> = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.SetDoubleAttributeNullable(arg0);

        return 1;
    }
}


const doubleAttributeNullable_getterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: get_doubleAttributeNullable as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Getter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNKNOWN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

const doubleAttributeNullable_setterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: set_doubleAttributeNullable as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Setter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn get_stringAttributeNullable(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: JSJitGetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let result: Option<DOMString> = this.GetStringAttributeNullable();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}

unsafe extern fn set_stringAttributeNullable(cx: *mut JSContext, obj: HandleObject, this: *const TestBinding, args: JSJitSetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let arg0: Option<DOMString> = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(strval) => strval,
            Err(_) => { return false as u8; },
        };
        let result: () = this.SetStringAttributeNullable(arg0);

        return 1;
    }
}


const stringAttributeNullable_getterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: get_stringAttributeNullable as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Getter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNKNOWN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

const stringAttributeNullable_setterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: set_stringAttributeNullable as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Setter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn get_usvstringAttributeNullable(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: JSJitGetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let result: Option<USVString> = this.GetUsvstringAttributeNullable();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}

unsafe extern fn set_usvstringAttributeNullable(cx: *mut JSContext, obj: HandleObject, this: *const TestBinding, args: JSJitSetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let arg0: Option<USVString> = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(strval) => strval,
            Err(_) => { return false as u8; },
        };
        let result: () = this.SetUsvstringAttributeNullable(arg0);

        return 1;
    }
}


const usvstringAttributeNullable_getterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: get_usvstringAttributeNullable as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Getter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNKNOWN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

const usvstringAttributeNullable_setterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: set_usvstringAttributeNullable as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Setter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn get_byteStringAttributeNullable(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: JSJitGetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let result: Option<ByteString> = this.GetByteStringAttributeNullable();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}

unsafe extern fn set_byteStringAttributeNullable(cx: *mut JSContext, obj: HandleObject, this: *const TestBinding, args: JSJitSetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let arg0: Option<ByteString> = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(strval) => strval,
            Err(_) => { return false as u8; },
        };
        let result: () = this.SetByteStringAttributeNullable(arg0);

        return 1;
    }
}


const byteStringAttributeNullable_getterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: get_byteStringAttributeNullable as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Getter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNKNOWN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

const byteStringAttributeNullable_setterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: set_byteStringAttributeNullable as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Setter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn get_enumAttributeNullable(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: JSJitGetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let result: Option<TestEnum> = this.GetEnumAttributeNullable();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const enumAttributeNullable_getterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: get_enumAttributeNullable as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Getter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNKNOWN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn get_interfaceAttributeNullable(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: JSJitGetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let result: Option<Root<Blob>> = this.GetInterfaceAttributeNullable();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}

unsafe extern fn set_interfaceAttributeNullable(cx: *mut JSContext, obj: HandleObject, this: *const TestBinding, args: JSJitSetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let arg0: Option<Root<Blob>> = if args.get(0).get().is_object() {
            Some(match native_from_handlevalue(args.get(0)) {
                Ok(val) => val,
                Err(()) => {
                    throw_type_error(cx, "value does not implement interface Blob.");
                    return false as u8;
                }
            })
        } else if args.get(0).get().is_null_or_undefined() {
            None
        } else {
            throw_type_error(cx, "Value is not an object.");
            return false as u8;
        };
        let result: () = this.SetInterfaceAttributeNullable(arg0.r());

        return 1;
    }
}


const interfaceAttributeNullable_getterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: get_interfaceAttributeNullable as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Getter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNKNOWN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

const interfaceAttributeNullable_setterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: set_interfaceAttributeNullable as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Setter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn get_objectAttributeNullable(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: JSJitGetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let result: *mut JSObject = this.GetObjectAttributeNullable(cx);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}

unsafe extern fn set_objectAttributeNullable(cx: *mut JSContext, obj: HandleObject, this: *const TestBinding, args: JSJitSetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let arg0: *mut JSObject = if args.get(0).get().is_object() {
            args.get(0).get().to_object()
        } else if args.get(0).get().is_null_or_undefined() {
            ptr::null_mut()
        } else {
            throw_type_error(cx, "Value is not an object.");
            return false as u8;
        };
        let result: () = this.SetObjectAttributeNullable(cx, arg0);

        return 1;
    }
}


const objectAttributeNullable_getterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: get_objectAttributeNullable as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Getter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNKNOWN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

const objectAttributeNullable_setterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: set_objectAttributeNullable as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Setter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn get_unionAttributeNullable(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: JSJitGetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let result: Option<UnionTypes::HTMLElementOrLong> = this.GetUnionAttributeNullable();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}

unsafe extern fn set_unionAttributeNullable(cx: *mut JSContext, obj: HandleObject, this: *const TestBinding, args: JSJitSetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let arg0: Option<UnionTypes::HTMLElementOrLong > = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(value) => value,
            Err(()) => { return false as u8; },
        };
        let result: () = this.SetUnionAttributeNullable(arg0);

        return 1;
    }
}


const unionAttributeNullable_getterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: get_unionAttributeNullable as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Getter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNKNOWN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

const unionAttributeNullable_setterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: set_unionAttributeNullable as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Setter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn get_union2AttributeNullable(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: JSJitGetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let result: Option<UnionTypes::EventOrString> = this.GetUnion2AttributeNullable();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}

unsafe extern fn set_union2AttributeNullable(cx: *mut JSContext, obj: HandleObject, this: *const TestBinding, args: JSJitSetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let arg0: Option<UnionTypes::EventOrString > = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(value) => value,
            Err(()) => { return false as u8; },
        };
        let result: () = this.SetUnion2AttributeNullable(arg0);

        return 1;
    }
}


const union2AttributeNullable_getterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: get_union2AttributeNullable as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Getter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNKNOWN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

const union2AttributeNullable_setterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: set_union2AttributeNullable as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Setter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn get_attrToBinaryRename(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: JSJitGetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let result: DOMString = this.BinaryRenamedAttribute();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}

unsafe extern fn set_attrToBinaryRename(cx: *mut JSContext, obj: HandleObject, this: *const TestBinding, args: JSJitSetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let arg0: DOMString = match FromJSValConvertible::from_jsval(cx, args.get(0), StringificationBehavior::Default) {
            Ok(strval) => strval,
            Err(_) => { return false as u8; },
        };
        let result: () = this.SetBinaryRenamedAttribute(arg0);

        return 1;
    }
}


const attrToBinaryRename_getterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: get_attrToBinaryRename as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Getter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_STRING as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

const attrToBinaryRename_setterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: set_attrToBinaryRename as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Setter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn get_forwardedAttribute(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: JSJitGetterCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let result: Root<TestBinding> = this.ForwardedAttribute();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}

unsafe extern fn set_forwardedAttribute(cx: *mut JSContext, obj: HandleObject, this: *const TestBinding, args: JSJitSetterCallArgs) -> u8 {
    unsafe {
        let mut v = RootedValue::new(cx, UndefinedValue());
        if JS_GetProperty(cx, obj, b"forwardedAttribute".as_ptr() as *const i8, v.handle_mut()) == 0 {
            return false as u8;
        }
        if !v.ptr.is_object() {
            throw_type_error(cx, "Value.forwardedAttribute is not an object.");
            return false as u8;
        }
        let target_obj = RootedObject::new(cx, v.ptr.to_object());
        JS_SetProperty(cx, target_obj.handle(), b"booleanAttribute".as_ptr() as *const i8, args.get(0))

    }
}


const forwardedAttribute_getterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: get_forwardedAttribute as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Getter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_OBJECT as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

const forwardedAttribute_setterinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: set_forwardedAttribute as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Setter as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn methToBinaryRename(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let result: () = this.BinaryRenamedMethod();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const methToBinaryRename_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: methToBinaryRename as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn receiveVoid(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let result: () = this.ReceiveVoid();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const receiveVoid_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: receiveVoid as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn receiveBoolean(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let result: bool = this.ReceiveBoolean();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const receiveBoolean_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: receiveBoolean as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_BOOLEAN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn receiveByte(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let result: i8 = this.ReceiveByte();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const receiveByte_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: receiveByte as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_INT32 as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn receiveOctet(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let result: u8 = this.ReceiveOctet();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const receiveOctet_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: receiveOctet as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_INT32 as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn receiveShort(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let result: i16 = this.ReceiveShort();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const receiveShort_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: receiveShort as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_INT32 as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn receiveUnsignedShort(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let result: u16 = this.ReceiveUnsignedShort();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const receiveUnsignedShort_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: receiveUnsignedShort as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_INT32 as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn receiveLong(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let result: i32 = this.ReceiveLong();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const receiveLong_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: receiveLong as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_INT32 as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn receiveUnsignedLong(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let result: u32 = this.ReceiveUnsignedLong();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const receiveUnsignedLong_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: receiveUnsignedLong as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_DOUBLE as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn receiveLongLong(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let result: i64 = this.ReceiveLongLong();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const receiveLongLong_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: receiveLongLong as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_DOUBLE as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn receiveUnsignedLongLong(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let result: u64 = this.ReceiveUnsignedLongLong();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const receiveUnsignedLongLong_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: receiveUnsignedLongLong as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_DOUBLE as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn receiveUnrestrictedFloat(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let result: f32 = this.ReceiveUnrestrictedFloat();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const receiveUnrestrictedFloat_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: receiveUnrestrictedFloat as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_DOUBLE as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn receiveFloat(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let result: Finite<f32> = this.ReceiveFloat();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const receiveFloat_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: receiveFloat as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_DOUBLE as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn receiveUnrestrictedDouble(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let result: f64 = this.ReceiveUnrestrictedDouble();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const receiveUnrestrictedDouble_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: receiveUnrestrictedDouble as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_DOUBLE as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn receiveDouble(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let result: Finite<f64> = this.ReceiveDouble();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const receiveDouble_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: receiveDouble as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_DOUBLE as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn receiveString(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let result: DOMString = this.ReceiveString();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const receiveString_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: receiveString as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_STRING as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn receiveUsvstring(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let result: USVString = this.ReceiveUsvstring();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const receiveUsvstring_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: receiveUsvstring as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_STRING as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn receiveByteString(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let result: ByteString = this.ReceiveByteString();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const receiveByteString_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: receiveByteString as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_STRING as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn receiveEnum(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let result: TestEnum = this.ReceiveEnum();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const receiveEnum_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: receiveEnum as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_STRING as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn receiveInterface(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let result: Root<Blob> = this.ReceiveInterface();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const receiveInterface_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: receiveInterface as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_OBJECT as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn receiveAny(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let result: JSVal = this.ReceiveAny(cx);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const receiveAny_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: receiveAny as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNKNOWN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn receiveObject(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let result: *mut JSObject = this.ReceiveObject(cx);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const receiveObject_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: receiveObject as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_OBJECT as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn receiveUnion(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let result: UnionTypes::HTMLElementOrLong = this.ReceiveUnion();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const receiveUnion_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: receiveUnion as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNKNOWN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn receiveUnion2(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let result: UnionTypes::EventOrString = this.ReceiveUnion2();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const receiveUnion2_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: receiveUnion2 as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNKNOWN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn receiveNullableByte(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let result: Option<i8> = this.ReceiveNullableByte();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const receiveNullableByte_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: receiveNullableByte as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNKNOWN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn receiveNullableBoolean(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let result: Option<bool> = this.ReceiveNullableBoolean();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const receiveNullableBoolean_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: receiveNullableBoolean as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNKNOWN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn receiveNullableOctet(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let result: Option<u8> = this.ReceiveNullableOctet();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const receiveNullableOctet_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: receiveNullableOctet as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNKNOWN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn receiveNullableShort(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let result: Option<i16> = this.ReceiveNullableShort();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const receiveNullableShort_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: receiveNullableShort as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNKNOWN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn receiveNullableUnsignedShort(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let result: Option<u16> = this.ReceiveNullableUnsignedShort();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const receiveNullableUnsignedShort_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: receiveNullableUnsignedShort as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNKNOWN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn receiveNullableLong(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let result: Option<i32> = this.ReceiveNullableLong();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const receiveNullableLong_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: receiveNullableLong as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNKNOWN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn receiveNullableUnsignedLong(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let result: Option<u32> = this.ReceiveNullableUnsignedLong();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const receiveNullableUnsignedLong_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: receiveNullableUnsignedLong as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNKNOWN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn receiveNullableLongLong(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let result: Option<i64> = this.ReceiveNullableLongLong();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const receiveNullableLongLong_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: receiveNullableLongLong as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNKNOWN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn receiveNullableUnsignedLongLong(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let result: Option<u64> = this.ReceiveNullableUnsignedLongLong();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const receiveNullableUnsignedLongLong_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: receiveNullableUnsignedLongLong as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNKNOWN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn receiveNullableUnrestrictedFloat(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let result: Option<f32> = this.ReceiveNullableUnrestrictedFloat();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const receiveNullableUnrestrictedFloat_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: receiveNullableUnrestrictedFloat as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNKNOWN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn receiveNullableFloat(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let result: Option<Finite<f32>> = this.ReceiveNullableFloat();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const receiveNullableFloat_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: receiveNullableFloat as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNKNOWN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn receiveNullableUnrestrictedDouble(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let result: Option<f64> = this.ReceiveNullableUnrestrictedDouble();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const receiveNullableUnrestrictedDouble_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: receiveNullableUnrestrictedDouble as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNKNOWN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn receiveNullableDouble(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let result: Option<Finite<f64>> = this.ReceiveNullableDouble();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const receiveNullableDouble_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: receiveNullableDouble as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNKNOWN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn receiveNullableString(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let result: Option<DOMString> = this.ReceiveNullableString();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const receiveNullableString_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: receiveNullableString as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNKNOWN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn receiveNullableUsvstring(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let result: Option<USVString> = this.ReceiveNullableUsvstring();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const receiveNullableUsvstring_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: receiveNullableUsvstring as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNKNOWN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn receiveNullableByteString(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let result: Option<ByteString> = this.ReceiveNullableByteString();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const receiveNullableByteString_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: receiveNullableByteString as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNKNOWN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn receiveNullableEnum(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let result: Option<TestEnum> = this.ReceiveNullableEnum();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const receiveNullableEnum_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: receiveNullableEnum as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNKNOWN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn receiveNullableInterface(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let result: Option<Root<Blob>> = this.ReceiveNullableInterface();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const receiveNullableInterface_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: receiveNullableInterface as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNKNOWN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn receiveNullableObject(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let result: *mut JSObject = this.ReceiveNullableObject(cx);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const receiveNullableObject_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: receiveNullableObject as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNKNOWN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn receiveNullableUnion(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let result: Option<UnionTypes::HTMLElementOrLong> = this.ReceiveNullableUnion();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const receiveNullableUnion_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: receiveNullableUnion as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNKNOWN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn receiveNullableUnion2(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let result: Option<UnionTypes::EventOrString> = this.ReceiveNullableUnion2();
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const receiveNullableUnion2_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: receiveNullableUnion2 as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNKNOWN as u32) << 8) |
                 ((true as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passBoolean(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx, "Not enough arguments to \"TestBinding.passBoolean\".");
            return 0;
        }
        let arg0: bool = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.PassBoolean(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passBoolean_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passBoolean as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passByte(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx, "Not enough arguments to \"TestBinding.passByte\".");
            return 0;
        }
        let arg0: i8 = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.PassByte(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passByte_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passByte as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOctet(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx, "Not enough arguments to \"TestBinding.passOctet\".");
            return 0;
        }
        let arg0: u8 = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.PassOctet(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOctet_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOctet as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passShort(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx, "Not enough arguments to \"TestBinding.passShort\".");
            return 0;
        }
        let arg0: i16 = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.PassShort(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passShort_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passShort as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passUnsignedShort(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx, "Not enough arguments to \"TestBinding.passUnsignedShort\".");
            return 0;
        }
        let arg0: u16 = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.PassUnsignedShort(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passUnsignedShort_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passUnsignedShort as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passLong(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx, "Not enough arguments to \"TestBinding.passLong\".");
            return 0;
        }
        let arg0: i32 = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.PassLong(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passLong_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passLong as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passUnsignedLong(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx, "Not enough arguments to \"TestBinding.passUnsignedLong\".");
            return 0;
        }
        let arg0: u32 = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.PassUnsignedLong(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passUnsignedLong_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passUnsignedLong as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passLongLong(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx, "Not enough arguments to \"TestBinding.passLongLong\".");
            return 0;
        }
        let arg0: i64 = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.PassLongLong(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passLongLong_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passLongLong as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passUnsignedLongLong(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx, "Not enough arguments to \"TestBinding.passUnsignedLongLong\".");
            return 0;
        }
        let arg0: u64 = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.PassUnsignedLongLong(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passUnsignedLongLong_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passUnsignedLongLong as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passUnrestrictedFloat(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx, "Not enough arguments to \"TestBinding.passUnrestrictedFloat\".");
            return 0;
        }
        let arg0: f32 = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.PassUnrestrictedFloat(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passUnrestrictedFloat_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passUnrestrictedFloat as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passFloat(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx, "Not enough arguments to \"TestBinding.passFloat\".");
            return 0;
        }
        let arg0: Finite<f32> = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.PassFloat(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passFloat_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passFloat as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passUnrestrictedDouble(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx, "Not enough arguments to \"TestBinding.passUnrestrictedDouble\".");
            return 0;
        }
        let arg0: f64 = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.PassUnrestrictedDouble(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passUnrestrictedDouble_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passUnrestrictedDouble as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passDouble(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx, "Not enough arguments to \"TestBinding.passDouble\".");
            return 0;
        }
        let arg0: Finite<f64> = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.PassDouble(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passDouble_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passDouble as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passString(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx, "Not enough arguments to \"TestBinding.passString\".");
            return 0;
        }
        let arg0: DOMString = match FromJSValConvertible::from_jsval(cx, args.get(0), StringificationBehavior::Default) {
            Ok(strval) => strval,
            Err(_) => { return false as u8; },
        };
        let result: () = this.PassString(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passString_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passString as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passUsvstring(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx, "Not enough arguments to \"TestBinding.passUsvstring\".");
            return 0;
        }
        let arg0: USVString = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(strval) => strval,
            Err(_) => { return false as u8; },
        };
        let result: () = this.PassUsvstring(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passUsvstring_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passUsvstring as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passByteString(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx, "Not enough arguments to \"TestBinding.passByteString\".");
            return 0;
        }
        let arg0: ByteString = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(strval) => strval,
            Err(_) => { return false as u8; },
        };
        let result: () = this.PassByteString(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passByteString_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passByteString as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passEnum(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx, "Not enough arguments to \"TestBinding.passEnum\".");
            return 0;
        }
        let arg0: TestEnum = match find_enum_string_index(cx, args.get(0), TestEnumValues::strings) {
            Err(_) => { return false as u8; },
            Ok(None) => { return false as u8; },
            Ok(Some(index)) => {
                //XXXjdm need some range checks up in here.
                unsafe { mem::transmute(index) }
            },
        };
        let result: () = this.PassEnum(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passEnum_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passEnum as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passInterface(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx, "Not enough arguments to \"TestBinding.passInterface\".");
            return 0;
        }
        let arg0: Root<Blob> = if args.get(0).get().is_object() {
            match native_from_handlevalue(args.get(0)) {
                Ok(val) => val,
                Err(()) => {
                    throw_type_error(cx, "value does not implement interface Blob.");
                    return false as u8;
                }
            }
        } else {
            throw_type_error(cx, "Value is not an object.");
            return false as u8;
        };
        let result: () = this.PassInterface(arg0.r());
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passInterface_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passInterface as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passUnion(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx, "Not enough arguments to \"TestBinding.passUnion\".");
            return 0;
        }
        let arg0: UnionTypes::HTMLElementOrLong = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(value) => value,
            Err(()) => { return false as u8; },
        };
        let result: () = this.PassUnion(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passUnion_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passUnion as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passUnion2(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx, "Not enough arguments to \"TestBinding.passUnion2\".");
            return 0;
        }
        let arg0: UnionTypes::EventOrString = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(value) => value,
            Err(()) => { return false as u8; },
        };
        let result: () = this.PassUnion2(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passUnion2_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passUnion2 as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passUnion3(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx, "Not enough arguments to \"TestBinding.passUnion3\".");
            return 0;
        }
        let arg0: UnionTypes::BlobOrString = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(value) => value,
            Err(()) => { return false as u8; },
        };
        let result: () = this.PassUnion3(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passUnion3_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passUnion3 as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passAny(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx, "Not enough arguments to \"TestBinding.passAny\".");
            return 0;
        }
        let arg0: HandleValue = args.get(0);
        let result: () = this.PassAny(cx, arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passAny_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passAny as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passObject(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx, "Not enough arguments to \"TestBinding.passObject\".");
            return 0;
        }
        let arg0: *mut JSObject = if args.get(0).get().is_object() {
            args.get(0).get().to_object()
        } else {
            throw_type_error(cx, "Value is not an object.");
            return false as u8;
        };
        let result: () = this.PassObject(cx, arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passObject_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passObject as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passCallbackFunction(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx, "Not enough arguments to \"TestBinding.passCallbackFunction\".");
            return 0;
        }
        let arg0: Rc<FunctionBinding::Function> = if args.get(0).get().is_object() {
            if IsCallable(args.get(0).get().to_object()) != 0 {
                FunctionBinding::Function::new(args.get(0).get().to_object())
            } else {
                throw_type_error(cx, "Value is not callable.");
                return false as u8;
            }
        } else {
            throw_type_error(cx, "Value is not an object.");
            return false as u8;
        };
        let result: () = this.PassCallbackFunction(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passCallbackFunction_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passCallbackFunction as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passCallbackInterface(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx, "Not enough arguments to \"TestBinding.passCallbackInterface\".");
            return 0;
        }
        let arg0: Rc<EventListenerBinding::EventListener> = EventListenerBinding::EventListener::new(args.get(0).get().to_object());
        let result: () = this.PassCallbackInterface(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passCallbackInterface_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passCallbackInterface as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passNullableBoolean(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx, "Not enough arguments to \"TestBinding.passNullableBoolean\".");
            return 0;
        }
        let arg0: Option<bool> = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.PassNullableBoolean(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passNullableBoolean_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passNullableBoolean as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passNullableByte(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx, "Not enough arguments to \"TestBinding.passNullableByte\".");
            return 0;
        }
        let arg0: Option<i8> = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.PassNullableByte(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passNullableByte_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passNullableByte as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passNullableOctet(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx, "Not enough arguments to \"TestBinding.passNullableOctet\".");
            return 0;
        }
        let arg0: Option<u8> = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.PassNullableOctet(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passNullableOctet_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passNullableOctet as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passNullableShort(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx, "Not enough arguments to \"TestBinding.passNullableShort\".");
            return 0;
        }
        let arg0: Option<i16> = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.PassNullableShort(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passNullableShort_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passNullableShort as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passNullableUnsignedShort(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx, "Not enough arguments to \"TestBinding.passNullableUnsignedShort\".");
            return 0;
        }
        let arg0: Option<u16> = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.PassNullableUnsignedShort(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passNullableUnsignedShort_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passNullableUnsignedShort as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passNullableLong(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx, "Not enough arguments to \"TestBinding.passNullableLong\".");
            return 0;
        }
        let arg0: Option<i32> = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.PassNullableLong(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passNullableLong_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passNullableLong as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passNullableUnsignedLong(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx, "Not enough arguments to \"TestBinding.passNullableUnsignedLong\".");
            return 0;
        }
        let arg0: Option<u32> = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.PassNullableUnsignedLong(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passNullableUnsignedLong_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passNullableUnsignedLong as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passNullableLongLong(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx, "Not enough arguments to \"TestBinding.passNullableLongLong\".");
            return 0;
        }
        let arg0: Option<i64> = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.PassNullableLongLong(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passNullableLongLong_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passNullableLongLong as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passNullableUnsignedLongLong(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx, "Not enough arguments to \"TestBinding.passNullableUnsignedLongLong\".");
            return 0;
        }
        let arg0: Option<u64> = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.PassNullableUnsignedLongLong(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passNullableUnsignedLongLong_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passNullableUnsignedLongLong as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passNullableUnrestrictedFloat(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx, "Not enough arguments to \"TestBinding.passNullableUnrestrictedFloat\".");
            return 0;
        }
        let arg0: Option<f32> = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.PassNullableUnrestrictedFloat(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passNullableUnrestrictedFloat_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passNullableUnrestrictedFloat as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passNullableFloat(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx, "Not enough arguments to \"TestBinding.passNullableFloat\".");
            return 0;
        }
        let arg0: Option<Finite<f32>> = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.PassNullableFloat(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passNullableFloat_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passNullableFloat as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passNullableUnrestrictedDouble(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx, "Not enough arguments to \"TestBinding.passNullableUnrestrictedDouble\".");
            return 0;
        }
        let arg0: Option<f64> = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.PassNullableUnrestrictedDouble(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passNullableUnrestrictedDouble_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passNullableUnrestrictedDouble as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passNullableDouble(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx, "Not enough arguments to \"TestBinding.passNullableDouble\".");
            return 0;
        }
        let arg0: Option<Finite<f64>> = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = this.PassNullableDouble(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passNullableDouble_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passNullableDouble as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passNullableString(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx, "Not enough arguments to \"TestBinding.passNullableString\".");
            return 0;
        }
        let arg0: Option<DOMString> = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(strval) => strval,
            Err(_) => { return false as u8; },
        };
        let result: () = this.PassNullableString(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passNullableString_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passNullableString as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passNullableUsvstring(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx, "Not enough arguments to \"TestBinding.passNullableUsvstring\".");
            return 0;
        }
        let arg0: Option<USVString> = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(strval) => strval,
            Err(_) => { return false as u8; },
        };
        let result: () = this.PassNullableUsvstring(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passNullableUsvstring_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passNullableUsvstring as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passNullableByteString(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx, "Not enough arguments to \"TestBinding.passNullableByteString\".");
            return 0;
        }
        let arg0: Option<ByteString> = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(strval) => strval,
            Err(_) => { return false as u8; },
        };
        let result: () = this.PassNullableByteString(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passNullableByteString_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passNullableByteString as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passNullableInterface(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx, "Not enough arguments to \"TestBinding.passNullableInterface\".");
            return 0;
        }
        let arg0: Option<Root<Blob>> = if args.get(0).get().is_object() {
            Some(match native_from_handlevalue(args.get(0)) {
                Ok(val) => val,
                Err(()) => {
                    throw_type_error(cx, "value does not implement interface Blob.");
                    return false as u8;
                }
            })
        } else if args.get(0).get().is_null_or_undefined() {
            None
        } else {
            throw_type_error(cx, "Value is not an object.");
            return false as u8;
        };
        let result: () = this.PassNullableInterface(arg0.r());
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passNullableInterface_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passNullableInterface as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passNullableObject(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx, "Not enough arguments to \"TestBinding.passNullableObject\".");
            return 0;
        }
        let arg0: *mut JSObject = if args.get(0).get().is_object() {
            args.get(0).get().to_object()
        } else if args.get(0).get().is_null_or_undefined() {
            ptr::null_mut()
        } else {
            throw_type_error(cx, "Value is not an object.");
            return false as u8;
        };
        let result: () = this.PassNullableObject(cx, arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passNullableObject_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passNullableObject as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passNullableUnion(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx, "Not enough arguments to \"TestBinding.passNullableUnion\".");
            return 0;
        }
        let arg0: Option<UnionTypes::HTMLElementOrLong > = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(value) => value,
            Err(()) => { return false as u8; },
        };
        let result: () = this.PassNullableUnion(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passNullableUnion_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passNullableUnion as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passNullableUnion2(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx, "Not enough arguments to \"TestBinding.passNullableUnion2\".");
            return 0;
        }
        let arg0: Option<UnionTypes::EventOrString > = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(value) => value,
            Err(()) => { return false as u8; },
        };
        let result: () = this.PassNullableUnion2(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passNullableUnion2_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passNullableUnion2 as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passNullableCallbackFunction(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx, "Not enough arguments to \"TestBinding.passNullableCallbackFunction\".");
            return 0;
        }
        let arg0: Option<Rc<FunctionBinding::Function>> = if args.get(0).get().is_object() {
            if IsCallable(args.get(0).get().to_object()) != 0 {
                Some(FunctionBinding::Function::new(args.get(0).get().to_object()))
            } else {
                throw_type_error(cx, "Value is not callable.");
                return false as u8;
            }
        } else if args.get(0).get().is_null_or_undefined() {
            None
        } else {
            throw_type_error(cx, "Value is not an object.");
            return false as u8;
        };
        let result: () = this.PassNullableCallbackFunction(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passNullableCallbackFunction_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passNullableCallbackFunction as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passNullableCallbackInterface(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx, "Not enough arguments to \"TestBinding.passNullableCallbackInterface\".");
            return 0;
        }
        let arg0: Option<Rc<EventListenerBinding::EventListener>> = if args.get(0).get().is_object() {
            Some(EventListenerBinding::EventListener::new(args.get(0).get().to_object()))
        } else if args.get(0).get().is_null_or_undefined() {
            None
        } else {
            throw_type_error(cx, "Value is not an object.");
            return false as u8;
        };
        let result: () = this.PassNullableCallbackInterface(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passNullableCallbackInterface_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passNullableCallbackInterface as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalBoolean(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<bool> = if 0 < argc {
            Some(match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            })
        } else {
            None
        };
        let result: () = this.PassOptionalBoolean(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalBoolean_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalBoolean as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalByte(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<i8> = if 0 < argc {
            Some(match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            })
        } else {
            None
        };
        let result: () = this.PassOptionalByte(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalByte_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalByte as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalOctet(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<u8> = if 0 < argc {
            Some(match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            })
        } else {
            None
        };
        let result: () = this.PassOptionalOctet(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalOctet_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalOctet as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalShort(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<i16> = if 0 < argc {
            Some(match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            })
        } else {
            None
        };
        let result: () = this.PassOptionalShort(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalShort_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalShort as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalUnsignedShort(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<u16> = if 0 < argc {
            Some(match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            })
        } else {
            None
        };
        let result: () = this.PassOptionalUnsignedShort(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalUnsignedShort_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalUnsignedShort as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalLong(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<i32> = if 0 < argc {
            Some(match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            })
        } else {
            None
        };
        let result: () = this.PassOptionalLong(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalLong_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalLong as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalUnsignedLong(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<u32> = if 0 < argc {
            Some(match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            })
        } else {
            None
        };
        let result: () = this.PassOptionalUnsignedLong(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalUnsignedLong_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalUnsignedLong as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalLongLong(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<i64> = if 0 < argc {
            Some(match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            })
        } else {
            None
        };
        let result: () = this.PassOptionalLongLong(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalLongLong_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalLongLong as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalUnsignedLongLong(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<u64> = if 0 < argc {
            Some(match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            })
        } else {
            None
        };
        let result: () = this.PassOptionalUnsignedLongLong(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalUnsignedLongLong_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalUnsignedLongLong as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalUnrestrictedFloat(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<f32> = if 0 < argc {
            Some(match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            })
        } else {
            None
        };
        let result: () = this.PassOptionalUnrestrictedFloat(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalUnrestrictedFloat_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalUnrestrictedFloat as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalFloat(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<Finite<f32>> = if 0 < argc {
            Some(match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            })
        } else {
            None
        };
        let result: () = this.PassOptionalFloat(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalFloat_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalFloat as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalUnrestrictedDouble(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<f64> = if 0 < argc {
            Some(match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            })
        } else {
            None
        };
        let result: () = this.PassOptionalUnrestrictedDouble(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalUnrestrictedDouble_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalUnrestrictedDouble as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalDouble(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<Finite<f64>> = if 0 < argc {
            Some(match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            })
        } else {
            None
        };
        let result: () = this.PassOptionalDouble(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalDouble_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalDouble as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalString(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<DOMString> = if 0 < argc {
            Some(match FromJSValConvertible::from_jsval(cx, args.get(0), StringificationBehavior::Default) {
                Ok(strval) => strval,
                Err(_) => { return false as u8; },
            })
        } else {
            None
        };
        let result: () = this.PassOptionalString(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalString_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalString as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalUsvstring(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<USVString> = if 0 < argc {
            Some(match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(strval) => strval,
                Err(_) => { return false as u8; },
            })
        } else {
            None
        };
        let result: () = this.PassOptionalUsvstring(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalUsvstring_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalUsvstring as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalByteString(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<ByteString> = if 0 < argc {
            Some(match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(strval) => strval,
                Err(_) => { return false as u8; },
            })
        } else {
            None
        };
        let result: () = this.PassOptionalByteString(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalByteString_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalByteString as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalEnum(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<TestEnum> = if 0 < argc {
            Some(match find_enum_string_index(cx, args.get(0), TestEnumValues::strings) {
                Err(_) => { return false as u8; },
                Ok(None) => { return false as u8; },
                Ok(Some(index)) => {
                    //XXXjdm need some range checks up in here.
                    unsafe { mem::transmute(index) }
                },
            })
        } else {
            None
        };
        let result: () = this.PassOptionalEnum(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalEnum_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalEnum as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalInterface(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<Root<Blob>> = if 0 < argc {
            Some(if args.get(0).get().is_object() {
                match native_from_handlevalue(args.get(0)) {
                    Ok(val) => val,
                    Err(()) => {
                        throw_type_error(cx, "value does not implement interface Blob.");
                        return false as u8;
                    }
                }
            } else {
                throw_type_error(cx, "Value is not an object.");
                return false as u8;
            })
        } else {
            None
        };
        let result: () = this.PassOptionalInterface(arg0.r());
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalInterface_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalInterface as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalUnion(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<UnionTypes::HTMLElementOrLong> = if 0 < argc {
            Some(match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(value) => value,
                Err(()) => { return false as u8; },
            })
        } else {
            None
        };
        let result: () = this.PassOptionalUnion(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalUnion_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalUnion as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalUnion2(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<UnionTypes::EventOrString> = if 0 < argc {
            Some(match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(value) => value,
                Err(()) => { return false as u8; },
            })
        } else {
            None
        };
        let result: () = this.PassOptionalUnion2(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalUnion2_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalUnion2 as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalAny(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: HandleValue = if 0 < argc {
            args.get(0)
        } else {
            HandleValue::undefined()
        };
        let result: () = this.PassOptionalAny(cx, arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalAny_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalAny as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalObject(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<*mut JSObject> = if 0 < argc {
            Some(if args.get(0).get().is_object() {
                args.get(0).get().to_object()
            } else {
                throw_type_error(cx, "Value is not an object.");
                return false as u8;
            })
        } else {
            None
        };
        let result: () = this.PassOptionalObject(cx, arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalObject_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalObject as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalCallbackFunction(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<Rc<FunctionBinding::Function>> = if 0 < argc {
            Some(if args.get(0).get().is_object() {
                if IsCallable(args.get(0).get().to_object()) != 0 {
                    FunctionBinding::Function::new(args.get(0).get().to_object())
                } else {
                    throw_type_error(cx, "Value is not callable.");
                    return false as u8;
                }
            } else {
                throw_type_error(cx, "Value is not an object.");
                return false as u8;
            })
        } else {
            None
        };
        let result: () = this.PassOptionalCallbackFunction(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalCallbackFunction_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalCallbackFunction as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalCallbackInterface(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<Rc<EventListenerBinding::EventListener>> = if 0 < argc {
            Some(EventListenerBinding::EventListener::new(args.get(0).get().to_object()))
        } else {
            None
        };
        let result: () = this.PassOptionalCallbackInterface(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalCallbackInterface_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalCallbackInterface as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableBoolean(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<Option<bool>> = if 0 < argc {
            Some(match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            })
        } else {
            None
        };
        let result: () = this.PassOptionalNullableBoolean(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableBoolean_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableBoolean as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableByte(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<Option<i8>> = if 0 < argc {
            Some(match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            })
        } else {
            None
        };
        let result: () = this.PassOptionalNullableByte(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableByte_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableByte as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableOctet(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<Option<u8>> = if 0 < argc {
            Some(match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            })
        } else {
            None
        };
        let result: () = this.PassOptionalNullableOctet(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableOctet_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableOctet as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableShort(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<Option<i16>> = if 0 < argc {
            Some(match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            })
        } else {
            None
        };
        let result: () = this.PassOptionalNullableShort(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableShort_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableShort as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableUnsignedShort(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<Option<u16>> = if 0 < argc {
            Some(match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            })
        } else {
            None
        };
        let result: () = this.PassOptionalNullableUnsignedShort(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableUnsignedShort_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableUnsignedShort as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableLong(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<Option<i32>> = if 0 < argc {
            Some(match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            })
        } else {
            None
        };
        let result: () = this.PassOptionalNullableLong(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableLong_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableLong as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableUnsignedLong(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<Option<u32>> = if 0 < argc {
            Some(match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            })
        } else {
            None
        };
        let result: () = this.PassOptionalNullableUnsignedLong(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableUnsignedLong_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableUnsignedLong as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableLongLong(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<Option<i64>> = if 0 < argc {
            Some(match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            })
        } else {
            None
        };
        let result: () = this.PassOptionalNullableLongLong(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableLongLong_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableLongLong as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableUnsignedLongLong(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<Option<u64>> = if 0 < argc {
            Some(match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            })
        } else {
            None
        };
        let result: () = this.PassOptionalNullableUnsignedLongLong(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableUnsignedLongLong_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableUnsignedLongLong as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableUnrestrictedFloat(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<Option<f32>> = if 0 < argc {
            Some(match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            })
        } else {
            None
        };
        let result: () = this.PassOptionalNullableUnrestrictedFloat(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableUnrestrictedFloat_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableUnrestrictedFloat as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableFloat(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<Option<Finite<f32>>> = if 0 < argc {
            Some(match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            })
        } else {
            None
        };
        let result: () = this.PassOptionalNullableFloat(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableFloat_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableFloat as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableUnrestrictedDouble(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<Option<f64>> = if 0 < argc {
            Some(match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            })
        } else {
            None
        };
        let result: () = this.PassOptionalNullableUnrestrictedDouble(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableUnrestrictedDouble_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableUnrestrictedDouble as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableDouble(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<Option<Finite<f64>>> = if 0 < argc {
            Some(match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            })
        } else {
            None
        };
        let result: () = this.PassOptionalNullableDouble(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableDouble_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableDouble as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableString(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<Option<DOMString>> = if 0 < argc {
            Some(match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(strval) => strval,
                Err(_) => { return false as u8; },
            })
        } else {
            None
        };
        let result: () = this.PassOptionalNullableString(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableString_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableString as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableUsvstring(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<Option<USVString>> = if 0 < argc {
            Some(match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(strval) => strval,
                Err(_) => { return false as u8; },
            })
        } else {
            None
        };
        let result: () = this.PassOptionalNullableUsvstring(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableUsvstring_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableUsvstring as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableByteString(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<Option<ByteString>> = if 0 < argc {
            Some(match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(strval) => strval,
                Err(_) => { return false as u8; },
            })
        } else {
            None
        };
        let result: () = this.PassOptionalNullableByteString(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableByteString_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableByteString as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableInterface(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<Option<Root<Blob>>> = if 0 < argc {
            Some(if args.get(0).get().is_object() {
                Some(match native_from_handlevalue(args.get(0)) {
                    Ok(val) => val,
                    Err(()) => {
                        throw_type_error(cx, "value does not implement interface Blob.");
                        return false as u8;
                    }
                })
            } else if args.get(0).get().is_null_or_undefined() {
                None
            } else {
                throw_type_error(cx, "Value is not an object.");
                return false as u8;
            })
        } else {
            None
        };
        let result: () = this.PassOptionalNullableInterface(arg0.r());
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableInterface_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableInterface as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableObject(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<*mut JSObject> = if 0 < argc {
            Some(if args.get(0).get().is_object() {
                args.get(0).get().to_object()
            } else if args.get(0).get().is_null_or_undefined() {
                ptr::null_mut()
            } else {
                throw_type_error(cx, "Value is not an object.");
                return false as u8;
            })
        } else {
            None
        };
        let result: () = this.PassOptionalNullableObject(cx, arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableObject_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableObject as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableUnion(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<Option<UnionTypes::HTMLElementOrLong >> = if 0 < argc {
            Some(match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(value) => value,
                Err(()) => { return false as u8; },
            })
        } else {
            None
        };
        let result: () = this.PassOptionalNullableUnion(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableUnion_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableUnion as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableUnion2(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<Option<UnionTypes::EventOrString >> = if 0 < argc {
            Some(match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(value) => value,
                Err(()) => { return false as u8; },
            })
        } else {
            None
        };
        let result: () = this.PassOptionalNullableUnion2(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableUnion2_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableUnion2 as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableCallbackFunction(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<Option<Rc<FunctionBinding::Function>>> = if 0 < argc {
            Some(if args.get(0).get().is_object() {
                if IsCallable(args.get(0).get().to_object()) != 0 {
                    Some(FunctionBinding::Function::new(args.get(0).get().to_object()))
                } else {
                    throw_type_error(cx, "Value is not callable.");
                    return false as u8;
                }
            } else if args.get(0).get().is_null_or_undefined() {
                None
            } else {
                throw_type_error(cx, "Value is not an object.");
                return false as u8;
            })
        } else {
            None
        };
        let result: () = this.PassOptionalNullableCallbackFunction(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableCallbackFunction_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableCallbackFunction as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableCallbackInterface(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<Option<Rc<EventListenerBinding::EventListener>>> = if 0 < argc {
            Some(if args.get(0).get().is_object() {
                Some(EventListenerBinding::EventListener::new(args.get(0).get().to_object()))
            } else if args.get(0).get().is_null_or_undefined() {
                None
            } else {
                throw_type_error(cx, "Value is not an object.");
                return false as u8;
            })
        } else {
            None
        };
        let result: () = this.PassOptionalNullableCallbackInterface(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableCallbackInterface_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableCallbackInterface as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalBooleanWithDefault(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: bool = if 0 < argc {
            match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            }
        } else {
            false
        };
        let result: () = this.PassOptionalBooleanWithDefault(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalBooleanWithDefault_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalBooleanWithDefault as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalByteWithDefault(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: i8 = if 0 < argc {
            match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            }
        } else {
            0
        };
        let result: () = this.PassOptionalByteWithDefault(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalByteWithDefault_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalByteWithDefault as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalOctetWithDefault(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: u8 = if 0 < argc {
            match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            }
        } else {
            19
        };
        let result: () = this.PassOptionalOctetWithDefault(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalOctetWithDefault_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalOctetWithDefault as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalShortWithDefault(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: i16 = if 0 < argc {
            match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            }
        } else {
            5
        };
        let result: () = this.PassOptionalShortWithDefault(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalShortWithDefault_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalShortWithDefault as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalUnsignedShortWithDefault(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: u16 = if 0 < argc {
            match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            }
        } else {
            2
        };
        let result: () = this.PassOptionalUnsignedShortWithDefault(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalUnsignedShortWithDefault_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalUnsignedShortWithDefault as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalLongWithDefault(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: i32 = if 0 < argc {
            match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            }
        } else {
            7
        };
        let result: () = this.PassOptionalLongWithDefault(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalLongWithDefault_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalLongWithDefault as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalUnsignedLongWithDefault(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: u32 = if 0 < argc {
            match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            }
        } else {
            6
        };
        let result: () = this.PassOptionalUnsignedLongWithDefault(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalUnsignedLongWithDefault_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalUnsignedLongWithDefault as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalLongLongWithDefault(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: i64 = if 0 < argc {
            match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            }
        } else {
            -12
        };
        let result: () = this.PassOptionalLongLongWithDefault(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalLongLongWithDefault_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalLongLongWithDefault as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalUnsignedLongLongWithDefault(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: u64 = if 0 < argc {
            match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            }
        } else {
            17
        };
        let result: () = this.PassOptionalUnsignedLongLongWithDefault(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalUnsignedLongLongWithDefault_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalUnsignedLongLongWithDefault as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalStringWithDefault(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: DOMString = if 0 < argc {
            match FromJSValConvertible::from_jsval(cx, args.get(0), StringificationBehavior::Default) {
                Ok(strval) => strval,
                Err(_) => { return false as u8; },
            }
        } else {
            "x".to_owned()
        };
        let result: () = this.PassOptionalStringWithDefault(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalStringWithDefault_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalStringWithDefault as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalUsvstringWithDefault(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: USVString = if 0 < argc {
            match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(strval) => strval,
                Err(_) => { return false as u8; },
            }
        } else {
            USVString("x".to_owned())
        };
        let result: () = this.PassOptionalUsvstringWithDefault(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalUsvstringWithDefault_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalUsvstringWithDefault as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalEnumWithDefault(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: TestEnum = if 0 < argc {
            match find_enum_string_index(cx, args.get(0), TestEnumValues::strings) {
                Err(_) => { return false as u8; },
                Ok(None) => { return false as u8; },
                Ok(Some(index)) => {
                    //XXXjdm need some range checks up in here.
                    unsafe { mem::transmute(index) }
                },
            }
        } else {
            TestEnum::Foo
        };
        let result: () = this.PassOptionalEnumWithDefault(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalEnumWithDefault_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalEnumWithDefault as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableBooleanWithDefault(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<bool> = if 0 < argc {
            match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            }
        } else {
            None
        };
        let result: () = this.PassOptionalNullableBooleanWithDefault(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableBooleanWithDefault_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableBooleanWithDefault as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableByteWithDefault(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<i8> = if 0 < argc {
            match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            }
        } else {
            None
        };
        let result: () = this.PassOptionalNullableByteWithDefault(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableByteWithDefault_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableByteWithDefault as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableOctetWithDefault(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<u8> = if 0 < argc {
            match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            }
        } else {
            None
        };
        let result: () = this.PassOptionalNullableOctetWithDefault(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableOctetWithDefault_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableOctetWithDefault as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableShortWithDefault(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<i16> = if 0 < argc {
            match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            }
        } else {
            None
        };
        let result: () = this.PassOptionalNullableShortWithDefault(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableShortWithDefault_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableShortWithDefault as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableUnsignedShortWithDefault(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<u16> = if 0 < argc {
            match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            }
        } else {
            None
        };
        let result: () = this.PassOptionalNullableUnsignedShortWithDefault(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableUnsignedShortWithDefault_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableUnsignedShortWithDefault as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableLongWithDefault(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<i32> = if 0 < argc {
            match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            }
        } else {
            None
        };
        let result: () = this.PassOptionalNullableLongWithDefault(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableLongWithDefault_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableLongWithDefault as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableUnsignedLongWithDefault(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<u32> = if 0 < argc {
            match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            }
        } else {
            None
        };
        let result: () = this.PassOptionalNullableUnsignedLongWithDefault(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableUnsignedLongWithDefault_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableUnsignedLongWithDefault as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableLongLongWithDefault(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<i64> = if 0 < argc {
            match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            }
        } else {
            None
        };
        let result: () = this.PassOptionalNullableLongLongWithDefault(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableLongLongWithDefault_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableLongLongWithDefault as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableUnsignedLongLongWithDefault(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<u64> = if 0 < argc {
            match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            }
        } else {
            None
        };
        let result: () = this.PassOptionalNullableUnsignedLongLongWithDefault(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableUnsignedLongLongWithDefault_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableUnsignedLongLongWithDefault as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableStringWithDefault(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<DOMString> = if 0 < argc {
            match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(strval) => strval,
                Err(_) => { return false as u8; },
            }
        } else {
            None
        };
        let result: () = this.PassOptionalNullableStringWithDefault(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableStringWithDefault_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableStringWithDefault as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableUsvstringWithDefault(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<USVString> = if 0 < argc {
            match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(strval) => strval,
                Err(_) => { return false as u8; },
            }
        } else {
            None
        };
        let result: () = this.PassOptionalNullableUsvstringWithDefault(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableUsvstringWithDefault_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableUsvstringWithDefault as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableByteStringWithDefault(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<ByteString> = if 0 < argc {
            match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(strval) => strval,
                Err(_) => { return false as u8; },
            }
        } else {
            None
        };
        let result: () = this.PassOptionalNullableByteStringWithDefault(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableByteStringWithDefault_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableByteStringWithDefault as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableInterfaceWithDefault(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<Root<Blob>> = if 0 < argc {
            if args.get(0).get().is_object() {
                Some(match native_from_handlevalue(args.get(0)) {
                    Ok(val) => val,
                    Err(()) => {
                        throw_type_error(cx, "value does not implement interface Blob.");
                        return false as u8;
                    }
                })
            } else if args.get(0).get().is_null_or_undefined() {
                None
            } else {
                throw_type_error(cx, "Value is not an object.");
                return false as u8;
            }
        } else {
            None
        };
        let result: () = this.PassOptionalNullableInterfaceWithDefault(arg0.r());
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableInterfaceWithDefault_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableInterfaceWithDefault as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableObjectWithDefault(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: *mut JSObject = if 0 < argc {
            if args.get(0).get().is_object() {
                args.get(0).get().to_object()
            } else if args.get(0).get().is_null_or_undefined() {
                ptr::null_mut()
            } else {
                throw_type_error(cx, "Value is not an object.");
                return false as u8;
            }
        } else {
            ptr::null_mut()
        };
        let result: () = this.PassOptionalNullableObjectWithDefault(cx, arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableObjectWithDefault_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableObjectWithDefault as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableUnionWithDefault(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<UnionTypes::HTMLElementOrLong > = if 0 < argc {
            match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(value) => value,
                Err(()) => { return false as u8; },
            }
        } else {
            None
        };
        let result: () = this.PassOptionalNullableUnionWithDefault(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableUnionWithDefault_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableUnionWithDefault as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableUnion2WithDefault(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<UnionTypes::EventOrString > = if 0 < argc {
            match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(value) => value,
                Err(()) => { return false as u8; },
            }
        } else {
            None
        };
        let result: () = this.PassOptionalNullableUnion2WithDefault(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableUnion2WithDefault_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableUnion2WithDefault as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableCallbackInterfaceWithDefault(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<Rc<EventListenerBinding::EventListener>> = if 0 < argc {
            if args.get(0).get().is_object() {
                Some(EventListenerBinding::EventListener::new(args.get(0).get().to_object()))
            } else if args.get(0).get().is_null_or_undefined() {
                None
            } else {
                throw_type_error(cx, "Value is not an object.");
                return false as u8;
            }
        } else {
            None
        };
        let result: () = this.PassOptionalNullableCallbackInterfaceWithDefault(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableCallbackInterfaceWithDefault_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableCallbackInterfaceWithDefault as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalAnyWithDefault(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: HandleValue = if 0 < argc {
            args.get(0)
        } else {
            HandleValue::null()
        };
        let result: () = this.PassOptionalAnyWithDefault(cx, arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalAnyWithDefault_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalAnyWithDefault as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableBooleanWithNonNullDefault(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<bool> = if 0 < argc {
            match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            }
        } else {
            Some(false)
        };
        let result: () = this.PassOptionalNullableBooleanWithNonNullDefault(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableBooleanWithNonNullDefault_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableBooleanWithNonNullDefault as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableByteWithNonNullDefault(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<i8> = if 0 < argc {
            match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            }
        } else {
            Some(7)
        };
        let result: () = this.PassOptionalNullableByteWithNonNullDefault(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableByteWithNonNullDefault_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableByteWithNonNullDefault as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableOctetWithNonNullDefault(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<u8> = if 0 < argc {
            match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            }
        } else {
            Some(7)
        };
        let result: () = this.PassOptionalNullableOctetWithNonNullDefault(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableOctetWithNonNullDefault_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableOctetWithNonNullDefault as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableShortWithNonNullDefault(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<i16> = if 0 < argc {
            match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            }
        } else {
            Some(7)
        };
        let result: () = this.PassOptionalNullableShortWithNonNullDefault(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableShortWithNonNullDefault_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableShortWithNonNullDefault as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableUnsignedShortWithNonNullDefault(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<u16> = if 0 < argc {
            match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            }
        } else {
            Some(7)
        };
        let result: () = this.PassOptionalNullableUnsignedShortWithNonNullDefault(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableUnsignedShortWithNonNullDefault_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableUnsignedShortWithNonNullDefault as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableLongWithNonNullDefault(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<i32> = if 0 < argc {
            match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            }
        } else {
            Some(7)
        };
        let result: () = this.PassOptionalNullableLongWithNonNullDefault(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableLongWithNonNullDefault_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableLongWithNonNullDefault as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableUnsignedLongWithNonNullDefault(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<u32> = if 0 < argc {
            match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            }
        } else {
            Some(7)
        };
        let result: () = this.PassOptionalNullableUnsignedLongWithNonNullDefault(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableUnsignedLongWithNonNullDefault_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableUnsignedLongWithNonNullDefault as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableLongLongWithNonNullDefault(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<i64> = if 0 < argc {
            match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            }
        } else {
            Some(7)
        };
        let result: () = this.PassOptionalNullableLongLongWithNonNullDefault(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableLongLongWithNonNullDefault_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableLongLongWithNonNullDefault as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableUnsignedLongLongWithNonNullDefault(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<u64> = if 0 < argc {
            match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(v) => v,
                Err(_) => { return false as u8; }
            }
        } else {
            Some(7)
        };
        let result: () = this.PassOptionalNullableUnsignedLongLongWithNonNullDefault(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableUnsignedLongLongWithNonNullDefault_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableUnsignedLongLongWithNonNullDefault as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableStringWithNonNullDefault(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<DOMString> = if 0 < argc {
            match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(strval) => strval,
                Err(_) => { return false as u8; },
            }
        } else {
            Some("x".to_owned())
        };
        let result: () = this.PassOptionalNullableStringWithNonNullDefault(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableStringWithNonNullDefault_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableStringWithNonNullDefault as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passOptionalNullableUsvstringWithNonNullDefault(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Option<USVString> = if 0 < argc {
            match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
                Ok(strval) => strval,
                Err(_) => { return false as u8; },
            }
        } else {
            Some(USVString("x".to_owned()))
        };
        let result: () = this.PassOptionalNullableUsvstringWithNonNullDefault(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passOptionalNullableUsvstringWithNonNullDefault_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passOptionalNullableUsvstringWithNonNullDefault as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passVariadicBoolean(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Vec<bool> = if 0 < argc {
            let mut vector: Vec<bool> = Vec::with_capacity((argc - 0) as usize);
            for variadicArg in 0..argc {
                let slot: bool = match FromJSValConvertible::from_jsval(cx, args.get(variadicArg), ()) {
                    Ok(v) => v,
                    Err(_) => { return false as u8; }
                };
                vector.push(slot);
            }
            vector
        } else {
            Vec::new()
        };
        let result: () = this.PassVariadicBoolean(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passVariadicBoolean_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passVariadicBoolean as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passVariadicByte(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Vec<i8> = if 0 < argc {
            let mut vector: Vec<i8> = Vec::with_capacity((argc - 0) as usize);
            for variadicArg in 0..argc {
                let slot: i8 = match FromJSValConvertible::from_jsval(cx, args.get(variadicArg), ()) {
                    Ok(v) => v,
                    Err(_) => { return false as u8; }
                };
                vector.push(slot);
            }
            vector
        } else {
            Vec::new()
        };
        let result: () = this.PassVariadicByte(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passVariadicByte_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passVariadicByte as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passVariadicOctet(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Vec<u8> = if 0 < argc {
            let mut vector: Vec<u8> = Vec::with_capacity((argc - 0) as usize);
            for variadicArg in 0..argc {
                let slot: u8 = match FromJSValConvertible::from_jsval(cx, args.get(variadicArg), ()) {
                    Ok(v) => v,
                    Err(_) => { return false as u8; }
                };
                vector.push(slot);
            }
            vector
        } else {
            Vec::new()
        };
        let result: () = this.PassVariadicOctet(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passVariadicOctet_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passVariadicOctet as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passVariadicShort(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Vec<i16> = if 0 < argc {
            let mut vector: Vec<i16> = Vec::with_capacity((argc - 0) as usize);
            for variadicArg in 0..argc {
                let slot: i16 = match FromJSValConvertible::from_jsval(cx, args.get(variadicArg), ()) {
                    Ok(v) => v,
                    Err(_) => { return false as u8; }
                };
                vector.push(slot);
            }
            vector
        } else {
            Vec::new()
        };
        let result: () = this.PassVariadicShort(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passVariadicShort_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passVariadicShort as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passVariadicUnsignedShort(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Vec<u16> = if 0 < argc {
            let mut vector: Vec<u16> = Vec::with_capacity((argc - 0) as usize);
            for variadicArg in 0..argc {
                let slot: u16 = match FromJSValConvertible::from_jsval(cx, args.get(variadicArg), ()) {
                    Ok(v) => v,
                    Err(_) => { return false as u8; }
                };
                vector.push(slot);
            }
            vector
        } else {
            Vec::new()
        };
        let result: () = this.PassVariadicUnsignedShort(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passVariadicUnsignedShort_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passVariadicUnsignedShort as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passVariadicLong(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Vec<i32> = if 0 < argc {
            let mut vector: Vec<i32> = Vec::with_capacity((argc - 0) as usize);
            for variadicArg in 0..argc {
                let slot: i32 = match FromJSValConvertible::from_jsval(cx, args.get(variadicArg), ()) {
                    Ok(v) => v,
                    Err(_) => { return false as u8; }
                };
                vector.push(slot);
            }
            vector
        } else {
            Vec::new()
        };
        let result: () = this.PassVariadicLong(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passVariadicLong_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passVariadicLong as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passVariadicUnsignedLong(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Vec<u32> = if 0 < argc {
            let mut vector: Vec<u32> = Vec::with_capacity((argc - 0) as usize);
            for variadicArg in 0..argc {
                let slot: u32 = match FromJSValConvertible::from_jsval(cx, args.get(variadicArg), ()) {
                    Ok(v) => v,
                    Err(_) => { return false as u8; }
                };
                vector.push(slot);
            }
            vector
        } else {
            Vec::new()
        };
        let result: () = this.PassVariadicUnsignedLong(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passVariadicUnsignedLong_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passVariadicUnsignedLong as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passVariadicLongLong(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Vec<i64> = if 0 < argc {
            let mut vector: Vec<i64> = Vec::with_capacity((argc - 0) as usize);
            for variadicArg in 0..argc {
                let slot: i64 = match FromJSValConvertible::from_jsval(cx, args.get(variadicArg), ()) {
                    Ok(v) => v,
                    Err(_) => { return false as u8; }
                };
                vector.push(slot);
            }
            vector
        } else {
            Vec::new()
        };
        let result: () = this.PassVariadicLongLong(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passVariadicLongLong_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passVariadicLongLong as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passVariadicUnsignedLongLong(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Vec<u64> = if 0 < argc {
            let mut vector: Vec<u64> = Vec::with_capacity((argc - 0) as usize);
            for variadicArg in 0..argc {
                let slot: u64 = match FromJSValConvertible::from_jsval(cx, args.get(variadicArg), ()) {
                    Ok(v) => v,
                    Err(_) => { return false as u8; }
                };
                vector.push(slot);
            }
            vector
        } else {
            Vec::new()
        };
        let result: () = this.PassVariadicUnsignedLongLong(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passVariadicUnsignedLongLong_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passVariadicUnsignedLongLong as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passVariadicUnrestrictedFloat(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Vec<f32> = if 0 < argc {
            let mut vector: Vec<f32> = Vec::with_capacity((argc - 0) as usize);
            for variadicArg in 0..argc {
                let slot: f32 = match FromJSValConvertible::from_jsval(cx, args.get(variadicArg), ()) {
                    Ok(v) => v,
                    Err(_) => { return false as u8; }
                };
                vector.push(slot);
            }
            vector
        } else {
            Vec::new()
        };
        let result: () = this.PassVariadicUnrestrictedFloat(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passVariadicUnrestrictedFloat_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passVariadicUnrestrictedFloat as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passVariadicFloat(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Vec<Finite<f32>> = if 0 < argc {
            let mut vector: Vec<Finite<f32>> = Vec::with_capacity((argc - 0) as usize);
            for variadicArg in 0..argc {
                let slot: Finite<f32> = match FromJSValConvertible::from_jsval(cx, args.get(variadicArg), ()) {
                    Ok(v) => v,
                    Err(_) => { return false as u8; }
                };
                vector.push(slot);
            }
            vector
        } else {
            Vec::new()
        };
        let result: () = this.PassVariadicFloat(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passVariadicFloat_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passVariadicFloat as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passVariadicUnrestrictedDouble(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Vec<f64> = if 0 < argc {
            let mut vector: Vec<f64> = Vec::with_capacity((argc - 0) as usize);
            for variadicArg in 0..argc {
                let slot: f64 = match FromJSValConvertible::from_jsval(cx, args.get(variadicArg), ()) {
                    Ok(v) => v,
                    Err(_) => { return false as u8; }
                };
                vector.push(slot);
            }
            vector
        } else {
            Vec::new()
        };
        let result: () = this.PassVariadicUnrestrictedDouble(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passVariadicUnrestrictedDouble_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passVariadicUnrestrictedDouble as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passVariadicDouble(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Vec<Finite<f64>> = if 0 < argc {
            let mut vector: Vec<Finite<f64>> = Vec::with_capacity((argc - 0) as usize);
            for variadicArg in 0..argc {
                let slot: Finite<f64> = match FromJSValConvertible::from_jsval(cx, args.get(variadicArg), ()) {
                    Ok(v) => v,
                    Err(_) => { return false as u8; }
                };
                vector.push(slot);
            }
            vector
        } else {
            Vec::new()
        };
        let result: () = this.PassVariadicDouble(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passVariadicDouble_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passVariadicDouble as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passVariadicString(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Vec<DOMString> = if 0 < argc {
            let mut vector: Vec<DOMString> = Vec::with_capacity((argc - 0) as usize);
            for variadicArg in 0..argc {
                let slot: DOMString = match FromJSValConvertible::from_jsval(cx, args.get(variadicArg), StringificationBehavior::Default) {
                    Ok(strval) => strval,
                    Err(_) => { return false as u8; },
                };
                vector.push(slot);
            }
            vector
        } else {
            Vec::new()
        };
        let result: () = this.PassVariadicString(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passVariadicString_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passVariadicString as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passVariadicUsvstring(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Vec<USVString> = if 0 < argc {
            let mut vector: Vec<USVString> = Vec::with_capacity((argc - 0) as usize);
            for variadicArg in 0..argc {
                let slot: USVString = match FromJSValConvertible::from_jsval(cx, args.get(variadicArg), ()) {
                    Ok(strval) => strval,
                    Err(_) => { return false as u8; },
                };
                vector.push(slot);
            }
            vector
        } else {
            Vec::new()
        };
        let result: () = this.PassVariadicUsvstring(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passVariadicUsvstring_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passVariadicUsvstring as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passVariadicByteString(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Vec<ByteString> = if 0 < argc {
            let mut vector: Vec<ByteString> = Vec::with_capacity((argc - 0) as usize);
            for variadicArg in 0..argc {
                let slot: ByteString = match FromJSValConvertible::from_jsval(cx, args.get(variadicArg), ()) {
                    Ok(strval) => strval,
                    Err(_) => { return false as u8; },
                };
                vector.push(slot);
            }
            vector
        } else {
            Vec::new()
        };
        let result: () = this.PassVariadicByteString(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passVariadicByteString_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passVariadicByteString as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passVariadicEnum(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Vec<TestEnum> = if 0 < argc {
            let mut vector: Vec<TestEnum> = Vec::with_capacity((argc - 0) as usize);
            for variadicArg in 0..argc {
                let slot: TestEnum = match find_enum_string_index(cx, args.get(variadicArg), TestEnumValues::strings) {
                    Err(_) => { return false as u8; },
                    Ok(None) => { return false as u8; },
                    Ok(Some(index)) => {
                        //XXXjdm need some range checks up in here.
                        unsafe { mem::transmute(index) }
                    },
                };
                vector.push(slot);
            }
            vector
        } else {
            Vec::new()
        };
        let result: () = this.PassVariadicEnum(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passVariadicEnum_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passVariadicEnum as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passVariadicUnion(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Vec<UnionTypes::HTMLElementOrLong> = if 0 < argc {
            let mut vector: Vec<UnionTypes::HTMLElementOrLong> = Vec::with_capacity((argc - 0) as usize);
            for variadicArg in 0..argc {
                let slot: UnionTypes::HTMLElementOrLong = match FromJSValConvertible::from_jsval(cx, args.get(variadicArg), ()) {
                    Ok(value) => value,
                    Err(()) => { return false as u8; },
                };
                vector.push(slot);
            }
            vector
        } else {
            Vec::new()
        };
        let result: () = this.PassVariadicUnion(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passVariadicUnion_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passVariadicUnion as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passVariadicUnion2(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Vec<UnionTypes::EventOrString> = if 0 < argc {
            let mut vector: Vec<UnionTypes::EventOrString> = Vec::with_capacity((argc - 0) as usize);
            for variadicArg in 0..argc {
                let slot: UnionTypes::EventOrString = match FromJSValConvertible::from_jsval(cx, args.get(variadicArg), ()) {
                    Ok(value) => value,
                    Err(()) => { return false as u8; },
                };
                vector.push(slot);
            }
            vector
        } else {
            Vec::new()
        };
        let result: () = this.PassVariadicUnion2(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passVariadicUnion2_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passVariadicUnion2 as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passVariadicUnion3(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Vec<UnionTypes::BlobOrString> = if 0 < argc {
            let mut vector: Vec<UnionTypes::BlobOrString> = Vec::with_capacity((argc - 0) as usize);
            for variadicArg in 0..argc {
                let slot: UnionTypes::BlobOrString = match FromJSValConvertible::from_jsval(cx, args.get(variadicArg), ()) {
                    Ok(value) => value,
                    Err(()) => { return false as u8; },
                };
                vector.push(slot);
            }
            vector
        } else {
            Vec::new()
        };
        let result: () = this.PassVariadicUnion3(arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passVariadicUnion3_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passVariadicUnion3 as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passVariadicAny(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Vec<HandleValue> = if 0 < argc {
            let mut vector: Vec<HandleValue> = Vec::with_capacity((argc - 0) as usize);
            for variadicArg in 0..argc {
                let slot: HandleValue = args.get(variadicArg);
                vector.push(slot);
            }
            vector
        } else {
            Vec::new()
        };
        let result: () = this.PassVariadicAny(cx, arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passVariadicAny_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passVariadicAny as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn passVariadicObject(cx: *mut JSContext, _obj: HandleObject, this: *const TestBinding, args: *const JSJitMethodCallArgs) -> u8 {
    unsafe {
        let this = &*this;
        let args = &*args;
        let argc = args.argc_;
        let arg0: Vec<*mut JSObject> = if 0 < argc {
            let mut vector: Vec<*mut JSObject> = Vec::with_capacity((argc - 0) as usize);
            for variadicArg in 0..argc {
                let slot: *mut JSObject = if args.get(variadicArg).get().is_object() {
                    args.get(variadicArg).get().to_object()
                } else {
                    throw_type_error(cx, "Value is not an object.");
                    return false as u8;
                };
                vector.push(slot);
            }
            vector
        } else {
            Vec::new()
        };
        let result: () = this.PassVariadicObject(cx, arg0);
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}


const passVariadicObject_methodinfo: JSJitInfo = JSJitInfo {
    _bindgen_data_1_: passVariadicObject as *const ::libc::c_void,
    protoID: PrototypeList::ID::TestBinding as u16,
    depth: 0,
    _bitfield_1: ((JSJitInfo_OpType::Method as u32) << 0) |
                 ((JSJitInfo_AliasSet::AliasEverything as u32) << 4) |
                 ((JSValueType::JSVAL_TYPE_UNDEFINED as u32) << 8) |
                 ((false as u32) << 16) |
                 ((false as u32) << 17) |
                 ((false as u32) << 18) |
                 ((false as u32) << 19) |
                 ((false as u32) << 20) |
                 ((0 as u32) << 21)
};

unsafe extern fn get_booleanAttributeStatic(cx: *mut JSContext, argc: libc::c_uint, vp: *mut JSVal) -> u8 {
    unsafe {
        let global = global_object_for_js_object(JS_CALLEE(cx, vp).to_object());
        let mut args = CallArgs::from_vp(vp, argc);
        let result: bool = TestBinding::BooleanAttributeStatic(global.r());
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}

unsafe extern fn set_booleanAttributeStatic(cx: *mut JSContext, argc: libc::c_uint, vp: *mut JSVal) -> u8 {
    unsafe {
        let global = global_object_for_js_object(JS_CALLEE(cx, vp).to_object());
        let args = CallArgs::from_vp(vp, argc);
        if (argc == 0) {
            throw_type_error(cx, "Not enough arguments to booleanAttributeStatic setter.");
            return 0;
        }let arg0: bool = match FromJSValConvertible::from_jsval(cx, args.get(0), ()) {
            Ok(v) => v,
            Err(_) => { return false as u8; }
        };
        let result: () = TestBinding::SetBooleanAttributeStatic(global.r(), arg0);

        return 1;
    }
}

unsafe extern fn receiveVoidStatic(cx: *mut JSContext, argc: libc::c_uint, vp: *mut JSVal) -> u8 {
    unsafe {
        let global = global_object_for_js_object(JS_CALLEE(cx, vp).to_object());
        let mut args = CallArgs::from_vp(vp, argc);
        let result: () = TestBinding::ReceiveVoidStatic(global.r());
        *args.rval().ptr = (result).to_jsval(cx);
        return 1;
    }
}

unsafe extern fn genericMethod(cx: *mut JSContext, argc: libc::c_uint, vp: *mut JSVal) -> u8 {
    unsafe {
        let thisobj = *(vp as *mut JSVal).offset(1);
        if !thisobj.is_null_or_undefined() && !thisobj.is_object() {
            return false as u8;
        }
        let obj = if thisobj.is_object() {
            RootedObject::new(cx, thisobj.to_object())
        } else {
            RootedObject::new(cx, GetGlobalForObjectCrossCompartment(JS_CALLEE(cx, vp).to_object_or_null()))
        };

        let this: Root<TestBinding> = match native_from_handleobject(obj.handle()) {
            Ok(val) => val,
            Err(()) => {
                throw_type_error(cx, "\"this\" object does not implement interface TestBinding.");
                return 0;
            }
        };

        let _info: *const JSJitInfo = RUST_FUNCTION_VALUE_TO_JITINFO(JS_CALLEE(cx, vp));
        return CallJitMethodOp(_info, cx, obj.handle(), mem::transmute(this.r()), argc, vp);
    }
}

unsafe extern fn genericGetter(cx: *mut JSContext, argc: libc::c_uint, vp: *mut JSVal) -> u8 {
    unsafe {
        let thisobj = *(vp as *mut JSVal).offset(1);
        if !thisobj.is_null_or_undefined() && !thisobj.is_object() {
            return false as u8;
        }
        let obj = if thisobj.is_object() {
            RootedObject::new(cx, thisobj.to_object())
        } else {
            RootedObject::new(cx, GetGlobalForObjectCrossCompartment(JS_CALLEE(cx, vp).to_object_or_null()))
        };

        let this: Root<TestBinding> = match native_from_handleobject(obj.handle()) {
            Ok(val) => val,
            Err(()) => {
                throw_type_error(cx, "\"this\" object does not implement interface TestBinding.");
                return 0;
            }
        };

        let info: *const JSJitInfo = RUST_FUNCTION_VALUE_TO_JITINFO(JS_CALLEE(cx, vp));
        return CallJitGetterOp(info, cx, obj.handle(), mem::transmute(this.r()), argc, vp);
    }
}

unsafe extern fn genericSetter(cx: *mut JSContext, argc: libc::c_uint, vp: *mut JSVal) -> u8 {
    unsafe {
        let thisobj = *(vp as *mut JSVal).offset(1);
        if !thisobj.is_null_or_undefined() && !thisobj.is_object() {
            return false as u8;
        }
        let obj = if thisobj.is_object() {
            RootedObject::new(cx, thisobj.to_object())
        } else {
            RootedObject::new(cx, GetGlobalForObjectCrossCompartment(JS_CALLEE(cx, vp).to_object_or_null()))
        };

        let this: Root<TestBinding> = match native_from_handleobject(obj.handle()) {
            Ok(val) => val,
            Err(()) => {
                throw_type_error(cx, "\"this\" object does not implement interface TestBinding.");
                return 0;
            }
        };

        let mut undef = UndefinedValue();
        let info: *const JSJitInfo = RUST_FUNCTION_VALUE_TO_JITINFO(JS_CALLEE(cx, vp));
        if CallJitSetterOp(info, cx, obj.handle(), mem::transmute(this.r()), argc, vp) == 0 {
            return 0;
        }
        *vp = UndefinedValue();
        return 1;
    }
}

unsafe extern fn _finalize(_fop: *mut FreeOp, obj: *mut JSObject) {
    unsafe {
        let this: *const TestBinding = native_from_reflector::<TestBinding>(obj);
        let _ = Box::from_raw(this as *mut TestBinding);
        debug!("TestBinding finalize: {:p}", this);
    }
}

unsafe extern fn _trace(trc: *mut JSTracer, obj: *mut JSObject) {
    unsafe {
        let this: *const TestBinding = native_from_reflector::<TestBinding>(obj);
        if this.is_null() { return; } // GC during obj creation
        (*this).trace(trc);
    }
}

static PrototypeClass: JSClass = JSClass {
    name: b"TestBindingPrototype\0" as *const u8 as *const libc::c_char,
    flags: JSCLASS_IS_DOMJSCLASS | (1 & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT, //JSCLASS_HAS_RESERVED_SLOTS(1)
    addProperty: None,
    delProperty: None,
    getProperty: None,
    setProperty: None,
    enumerate: None,
    resolve: None,
    convert: None,
    finalize: None,
    call: None,
    hasInstance: None,
    construct: None,
    trace: None,
    reserved: [0 as *mut libc::c_void; 25]
};

const sStaticMethods: &'static [JSFunctionSpec] = &[
    JSFunctionSpec { name: b"receiveVoidStatic\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(receiveVoidStatic), info: 0 as *const JSJitInfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: 0 as *const i8, call: JSNativeWrapper { op: None, info: 0 as *const JSJitInfo }, nargs: 0, flags: 0, selfHostedName: 0 as *const i8 }
];
const sStaticAttributes: &'static [JSPropertySpec] = &[
    JSPropertySpec { name: b"booleanAttributeStatic\0" as *const u8 as *const libc::c_char, flags: ((JSPROP_SHARED | JSPROP_ENUMERATE) & 0xFF) as u8, getter: JSNativeWrapper { op: Some(get_booleanAttributeStatic), info: 0 as *const JSJitInfo }, setter: JSNativeWrapper { op: Some(set_booleanAttributeStatic), info: 0 as *const JSJitInfo } },
    JSPropertySpec { name: 0 as *const i8, flags: 0, getter: JSNativeWrapper { op: None, info: 0 as *const JSJitInfo }, setter: JSNativeWrapper { op: None, info: 0 as *const JSJitInfo } }
];
const sMethods: &'static [JSFunctionSpec] = &[
    JSFunctionSpec { name: b"methToBinaryRename\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &methToBinaryRename_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"receiveVoid\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &receiveVoid_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"receiveBoolean\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &receiveBoolean_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"receiveByte\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &receiveByte_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"receiveOctet\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &receiveOctet_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"receiveShort\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &receiveShort_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"receiveUnsignedShort\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &receiveUnsignedShort_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"receiveLong\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &receiveLong_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"receiveUnsignedLong\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &receiveUnsignedLong_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"receiveLongLong\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &receiveLongLong_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"receiveUnsignedLongLong\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &receiveUnsignedLongLong_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"receiveUnrestrictedFloat\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &receiveUnrestrictedFloat_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"receiveFloat\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &receiveFloat_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"receiveUnrestrictedDouble\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &receiveUnrestrictedDouble_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"receiveDouble\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &receiveDouble_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"receiveString\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &receiveString_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"receiveUsvstring\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &receiveUsvstring_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"receiveByteString\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &receiveByteString_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"receiveEnum\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &receiveEnum_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"receiveInterface\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &receiveInterface_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"receiveAny\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &receiveAny_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"receiveObject\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &receiveObject_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"receiveUnion\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &receiveUnion_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"receiveUnion2\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &receiveUnion2_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"receiveNullableByte\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &receiveNullableByte_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"receiveNullableBoolean\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &receiveNullableBoolean_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"receiveNullableOctet\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &receiveNullableOctet_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"receiveNullableShort\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &receiveNullableShort_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"receiveNullableUnsignedShort\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &receiveNullableUnsignedShort_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"receiveNullableLong\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &receiveNullableLong_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"receiveNullableUnsignedLong\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &receiveNullableUnsignedLong_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"receiveNullableLongLong\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &receiveNullableLongLong_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"receiveNullableUnsignedLongLong\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &receiveNullableUnsignedLongLong_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"receiveNullableUnrestrictedFloat\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &receiveNullableUnrestrictedFloat_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"receiveNullableFloat\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &receiveNullableFloat_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"receiveNullableUnrestrictedDouble\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &receiveNullableUnrestrictedDouble_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"receiveNullableDouble\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &receiveNullableDouble_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"receiveNullableString\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &receiveNullableString_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"receiveNullableUsvstring\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &receiveNullableUsvstring_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"receiveNullableByteString\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &receiveNullableByteString_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"receiveNullableEnum\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &receiveNullableEnum_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"receiveNullableInterface\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &receiveNullableInterface_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"receiveNullableObject\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &receiveNullableObject_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"receiveNullableUnion\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &receiveNullableUnion_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"receiveNullableUnion2\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &receiveNullableUnion2_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passBoolean\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passBoolean_methodinfo}, nargs: 1, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passByte\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passByte_methodinfo}, nargs: 1, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOctet\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOctet_methodinfo}, nargs: 1, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passShort\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passShort_methodinfo}, nargs: 1, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passUnsignedShort\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passUnsignedShort_methodinfo}, nargs: 1, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passLong\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passLong_methodinfo}, nargs: 1, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passUnsignedLong\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passUnsignedLong_methodinfo}, nargs: 1, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passLongLong\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passLongLong_methodinfo}, nargs: 1, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passUnsignedLongLong\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passUnsignedLongLong_methodinfo}, nargs: 1, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passUnrestrictedFloat\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passUnrestrictedFloat_methodinfo}, nargs: 1, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passFloat\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passFloat_methodinfo}, nargs: 1, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passUnrestrictedDouble\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passUnrestrictedDouble_methodinfo}, nargs: 1, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passDouble\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passDouble_methodinfo}, nargs: 1, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passString\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passString_methodinfo}, nargs: 1, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passUsvstring\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passUsvstring_methodinfo}, nargs: 1, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passByteString\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passByteString_methodinfo}, nargs: 1, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passEnum\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passEnum_methodinfo}, nargs: 1, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passInterface\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passInterface_methodinfo}, nargs: 1, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passUnion\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passUnion_methodinfo}, nargs: 1, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passUnion2\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passUnion2_methodinfo}, nargs: 1, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passUnion3\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passUnion3_methodinfo}, nargs: 1, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passAny\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passAny_methodinfo}, nargs: 1, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passObject\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passObject_methodinfo}, nargs: 1, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passCallbackFunction\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passCallbackFunction_methodinfo}, nargs: 1, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passCallbackInterface\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passCallbackInterface_methodinfo}, nargs: 1, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passNullableBoolean\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passNullableBoolean_methodinfo}, nargs: 1, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passNullableByte\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passNullableByte_methodinfo}, nargs: 1, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passNullableOctet\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passNullableOctet_methodinfo}, nargs: 1, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passNullableShort\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passNullableShort_methodinfo}, nargs: 1, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passNullableUnsignedShort\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passNullableUnsignedShort_methodinfo}, nargs: 1, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passNullableLong\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passNullableLong_methodinfo}, nargs: 1, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passNullableUnsignedLong\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passNullableUnsignedLong_methodinfo}, nargs: 1, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passNullableLongLong\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passNullableLongLong_methodinfo}, nargs: 1, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passNullableUnsignedLongLong\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passNullableUnsignedLongLong_methodinfo}, nargs: 1, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passNullableUnrestrictedFloat\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passNullableUnrestrictedFloat_methodinfo}, nargs: 1, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passNullableFloat\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passNullableFloat_methodinfo}, nargs: 1, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passNullableUnrestrictedDouble\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passNullableUnrestrictedDouble_methodinfo}, nargs: 1, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passNullableDouble\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passNullableDouble_methodinfo}, nargs: 1, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passNullableString\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passNullableString_methodinfo}, nargs: 1, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passNullableUsvstring\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passNullableUsvstring_methodinfo}, nargs: 1, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passNullableByteString\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passNullableByteString_methodinfo}, nargs: 1, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passNullableInterface\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passNullableInterface_methodinfo}, nargs: 1, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passNullableObject\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passNullableObject_methodinfo}, nargs: 1, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passNullableUnion\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passNullableUnion_methodinfo}, nargs: 1, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passNullableUnion2\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passNullableUnion2_methodinfo}, nargs: 1, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passNullableCallbackFunction\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passNullableCallbackFunction_methodinfo}, nargs: 1, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passNullableCallbackInterface\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passNullableCallbackInterface_methodinfo}, nargs: 1, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalBoolean\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalBoolean_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalByte\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalByte_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalOctet\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalOctet_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalShort\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalShort_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalUnsignedShort\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalUnsignedShort_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalLong\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalLong_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalUnsignedLong\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalUnsignedLong_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalLongLong\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalLongLong_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalUnsignedLongLong\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalUnsignedLongLong_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalUnrestrictedFloat\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalUnrestrictedFloat_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalFloat\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalFloat_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalUnrestrictedDouble\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalUnrestrictedDouble_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalDouble\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalDouble_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalString\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalString_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalUsvstring\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalUsvstring_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalByteString\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalByteString_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalEnum\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalEnum_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalInterface\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalInterface_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalUnion\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalUnion_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalUnion2\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalUnion2_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalAny\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalAny_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalObject\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalObject_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalCallbackFunction\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalCallbackFunction_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalCallbackInterface\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalCallbackInterface_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableBoolean\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableBoolean_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableByte\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableByte_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableOctet\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableOctet_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableShort\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableShort_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableUnsignedShort\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableUnsignedShort_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableLong\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableLong_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableUnsignedLong\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableUnsignedLong_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableLongLong\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableLongLong_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableUnsignedLongLong\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableUnsignedLongLong_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableUnrestrictedFloat\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableUnrestrictedFloat_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableFloat\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableFloat_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableUnrestrictedDouble\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableUnrestrictedDouble_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableDouble\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableDouble_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableString\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableString_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableUsvstring\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableUsvstring_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableByteString\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableByteString_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableInterface\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableInterface_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableObject\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableObject_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableUnion\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableUnion_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableUnion2\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableUnion2_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableCallbackFunction\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableCallbackFunction_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableCallbackInterface\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableCallbackInterface_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalBooleanWithDefault\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalBooleanWithDefault_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalByteWithDefault\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalByteWithDefault_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalOctetWithDefault\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalOctetWithDefault_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalShortWithDefault\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalShortWithDefault_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalUnsignedShortWithDefault\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalUnsignedShortWithDefault_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalLongWithDefault\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalLongWithDefault_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalUnsignedLongWithDefault\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalUnsignedLongWithDefault_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalLongLongWithDefault\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalLongLongWithDefault_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalUnsignedLongLongWithDefault\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalUnsignedLongLongWithDefault_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalStringWithDefault\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalStringWithDefault_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalUsvstringWithDefault\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalUsvstringWithDefault_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalEnumWithDefault\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalEnumWithDefault_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableBooleanWithDefault\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableBooleanWithDefault_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableByteWithDefault\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableByteWithDefault_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableOctetWithDefault\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableOctetWithDefault_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableShortWithDefault\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableShortWithDefault_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableUnsignedShortWithDefault\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableUnsignedShortWithDefault_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableLongWithDefault\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableLongWithDefault_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableUnsignedLongWithDefault\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableUnsignedLongWithDefault_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableLongLongWithDefault\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableLongLongWithDefault_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableUnsignedLongLongWithDefault\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableUnsignedLongLongWithDefault_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableStringWithDefault\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableStringWithDefault_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableUsvstringWithDefault\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableUsvstringWithDefault_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableByteStringWithDefault\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableByteStringWithDefault_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableInterfaceWithDefault\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableInterfaceWithDefault_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableObjectWithDefault\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableObjectWithDefault_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableUnionWithDefault\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableUnionWithDefault_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableUnion2WithDefault\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableUnion2WithDefault_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableCallbackInterfaceWithDefault\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableCallbackInterfaceWithDefault_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalAnyWithDefault\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalAnyWithDefault_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableBooleanWithNonNullDefault\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableBooleanWithNonNullDefault_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableByteWithNonNullDefault\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableByteWithNonNullDefault_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableOctetWithNonNullDefault\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableOctetWithNonNullDefault_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableShortWithNonNullDefault\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableShortWithNonNullDefault_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableUnsignedShortWithNonNullDefault\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableUnsignedShortWithNonNullDefault_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableLongWithNonNullDefault\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableLongWithNonNullDefault_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableUnsignedLongWithNonNullDefault\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableUnsignedLongWithNonNullDefault_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableLongLongWithNonNullDefault\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableLongLongWithNonNullDefault_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableUnsignedLongLongWithNonNullDefault\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableUnsignedLongLongWithNonNullDefault_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableStringWithNonNullDefault\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableStringWithNonNullDefault_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passOptionalNullableUsvstringWithNonNullDefault\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passOptionalNullableUsvstringWithNonNullDefault_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passVariadicBoolean\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passVariadicBoolean_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passVariadicByte\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passVariadicByte_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passVariadicOctet\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passVariadicOctet_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passVariadicShort\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passVariadicShort_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passVariadicUnsignedShort\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passVariadicUnsignedShort_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passVariadicLong\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passVariadicLong_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passVariadicUnsignedLong\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passVariadicUnsignedLong_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passVariadicLongLong\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passVariadicLongLong_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passVariadicUnsignedLongLong\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passVariadicUnsignedLongLong_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passVariadicUnrestrictedFloat\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passVariadicUnrestrictedFloat_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passVariadicFloat\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passVariadicFloat_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passVariadicUnrestrictedDouble\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passVariadicUnrestrictedDouble_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passVariadicDouble\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passVariadicDouble_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passVariadicString\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passVariadicString_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passVariadicUsvstring\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passVariadicUsvstring_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passVariadicByteString\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passVariadicByteString_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passVariadicEnum\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passVariadicEnum_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passVariadicUnion\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passVariadicUnion_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passVariadicUnion2\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passVariadicUnion2_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passVariadicUnion3\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passVariadicUnion3_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passVariadicAny\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passVariadicAny_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: b"passVariadicObject\0" as *const u8 as *const libc::c_char, call: JSNativeWrapper {op: Some(genericMethod), info: &passVariadicObject_methodinfo}, nargs: 0, flags: JSPROP_ENUMERATE as u16, selfHostedName: 0 as *const i8 },
    JSFunctionSpec { name: 0 as *const i8, call: JSNativeWrapper { op: None, info: 0 as *const JSJitInfo }, nargs: 0, flags: 0, selfHostedName: 0 as *const i8 }
];
const sAttributes: &'static [JSPropertySpec] = &[
    JSPropertySpec { name: b"booleanAttribute\0" as *const u8 as *const libc::c_char, flags: ((JSPROP_SHARED | JSPROP_ENUMERATE) & 0xFF) as u8, getter: JSNativeWrapper { op: Some(genericGetter), info: &booleanAttribute_getterinfo }, setter: JSNativeWrapper { op: Some(genericSetter), info: &booleanAttribute_setterinfo } },
    JSPropertySpec { name: b"byteAttribute\0" as *const u8 as *const libc::c_char, flags: ((JSPROP_SHARED | JSPROP_ENUMERATE) & 0xFF) as u8, getter: JSNativeWrapper { op: Some(genericGetter), info: &byteAttribute_getterinfo }, setter: JSNativeWrapper { op: Some(genericSetter), info: &byteAttribute_setterinfo } },
    JSPropertySpec { name: b"octetAttribute\0" as *const u8 as *const libc::c_char, flags: ((JSPROP_SHARED | JSPROP_ENUMERATE) & 0xFF) as u8, getter: JSNativeWrapper { op: Some(genericGetter), info: &octetAttribute_getterinfo }, setter: JSNativeWrapper { op: Some(genericSetter), info: &octetAttribute_setterinfo } },
    JSPropertySpec { name: b"shortAttribute\0" as *const u8 as *const libc::c_char, flags: ((JSPROP_SHARED | JSPROP_ENUMERATE) & 0xFF) as u8, getter: JSNativeWrapper { op: Some(genericGetter), info: &shortAttribute_getterinfo }, setter: JSNativeWrapper { op: Some(genericSetter), info: &shortAttribute_setterinfo } },
    JSPropertySpec { name: b"unsignedShortAttribute\0" as *const u8 as *const libc::c_char, flags: ((JSPROP_SHARED | JSPROP_ENUMERATE) & 0xFF) as u8, getter: JSNativeWrapper { op: Some(genericGetter), info: &unsignedShortAttribute_getterinfo }, setter: JSNativeWrapper { op: Some(genericSetter), info: &unsignedShortAttribute_setterinfo } },
    JSPropertySpec { name: b"longAttribute\0" as *const u8 as *const libc::c_char, flags: ((JSPROP_SHARED | JSPROP_ENUMERATE) & 0xFF) as u8, getter: JSNativeWrapper { op: Some(genericGetter), info: &longAttribute_getterinfo }, setter: JSNativeWrapper { op: Some(genericSetter), info: &longAttribute_setterinfo } },
    JSPropertySpec { name: b"unsignedLongAttribute\0" as *const u8 as *const libc::c_char, flags: ((JSPROP_SHARED | JSPROP_ENUMERATE) & 0xFF) as u8, getter: JSNativeWrapper { op: Some(genericGetter), info: &unsignedLongAttribute_getterinfo }, setter: JSNativeWrapper { op: Some(genericSetter), info: &unsignedLongAttribute_setterinfo } },
    JSPropertySpec { name: b"longLongAttribute\0" as *const u8 as *const libc::c_char, flags: ((JSPROP_SHARED | JSPROP_ENUMERATE) & 0xFF) as u8, getter: JSNativeWrapper { op: Some(genericGetter), info: &longLongAttribute_getterinfo }, setter: JSNativeWrapper { op: Some(genericSetter), info: &longLongAttribute_setterinfo } },
    JSPropertySpec { name: b"unsignedLongLongAttribute\0" as *const u8 as *const libc::c_char, flags: ((JSPROP_SHARED | JSPROP_ENUMERATE) & 0xFF) as u8, getter: JSNativeWrapper { op: Some(genericGetter), info: &unsignedLongLongAttribute_getterinfo }, setter: JSNativeWrapper { op: Some(genericSetter), info: &unsignedLongLongAttribute_setterinfo } },
    JSPropertySpec { name: b"unrestrictedFloatAttribute\0" as *const u8 as *const libc::c_char, flags: ((JSPROP_SHARED | JSPROP_ENUMERATE) & 0xFF) as u8, getter: JSNativeWrapper { op: Some(genericGetter), info: &unrestrictedFloatAttribute_getterinfo }, setter: JSNativeWrapper { op: Some(genericSetter), info: &unrestrictedFloatAttribute_setterinfo } },
    JSPropertySpec { name: b"floatAttribute\0" as *const u8 as *const libc::c_char, flags: ((JSPROP_SHARED | JSPROP_ENUMERATE) & 0xFF) as u8, getter: JSNativeWrapper { op: Some(genericGetter), info: &floatAttribute_getterinfo }, setter: JSNativeWrapper { op: Some(genericSetter), info: &floatAttribute_setterinfo } },
    JSPropertySpec { name: b"unrestrictedDoubleAttribute\0" as *const u8 as *const libc::c_char, flags: ((JSPROP_SHARED | JSPROP_ENUMERATE) & 0xFF) as u8, getter: JSNativeWrapper { op: Some(genericGetter), info: &unrestrictedDoubleAttribute_getterinfo }, setter: JSNativeWrapper { op: Some(genericSetter), info: &unrestrictedDoubleAttribute_setterinfo } },
    JSPropertySpec { name: b"doubleAttribute\0" as *const u8 as *const libc::c_char, flags: ((JSPROP_SHARED | JSPROP_ENUMERATE) & 0xFF) as u8, getter: JSNativeWrapper { op: Some(genericGetter), info: &doubleAttribute_getterinfo }, setter: JSNativeWrapper { op: Some(genericSetter), info: &doubleAttribute_setterinfo } },
    JSPropertySpec { name: b"stringAttribute\0" as *const u8 as *const libc::c_char, flags: ((JSPROP_SHARED | JSPROP_ENUMERATE) & 0xFF) as u8, getter: JSNativeWrapper { op: Some(genericGetter), info: &stringAttribute_getterinfo }, setter: JSNativeWrapper { op: Some(genericSetter), info: &stringAttribute_setterinfo } },
    JSPropertySpec { name: b"usvstringAttribute\0" as *const u8 as *const libc::c_char, flags: ((JSPROP_SHARED | JSPROP_ENUMERATE) & 0xFF) as u8, getter: JSNativeWrapper { op: Some(genericGetter), info: &usvstringAttribute_getterinfo }, setter: JSNativeWrapper { op: Some(genericSetter), info: &usvstringAttribute_setterinfo } },
    JSPropertySpec { name: b"byteStringAttribute\0" as *const u8 as *const libc::c_char, flags: ((JSPROP_SHARED | JSPROP_ENUMERATE) & 0xFF) as u8, getter: JSNativeWrapper { op: Some(genericGetter), info: &byteStringAttribute_getterinfo }, setter: JSNativeWrapper { op: Some(genericSetter), info: &byteStringAttribute_setterinfo } },
    JSPropertySpec { name: b"enumAttribute\0" as *const u8 as *const libc::c_char, flags: ((JSPROP_SHARED | JSPROP_ENUMERATE) & 0xFF) as u8, getter: JSNativeWrapper { op: Some(genericGetter), info: &enumAttribute_getterinfo }, setter: JSNativeWrapper { op: Some(genericSetter), info: &enumAttribute_setterinfo } },
    JSPropertySpec { name: b"interfaceAttribute\0" as *const u8 as *const libc::c_char, flags: ((JSPROP_SHARED | JSPROP_ENUMERATE) & 0xFF) as u8, getter: JSNativeWrapper { op: Some(genericGetter), info: &interfaceAttribute_getterinfo }, setter: JSNativeWrapper { op: Some(genericSetter), info: &interfaceAttribute_setterinfo } },
    JSPropertySpec { name: b"unionAttribute\0" as *const u8 as *const libc::c_char, flags: ((JSPROP_SHARED | JSPROP_ENUMERATE) & 0xFF) as u8, getter: JSNativeWrapper { op: Some(genericGetter), info: &unionAttribute_getterinfo }, setter: JSNativeWrapper { op: Some(genericSetter), info: &unionAttribute_setterinfo } },
    JSPropertySpec { name: b"union2Attribute\0" as *const u8 as *const libc::c_char, flags: ((JSPROP_SHARED | JSPROP_ENUMERATE) & 0xFF) as u8, getter: JSNativeWrapper { op: Some(genericGetter), info: &union2Attribute_getterinfo }, setter: JSNativeWrapper { op: Some(genericSetter), info: &union2Attribute_setterinfo } },
    JSPropertySpec { name: b"arrayAttribute\0" as *const u8 as *const libc::c_char, flags: ((JSPROP_SHARED | JSPROP_ENUMERATE) & 0xFF) as u8, getter: JSNativeWrapper { op: Some(genericGetter), info: &arrayAttribute_getterinfo }, setter: JSNativeWrapper { op: None, info: 0 as *const JSJitInfo } },
    JSPropertySpec { name: b"anyAttribute\0" as *const u8 as *const libc::c_char, flags: ((JSPROP_SHARED | JSPROP_ENUMERATE) & 0xFF) as u8, getter: JSNativeWrapper { op: Some(genericGetter), info: &anyAttribute_getterinfo }, setter: JSNativeWrapper { op: Some(genericSetter), info: &anyAttribute_setterinfo } },
    JSPropertySpec { name: b"objectAttribute\0" as *const u8 as *const libc::c_char, flags: ((JSPROP_SHARED | JSPROP_ENUMERATE) & 0xFF) as u8, getter: JSNativeWrapper { op: Some(genericGetter), info: &objectAttribute_getterinfo }, setter: JSNativeWrapper { op: Some(genericSetter), info: &objectAttribute_setterinfo } },
    JSPropertySpec { name: b"booleanAttributeNullable\0" as *const u8 as *const libc::c_char, flags: ((JSPROP_SHARED | JSPROP_ENUMERATE) & 0xFF) as u8, getter: JSNativeWrapper { op: Some(genericGetter), info: &booleanAttributeNullable_getterinfo }, setter: JSNativeWrapper { op: Some(genericSetter), info: &booleanAttributeNullable_setterinfo } },
    JSPropertySpec { name: b"byteAttributeNullable\0" as *const u8 as *const libc::c_char, flags: ((JSPROP_SHARED | JSPROP_ENUMERATE) & 0xFF) as u8, getter: JSNativeWrapper { op: Some(genericGetter), info: &byteAttributeNullable_getterinfo }, setter: JSNativeWrapper { op: Some(genericSetter), info: &byteAttributeNullable_setterinfo } },
    JSPropertySpec { name: b"octetAttributeNullable\0" as *const u8 as *const libc::c_char, flags: ((JSPROP_SHARED | JSPROP_ENUMERATE) & 0xFF) as u8, getter: JSNativeWrapper { op: Some(genericGetter), info: &octetAttributeNullable_getterinfo }, setter: JSNativeWrapper { op: Some(genericSetter), info: &octetAttributeNullable_setterinfo } },
    JSPropertySpec { name: b"shortAttributeNullable\0" as *const u8 as *const libc::c_char, flags: ((JSPROP_SHARED | JSPROP_ENUMERATE) & 0xFF) as u8, getter: JSNativeWrapper { op: Some(genericGetter), info: &shortAttributeNullable_getterinfo }, setter: JSNativeWrapper { op: Some(genericSetter), info: &shortAttributeNullable_setterinfo } },
    JSPropertySpec { name: b"unsignedShortAttributeNullable\0" as *const u8 as *const libc::c_char, flags: ((JSPROP_SHARED | JSPROP_ENUMERATE) & 0xFF) as u8, getter: JSNativeWrapper { op: Some(genericGetter), info: &unsignedShortAttributeNullable_getterinfo }, setter: JSNativeWrapper { op: Some(genericSetter), info: &unsignedShortAttributeNullable_setterinfo } },
    JSPropertySpec { name: b"longAttributeNullable\0" as *const u8 as *const libc::c_char, flags: ((JSPROP_SHARED | JSPROP_ENUMERATE) & 0xFF) as u8, getter: JSNativeWrapper { op: Some(genericGetter), info: &longAttributeNullable_getterinfo }, setter: JSNativeWrapper { op: Some(genericSetter), info: &longAttributeNullable_setterinfo } },
    JSPropertySpec { name: b"unsignedLongAttributeNullable\0" as *const u8 as *const libc::c_char, flags: ((JSPROP_SHARED | JSPROP_ENUMERATE) & 0xFF) as u8, getter: JSNativeWrapper { op: Some(genericGetter), info: &unsignedLongAttributeNullable_getterinfo }, setter: JSNativeWrapper { op: Some(genericSetter), info: &unsignedLongAttributeNullable_setterinfo } },
    JSPropertySpec { name: b"longLongAttributeNullable\0" as *const u8 as *const libc::c_char, flags: ((JSPROP_SHARED | JSPROP_ENUMERATE) & 0xFF) as u8, getter: JSNativeWrapper { op: Some(genericGetter), info: &longLongAttributeNullable_getterinfo }, setter: JSNativeWrapper { op: Some(genericSetter), info: &longLongAttributeNullable_setterinfo } },
    JSPropertySpec { name: b"unsignedLongLongAttributeNullable\0" as *const u8 as *const libc::c_char, flags: ((JSPROP_SHARED | JSPROP_ENUMERATE) & 0xFF) as u8, getter: JSNativeWrapper { op: Some(genericGetter), info: &unsignedLongLongAttributeNullable_getterinfo }, setter: JSNativeWrapper { op: Some(genericSetter), info: &unsignedLongLongAttributeNullable_setterinfo } },
    JSPropertySpec { name: b"unrestrictedFloatAttributeNullable\0" as *const u8 as *const libc::c_char, flags: ((JSPROP_SHARED | JSPROP_ENUMERATE) & 0xFF) as u8, getter: JSNativeWrapper { op: Some(genericGetter), info: &unrestrictedFloatAttributeNullable_getterinfo }, setter: JSNativeWrapper { op: Some(genericSetter), info: &unrestrictedFloatAttributeNullable_setterinfo } },
    JSPropertySpec { name: b"floatAttributeNullable\0" as *const u8 as *const libc::c_char, flags: ((JSPROP_SHARED | JSPROP_ENUMERATE) & 0xFF) as u8, getter: JSNativeWrapper { op: Some(genericGetter), info: &floatAttributeNullable_getterinfo }, setter: JSNativeWrapper { op: Some(genericSetter), info: &floatAttributeNullable_setterinfo } },
    JSPropertySpec { name: b"unrestrictedDoubleAttributeNullable\0" as *const u8 as *const libc::c_char, flags: ((JSPROP_SHARED | JSPROP_ENUMERATE) & 0xFF) as u8, getter: JSNativeWrapper { op: Some(genericGetter), info: &unrestrictedDoubleAttributeNullable_getterinfo }, setter: JSNativeWrapper { op: Some(genericSetter), info: &unrestrictedDoubleAttributeNullable_setterinfo } },
    JSPropertySpec { name: b"doubleAttributeNullable\0" as *const u8 as *const libc::c_char, flags: ((JSPROP_SHARED | JSPROP_ENUMERATE) & 0xFF) as u8, getter: JSNativeWrapper { op: Some(genericGetter), info: &doubleAttributeNullable_getterinfo }, setter: JSNativeWrapper { op: Some(genericSetter), info: &doubleAttributeNullable_setterinfo } },
    JSPropertySpec { name: b"stringAttributeNullable\0" as *const u8 as *const libc::c_char, flags: ((JSPROP_SHARED | JSPROP_ENUMERATE) & 0xFF) as u8, getter: JSNativeWrapper { op: Some(genericGetter), info: &stringAttributeNullable_getterinfo }, setter: JSNativeWrapper { op: Some(genericSetter), info: &stringAttributeNullable_setterinfo } },
    JSPropertySpec { name: b"usvstringAttributeNullable\0" as *const u8 as *const libc::c_char, flags: ((JSPROP_SHARED | JSPROP_ENUMERATE) & 0xFF) as u8, getter: JSNativeWrapper { op: Some(genericGetter), info: &usvstringAttributeNullable_getterinfo }, setter: JSNativeWrapper { op: Some(genericSetter), info: &usvstringAttributeNullable_setterinfo } },
    JSPropertySpec { name: b"byteStringAttributeNullable\0" as *const u8 as *const libc::c_char, flags: ((JSPROP_SHARED | JSPROP_ENUMERATE) & 0xFF) as u8, getter: JSNativeWrapper { op: Some(genericGetter), info: &byteStringAttributeNullable_getterinfo }, setter: JSNativeWrapper { op: Some(genericSetter), info: &byteStringAttributeNullable_setterinfo } },
    JSPropertySpec { name: b"enumAttributeNullable\0" as *const u8 as *const libc::c_char, flags: ((JSPROP_SHARED | JSPROP_ENUMERATE) & 0xFF) as u8, getter: JSNativeWrapper { op: Some(genericGetter), info: &enumAttributeNullable_getterinfo }, setter: JSNativeWrapper { op: None, info: 0 as *const JSJitInfo } },
    JSPropertySpec { name: b"interfaceAttributeNullable\0" as *const u8 as *const libc::c_char, flags: ((JSPROP_SHARED | JSPROP_ENUMERATE) & 0xFF) as u8, getter: JSNativeWrapper { op: Some(genericGetter), info: &interfaceAttributeNullable_getterinfo }, setter: JSNativeWrapper { op: Some(genericSetter), info: &interfaceAttributeNullable_setterinfo } },
    JSPropertySpec { name: b"objectAttributeNullable\0" as *const u8 as *const libc::c_char, flags: ((JSPROP_SHARED | JSPROP_ENUMERATE) & 0xFF) as u8, getter: JSNativeWrapper { op: Some(genericGetter), info: &objectAttributeNullable_getterinfo }, setter: JSNativeWrapper { op: Some(genericSetter), info: &objectAttributeNullable_setterinfo } },
    JSPropertySpec { name: b"unionAttributeNullable\0" as *const u8 as *const libc::c_char, flags: ((JSPROP_SHARED | JSPROP_ENUMERATE) & 0xFF) as u8, getter: JSNativeWrapper { op: Some(genericGetter), info: &unionAttributeNullable_getterinfo }, setter: JSNativeWrapper { op: Some(genericSetter), info: &unionAttributeNullable_setterinfo } },
    JSPropertySpec { name: b"union2AttributeNullable\0" as *const u8 as *const libc::c_char, flags: ((JSPROP_SHARED | JSPROP_ENUMERATE) & 0xFF) as u8, getter: JSNativeWrapper { op: Some(genericGetter), info: &union2AttributeNullable_getterinfo }, setter: JSNativeWrapper { op: Some(genericSetter), info: &union2AttributeNullable_setterinfo } },
    JSPropertySpec { name: b"attrToBinaryRename\0" as *const u8 as *const libc::c_char, flags: ((JSPROP_SHARED | JSPROP_ENUMERATE) & 0xFF) as u8, getter: JSNativeWrapper { op: Some(genericGetter), info: &attrToBinaryRename_getterinfo }, setter: JSNativeWrapper { op: Some(genericSetter), info: &attrToBinaryRename_setterinfo } },
    JSPropertySpec { name: b"forwardedAttribute\0" as *const u8 as *const libc::c_char, flags: ((JSPROP_SHARED | JSPROP_ENUMERATE) & 0xFF) as u8, getter: JSNativeWrapper { op: Some(genericGetter), info: &forwardedAttribute_getterinfo }, setter: JSNativeWrapper { op: Some(genericSetter), info: &forwardedAttribute_setterinfo } },
    JSPropertySpec { name: 0 as *const i8, flags: 0, getter: JSNativeWrapper { op: None, info: 0 as *const JSJitInfo }, setter: JSNativeWrapper { op: None, info: 0 as *const JSJitInfo } }
];

static sNativeProperties: NativeProperties = NativeProperties {
    static_methods: Some(sStaticMethods),
    static_attrs: Some(sStaticAttributes),
    methods: Some(sMethods),
    attrs: Some(sAttributes),
    consts: None,
};

pub static sNativePropertyHooks: NativePropertyHooks = NativePropertyHooks {
    native_properties: &sNativeProperties,
    proto_hooks: None,
};

fn CreateInterfaceObjects(cx: *mut JSContext, global: HandleObject, receiver: HandleObject) -> *mut JSObject {
    unsafe {
        let parent_proto = RootedObject::new(cx, JS_GetObjectPrototype(cx, global));
        assert!(!parent_proto.ptr.is_null());

        return do_create_interface_objects(cx, receiver, parent_proto.handle(),
                                           Some(&PrototypeClass), Some((throwing_constructor as NonNullJSNative, "TestBinding", 0)),
                                           &Class.dom_class,
                                           &sNativeProperties);
    }
}

pub mod TestBindingConstants {
} // mod TestBindingConstants
pub fn DefineDOMInterface(cx: *mut JSContext, global: HandleObject) {
    unsafe {
        assert!(!global.get().is_null());
        assert!(!GetProtoObject(cx, global, global).is_null());
    }
}

static Class: DOMJSClass = DOMJSClass {
    base: js::jsapi::Class {
        name: b"TestBinding\0" as *const u8 as *const libc::c_char,
        flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_IMPLEMENTS_BARRIERS | 0 | (((1) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT), //JSCLASS_HAS_RESERVED_SLOTS(1),
        addProperty: None,
        delProperty: None,
        getProperty: None,
        setProperty: None,
        enumerate: None,
        resolve: None,
        convert: None,
        finalize: Some(_finalize),
        call: None,
        hasInstance: None,
        construct: None,
        trace: Some(_trace),

        spec: js::jsapi::ClassSpec {
            createConstructor: None,
            createPrototype: None,
            constructorFunctions: 0 as *const js::jsapi::JSFunctionSpec,
            constructorProperties: 0 as *const js::jsapi::JSPropertySpec,
            prototypeFunctions: 0 as *const js::jsapi::JSFunctionSpec,
            prototypeProperties: 0 as *const js::jsapi::JSPropertySpec,
            finishInit: None,
            flags: 0,
        },

        ext: js::jsapi::ClassExtension {
            outerObject: None,
            innerObject: None,
            isWrappedNative: 0,
            weakmapKeyDelegateOp: None,
            objectMovedOp: None,
        },

        ops: js::jsapi::ObjectOps {
            lookupProperty: None,
            defineProperty: None,
            hasProperty: None,
            getProperty: None,
            setProperty: None,
            getOwnPropertyDescriptor: None,
            deleteProperty: None,
            watch: None,
            unwatch: None,
            getElements: None,
            enumerate: None,
            thisObject: None,
        },
    },
    dom_class:     DOMClass {
        interface_chain: [ PrototypeList::ID::TestBinding, PrototypeList::ID::Count, PrototypeList::ID::Count, PrototypeList::ID::Count, PrototypeList::ID::Count, PrototypeList::ID::Count ],
        native_hooks: &sNativePropertyHooks,
    }
};

pub fn Wrap(cx: *mut JSContext, scope: GlobalRef, mut object: Box<TestBinding>) -> Root<TestBinding> {
    unsafe {
        let _ar = JSAutoRequest::new(cx);
        let scope = RootedObject::new(cx, scope.reflector().get_jsobject());
        assert!(!scope.ptr.is_null());
        assert!(((*JS_GetClass(scope.ptr)).flags & JSCLASS_IS_GLOBAL) != 0);

        let proto = {
            let _ac = JSAutoCompartment::new(cx, scope.ptr);
            GetProtoObject(cx, scope.handle(), scope.handle())
        };
        assert!(!proto.is_null());
        let proto = RootedObject::new(cx, proto);

        let mut raw = boxed::into_raw(object);
        let _rt = RootedTraceable::new(&*raw);
        let obj = {
            let _ac = JSAutoCompartment::new(cx, proto.ptr);
            JS_NewObjectWithGivenProto(cx, &Class.base as *const js::jsapi::Class as *const JSClass, proto.handle())
        };
        let obj = RootedObject::new(cx, obj);assert!(!obj.ptr.is_null());

        JS_SetReservedSlot(obj.ptr, DOM_OBJECT_SLOT,
                           PrivateValue(raw as *const libc::c_void));

        (*raw).init_reflector(obj.ptr);

        Root::from_ref(&*raw)
    }
}

impl IDLInterface for TestBinding {
    fn get_prototype_id() -> PrototypeList::ID {
        PrototypeList::ID::TestBinding
    }
    fn get_prototype_depth() -> usize {
        0
    }
}

pub trait TestBindingMethods {
    fn BooleanAttribute(self) -> bool;
    fn SetBooleanAttribute(self, value: bool) -> ();
    fn ByteAttribute(self) -> i8;
    fn SetByteAttribute(self, value: i8) -> ();
    fn OctetAttribute(self) -> u8;
    fn SetOctetAttribute(self, value: u8) -> ();
    fn ShortAttribute(self) -> i16;
    fn SetShortAttribute(self, value: i16) -> ();
    fn UnsignedShortAttribute(self) -> u16;
    fn SetUnsignedShortAttribute(self, value: u16) -> ();
    fn LongAttribute(self) -> i32;
    fn SetLongAttribute(self, value: i32) -> ();
    fn UnsignedLongAttribute(self) -> u32;
    fn SetUnsignedLongAttribute(self, value: u32) -> ();
    fn LongLongAttribute(self) -> i64;
    fn SetLongLongAttribute(self, value: i64) -> ();
    fn UnsignedLongLongAttribute(self) -> u64;
    fn SetUnsignedLongLongAttribute(self, value: u64) -> ();
    fn UnrestrictedFloatAttribute(self) -> f32;
    fn SetUnrestrictedFloatAttribute(self, value: f32) -> ();
    fn FloatAttribute(self) -> Finite<f32>;
    fn SetFloatAttribute(self, value: Finite<f32>) -> ();
    fn UnrestrictedDoubleAttribute(self) -> f64;
    fn SetUnrestrictedDoubleAttribute(self, value: f64) -> ();
    fn DoubleAttribute(self) -> Finite<f64>;
    fn SetDoubleAttribute(self, value: Finite<f64>) -> ();
    fn StringAttribute(self) -> DOMString;
    fn SetStringAttribute(self, value: DOMString) -> ();
    fn UsvstringAttribute(self) -> USVString;
    fn SetUsvstringAttribute(self, value: USVString) -> ();
    fn ByteStringAttribute(self) -> ByteString;
    fn SetByteStringAttribute(self, value: ByteString) -> ();
    fn EnumAttribute(self) -> TestEnum;
    fn SetEnumAttribute(self, value: TestEnum) -> ();
    fn InterfaceAttribute(self) -> Root<Blob>;
    fn SetInterfaceAttribute(self, value: &Blob) -> ();
    fn UnionAttribute(self) -> UnionTypes::HTMLElementOrLong;
    fn SetUnionAttribute(self, value: UnionTypes::HTMLElementOrLong) -> ();
    fn Union2Attribute(self) -> UnionTypes::EventOrString;
    fn SetUnion2Attribute(self, value: UnionTypes::EventOrString) -> ();
    fn ArrayAttribute(self, cx: *mut JSContext) -> *mut JSObject;
    fn AnyAttribute(self, cx: *mut JSContext) -> JSVal;
    fn SetAnyAttribute(self, cx: *mut JSContext, value: HandleValue) -> ();
    fn ObjectAttribute(self, cx: *mut JSContext) -> *mut JSObject;
    fn SetObjectAttribute(self, cx: *mut JSContext, value: *mut JSObject) -> ();
    fn GetBooleanAttributeNullable(self) -> Option<bool>;
    fn SetBooleanAttributeNullable(self, value: Option<bool>) -> ();
    fn GetByteAttributeNullable(self) -> Option<i8>;
    fn SetByteAttributeNullable(self, value: Option<i8>) -> ();
    fn GetOctetAttributeNullable(self) -> Option<u8>;
    fn SetOctetAttributeNullable(self, value: Option<u8>) -> ();
    fn GetShortAttributeNullable(self) -> Option<i16>;
    fn SetShortAttributeNullable(self, value: Option<i16>) -> ();
    fn GetUnsignedShortAttributeNullable(self) -> Option<u16>;
    fn SetUnsignedShortAttributeNullable(self, value: Option<u16>) -> ();
    fn GetLongAttributeNullable(self) -> Option<i32>;
    fn SetLongAttributeNullable(self, value: Option<i32>) -> ();
    fn GetUnsignedLongAttributeNullable(self) -> Option<u32>;
    fn SetUnsignedLongAttributeNullable(self, value: Option<u32>) -> ();
    fn GetLongLongAttributeNullable(self) -> Option<i64>;
    fn SetLongLongAttributeNullable(self, value: Option<i64>) -> ();
    fn GetUnsignedLongLongAttributeNullable(self) -> Option<u64>;
    fn SetUnsignedLongLongAttributeNullable(self, value: Option<u64>) -> ();
    fn GetUnrestrictedFloatAttributeNullable(self) -> Option<f32>;
    fn SetUnrestrictedFloatAttributeNullable(self, value: Option<f32>) -> ();
    fn GetFloatAttributeNullable(self) -> Option<Finite<f32>>;
    fn SetFloatAttributeNullable(self, value: Option<Finite<f32>>) -> ();
    fn GetUnrestrictedDoubleAttributeNullable(self) -> Option<f64>;
    fn SetUnrestrictedDoubleAttributeNullable(self, value: Option<f64>) -> ();
    fn GetDoubleAttributeNullable(self) -> Option<Finite<f64>>;
    fn SetDoubleAttributeNullable(self, value: Option<Finite<f64>>) -> ();
    fn GetStringAttributeNullable(self) -> Option<DOMString>;
    fn SetStringAttributeNullable(self, value: Option<DOMString>) -> ();
    fn GetUsvstringAttributeNullable(self) -> Option<USVString>;
    fn SetUsvstringAttributeNullable(self, value: Option<USVString>) -> ();
    fn GetByteStringAttributeNullable(self) -> Option<ByteString>;
    fn SetByteStringAttributeNullable(self, value: Option<ByteString>) -> ();
    fn GetEnumAttributeNullable(self) -> Option<TestEnum>;
    fn GetInterfaceAttributeNullable(self) -> Option<Root<Blob>>;
    fn SetInterfaceAttributeNullable(self, value: Option<&Blob>) -> ();
    fn GetObjectAttributeNullable(self, cx: *mut JSContext) -> *mut JSObject;
    fn SetObjectAttributeNullable(self, cx: *mut JSContext, value: *mut JSObject) -> ();
    fn GetUnionAttributeNullable(self) -> Option<UnionTypes::HTMLElementOrLong>;
    fn SetUnionAttributeNullable(self, value: Option<UnionTypes::HTMLElementOrLong >) -> ();
    fn GetUnion2AttributeNullable(self) -> Option<UnionTypes::EventOrString>;
    fn SetUnion2AttributeNullable(self, value: Option<UnionTypes::EventOrString >) -> ();
    fn BinaryRenamedAttribute(self) -> DOMString;
    fn SetBinaryRenamedAttribute(self, value: DOMString) -> ();
    fn ForwardedAttribute(self) -> Root<TestBinding>;
    fn BinaryRenamedMethod(self) -> ();
    fn ReceiveVoid(self) -> ();
    fn ReceiveBoolean(self) -> bool;
    fn ReceiveByte(self) -> i8;
    fn ReceiveOctet(self) -> u8;
    fn ReceiveShort(self) -> i16;
    fn ReceiveUnsignedShort(self) -> u16;
    fn ReceiveLong(self) -> i32;
    fn ReceiveUnsignedLong(self) -> u32;
    fn ReceiveLongLong(self) -> i64;
    fn ReceiveUnsignedLongLong(self) -> u64;
    fn ReceiveUnrestrictedFloat(self) -> f32;
    fn ReceiveFloat(self) -> Finite<f32>;
    fn ReceiveUnrestrictedDouble(self) -> f64;
    fn ReceiveDouble(self) -> Finite<f64>;
    fn ReceiveString(self) -> DOMString;
    fn ReceiveUsvstring(self) -> USVString;
    fn ReceiveByteString(self) -> ByteString;
    fn ReceiveEnum(self) -> TestEnum;
    fn ReceiveInterface(self) -> Root<Blob>;
    fn ReceiveAny(self, cx: *mut JSContext) -> JSVal;
    fn ReceiveObject(self, cx: *mut JSContext) -> *mut JSObject;
    fn ReceiveUnion(self) -> UnionTypes::HTMLElementOrLong;
    fn ReceiveUnion2(self) -> UnionTypes::EventOrString;
    fn ReceiveNullableByte(self) -> Option<i8>;
    fn ReceiveNullableBoolean(self) -> Option<bool>;
    fn ReceiveNullableOctet(self) -> Option<u8>;
    fn ReceiveNullableShort(self) -> Option<i16>;
    fn ReceiveNullableUnsignedShort(self) -> Option<u16>;
    fn ReceiveNullableLong(self) -> Option<i32>;
    fn ReceiveNullableUnsignedLong(self) -> Option<u32>;
    fn ReceiveNullableLongLong(self) -> Option<i64>;
    fn ReceiveNullableUnsignedLongLong(self) -> Option<u64>;
    fn ReceiveNullableUnrestrictedFloat(self) -> Option<f32>;
    fn ReceiveNullableFloat(self) -> Option<Finite<f32>>;
    fn ReceiveNullableUnrestrictedDouble(self) -> Option<f64>;
    fn ReceiveNullableDouble(self) -> Option<Finite<f64>>;
    fn ReceiveNullableString(self) -> Option<DOMString>;
    fn ReceiveNullableUsvstring(self) -> Option<USVString>;
    fn ReceiveNullableByteString(self) -> Option<ByteString>;
    fn ReceiveNullableEnum(self) -> Option<TestEnum>;
    fn ReceiveNullableInterface(self) -> Option<Root<Blob>>;
    fn ReceiveNullableObject(self, cx: *mut JSContext) -> *mut JSObject;
    fn ReceiveNullableUnion(self) -> Option<UnionTypes::HTMLElementOrLong>;
    fn ReceiveNullableUnion2(self) -> Option<UnionTypes::EventOrString>;
    fn PassBoolean(self, arg: bool) -> ();
    fn PassByte(self, arg: i8) -> ();
    fn PassOctet(self, arg: u8) -> ();
    fn PassShort(self, arg: i16) -> ();
    fn PassUnsignedShort(self, arg: u16) -> ();
    fn PassLong(self, arg: i32) -> ();
    fn PassUnsignedLong(self, arg: u32) -> ();
    fn PassLongLong(self, arg: i64) -> ();
    fn PassUnsignedLongLong(self, arg: u64) -> ();
    fn PassUnrestrictedFloat(self, arg: f32) -> ();
    fn PassFloat(self, arg: Finite<f32>) -> ();
    fn PassUnrestrictedDouble(self, arg: f64) -> ();
    fn PassDouble(self, arg: Finite<f64>) -> ();
    fn PassString(self, arg: DOMString) -> ();
    fn PassUsvstring(self, arg: USVString) -> ();
    fn PassByteString(self, arg: ByteString) -> ();
    fn PassEnum(self, arg: TestEnum) -> ();
    fn PassInterface(self, arg: &Blob) -> ();
    fn PassUnion(self, arg: UnionTypes::HTMLElementOrLong) -> ();
    fn PassUnion2(self, data: UnionTypes::EventOrString) -> ();
    fn PassUnion3(self, data: UnionTypes::BlobOrString) -> ();
    fn PassAny(self, cx: *mut JSContext, arg: HandleValue) -> ();
    fn PassObject(self, cx: *mut JSContext, arg: *mut JSObject) -> ();
    fn PassCallbackFunction(self, fun: Rc<FunctionBinding::Function>) -> ();
    fn PassCallbackInterface(self, listener: Rc<EventListenerBinding::EventListener>) -> ();
    fn PassNullableBoolean(self, arg: Option<bool>) -> ();
    fn PassNullableByte(self, arg: Option<i8>) -> ();
    fn PassNullableOctet(self, arg: Option<u8>) -> ();
    fn PassNullableShort(self, arg: Option<i16>) -> ();
    fn PassNullableUnsignedShort(self, arg: Option<u16>) -> ();
    fn PassNullableLong(self, arg: Option<i32>) -> ();
    fn PassNullableUnsignedLong(self, arg: Option<u32>) -> ();
    fn PassNullableLongLong(self, arg: Option<i64>) -> ();
    fn PassNullableUnsignedLongLong(self, arg: Option<u64>) -> ();
    fn PassNullableUnrestrictedFloat(self, arg: Option<f32>) -> ();
    fn PassNullableFloat(self, arg: Option<Finite<f32>>) -> ();
    fn PassNullableUnrestrictedDouble(self, arg: Option<f64>) -> ();
    fn PassNullableDouble(self, arg: Option<Finite<f64>>) -> ();
    fn PassNullableString(self, arg: Option<DOMString>) -> ();
    fn PassNullableUsvstring(self, arg: Option<USVString>) -> ();
    fn PassNullableByteString(self, arg: Option<ByteString>) -> ();
    fn PassNullableInterface(self, arg: Option<&Blob>) -> ();
    fn PassNullableObject(self, cx: *mut JSContext, arg: *mut JSObject) -> ();
    fn PassNullableUnion(self, arg: Option<UnionTypes::HTMLElementOrLong >) -> ();
    fn PassNullableUnion2(self, data: Option<UnionTypes::EventOrString >) -> ();
    fn PassNullableCallbackFunction(self, fun: Option<Rc<FunctionBinding::Function>>) -> ();
    fn PassNullableCallbackInterface(self, listener: Option<Rc<EventListenerBinding::EventListener>>) -> ();
    fn PassOptionalBoolean(self, arg: Option<bool>) -> ();
    fn PassOptionalByte(self, arg: Option<i8>) -> ();
    fn PassOptionalOctet(self, arg: Option<u8>) -> ();
    fn PassOptionalShort(self, arg: Option<i16>) -> ();
    fn PassOptionalUnsignedShort(self, arg: Option<u16>) -> ();
    fn PassOptionalLong(self, arg: Option<i32>) -> ();
    fn PassOptionalUnsignedLong(self, arg: Option<u32>) -> ();
    fn PassOptionalLongLong(self, arg: Option<i64>) -> ();
    fn PassOptionalUnsignedLongLong(self, arg: Option<u64>) -> ();
    fn PassOptionalUnrestrictedFloat(self, arg: Option<f32>) -> ();
    fn PassOptionalFloat(self, arg: Option<Finite<f32>>) -> ();
    fn PassOptionalUnrestrictedDouble(self, arg: Option<f64>) -> ();
    fn PassOptionalDouble(self, arg: Option<Finite<f64>>) -> ();
    fn PassOptionalString(self, arg: Option<DOMString>) -> ();
    fn PassOptionalUsvstring(self, arg: Option<USVString>) -> ();
    fn PassOptionalByteString(self, arg: Option<ByteString>) -> ();
    fn PassOptionalEnum(self, arg: Option<TestEnum>) -> ();
    fn PassOptionalInterface(self, arg: Option<&Blob>) -> ();
    fn PassOptionalUnion(self, arg: Option<UnionTypes::HTMLElementOrLong>) -> ();
    fn PassOptionalUnion2(self, data: Option<UnionTypes::EventOrString>) -> ();
    fn PassOptionalAny(self, cx: *mut JSContext, arg: HandleValue) -> ();
    fn PassOptionalObject(self, cx: *mut JSContext, arg: Option<*mut JSObject>) -> ();
    fn PassOptionalCallbackFunction(self, fun: Option<Rc<FunctionBinding::Function>>) -> ();
    fn PassOptionalCallbackInterface(self, listener: Option<Rc<EventListenerBinding::EventListener>>) -> ();
    fn PassOptionalNullableBoolean(self, arg: Option<Option<bool>>) -> ();
    fn PassOptionalNullableByte(self, arg: Option<Option<i8>>) -> ();
    fn PassOptionalNullableOctet(self, arg: Option<Option<u8>>) -> ();
    fn PassOptionalNullableShort(self, arg: Option<Option<i16>>) -> ();
    fn PassOptionalNullableUnsignedShort(self, arg: Option<Option<u16>>) -> ();
    fn PassOptionalNullableLong(self, arg: Option<Option<i32>>) -> ();
    fn PassOptionalNullableUnsignedLong(self, arg: Option<Option<u32>>) -> ();
    fn PassOptionalNullableLongLong(self, arg: Option<Option<i64>>) -> ();
    fn PassOptionalNullableUnsignedLongLong(self, arg: Option<Option<u64>>) -> ();
    fn PassOptionalNullableUnrestrictedFloat(self, arg: Option<Option<f32>>) -> ();
    fn PassOptionalNullableFloat(self, arg: Option<Option<Finite<f32>>>) -> ();
    fn PassOptionalNullableUnrestrictedDouble(self, arg: Option<Option<f64>>) -> ();
    fn PassOptionalNullableDouble(self, arg: Option<Option<Finite<f64>>>) -> ();
    fn PassOptionalNullableString(self, arg: Option<Option<DOMString>>) -> ();
    fn PassOptionalNullableUsvstring(self, arg: Option<Option<USVString>>) -> ();
    fn PassOptionalNullableByteString(self, arg: Option<Option<ByteString>>) -> ();
    fn PassOptionalNullableInterface(self, arg: Option<Option<&Blob>>) -> ();
    fn PassOptionalNullableObject(self, cx: *mut JSContext, arg: Option<*mut JSObject>) -> ();
    fn PassOptionalNullableUnion(self, arg: Option<Option<UnionTypes::HTMLElementOrLong >>) -> ();
    fn PassOptionalNullableUnion2(self, data: Option<Option<UnionTypes::EventOrString >>) -> ();
    fn PassOptionalNullableCallbackFunction(self, fun: Option<Option<Rc<FunctionBinding::Function>>>) -> ();
    fn PassOptionalNullableCallbackInterface(self, listener: Option<Option<Rc<EventListenerBinding::EventListener>>>) -> ();
    fn PassOptionalBooleanWithDefault(self, arg: bool) -> ();
    fn PassOptionalByteWithDefault(self, arg: i8) -> ();
    fn PassOptionalOctetWithDefault(self, arg: u8) -> ();
    fn PassOptionalShortWithDefault(self, arg: i16) -> ();
    fn PassOptionalUnsignedShortWithDefault(self, arg: u16) -> ();
    fn PassOptionalLongWithDefault(self, arg: i32) -> ();
    fn PassOptionalUnsignedLongWithDefault(self, arg: u32) -> ();
    fn PassOptionalLongLongWithDefault(self, arg: i64) -> ();
    fn PassOptionalUnsignedLongLongWithDefault(self, arg: u64) -> ();
    fn PassOptionalStringWithDefault(self, arg: DOMString) -> ();
    fn PassOptionalUsvstringWithDefault(self, arg: USVString) -> ();
    fn PassOptionalEnumWithDefault(self, arg: TestEnum) -> ();
    fn PassOptionalNullableBooleanWithDefault(self, arg: Option<bool>) -> ();
    fn PassOptionalNullableByteWithDefault(self, arg: Option<i8>) -> ();
    fn PassOptionalNullableOctetWithDefault(self, arg: Option<u8>) -> ();
    fn PassOptionalNullableShortWithDefault(self, arg: Option<i16>) -> ();
    fn PassOptionalNullableUnsignedShortWithDefault(self, arg: Option<u16>) -> ();
    fn PassOptionalNullableLongWithDefault(self, arg: Option<i32>) -> ();
    fn PassOptionalNullableUnsignedLongWithDefault(self, arg: Option<u32>) -> ();
    fn PassOptionalNullableLongLongWithDefault(self, arg: Option<i64>) -> ();
    fn PassOptionalNullableUnsignedLongLongWithDefault(self, arg: Option<u64>) -> ();
    fn PassOptionalNullableStringWithDefault(self, arg: Option<DOMString>) -> ();
    fn PassOptionalNullableUsvstringWithDefault(self, arg: Option<USVString>) -> ();
    fn PassOptionalNullableByteStringWithDefault(self, arg: Option<ByteString>) -> ();
    fn PassOptionalNullableInterfaceWithDefault(self, arg: Option<&Blob>) -> ();
    fn PassOptionalNullableObjectWithDefault(self, cx: *mut JSContext, arg: *mut JSObject) -> ();
    fn PassOptionalNullableUnionWithDefault(self, arg: Option<UnionTypes::HTMLElementOrLong >) -> ();
    fn PassOptionalNullableUnion2WithDefault(self, data: Option<UnionTypes::EventOrString >) -> ();
    fn PassOptionalNullableCallbackInterfaceWithDefault(self, listener: Option<Rc<EventListenerBinding::EventListener>>) -> ();
    fn PassOptionalAnyWithDefault(self, cx: *mut JSContext, arg: HandleValue) -> ();
    fn PassOptionalNullableBooleanWithNonNullDefault(self, arg: Option<bool>) -> ();
    fn PassOptionalNullableByteWithNonNullDefault(self, arg: Option<i8>) -> ();
    fn PassOptionalNullableOctetWithNonNullDefault(self, arg: Option<u8>) -> ();
    fn PassOptionalNullableShortWithNonNullDefault(self, arg: Option<i16>) -> ();
    fn PassOptionalNullableUnsignedShortWithNonNullDefault(self, arg: Option<u16>) -> ();
    fn PassOptionalNullableLongWithNonNullDefault(self, arg: Option<i32>) -> ();
    fn PassOptionalNullableUnsignedLongWithNonNullDefault(self, arg: Option<u32>) -> ();
    fn PassOptionalNullableLongLongWithNonNullDefault(self, arg: Option<i64>) -> ();
    fn PassOptionalNullableUnsignedLongLongWithNonNullDefault(self, arg: Option<u64>) -> ();
    fn PassOptionalNullableStringWithNonNullDefault(self, arg: Option<DOMString>) -> ();
    fn PassOptionalNullableUsvstringWithNonNullDefault(self, arg: Option<USVString>) -> ();
    fn PassVariadicBoolean(self, args: Vec<bool>) -> ();
    fn PassVariadicByte(self, args: Vec<i8>) -> ();
    fn PassVariadicOctet(self, args: Vec<u8>) -> ();
    fn PassVariadicShort(self, args: Vec<i16>) -> ();
    fn PassVariadicUnsignedShort(self, args: Vec<u16>) -> ();
    fn PassVariadicLong(self, args: Vec<i32>) -> ();
    fn PassVariadicUnsignedLong(self, args: Vec<u32>) -> ();
    fn PassVariadicLongLong(self, args: Vec<i64>) -> ();
    fn PassVariadicUnsignedLongLong(self, args: Vec<u64>) -> ();
    fn PassVariadicUnrestrictedFloat(self, args: Vec<f32>) -> ();
    fn PassVariadicFloat(self, args: Vec<Finite<f32>>) -> ();
    fn PassVariadicUnrestrictedDouble(self, args: Vec<f64>) -> ();
    fn PassVariadicDouble(self, args: Vec<Finite<f64>>) -> ();
    fn PassVariadicString(self, args: Vec<DOMString>) -> ();
    fn PassVariadicUsvstring(self, args: Vec<USVString>) -> ();
    fn PassVariadicByteString(self, args: Vec<ByteString>) -> ();
    fn PassVariadicEnum(self, args: Vec<TestEnum>) -> ();
    fn PassVariadicUnion(self, args: Vec<UnionTypes::HTMLElementOrLong>) -> ();
    fn PassVariadicUnion2(self, args: Vec<UnionTypes::EventOrString>) -> ();
    fn PassVariadicUnion3(self, args: Vec<UnionTypes::BlobOrString>) -> ();
    fn PassVariadicAny(self, cx: *mut JSContext, args: Vec<HandleValue>) -> ();
    fn PassVariadicObject(self, cx: *mut JSContext, args: Vec<*mut JSObject>) -> ();
}