diff --git a/.clang-format-ignore b/.clang-format-ignore index 9ffc9a09e9da..bb19da090c57 100644 --- a/.clang-format-ignore +++ b/.clang-format-ignore @@ -69,8 +69,7 @@ xpcom/reflect/xptcall/md/unix/.* # Askama template code, which isn't valid C++ in its original form toolkit/components/uniffi-bindgen-gecko-js/src/templates/.* # Generated from that template code -toolkit/components/uniffi-js/UniFFIGeneratedScaffolding.cpp -toolkit/components/uniffi-js/UniFFIFixtureScaffolding.cpp +toolkit/components/uniffi-js/GeneratedScaffolding.cpp # Generated from ./tools/rewriting/ThirdPartyPaths.txt # awk '{print ""$1".*"}' ./tools/rewriting/ThirdPartyPaths.txt diff --git a/.prettierignore b/.prettierignore index 8281c52e2385..0fdcd9b6d58f 100644 --- a/.prettierignore +++ b/.prettierignore @@ -1563,8 +1563,7 @@ toolkit/components/nimbus/schemas/ExperimentFeatureManifest.schema.json toolkit/components/nimbus/schemas/NimbusExperiment.schema.json toolkit/components/pdfjs/PdfJsDefaultPrefs.js toolkit/components/pdfjs/PdfJsOverridePrefs.js -toolkit/components/uniffi-js/UniFFIGeneratedScaffolding.cpp -toolkit/components/uniffi-js/UniFFIFixtureScaffolding.cpp +toolkit/components/uniffi-js/GeneratedScaffolding.cpp toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated tools/@types/tspaths.json tools/browsertime/package.json diff --git a/Cargo.lock b/Cargo.lock index f532d3d39e23..da469fc97869 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2524,6 +2524,7 @@ dependencies = [ name = "gkrust-uniffi-components" version = "0.1.0" dependencies = [ + "hashbrown 0.15.2", "relevancy", "search", "suggest", diff --git a/toolkit/components/uniffi-bindgen-gecko-js/components/Cargo.toml b/toolkit/components/uniffi-bindgen-gecko-js/components/Cargo.toml index 0c27a6747c37..46d1ea0ef352 100644 --- a/toolkit/components/uniffi-bindgen-gecko-js/components/Cargo.toml +++ b/toolkit/components/uniffi-bindgen-gecko-js/components/Cargo.toml @@ -22,6 +22,8 @@ search = "0.1" suggest = "0.1" relevancy = "0.1" webext-storage = "0.1" +# Workaround for https://bugzilla.mozilla.org/show_bug.cgi?id=1959469 +hashbrown = { version = "0.15.2", features = [ "default-hasher" ] } [features] # Should we depend on xpcom crates? diff --git a/toolkit/components/uniffi-bindgen-gecko-js/mach_commands.py b/toolkit/components/uniffi-bindgen-gecko-js/mach_commands.py index e1af82350d01..c72d09a1928a 100644 --- a/toolkit/components/uniffi-bindgen-gecko-js/mach_commands.py +++ b/toolkit/components/uniffi-bindgen-gecko-js/mach_commands.py @@ -7,7 +7,7 @@ import subprocess from mach.decorators import Command, SubCommand -CPP_PATH = "toolkit/components/uniffi-js/UniFFIGeneratedScaffolding.cpp" +CPP_PATH = "toolkit/components/uniffi-js/GeneratedScaffolding.cpp" JS_DIR = "toolkit/components/uniffi-bindgen-gecko-js/components/generated" FIXTURE_JS_DIR = "toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated" DOCS_PATH = "docs/rust-components/api/js/" diff --git a/toolkit/components/uniffi-bindgen-gecko-js/src/render/cpp.rs b/toolkit/components/uniffi-bindgen-gecko-js/src/render/cpp.rs index 2bc575ccfb0f..11b8600b6b65 100644 --- a/toolkit/components/uniffi-bindgen-gecko-js/src/render/cpp.rs +++ b/toolkit/components/uniffi-bindgen-gecko-js/src/render/cpp.rs @@ -93,7 +93,7 @@ impl CPPScaffoldingTemplate { arg_types: ffi_func .arguments() .iter() - .map(|a| cpp_type(&a.type_())) + .map(|a| ffi_type_name(&a.type_())) .chain( ffi_func .has_rust_call_status_arg() @@ -108,7 +108,7 @@ impl CPPScaffoldingTemplate { arg_types: ffi_callback .arguments() .into_iter() - .map(|a| cpp_type(&a.type_())) + .map(|a| ffi_type_name(&a.type_())) .chain( ffi_callback .has_rust_call_status_arg() @@ -125,7 +125,7 @@ impl CPPScaffoldingTemplate { .into_iter() .map(|f| FfiFieldCpp { name: f.name().to_snake_case(), - type_: cpp_type(&f.type_()), + type_: ffi_type_name(&f.type_()), }) .collect(), }), @@ -142,6 +142,7 @@ impl CPPScaffoldingTemplate { .map(move |obj| PointerType { object_id: object_ids.get(&c.ci, obj), name: pointer_type(&c.ci.namespace(), obj.name()), + ffi_value_class: pointer_ffi_value_class(&c.ci.namespace(), obj.name()), label: format!("{}::{}", c.ci.namespace(), obj.name()), clone_fn: obj.ffi_object_clone().name().to_string(), free_fn: obj.ffi_object_free().name().to_string(), @@ -182,7 +183,7 @@ impl CPPScaffoldingTemplate { let cbi_name_snake = cbi.name().to_snake_case(); CallbackInterfaceVTable { - type_: cpp_type(&cbi.vtable()), + type_: ffi_type_name(&cbi.vtable()), var_name: format!("kCallbackInterfaceVtable{cbi_name}"), method_handlers: cbi .vtable_methods() @@ -196,13 +197,13 @@ impl CPPScaffoldingTemplate { arguments: method .arguments() .iter() - .map(|arg| CallbackMethodArgument { - name: arg.name().to_snake_case(), - type_: cpp_type(&arg.as_type().into()), - scaffolding_converter: scaffolding_converter( - ci, - &arg.as_type().into(), - ), + .map(|arg| { + let ffi_type = arg.as_type().into(); + CallbackMethodArgument { + name: arg.name().to_snake_case(), + ffi_type: ffi_type_name(&ffi_type), + ffi_value_class: ffi_value_class(ci, &ffi_type), + } }) .collect(), } @@ -297,6 +298,7 @@ struct FfiFieldCpp { struct PointerType { object_id: usize, name: String, + ffi_value_class: String, label: String, clone_fn: String, free_fn: String, @@ -337,8 +339,8 @@ struct CallbackMethodHandler { struct CallbackMethodArgument { name: String, - type_: String, - scaffolding_converter: String, + ffi_type: String, + ffi_value_class: String, } struct ScaffoldingCall { @@ -366,7 +368,7 @@ impl ScaffoldingCall { .into_iter() .map(|a| ScaffoldingCallArgument { var_name: format!("m{}", a.name().to_upper_camel_case()), - scaffolding_converter: scaffolding_converter(ci, &a.type_()), + ffi_value_class: ffi_value_class(ci, &a.type_()), }) .collect::>(); @@ -384,8 +386,9 @@ impl ScaffoldingCall { // function always returns a handle. return_type: callable .return_type() + .map(|return_type| FfiType::from(return_type)) .map(|return_type| ScaffoldingCallReturnType { - scaffolding_converter: scaffolding_converter(ci, &return_type.into()), + ffi_value_class: ffi_value_class(ci, &return_type), }), arguments, async_info, @@ -398,12 +401,12 @@ impl ScaffoldingCall { } struct ScaffoldingCallReturnType { - scaffolding_converter: String, + ffi_value_class: String, } struct ScaffoldingCallArgument { var_name: String, - scaffolding_converter: String, + ffi_value_class: String, } struct ScaffoldingCallAsyncInfo { @@ -412,7 +415,7 @@ struct ScaffoldingCallAsyncInfo { free_fn: String, } -fn scaffolding_converter(ci: &ComponentInterface, ffi_type: &FfiType) -> String { +fn ffi_value_class(ci: &ComponentInterface, ffi_type: &FfiType) -> String { match ffi_type { FfiType::RustArcPtr(name) => { // Check if this is an external type @@ -420,18 +423,24 @@ fn scaffolding_converter(ci: &ComponentInterface, ffi_type: &FfiType) -> String let external_ty_name = ty.name().expect("External type without name"); let crate_name = ty.module_path().expect("External type without module path"); if external_ty_name == name { - return format!( - "ScaffoldingObjectConverter<&{}>", - pointer_type(crate_name_to_namespace(&crate_name), name), - ); + return pointer_ffi_value_class(crate_name_to_namespace(&crate_name), name); } } - format!( - "ScaffoldingObjectConverter<&{}>", - pointer_type(ci.namespace(), name), - ) + pointer_ffi_value_class(ci.namespace(), name) } - _ => format!("ScaffoldingConverter<{}>", cpp_type(ffi_type)), + FfiType::UInt8 + | FfiType::Int8 + | FfiType::UInt16 + | FfiType::Int16 + | FfiType::UInt32 + | FfiType::Int32 + | FfiType::UInt64 + | FfiType::Int64 => format!("FfiValueInt<{}>", ffi_type_name(ffi_type)), + FfiType::Float32 | FfiType::Float64 => { + format!("FfiValueFloat<{}>", ffi_type_name(ffi_type)) + } + FfiType::RustBuffer(_) => "FfiValueRustBuffer".to_owned(), + _ => format!("FfiConverter<{}>", ffi_type_name(ffi_type)), } } @@ -443,8 +452,16 @@ fn pointer_type(namespace: &str, name: &str) -> String { ) } -// Type for the Rust scaffolding code -fn cpp_type(ffi_type: &FfiType) -> String { +fn pointer_ffi_value_class(namespace: &str, name: &str) -> String { + format!( + "FfiValueObjectHandle{}{}", + namespace.to_upper_camel_case(), + name.to_upper_camel_case() + ) +} + +// C++ type for an FFI value +fn ffi_type_name(ffi_type: &FfiType) -> String { match ffi_type { FfiType::UInt8 => "uint8_t".to_owned(), FfiType::Int8 => "int8_t".to_owned(), @@ -464,14 +481,14 @@ fn cpp_type(ffi_type: &FfiType) -> String { FfiType::Callback(name) | FfiType::Struct(name) => name.to_owned(), FfiType::VoidPointer => "void*".to_owned(), FfiType::MutReference(inner) | FfiType::Reference(inner) => { - format!("{}*", cpp_type(inner.as_ref())) + format!("{}*", ffi_type_name(inner.as_ref())) } } } fn return_type(ffi_type: Option<&FfiType>) -> String { match ffi_type { - Some(t) => cpp_type(t), + Some(t) => ffi_type_name(t), None => "void".to_owned(), } } diff --git a/toolkit/components/uniffi-bindgen-gecko-js/src/templates/UniFFIScaffolding.cpp b/toolkit/components/uniffi-bindgen-gecko-js/src/templates/UniFFIScaffolding.cpp index a4839eec9d09..d4f5811a9547 100644 --- a/toolkit/components/uniffi-bindgen-gecko-js/src/templates/UniFFIScaffolding.cpp +++ b/toolkit/components/uniffi-bindgen-gecko-js/src/templates/UniFFIScaffolding.cpp @@ -10,12 +10,12 @@ #include "mozilla/StaticPtr.h" #include "mozilla/UniquePtr.h" #include "mozilla/dom/Promise.h" -#include "mozilla/dom/ScaffoldingConverter.h" -#include "mozilla/dom/UniFFICall.h" -#include "mozilla/dom/UniFFICallbacks.h" -#include "mozilla/dom/UniFFIPointerType.h" +#include "mozilla/uniffi/Call.h" +#include "mozilla/uniffi/Callbacks.h" +#include "mozilla/uniffi/FfiValue.h" +#include "mozilla/uniffi/PointerType.h" #include "mozilla/dom/UniFFIScaffolding.h" -#include "mozilla/dom/UniFFIRust.h" +#include "mozilla/uniffi/Rust.h" namespace mozilla::uniffi { @@ -53,7 +53,7 @@ extern "C" { {%- endfor %} } -// Define pointer types +// Define pointer types and FfiValueObjectHandle* classes {%- for (preprocessor_condition, pointer_types, preprocessor_condition_end) in all_pointer_types.iter() %} {{ preprocessor_condition }} {%- for pointer_type in pointer_types %} @@ -62,6 +62,75 @@ const static mozilla::uniffi::UniFFIPointerType {{ pointer_type.name }} { {{ pointer_type.clone_fn }}, {{ pointer_type.free_fn }}, }; + +class {{ pointer_type.ffi_value_class }} { + private: + void* mValue = nullptr; + + public: + {{ pointer_type.ffi_value_class }}() = default; + explicit {{ pointer_type.ffi_value_class }}(void* aValue) : mValue(aValue) {} + + // Delete copy constructor and assignment as this type is non-copyable. + {{ pointer_type.ffi_value_class }}(const {{ pointer_type.ffi_value_class }}&) = delete; + {{ pointer_type.ffi_value_class }}& operator=(const {{ pointer_type.ffi_value_class }}&) = delete; + + {{ pointer_type.ffi_value_class }}& operator=({{ pointer_type.ffi_value_class }}&& aOther) { + FreeHandle(); + mValue = aOther.mValue; + aOther.mValue = nullptr; + return *this; + } + + void Lower(const dom::OwningUniFFIScaffoldingValue& aValue, + ErrorResult& aError) { + if (!aValue.IsUniFFIPointer()) { + aError.ThrowTypeError("Expected UniFFI pointer argument"_ns); + return; + } + dom::UniFFIPointer& value = aValue.GetAsUniFFIPointer(); + if (!value.IsSamePtrType(&{{ pointer_type.name }})) { + aError.ThrowTypeError("Incorrect UniFFI pointer type"_ns); + return; + } + FreeHandle(); + mValue = value.ClonePtr(); + } + + void Lift(JSContext* aContext, dom::OwningUniFFIScaffoldingValue* aDest, + ErrorResult& aError) { + aDest->SetAsUniFFIPointer() = + dom::UniFFIPointer::Create(mValue, &{{ pointer_type.name }}); + mValue = nullptr; + } + + void* IntoRust() { + auto temp = mValue; + mValue = nullptr; + return temp; + } + + static {{ pointer_type.ffi_value_class }} FromRust(void* aValue) { + return {{ pointer_type.ffi_value_class }}(aValue); + } + + void FreeHandle() { + if (mValue) { + RustCallStatus callStatus{}; + ({{ pointer_type.free_fn }})(mValue, &callStatus); + // No need to check `RustCallStatus`, it's only part of the API to match + // other FFI calls. The free function can never fail. + } + } + + ~{{ pointer_type.ffi_value_class }}() { + // If the pointer is non-null, this means Lift/IntoRust was never called + // because there was some failure along the way. Free the pointer to avoid a + // leak + FreeHandle(); + } +}; + {%- endfor %} {{ preprocessor_condition_end }} {%- endfor %} @@ -78,15 +147,15 @@ static StaticRefPtr {{ cbi.js_handler_var }}; class {{ handler.class_name }} : public UniffiCallbackMethodHandlerBase { private: - // Rust arguments, converted using ScaffoldingConverter::FromRust. + // Rust arguments {%- for a in handler.arguments %} - typename {{ a.scaffolding_converter }}::IntermediateType {{ a.name }}; + {{ a.ffi_value_class }} {{ a.name }}{}; {%- endfor %} public: - {{ handler.class_name }}(size_t aObjectHandle{%- for a in handler.arguments %}, {{ a.type_ }} {{ a.name }}{%- endfor %}) + {{ handler.class_name }}(size_t aObjectHandle{%- for a in handler.arguments %}, {{ a.ffi_type }} {{ a.name }}{%- endfor %}) : UniffiCallbackMethodHandlerBase("{{ cbi.name }}", aObjectHandle) - {%- for a in handler.arguments %}, {{ a.name }}({{ a.scaffolding_converter }}::FromRust({{ a.name }})){% endfor %} { + {%- for a in handler.arguments %}, {{ a.name }}({{ a.ffi_value_class }}::FromRust({{ a.name }})){% endfor %} { } MOZ_CAN_RUN_SCRIPT @@ -102,9 +171,8 @@ public: // Convert each argument {%- for a in handler.arguments %} - {{ a.scaffolding_converter }}::IntoJs( + {{ a.name }}.Lift( aCx, - std::move(this->{{ a.name }}), &uniffiArgs[{{ loop.index0 }}], aError); if (aError.Failed()) { @@ -123,7 +191,7 @@ public: extern "C" void {{ handler.fn_name }}( uint64_t uniffiHandle, - {% for a in handler.arguments %}{{ a.type_ }} {{ a.name }}, {% endfor %} + {% for a in handler.arguments %}{{ a.ffi_type }} {{ a.name }}, {% endfor %} void* uniffiOutReturn, RustCallStatus* uniffiCallStatus ) { @@ -223,20 +291,20 @@ class {{ scaffolding_call.handler_class_name }} : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields {%- for arg in scaffolding_call.arguments %} - typename {{ arg.scaffolding_converter }}::IntermediateType {{ arg.var_name }}; + {{ arg.ffi_value_class }} {{ arg.var_name }}{}; {%- endfor %} // MakeRustCall stores the result of the call in these fields {%- match scaffolding_call.return_type %} {%- when Some(return_type) %} - typename {{ return_type.scaffolding_converter }}::IntermediateType mUniffiReturnValue; + {{ return_type.ffi_value_class }} mUniffiReturnValue{}; {%- else %} {%- endmatch %} public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { {%- for arg in scaffolding_call.arguments %} - {{ arg.scaffolding_converter }}::FromJs(aArgs[{{ loop.index0 }}], &{{ arg.var_name }}, aError); + {{ arg.var_name }}.Lower(aArgs[{{ loop.index0 }}], aError); if (aError.Failed()) { return; } @@ -246,10 +314,10 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { {%- match scaffolding_call.return_type %} {%- when Some(return_type) %} - mUniffiReturnValue = {{ return_type.scaffolding_converter }}::FromRust( + mUniffiReturnValue = {{ return_type.ffi_value_class }}::FromRust( {{ scaffolding_call.ffi_func_name }}( {%- for arg in scaffolding_call.arguments %} - {{ arg.scaffolding_converter }}::IntoRust(std::move({{ arg.var_name }})), + {{ arg.var_name }}.IntoRust(), {%- endfor %} aOutStatus ) @@ -257,7 +325,7 @@ public: {%- else %} {{ scaffolding_call.ffi_func_name }}( {%- for arg in scaffolding_call.arguments %} - {{ arg.scaffolding_converter }}::IntoRust(std::move({{ arg.var_name }})), + {{ arg.var_name }}.IntoRust(), {%- endfor %} aOutStatus ); @@ -267,9 +335,8 @@ public: virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { {%- match scaffolding_call.return_type %} {%- when Some(return_type) %} - {{ return_type.scaffolding_converter }}::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -286,7 +353,7 @@ private: // Complete stores the result of the call in mUniffiReturnValue {%- match scaffolding_call.return_type %} {%- when Some(return_type) %} - typename {{ return_type.scaffolding_converter }}::IntermediateType mUniffiReturnValue; + {{ return_type.ffi_value_class }} mUniffiReturnValue{}; {%- else %} {%- endmatch %} @@ -296,8 +363,8 @@ protected: // return a future. void PrepareArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { {%- for arg in scaffolding_call.arguments %} - typename {{ arg.scaffolding_converter }}::IntermediateType {{ arg.var_name }}; - {{ arg.scaffolding_converter }}::FromJs(aArgs[{{ loop.index0 }}], &{{ arg.var_name }}, aError); + {{ arg.ffi_value_class }} {{ arg.var_name }}{}; + {{ arg.var_name }}.Lower(aArgs[{{ loop.index0 }}], aError); if (aError.Failed()) { return; } @@ -305,7 +372,7 @@ protected: mFutureHandle = {{ scaffolding_call.ffi_func_name }}( {%- for arg in scaffolding_call.arguments %} - {{ arg.scaffolding_converter }}::IntoRust(std::move({{ arg.var_name }})){% if !loop.last %},{% endif %} + {{ arg.var_name }}.IntoRust(){% if !loop.last %},{% endif %} {%- endfor %} ); } @@ -313,7 +380,7 @@ protected: void CallCompleteFn(RustCallStatus* aOutStatus) override { {%- match scaffolding_call.return_type %} {%- when Some(return_type) %} - mUniffiReturnValue = {{ return_type.scaffolding_converter }}::FromRust( + mUniffiReturnValue = {{ return_type.ffi_value_class }}::FromRust( {{ async_info.complete_fn }}(mFutureHandle, aOutStatus)); {%- else %} {{ async_info.complete_fn }}(mFutureHandle, aOutStatus); @@ -324,9 +391,8 @@ public: void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { {%- match scaffolding_call.return_type %} {%- when Some(return_type) %} - {{ return_type.scaffolding_converter }}::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); diff --git a/toolkit/components/uniffi-js/UniFFICall.cpp b/toolkit/components/uniffi-js/Call.cpp similarity index 93% rename from toolkit/components/uniffi-js/UniFFICall.cpp rename to toolkit/components/uniffi-js/Call.cpp index e09a24920204..a9c1bf31074b 100644 --- a/toolkit/components/uniffi-js/UniFFICall.cpp +++ b/toolkit/components/uniffi-js/Call.cpp @@ -7,7 +7,7 @@ #include "nsThreadUtils.h" #include "mozilla/dom/Promise.h" #include "mozilla/dom/RootedDictionary.h" -#include "mozilla/dom/UniFFICall.h" +#include "mozilla/uniffi/Call.h" namespace mozilla::uniffi { extern mozilla::LazyLogModule gUniffiLogger; @@ -32,7 +32,8 @@ void UniffiSyncCallHandler::CallSync( aHandler->MakeRustCall(&callStatus); aHandler->mUniffiCallStatusCode = callStatus.code; if (callStatus.error_buf.data) { - aHandler->mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf); + aHandler->mUniffiCallStatusErrorBuf = + FfiValueRustBuffer(callStatus.error_buf); } aHandler->ExtractCallResult(aGlobal.Context(), aReturnValue, aError); } @@ -71,7 +72,7 @@ already_AddRefed UniffiSyncCallHandler::CallAsyncWrapper( handler->mUniffiCallStatusCode = callStatus.code; if (callStatus.error_buf.data) { handler->mUniffiCallStatusErrorBuf = - OwnedRustBuffer(callStatus.error_buf); + FfiValueRustBuffer(callStatus.error_buf); } taskPromise->Resolve(std::move(handler), __func__); }), @@ -125,13 +126,7 @@ void UniffiCallHandlerBase::ExtractCallResult( // Rust Err() value. Populate data with the `RustBuffer` containing the // error aDest.mCode = dom::UniFFIScaffoldingCallCode::Error; - - JS::Rooted obj(aCx); - mUniffiCallStatusErrorBuf.IntoArrayBuffer(aCx, &obj, aError); - if (aError.Failed()) { - break; - } - aDest.mData.Construct().SetAsArrayBuffer().Init(obj); + mUniffiCallStatusErrorBuf.Lift(aCx, &aDest.mData.Construct(), aError); break; } @@ -139,13 +134,8 @@ void UniffiCallHandlerBase::ExtractCallResult( // This indicates a RustError, which should rarely happen in practice. // The normal case is a Rust panic, but FF sets panic=abort. aDest.mCode = dom::UniFFIScaffoldingCallCode::Internal_error; - if (mUniffiCallStatusErrorBuf.IsValid()) { - JS::Rooted obj(aCx); - mUniffiCallStatusErrorBuf.IntoArrayBuffer(aCx, &obj, aError); - if (aError.Failed()) { - break; - } - aDest.mData.Construct().SetAsArrayBuffer().Init(obj); + if (mUniffiCallStatusErrorBuf.IsSet()) { + mUniffiCallStatusErrorBuf.Lift(aCx, &aDest.mData.Construct(), aError); } break; @@ -283,7 +273,8 @@ void UniffiAsyncCallHandler::Finish( aHandler->CallCompleteFn(&callStatus); aHandler->mUniffiCallStatusCode = callStatus.code; if (callStatus.error_buf.data) { - aHandler->mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf); + aHandler->mUniffiCallStatusErrorBuf = + FfiValueRustBuffer(callStatus.error_buf); } aHandler->ExtractCallResult(aes.cx(), returnValue, error); error.WouldReportJSException(); diff --git a/toolkit/components/uniffi-js/UniFFICall.h b/toolkit/components/uniffi-js/Call.h similarity index 97% rename from toolkit/components/uniffi-js/UniFFICall.h rename to toolkit/components/uniffi-js/Call.h index d10c1eeaf8bb..2aacc932e32a 100644 --- a/toolkit/components/uniffi-js/UniFFICall.h +++ b/toolkit/components/uniffi-js/Call.h @@ -9,9 +9,10 @@ #include "mozilla/RefPtr.h" #include "mozilla/UniquePtr.h" -#include "mozilla/dom/OwnedRustBuffer.h" -#include "mozilla/dom/UniFFIRust.h" #include "mozilla/dom/UniFFIScaffolding.h" +#include "mozilla/uniffi/OwnedRustBuffer.h" +#include "mozilla/uniffi/FfiValue.h" +#include "mozilla/uniffi/Rust.h" namespace mozilla::uniffi { @@ -59,7 +60,7 @@ class UniffiCallHandlerBase { // Call status from the rust call int8_t mUniffiCallStatusCode = RUST_CALL_SUCCESS; - OwnedRustBuffer mUniffiCallStatusErrorBuf; + FfiValueRustBuffer mUniffiCallStatusErrorBuf; }; // Call scaffolding functions for synchronous Rust calls diff --git a/toolkit/components/uniffi-js/UniFFICallbacks.cpp b/toolkit/components/uniffi-js/Callbacks.cpp similarity index 96% rename from toolkit/components/uniffi-js/UniFFICallbacks.cpp rename to toolkit/components/uniffi-js/Callbacks.cpp index 14b5ab5ab31a..0cc8c4935172 100644 --- a/toolkit/components/uniffi-js/UniFFICallbacks.cpp +++ b/toolkit/components/uniffi-js/Callbacks.cpp @@ -7,10 +7,10 @@ #include "nsPrintfCString.h" #include "nsString.h" #include "nsThreadUtils.h" -#include "mozilla/dom/OwnedRustBuffer.h" +#include "mozilla/uniffi/OwnedRustBuffer.h" #include "mozilla/dom/RootedDictionary.h" #include "mozilla/dom/UniFFIBinding.h" -#include "mozilla/dom/UniFFICallbacks.h" +#include "mozilla/uniffi/Callbacks.h" #include "mozilla/Maybe.h" #include "mozilla/Logging.h" #include "mozilla/RefPtr.h" diff --git a/toolkit/components/uniffi-js/UniFFICallbacks.h b/toolkit/components/uniffi-js/Callbacks.h similarity index 99% rename from toolkit/components/uniffi-js/UniFFICallbacks.h rename to toolkit/components/uniffi-js/Callbacks.h index 6fba413f891f..67f49786ce6b 100644 --- a/toolkit/components/uniffi-js/UniFFICallbacks.h +++ b/toolkit/components/uniffi-js/Callbacks.h @@ -9,8 +9,8 @@ #include "mozilla/StaticPtr.h" #include "mozilla/UniquePtr.h" -#include "mozilla/dom/UniFFIRust.h" #include "mozilla/dom/UniFFIScaffolding.h" +#include "mozilla/uniffi/Rust.h" namespace mozilla::uniffi { diff --git a/toolkit/components/uniffi-js/FfiValue.h b/toolkit/components/uniffi-js/FfiValue.h new file mode 100644 index 000000000000..164584b33836 --- /dev/null +++ b/toolkit/components/uniffi-js/FfiValue.h @@ -0,0 +1,160 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_UniFFIFfiConverter_h +#define mozilla_UniFFIFfiConverter_h + +#include +#include +#include "nsString.h" +#include "mozilla/ResultVariant.h" +#include "mozilla/dom/PrimitiveConversions.h" +#include "mozilla/dom/TypedArray.h" +#include "mozilla/dom/UniFFIBinding.h" +#include "mozilla/dom/UniFFIPointer.h" +#include "mozilla/dom/UniFFIScaffolding.h" +#include "mozilla/uniffi/OwnedRustBuffer.h" +#include "mozilla/uniffi/PointerType.h" +#include "mozilla/uniffi/Rust.h" + +namespace mozilla::uniffi { + +// This header defines the `FfiValue*` classes, which handle conversions between +// FFI values and the JS `OwningUniFFIScaffoldingValue` class. +// +// The exact signatures vary slightly, but in all FfiValue classes define these +// functions: +// - `Lower` -- Convert a `OwningUniFFIScaffoldingValue` into an `FfiValue`. +// - `Lift` -- Convert a `FfiValue` into a `OwningUniFFIScaffoldingValue`. +// - `IntoRust` -- Convert a `FfiValue` into a raw FFI type to pass to Rust +// - `FromRust` -- Convert a raw FFI type from Rust into a `FfiValue` +// +// Also, each `FfiValue` class defines a default constructor. +// For types that hold resources like `FfiValueRustBuffer`, `Lift` and +// `IntoRust` move resources out of the value, leaving behind the default. + +// FfiValue class for integer values +template +class FfiValueInt { + private: + T mValue = 0; + + public: + FfiValueInt() = default; + explicit FfiValueInt(T aValue) : mValue(aValue) {} + + void Lower(const dom::OwningUniFFIScaffoldingValue& aValue, + ErrorResult& aError) { + if (!aValue.IsDouble()) { + aError.ThrowTypeError("Bad argument type"_ns); + return; + } + double floatValue = aValue.GetAsDouble(); + + // Use PrimitiveConversionTraits_Limits rather than std::numeric_limits, + // since it handles JS-specific bounds like the 64-bit integer limits. + // (see Number.MAX_SAFE_INTEGER and Number.MIN_SAFE_INTEGER) + if (floatValue < dom::PrimitiveConversionTraits_Limits::min() || + floatValue > dom::PrimitiveConversionTraits_Limits::max()) { + aError.ThrowRangeError("Integer value is out of range"_ns); + return; + } + + T intValue = static_cast(floatValue); + if (intValue != floatValue) { + aError.ThrowTypeError("Not an integer"_ns); + return; + } + mValue = intValue; + } + + void Lift(JSContext* aContext, dom::OwningUniFFIScaffoldingValue* aDest, + ErrorResult& aError) { + if (mValue < dom::PrimitiveConversionTraits_Limits::min() || + mValue > dom::PrimitiveConversionTraits_Limits::max()) { + aError.ThrowRangeError( + "64-bit value cannot be precisely represented in JS"_ns); + return; + } + aDest->SetAsDouble() = mValue; + } + + T IntoRust() { return mValue; } + + static FfiValueInt FromRust(T aValue) { return FfiValueInt(aValue); }; +}; + +// FfiValue class for floating point values +template +class FfiValueFloat { + private: + T mValue = 0.0; + + public: + FfiValueFloat() = default; + explicit FfiValueFloat(T aValue) : mValue(aValue) {} + + void Lower(const dom::OwningUniFFIScaffoldingValue& aValue, + ErrorResult& aError) { + if (!aValue.IsDouble()) { + aError.ThrowTypeError("Bad argument type"_ns); + return; + } + mValue = aValue.GetAsDouble(); + } + + void Lift(JSContext* aContext, dom::OwningUniFFIScaffoldingValue* aDest, + ErrorResult& aError) { + aDest->SetAsDouble() = mValue; + } + + T IntoRust() { return mValue; } + + static FfiValueFloat FromRust(T aValue) { return FfiValueFloat(aValue); } +}; + +class FfiValueRustBuffer { + private: + OwnedRustBuffer mValue; + + public: + FfiValueRustBuffer() = default; + explicit FfiValueRustBuffer(RustBuffer aValue) + : mValue(OwnedRustBuffer(aValue)) {} + explicit FfiValueRustBuffer(OwnedRustBuffer aValue) + : mValue(std::move(aValue)) {} + + void Lower(const dom::OwningUniFFIScaffoldingValue& aValue, + ErrorResult& aError) { + if (!aValue.IsArrayBuffer()) { + aError.ThrowTypeError("Expected ArrayBuffer argument"_ns); + return; + } + mValue = OwnedRustBuffer::FromArrayBuffer(aValue.GetAsArrayBuffer()); + } + + void Lift(JSContext* aContext, dom::OwningUniFFIScaffoldingValue* aDest, + ErrorResult& aError) { + JS::Rooted obj(aContext); + mValue.IntoArrayBuffer(aContext, &obj, aError); + if (aError.Failed()) { + return; + } + aDest->SetAsArrayBuffer().Init(obj); + } + + RustBuffer IntoRust() { return mValue.IntoRustBuffer(); } + + static FfiValueRustBuffer FromRust(RustBuffer aValue) { + return FfiValueRustBuffer(OwnedRustBuffer(aValue)); + } + + bool IsSet() { return mValue.IsValid(); } +}; + +} // namespace mozilla::uniffi + +#endif // mozilla_UniFFIFfiConverter_h diff --git a/toolkit/components/uniffi-js/UniFFIGeneratedScaffolding.cpp b/toolkit/components/uniffi-js/GeneratedScaffolding.cpp similarity index 73% rename from toolkit/components/uniffi-js/UniFFIGeneratedScaffolding.cpp rename to toolkit/components/uniffi-js/GeneratedScaffolding.cpp index 582dc3ac06e4..01f20a148166 100644 --- a/toolkit/components/uniffi-js/UniFFIGeneratedScaffolding.cpp +++ b/toolkit/components/uniffi-js/GeneratedScaffolding.cpp @@ -10,12 +10,12 @@ #include "mozilla/StaticPtr.h" #include "mozilla/UniquePtr.h" #include "mozilla/dom/Promise.h" -#include "mozilla/dom/ScaffoldingConverter.h" -#include "mozilla/dom/UniFFICall.h" -#include "mozilla/dom/UniFFICallbacks.h" -#include "mozilla/dom/UniFFIPointerType.h" +#include "mozilla/uniffi/Call.h" +#include "mozilla/uniffi/Callbacks.h" +#include "mozilla/uniffi/FfiValue.h" +#include "mozilla/uniffi/PointerType.h" #include "mozilla/dom/UniFFIScaffolding.h" -#include "mozilla/dom/UniFFIRust.h" +#include "mozilla/uniffi/Rust.h" namespace mozilla::uniffi { @@ -1725,125 +1725,1689 @@ extern "C" { #endif /* MOZ_UNIFFI_FIXTURES */ } -// Define pointer types +// Define pointer types and FfiValueObjectHandle* classes const static mozilla::uniffi::UniFFIPointerType kRelevancyRelevancyStorePointerType { "relevancy::RelevancyStore"_ns, uniffi_relevancy_fn_clone_relevancystore, uniffi_relevancy_fn_free_relevancystore, }; + +class FfiValueObjectHandleRelevancyRelevancyStore { + private: + void* mValue = nullptr; + + public: + FfiValueObjectHandleRelevancyRelevancyStore() = default; + explicit FfiValueObjectHandleRelevancyRelevancyStore(void* aValue) : mValue(aValue) {} + + // Delete copy constructor and assignment as this type is non-copyable. + FfiValueObjectHandleRelevancyRelevancyStore(const FfiValueObjectHandleRelevancyRelevancyStore&) = delete; + FfiValueObjectHandleRelevancyRelevancyStore& operator=(const FfiValueObjectHandleRelevancyRelevancyStore&) = delete; + + FfiValueObjectHandleRelevancyRelevancyStore& operator=(FfiValueObjectHandleRelevancyRelevancyStore&& aOther) { + FreeHandle(); + mValue = aOther.mValue; + aOther.mValue = nullptr; + return *this; + } + + void Lower(const dom::OwningUniFFIScaffoldingValue& aValue, + ErrorResult& aError) { + if (!aValue.IsUniFFIPointer()) { + aError.ThrowTypeError("Expected UniFFI pointer argument"_ns); + return; + } + dom::UniFFIPointer& value = aValue.GetAsUniFFIPointer(); + if (!value.IsSamePtrType(&kRelevancyRelevancyStorePointerType)) { + aError.ThrowTypeError("Incorrect UniFFI pointer type"_ns); + return; + } + FreeHandle(); + mValue = value.ClonePtr(); + } + + void Lift(JSContext* aContext, dom::OwningUniFFIScaffoldingValue* aDest, + ErrorResult& aError) { + aDest->SetAsUniFFIPointer() = + dom::UniFFIPointer::Create(mValue, &kRelevancyRelevancyStorePointerType); + mValue = nullptr; + } + + void* IntoRust() { + auto temp = mValue; + mValue = nullptr; + return temp; + } + + static FfiValueObjectHandleRelevancyRelevancyStore FromRust(void* aValue) { + return FfiValueObjectHandleRelevancyRelevancyStore(aValue); + } + + void FreeHandle() { + if (mValue) { + RustCallStatus callStatus{}; + (uniffi_relevancy_fn_free_relevancystore)(mValue, &callStatus); + // No need to check `RustCallStatus`, it's only part of the API to match + // other FFI calls. The free function can never fail. + } + } + + ~FfiValueObjectHandleRelevancyRelevancyStore() { + // If the pointer is non-null, this means Lift/IntoRust was never called + // because there was some failure along the way. Free the pointer to avoid a + // leak + FreeHandle(); + } +}; const static mozilla::uniffi::UniFFIPointerType kRemoteSettingsRemoteSettingsPointerType { "remote_settings::RemoteSettings"_ns, uniffi_remote_settings_fn_clone_remotesettings, uniffi_remote_settings_fn_free_remotesettings, }; + +class FfiValueObjectHandleRemoteSettingsRemoteSettings { + private: + void* mValue = nullptr; + + public: + FfiValueObjectHandleRemoteSettingsRemoteSettings() = default; + explicit FfiValueObjectHandleRemoteSettingsRemoteSettings(void* aValue) : mValue(aValue) {} + + // Delete copy constructor and assignment as this type is non-copyable. + FfiValueObjectHandleRemoteSettingsRemoteSettings(const FfiValueObjectHandleRemoteSettingsRemoteSettings&) = delete; + FfiValueObjectHandleRemoteSettingsRemoteSettings& operator=(const FfiValueObjectHandleRemoteSettingsRemoteSettings&) = delete; + + FfiValueObjectHandleRemoteSettingsRemoteSettings& operator=(FfiValueObjectHandleRemoteSettingsRemoteSettings&& aOther) { + FreeHandle(); + mValue = aOther.mValue; + aOther.mValue = nullptr; + return *this; + } + + void Lower(const dom::OwningUniFFIScaffoldingValue& aValue, + ErrorResult& aError) { + if (!aValue.IsUniFFIPointer()) { + aError.ThrowTypeError("Expected UniFFI pointer argument"_ns); + return; + } + dom::UniFFIPointer& value = aValue.GetAsUniFFIPointer(); + if (!value.IsSamePtrType(&kRemoteSettingsRemoteSettingsPointerType)) { + aError.ThrowTypeError("Incorrect UniFFI pointer type"_ns); + return; + } + FreeHandle(); + mValue = value.ClonePtr(); + } + + void Lift(JSContext* aContext, dom::OwningUniFFIScaffoldingValue* aDest, + ErrorResult& aError) { + aDest->SetAsUniFFIPointer() = + dom::UniFFIPointer::Create(mValue, &kRemoteSettingsRemoteSettingsPointerType); + mValue = nullptr; + } + + void* IntoRust() { + auto temp = mValue; + mValue = nullptr; + return temp; + } + + static FfiValueObjectHandleRemoteSettingsRemoteSettings FromRust(void* aValue) { + return FfiValueObjectHandleRemoteSettingsRemoteSettings(aValue); + } + + void FreeHandle() { + if (mValue) { + RustCallStatus callStatus{}; + (uniffi_remote_settings_fn_free_remotesettings)(mValue, &callStatus); + // No need to check `RustCallStatus`, it's only part of the API to match + // other FFI calls. The free function can never fail. + } + } + + ~FfiValueObjectHandleRemoteSettingsRemoteSettings() { + // If the pointer is non-null, this means Lift/IntoRust was never called + // because there was some failure along the way. Free the pointer to avoid a + // leak + FreeHandle(); + } +}; const static mozilla::uniffi::UniFFIPointerType kRemoteSettingsRemoteSettingsClientPointerType { "remote_settings::RemoteSettingsClient"_ns, uniffi_remote_settings_fn_clone_remotesettingsclient, uniffi_remote_settings_fn_free_remotesettingsclient, }; + +class FfiValueObjectHandleRemoteSettingsRemoteSettingsClient { + private: + void* mValue = nullptr; + + public: + FfiValueObjectHandleRemoteSettingsRemoteSettingsClient() = default; + explicit FfiValueObjectHandleRemoteSettingsRemoteSettingsClient(void* aValue) : mValue(aValue) {} + + // Delete copy constructor and assignment as this type is non-copyable. + FfiValueObjectHandleRemoteSettingsRemoteSettingsClient(const FfiValueObjectHandleRemoteSettingsRemoteSettingsClient&) = delete; + FfiValueObjectHandleRemoteSettingsRemoteSettingsClient& operator=(const FfiValueObjectHandleRemoteSettingsRemoteSettingsClient&) = delete; + + FfiValueObjectHandleRemoteSettingsRemoteSettingsClient& operator=(FfiValueObjectHandleRemoteSettingsRemoteSettingsClient&& aOther) { + FreeHandle(); + mValue = aOther.mValue; + aOther.mValue = nullptr; + return *this; + } + + void Lower(const dom::OwningUniFFIScaffoldingValue& aValue, + ErrorResult& aError) { + if (!aValue.IsUniFFIPointer()) { + aError.ThrowTypeError("Expected UniFFI pointer argument"_ns); + return; + } + dom::UniFFIPointer& value = aValue.GetAsUniFFIPointer(); + if (!value.IsSamePtrType(&kRemoteSettingsRemoteSettingsClientPointerType)) { + aError.ThrowTypeError("Incorrect UniFFI pointer type"_ns); + return; + } + FreeHandle(); + mValue = value.ClonePtr(); + } + + void Lift(JSContext* aContext, dom::OwningUniFFIScaffoldingValue* aDest, + ErrorResult& aError) { + aDest->SetAsUniFFIPointer() = + dom::UniFFIPointer::Create(mValue, &kRemoteSettingsRemoteSettingsClientPointerType); + mValue = nullptr; + } + + void* IntoRust() { + auto temp = mValue; + mValue = nullptr; + return temp; + } + + static FfiValueObjectHandleRemoteSettingsRemoteSettingsClient FromRust(void* aValue) { + return FfiValueObjectHandleRemoteSettingsRemoteSettingsClient(aValue); + } + + void FreeHandle() { + if (mValue) { + RustCallStatus callStatus{}; + (uniffi_remote_settings_fn_free_remotesettingsclient)(mValue, &callStatus); + // No need to check `RustCallStatus`, it's only part of the API to match + // other FFI calls. The free function can never fail. + } + } + + ~FfiValueObjectHandleRemoteSettingsRemoteSettingsClient() { + // If the pointer is non-null, this means Lift/IntoRust was never called + // because there was some failure along the way. Free the pointer to avoid a + // leak + FreeHandle(); + } +}; const static mozilla::uniffi::UniFFIPointerType kRemoteSettingsRemoteSettingsServicePointerType { "remote_settings::RemoteSettingsService"_ns, uniffi_remote_settings_fn_clone_remotesettingsservice, uniffi_remote_settings_fn_free_remotesettingsservice, }; + +class FfiValueObjectHandleRemoteSettingsRemoteSettingsService { + private: + void* mValue = nullptr; + + public: + FfiValueObjectHandleRemoteSettingsRemoteSettingsService() = default; + explicit FfiValueObjectHandleRemoteSettingsRemoteSettingsService(void* aValue) : mValue(aValue) {} + + // Delete copy constructor and assignment as this type is non-copyable. + FfiValueObjectHandleRemoteSettingsRemoteSettingsService(const FfiValueObjectHandleRemoteSettingsRemoteSettingsService&) = delete; + FfiValueObjectHandleRemoteSettingsRemoteSettingsService& operator=(const FfiValueObjectHandleRemoteSettingsRemoteSettingsService&) = delete; + + FfiValueObjectHandleRemoteSettingsRemoteSettingsService& operator=(FfiValueObjectHandleRemoteSettingsRemoteSettingsService&& aOther) { + FreeHandle(); + mValue = aOther.mValue; + aOther.mValue = nullptr; + return *this; + } + + void Lower(const dom::OwningUniFFIScaffoldingValue& aValue, + ErrorResult& aError) { + if (!aValue.IsUniFFIPointer()) { + aError.ThrowTypeError("Expected UniFFI pointer argument"_ns); + return; + } + dom::UniFFIPointer& value = aValue.GetAsUniFFIPointer(); + if (!value.IsSamePtrType(&kRemoteSettingsRemoteSettingsServicePointerType)) { + aError.ThrowTypeError("Incorrect UniFFI pointer type"_ns); + return; + } + FreeHandle(); + mValue = value.ClonePtr(); + } + + void Lift(JSContext* aContext, dom::OwningUniFFIScaffoldingValue* aDest, + ErrorResult& aError) { + aDest->SetAsUniFFIPointer() = + dom::UniFFIPointer::Create(mValue, &kRemoteSettingsRemoteSettingsServicePointerType); + mValue = nullptr; + } + + void* IntoRust() { + auto temp = mValue; + mValue = nullptr; + return temp; + } + + static FfiValueObjectHandleRemoteSettingsRemoteSettingsService FromRust(void* aValue) { + return FfiValueObjectHandleRemoteSettingsRemoteSettingsService(aValue); + } + + void FreeHandle() { + if (mValue) { + RustCallStatus callStatus{}; + (uniffi_remote_settings_fn_free_remotesettingsservice)(mValue, &callStatus); + // No need to check `RustCallStatus`, it's only part of the API to match + // other FFI calls. The free function can never fail. + } + } + + ~FfiValueObjectHandleRemoteSettingsRemoteSettingsService() { + // If the pointer is non-null, this means Lift/IntoRust was never called + // because there was some failure along the way. Free the pointer to avoid a + // leak + FreeHandle(); + } +}; const static mozilla::uniffi::UniFFIPointerType kSearchSearchEngineSelectorPointerType { "search::SearchEngineSelector"_ns, uniffi_search_fn_clone_searchengineselector, uniffi_search_fn_free_searchengineselector, }; + +class FfiValueObjectHandleSearchSearchEngineSelector { + private: + void* mValue = nullptr; + + public: + FfiValueObjectHandleSearchSearchEngineSelector() = default; + explicit FfiValueObjectHandleSearchSearchEngineSelector(void* aValue) : mValue(aValue) {} + + // Delete copy constructor and assignment as this type is non-copyable. + FfiValueObjectHandleSearchSearchEngineSelector(const FfiValueObjectHandleSearchSearchEngineSelector&) = delete; + FfiValueObjectHandleSearchSearchEngineSelector& operator=(const FfiValueObjectHandleSearchSearchEngineSelector&) = delete; + + FfiValueObjectHandleSearchSearchEngineSelector& operator=(FfiValueObjectHandleSearchSearchEngineSelector&& aOther) { + FreeHandle(); + mValue = aOther.mValue; + aOther.mValue = nullptr; + return *this; + } + + void Lower(const dom::OwningUniFFIScaffoldingValue& aValue, + ErrorResult& aError) { + if (!aValue.IsUniFFIPointer()) { + aError.ThrowTypeError("Expected UniFFI pointer argument"_ns); + return; + } + dom::UniFFIPointer& value = aValue.GetAsUniFFIPointer(); + if (!value.IsSamePtrType(&kSearchSearchEngineSelectorPointerType)) { + aError.ThrowTypeError("Incorrect UniFFI pointer type"_ns); + return; + } + FreeHandle(); + mValue = value.ClonePtr(); + } + + void Lift(JSContext* aContext, dom::OwningUniFFIScaffoldingValue* aDest, + ErrorResult& aError) { + aDest->SetAsUniFFIPointer() = + dom::UniFFIPointer::Create(mValue, &kSearchSearchEngineSelectorPointerType); + mValue = nullptr; + } + + void* IntoRust() { + auto temp = mValue; + mValue = nullptr; + return temp; + } + + static FfiValueObjectHandleSearchSearchEngineSelector FromRust(void* aValue) { + return FfiValueObjectHandleSearchSearchEngineSelector(aValue); + } + + void FreeHandle() { + if (mValue) { + RustCallStatus callStatus{}; + (uniffi_search_fn_free_searchengineselector)(mValue, &callStatus); + // No need to check `RustCallStatus`, it's only part of the API to match + // other FFI calls. The free function can never fail. + } + } + + ~FfiValueObjectHandleSearchSearchEngineSelector() { + // If the pointer is non-null, this means Lift/IntoRust was never called + // because there was some failure along the way. Free the pointer to avoid a + // leak + FreeHandle(); + } +}; const static mozilla::uniffi::UniFFIPointerType kSuggestSuggestStorePointerType { "suggest::SuggestStore"_ns, uniffi_suggest_fn_clone_suggeststore, uniffi_suggest_fn_free_suggeststore, }; + +class FfiValueObjectHandleSuggestSuggestStore { + private: + void* mValue = nullptr; + + public: + FfiValueObjectHandleSuggestSuggestStore() = default; + explicit FfiValueObjectHandleSuggestSuggestStore(void* aValue) : mValue(aValue) {} + + // Delete copy constructor and assignment as this type is non-copyable. + FfiValueObjectHandleSuggestSuggestStore(const FfiValueObjectHandleSuggestSuggestStore&) = delete; + FfiValueObjectHandleSuggestSuggestStore& operator=(const FfiValueObjectHandleSuggestSuggestStore&) = delete; + + FfiValueObjectHandleSuggestSuggestStore& operator=(FfiValueObjectHandleSuggestSuggestStore&& aOther) { + FreeHandle(); + mValue = aOther.mValue; + aOther.mValue = nullptr; + return *this; + } + + void Lower(const dom::OwningUniFFIScaffoldingValue& aValue, + ErrorResult& aError) { + if (!aValue.IsUniFFIPointer()) { + aError.ThrowTypeError("Expected UniFFI pointer argument"_ns); + return; + } + dom::UniFFIPointer& value = aValue.GetAsUniFFIPointer(); + if (!value.IsSamePtrType(&kSuggestSuggestStorePointerType)) { + aError.ThrowTypeError("Incorrect UniFFI pointer type"_ns); + return; + } + FreeHandle(); + mValue = value.ClonePtr(); + } + + void Lift(JSContext* aContext, dom::OwningUniFFIScaffoldingValue* aDest, + ErrorResult& aError) { + aDest->SetAsUniFFIPointer() = + dom::UniFFIPointer::Create(mValue, &kSuggestSuggestStorePointerType); + mValue = nullptr; + } + + void* IntoRust() { + auto temp = mValue; + mValue = nullptr; + return temp; + } + + static FfiValueObjectHandleSuggestSuggestStore FromRust(void* aValue) { + return FfiValueObjectHandleSuggestSuggestStore(aValue); + } + + void FreeHandle() { + if (mValue) { + RustCallStatus callStatus{}; + (uniffi_suggest_fn_free_suggeststore)(mValue, &callStatus); + // No need to check `RustCallStatus`, it's only part of the API to match + // other FFI calls. The free function can never fail. + } + } + + ~FfiValueObjectHandleSuggestSuggestStore() { + // If the pointer is non-null, this means Lift/IntoRust was never called + // because there was some failure along the way. Free the pointer to avoid a + // leak + FreeHandle(); + } +}; const static mozilla::uniffi::UniFFIPointerType kSuggestSuggestStoreBuilderPointerType { "suggest::SuggestStoreBuilder"_ns, uniffi_suggest_fn_clone_suggeststorebuilder, uniffi_suggest_fn_free_suggeststorebuilder, }; + +class FfiValueObjectHandleSuggestSuggestStoreBuilder { + private: + void* mValue = nullptr; + + public: + FfiValueObjectHandleSuggestSuggestStoreBuilder() = default; + explicit FfiValueObjectHandleSuggestSuggestStoreBuilder(void* aValue) : mValue(aValue) {} + + // Delete copy constructor and assignment as this type is non-copyable. + FfiValueObjectHandleSuggestSuggestStoreBuilder(const FfiValueObjectHandleSuggestSuggestStoreBuilder&) = delete; + FfiValueObjectHandleSuggestSuggestStoreBuilder& operator=(const FfiValueObjectHandleSuggestSuggestStoreBuilder&) = delete; + + FfiValueObjectHandleSuggestSuggestStoreBuilder& operator=(FfiValueObjectHandleSuggestSuggestStoreBuilder&& aOther) { + FreeHandle(); + mValue = aOther.mValue; + aOther.mValue = nullptr; + return *this; + } + + void Lower(const dom::OwningUniFFIScaffoldingValue& aValue, + ErrorResult& aError) { + if (!aValue.IsUniFFIPointer()) { + aError.ThrowTypeError("Expected UniFFI pointer argument"_ns); + return; + } + dom::UniFFIPointer& value = aValue.GetAsUniFFIPointer(); + if (!value.IsSamePtrType(&kSuggestSuggestStoreBuilderPointerType)) { + aError.ThrowTypeError("Incorrect UniFFI pointer type"_ns); + return; + } + FreeHandle(); + mValue = value.ClonePtr(); + } + + void Lift(JSContext* aContext, dom::OwningUniFFIScaffoldingValue* aDest, + ErrorResult& aError) { + aDest->SetAsUniFFIPointer() = + dom::UniFFIPointer::Create(mValue, &kSuggestSuggestStoreBuilderPointerType); + mValue = nullptr; + } + + void* IntoRust() { + auto temp = mValue; + mValue = nullptr; + return temp; + } + + static FfiValueObjectHandleSuggestSuggestStoreBuilder FromRust(void* aValue) { + return FfiValueObjectHandleSuggestSuggestStoreBuilder(aValue); + } + + void FreeHandle() { + if (mValue) { + RustCallStatus callStatus{}; + (uniffi_suggest_fn_free_suggeststorebuilder)(mValue, &callStatus); + // No need to check `RustCallStatus`, it's only part of the API to match + // other FFI calls. The free function can never fail. + } + } + + ~FfiValueObjectHandleSuggestSuggestStoreBuilder() { + // If the pointer is non-null, this means Lift/IntoRust was never called + // because there was some failure along the way. Free the pointer to avoid a + // leak + FreeHandle(); + } +}; const static mozilla::uniffi::UniFFIPointerType kTabsRemoteCommandStorePointerType { "tabs::RemoteCommandStore"_ns, uniffi_tabs_fn_clone_remotecommandstore, uniffi_tabs_fn_free_remotecommandstore, }; + +class FfiValueObjectHandleTabsRemoteCommandStore { + private: + void* mValue = nullptr; + + public: + FfiValueObjectHandleTabsRemoteCommandStore() = default; + explicit FfiValueObjectHandleTabsRemoteCommandStore(void* aValue) : mValue(aValue) {} + + // Delete copy constructor and assignment as this type is non-copyable. + FfiValueObjectHandleTabsRemoteCommandStore(const FfiValueObjectHandleTabsRemoteCommandStore&) = delete; + FfiValueObjectHandleTabsRemoteCommandStore& operator=(const FfiValueObjectHandleTabsRemoteCommandStore&) = delete; + + FfiValueObjectHandleTabsRemoteCommandStore& operator=(FfiValueObjectHandleTabsRemoteCommandStore&& aOther) { + FreeHandle(); + mValue = aOther.mValue; + aOther.mValue = nullptr; + return *this; + } + + void Lower(const dom::OwningUniFFIScaffoldingValue& aValue, + ErrorResult& aError) { + if (!aValue.IsUniFFIPointer()) { + aError.ThrowTypeError("Expected UniFFI pointer argument"_ns); + return; + } + dom::UniFFIPointer& value = aValue.GetAsUniFFIPointer(); + if (!value.IsSamePtrType(&kTabsRemoteCommandStorePointerType)) { + aError.ThrowTypeError("Incorrect UniFFI pointer type"_ns); + return; + } + FreeHandle(); + mValue = value.ClonePtr(); + } + + void Lift(JSContext* aContext, dom::OwningUniFFIScaffoldingValue* aDest, + ErrorResult& aError) { + aDest->SetAsUniFFIPointer() = + dom::UniFFIPointer::Create(mValue, &kTabsRemoteCommandStorePointerType); + mValue = nullptr; + } + + void* IntoRust() { + auto temp = mValue; + mValue = nullptr; + return temp; + } + + static FfiValueObjectHandleTabsRemoteCommandStore FromRust(void* aValue) { + return FfiValueObjectHandleTabsRemoteCommandStore(aValue); + } + + void FreeHandle() { + if (mValue) { + RustCallStatus callStatus{}; + (uniffi_tabs_fn_free_remotecommandstore)(mValue, &callStatus); + // No need to check `RustCallStatus`, it's only part of the API to match + // other FFI calls. The free function can never fail. + } + } + + ~FfiValueObjectHandleTabsRemoteCommandStore() { + // If the pointer is non-null, this means Lift/IntoRust was never called + // because there was some failure along the way. Free the pointer to avoid a + // leak + FreeHandle(); + } +}; const static mozilla::uniffi::UniFFIPointerType kTabsTabsBridgedEnginePointerType { "tabs::TabsBridgedEngine"_ns, uniffi_tabs_fn_clone_tabsbridgedengine, uniffi_tabs_fn_free_tabsbridgedengine, }; + +class FfiValueObjectHandleTabsTabsBridgedEngine { + private: + void* mValue = nullptr; + + public: + FfiValueObjectHandleTabsTabsBridgedEngine() = default; + explicit FfiValueObjectHandleTabsTabsBridgedEngine(void* aValue) : mValue(aValue) {} + + // Delete copy constructor and assignment as this type is non-copyable. + FfiValueObjectHandleTabsTabsBridgedEngine(const FfiValueObjectHandleTabsTabsBridgedEngine&) = delete; + FfiValueObjectHandleTabsTabsBridgedEngine& operator=(const FfiValueObjectHandleTabsTabsBridgedEngine&) = delete; + + FfiValueObjectHandleTabsTabsBridgedEngine& operator=(FfiValueObjectHandleTabsTabsBridgedEngine&& aOther) { + FreeHandle(); + mValue = aOther.mValue; + aOther.mValue = nullptr; + return *this; + } + + void Lower(const dom::OwningUniFFIScaffoldingValue& aValue, + ErrorResult& aError) { + if (!aValue.IsUniFFIPointer()) { + aError.ThrowTypeError("Expected UniFFI pointer argument"_ns); + return; + } + dom::UniFFIPointer& value = aValue.GetAsUniFFIPointer(); + if (!value.IsSamePtrType(&kTabsTabsBridgedEnginePointerType)) { + aError.ThrowTypeError("Incorrect UniFFI pointer type"_ns); + return; + } + FreeHandle(); + mValue = value.ClonePtr(); + } + + void Lift(JSContext* aContext, dom::OwningUniFFIScaffoldingValue* aDest, + ErrorResult& aError) { + aDest->SetAsUniFFIPointer() = + dom::UniFFIPointer::Create(mValue, &kTabsTabsBridgedEnginePointerType); + mValue = nullptr; + } + + void* IntoRust() { + auto temp = mValue; + mValue = nullptr; + return temp; + } + + static FfiValueObjectHandleTabsTabsBridgedEngine FromRust(void* aValue) { + return FfiValueObjectHandleTabsTabsBridgedEngine(aValue); + } + + void FreeHandle() { + if (mValue) { + RustCallStatus callStatus{}; + (uniffi_tabs_fn_free_tabsbridgedengine)(mValue, &callStatus); + // No need to check `RustCallStatus`, it's only part of the API to match + // other FFI calls. The free function can never fail. + } + } + + ~FfiValueObjectHandleTabsTabsBridgedEngine() { + // If the pointer is non-null, this means Lift/IntoRust was never called + // because there was some failure along the way. Free the pointer to avoid a + // leak + FreeHandle(); + } +}; const static mozilla::uniffi::UniFFIPointerType kTabsTabsStorePointerType { "tabs::TabsStore"_ns, uniffi_tabs_fn_clone_tabsstore, uniffi_tabs_fn_free_tabsstore, }; + +class FfiValueObjectHandleTabsTabsStore { + private: + void* mValue = nullptr; + + public: + FfiValueObjectHandleTabsTabsStore() = default; + explicit FfiValueObjectHandleTabsTabsStore(void* aValue) : mValue(aValue) {} + + // Delete copy constructor and assignment as this type is non-copyable. + FfiValueObjectHandleTabsTabsStore(const FfiValueObjectHandleTabsTabsStore&) = delete; + FfiValueObjectHandleTabsTabsStore& operator=(const FfiValueObjectHandleTabsTabsStore&) = delete; + + FfiValueObjectHandleTabsTabsStore& operator=(FfiValueObjectHandleTabsTabsStore&& aOther) { + FreeHandle(); + mValue = aOther.mValue; + aOther.mValue = nullptr; + return *this; + } + + void Lower(const dom::OwningUniFFIScaffoldingValue& aValue, + ErrorResult& aError) { + if (!aValue.IsUniFFIPointer()) { + aError.ThrowTypeError("Expected UniFFI pointer argument"_ns); + return; + } + dom::UniFFIPointer& value = aValue.GetAsUniFFIPointer(); + if (!value.IsSamePtrType(&kTabsTabsStorePointerType)) { + aError.ThrowTypeError("Incorrect UniFFI pointer type"_ns); + return; + } + FreeHandle(); + mValue = value.ClonePtr(); + } + + void Lift(JSContext* aContext, dom::OwningUniFFIScaffoldingValue* aDest, + ErrorResult& aError) { + aDest->SetAsUniFFIPointer() = + dom::UniFFIPointer::Create(mValue, &kTabsTabsStorePointerType); + mValue = nullptr; + } + + void* IntoRust() { + auto temp = mValue; + mValue = nullptr; + return temp; + } + + static FfiValueObjectHandleTabsTabsStore FromRust(void* aValue) { + return FfiValueObjectHandleTabsTabsStore(aValue); + } + + void FreeHandle() { + if (mValue) { + RustCallStatus callStatus{}; + (uniffi_tabs_fn_free_tabsstore)(mValue, &callStatus); + // No need to check `RustCallStatus`, it's only part of the API to match + // other FFI calls. The free function can never fail. + } + } + + ~FfiValueObjectHandleTabsTabsStore() { + // If the pointer is non-null, this means Lift/IntoRust was never called + // because there was some failure along the way. Free the pointer to avoid a + // leak + FreeHandle(); + } +}; const static mozilla::uniffi::UniFFIPointerType kWebextstorageWebExtStorageBridgedEnginePointerType { "webextstorage::WebExtStorageBridgedEngine"_ns, uniffi_webext_storage_fn_clone_webextstoragebridgedengine, uniffi_webext_storage_fn_free_webextstoragebridgedengine, }; + +class FfiValueObjectHandleWebextstorageWebExtStorageBridgedEngine { + private: + void* mValue = nullptr; + + public: + FfiValueObjectHandleWebextstorageWebExtStorageBridgedEngine() = default; + explicit FfiValueObjectHandleWebextstorageWebExtStorageBridgedEngine(void* aValue) : mValue(aValue) {} + + // Delete copy constructor and assignment as this type is non-copyable. + FfiValueObjectHandleWebextstorageWebExtStorageBridgedEngine(const FfiValueObjectHandleWebextstorageWebExtStorageBridgedEngine&) = delete; + FfiValueObjectHandleWebextstorageWebExtStorageBridgedEngine& operator=(const FfiValueObjectHandleWebextstorageWebExtStorageBridgedEngine&) = delete; + + FfiValueObjectHandleWebextstorageWebExtStorageBridgedEngine& operator=(FfiValueObjectHandleWebextstorageWebExtStorageBridgedEngine&& aOther) { + FreeHandle(); + mValue = aOther.mValue; + aOther.mValue = nullptr; + return *this; + } + + void Lower(const dom::OwningUniFFIScaffoldingValue& aValue, + ErrorResult& aError) { + if (!aValue.IsUniFFIPointer()) { + aError.ThrowTypeError("Expected UniFFI pointer argument"_ns); + return; + } + dom::UniFFIPointer& value = aValue.GetAsUniFFIPointer(); + if (!value.IsSamePtrType(&kWebextstorageWebExtStorageBridgedEnginePointerType)) { + aError.ThrowTypeError("Incorrect UniFFI pointer type"_ns); + return; + } + FreeHandle(); + mValue = value.ClonePtr(); + } + + void Lift(JSContext* aContext, dom::OwningUniFFIScaffoldingValue* aDest, + ErrorResult& aError) { + aDest->SetAsUniFFIPointer() = + dom::UniFFIPointer::Create(mValue, &kWebextstorageWebExtStorageBridgedEnginePointerType); + mValue = nullptr; + } + + void* IntoRust() { + auto temp = mValue; + mValue = nullptr; + return temp; + } + + static FfiValueObjectHandleWebextstorageWebExtStorageBridgedEngine FromRust(void* aValue) { + return FfiValueObjectHandleWebextstorageWebExtStorageBridgedEngine(aValue); + } + + void FreeHandle() { + if (mValue) { + RustCallStatus callStatus{}; + (uniffi_webext_storage_fn_free_webextstoragebridgedengine)(mValue, &callStatus); + // No need to check `RustCallStatus`, it's only part of the API to match + // other FFI calls. The free function can never fail. + } + } + + ~FfiValueObjectHandleWebextstorageWebExtStorageBridgedEngine() { + // If the pointer is non-null, this means Lift/IntoRust was never called + // because there was some failure along the way. Free the pointer to avoid a + // leak + FreeHandle(); + } +}; const static mozilla::uniffi::UniFFIPointerType kWebextstorageWebExtStorageStorePointerType { "webextstorage::WebExtStorageStore"_ns, uniffi_webext_storage_fn_clone_webextstoragestore, uniffi_webext_storage_fn_free_webextstoragestore, }; +class FfiValueObjectHandleWebextstorageWebExtStorageStore { + private: + void* mValue = nullptr; + + public: + FfiValueObjectHandleWebextstorageWebExtStorageStore() = default; + explicit FfiValueObjectHandleWebextstorageWebExtStorageStore(void* aValue) : mValue(aValue) {} + + // Delete copy constructor and assignment as this type is non-copyable. + FfiValueObjectHandleWebextstorageWebExtStorageStore(const FfiValueObjectHandleWebextstorageWebExtStorageStore&) = delete; + FfiValueObjectHandleWebextstorageWebExtStorageStore& operator=(const FfiValueObjectHandleWebextstorageWebExtStorageStore&) = delete; + + FfiValueObjectHandleWebextstorageWebExtStorageStore& operator=(FfiValueObjectHandleWebextstorageWebExtStorageStore&& aOther) { + FreeHandle(); + mValue = aOther.mValue; + aOther.mValue = nullptr; + return *this; + } + + void Lower(const dom::OwningUniFFIScaffoldingValue& aValue, + ErrorResult& aError) { + if (!aValue.IsUniFFIPointer()) { + aError.ThrowTypeError("Expected UniFFI pointer argument"_ns); + return; + } + dom::UniFFIPointer& value = aValue.GetAsUniFFIPointer(); + if (!value.IsSamePtrType(&kWebextstorageWebExtStorageStorePointerType)) { + aError.ThrowTypeError("Incorrect UniFFI pointer type"_ns); + return; + } + FreeHandle(); + mValue = value.ClonePtr(); + } + + void Lift(JSContext* aContext, dom::OwningUniFFIScaffoldingValue* aDest, + ErrorResult& aError) { + aDest->SetAsUniFFIPointer() = + dom::UniFFIPointer::Create(mValue, &kWebextstorageWebExtStorageStorePointerType); + mValue = nullptr; + } + + void* IntoRust() { + auto temp = mValue; + mValue = nullptr; + return temp; + } + + static FfiValueObjectHandleWebextstorageWebExtStorageStore FromRust(void* aValue) { + return FfiValueObjectHandleWebextstorageWebExtStorageStore(aValue); + } + + void FreeHandle() { + if (mValue) { + RustCallStatus callStatus{}; + (uniffi_webext_storage_fn_free_webextstoragestore)(mValue, &callStatus); + // No need to check `RustCallStatus`, it's only part of the API to match + // other FFI calls. The free function can never fail. + } + } + + ~FfiValueObjectHandleWebextstorageWebExtStorageStore() { + // If the pointer is non-null, this means Lift/IntoRust was never called + // because there was some failure along the way. Free the pointer to avoid a + // leak + FreeHandle(); + } +}; + #ifdef MOZ_UNIFFI_FIXTURES const static mozilla::uniffi::UniFFIPointerType kFuturesFutureTesterPointerType { "futures::FutureTester"_ns, uniffi_uniffi_fixture_futures_fn_clone_futuretester, uniffi_uniffi_fixture_futures_fn_free_futuretester, }; + +class FfiValueObjectHandleFuturesFutureTester { + private: + void* mValue = nullptr; + + public: + FfiValueObjectHandleFuturesFutureTester() = default; + explicit FfiValueObjectHandleFuturesFutureTester(void* aValue) : mValue(aValue) {} + + // Delete copy constructor and assignment as this type is non-copyable. + FfiValueObjectHandleFuturesFutureTester(const FfiValueObjectHandleFuturesFutureTester&) = delete; + FfiValueObjectHandleFuturesFutureTester& operator=(const FfiValueObjectHandleFuturesFutureTester&) = delete; + + FfiValueObjectHandleFuturesFutureTester& operator=(FfiValueObjectHandleFuturesFutureTester&& aOther) { + FreeHandle(); + mValue = aOther.mValue; + aOther.mValue = nullptr; + return *this; + } + + void Lower(const dom::OwningUniFFIScaffoldingValue& aValue, + ErrorResult& aError) { + if (!aValue.IsUniFFIPointer()) { + aError.ThrowTypeError("Expected UniFFI pointer argument"_ns); + return; + } + dom::UniFFIPointer& value = aValue.GetAsUniFFIPointer(); + if (!value.IsSamePtrType(&kFuturesFutureTesterPointerType)) { + aError.ThrowTypeError("Incorrect UniFFI pointer type"_ns); + return; + } + FreeHandle(); + mValue = value.ClonePtr(); + } + + void Lift(JSContext* aContext, dom::OwningUniFFIScaffoldingValue* aDest, + ErrorResult& aError) { + aDest->SetAsUniFFIPointer() = + dom::UniFFIPointer::Create(mValue, &kFuturesFutureTesterPointerType); + mValue = nullptr; + } + + void* IntoRust() { + auto temp = mValue; + mValue = nullptr; + return temp; + } + + static FfiValueObjectHandleFuturesFutureTester FromRust(void* aValue) { + return FfiValueObjectHandleFuturesFutureTester(aValue); + } + + void FreeHandle() { + if (mValue) { + RustCallStatus callStatus{}; + (uniffi_uniffi_fixture_futures_fn_free_futuretester)(mValue, &callStatus); + // No need to check `RustCallStatus`, it's only part of the API to match + // other FFI calls. The free function can never fail. + } + } + + ~FfiValueObjectHandleFuturesFutureTester() { + // If the pointer is non-null, this means Lift/IntoRust was never called + // because there was some failure along the way. Free the pointer to avoid a + // leak + FreeHandle(); + } +}; const static mozilla::uniffi::UniFFIPointerType kFuturesRustTaskPointerType { "futures::RustTask"_ns, uniffi_uniffi_fixture_futures_fn_clone_rusttask, uniffi_uniffi_fixture_futures_fn_free_rusttask, }; + +class FfiValueObjectHandleFuturesRustTask { + private: + void* mValue = nullptr; + + public: + FfiValueObjectHandleFuturesRustTask() = default; + explicit FfiValueObjectHandleFuturesRustTask(void* aValue) : mValue(aValue) {} + + // Delete copy constructor and assignment as this type is non-copyable. + FfiValueObjectHandleFuturesRustTask(const FfiValueObjectHandleFuturesRustTask&) = delete; + FfiValueObjectHandleFuturesRustTask& operator=(const FfiValueObjectHandleFuturesRustTask&) = delete; + + FfiValueObjectHandleFuturesRustTask& operator=(FfiValueObjectHandleFuturesRustTask&& aOther) { + FreeHandle(); + mValue = aOther.mValue; + aOther.mValue = nullptr; + return *this; + } + + void Lower(const dom::OwningUniFFIScaffoldingValue& aValue, + ErrorResult& aError) { + if (!aValue.IsUniFFIPointer()) { + aError.ThrowTypeError("Expected UniFFI pointer argument"_ns); + return; + } + dom::UniFFIPointer& value = aValue.GetAsUniFFIPointer(); + if (!value.IsSamePtrType(&kFuturesRustTaskPointerType)) { + aError.ThrowTypeError("Incorrect UniFFI pointer type"_ns); + return; + } + FreeHandle(); + mValue = value.ClonePtr(); + } + + void Lift(JSContext* aContext, dom::OwningUniFFIScaffoldingValue* aDest, + ErrorResult& aError) { + aDest->SetAsUniFFIPointer() = + dom::UniFFIPointer::Create(mValue, &kFuturesRustTaskPointerType); + mValue = nullptr; + } + + void* IntoRust() { + auto temp = mValue; + mValue = nullptr; + return temp; + } + + static FfiValueObjectHandleFuturesRustTask FromRust(void* aValue) { + return FfiValueObjectHandleFuturesRustTask(aValue); + } + + void FreeHandle() { + if (mValue) { + RustCallStatus callStatus{}; + (uniffi_uniffi_fixture_futures_fn_free_rusttask)(mValue, &callStatus); + // No need to check `RustCallStatus`, it's only part of the API to match + // other FFI calls. The free function can never fail. + } + } + + ~FfiValueObjectHandleFuturesRustTask() { + // If the pointer is non-null, this means Lift/IntoRust was never called + // because there was some failure along the way. Free the pointer to avoid a + // leak + FreeHandle(); + } +}; const static mozilla::uniffi::UniFFIPointerType kFuturesTravellerPointerType { "futures::Traveller"_ns, uniffi_uniffi_fixture_futures_fn_clone_traveller, uniffi_uniffi_fixture_futures_fn_free_traveller, }; + +class FfiValueObjectHandleFuturesTraveller { + private: + void* mValue = nullptr; + + public: + FfiValueObjectHandleFuturesTraveller() = default; + explicit FfiValueObjectHandleFuturesTraveller(void* aValue) : mValue(aValue) {} + + // Delete copy constructor and assignment as this type is non-copyable. + FfiValueObjectHandleFuturesTraveller(const FfiValueObjectHandleFuturesTraveller&) = delete; + FfiValueObjectHandleFuturesTraveller& operator=(const FfiValueObjectHandleFuturesTraveller&) = delete; + + FfiValueObjectHandleFuturesTraveller& operator=(FfiValueObjectHandleFuturesTraveller&& aOther) { + FreeHandle(); + mValue = aOther.mValue; + aOther.mValue = nullptr; + return *this; + } + + void Lower(const dom::OwningUniFFIScaffoldingValue& aValue, + ErrorResult& aError) { + if (!aValue.IsUniFFIPointer()) { + aError.ThrowTypeError("Expected UniFFI pointer argument"_ns); + return; + } + dom::UniFFIPointer& value = aValue.GetAsUniFFIPointer(); + if (!value.IsSamePtrType(&kFuturesTravellerPointerType)) { + aError.ThrowTypeError("Incorrect UniFFI pointer type"_ns); + return; + } + FreeHandle(); + mValue = value.ClonePtr(); + } + + void Lift(JSContext* aContext, dom::OwningUniFFIScaffoldingValue* aDest, + ErrorResult& aError) { + aDest->SetAsUniFFIPointer() = + dom::UniFFIPointer::Create(mValue, &kFuturesTravellerPointerType); + mValue = nullptr; + } + + void* IntoRust() { + auto temp = mValue; + mValue = nullptr; + return temp; + } + + static FfiValueObjectHandleFuturesTraveller FromRust(void* aValue) { + return FfiValueObjectHandleFuturesTraveller(aValue); + } + + void FreeHandle() { + if (mValue) { + RustCallStatus callStatus{}; + (uniffi_uniffi_fixture_futures_fn_free_traveller)(mValue, &callStatus); + // No need to check `RustCallStatus`, it's only part of the API to match + // other FFI calls. The free function can never fail. + } + } + + ~FfiValueObjectHandleFuturesTraveller() { + // If the pointer is non-null, this means Lift/IntoRust was never called + // because there was some failure along the way. Free the pointer to avoid a + // leak + FreeHandle(); + } +}; const static mozilla::uniffi::UniFFIPointerType kFuturesWorkerQueuePointerType { "futures::WorkerQueue"_ns, uniffi_uniffi_fixture_futures_fn_clone_workerqueue, uniffi_uniffi_fixture_futures_fn_free_workerqueue, }; + +class FfiValueObjectHandleFuturesWorkerQueue { + private: + void* mValue = nullptr; + + public: + FfiValueObjectHandleFuturesWorkerQueue() = default; + explicit FfiValueObjectHandleFuturesWorkerQueue(void* aValue) : mValue(aValue) {} + + // Delete copy constructor and assignment as this type is non-copyable. + FfiValueObjectHandleFuturesWorkerQueue(const FfiValueObjectHandleFuturesWorkerQueue&) = delete; + FfiValueObjectHandleFuturesWorkerQueue& operator=(const FfiValueObjectHandleFuturesWorkerQueue&) = delete; + + FfiValueObjectHandleFuturesWorkerQueue& operator=(FfiValueObjectHandleFuturesWorkerQueue&& aOther) { + FreeHandle(); + mValue = aOther.mValue; + aOther.mValue = nullptr; + return *this; + } + + void Lower(const dom::OwningUniFFIScaffoldingValue& aValue, + ErrorResult& aError) { + if (!aValue.IsUniFFIPointer()) { + aError.ThrowTypeError("Expected UniFFI pointer argument"_ns); + return; + } + dom::UniFFIPointer& value = aValue.GetAsUniFFIPointer(); + if (!value.IsSamePtrType(&kFuturesWorkerQueuePointerType)) { + aError.ThrowTypeError("Incorrect UniFFI pointer type"_ns); + return; + } + FreeHandle(); + mValue = value.ClonePtr(); + } + + void Lift(JSContext* aContext, dom::OwningUniFFIScaffoldingValue* aDest, + ErrorResult& aError) { + aDest->SetAsUniFFIPointer() = + dom::UniFFIPointer::Create(mValue, &kFuturesWorkerQueuePointerType); + mValue = nullptr; + } + + void* IntoRust() { + auto temp = mValue; + mValue = nullptr; + return temp; + } + + static FfiValueObjectHandleFuturesWorkerQueue FromRust(void* aValue) { + return FfiValueObjectHandleFuturesWorkerQueue(aValue); + } + + void FreeHandle() { + if (mValue) { + RustCallStatus callStatus{}; + (uniffi_uniffi_fixture_futures_fn_free_workerqueue)(mValue, &callStatus); + // No need to check `RustCallStatus`, it's only part of the API to match + // other FFI calls. The free function can never fail. + } + } + + ~FfiValueObjectHandleFuturesWorkerQueue() { + // If the pointer is non-null, this means Lift/IntoRust was never called + // because there was some failure along the way. Free the pointer to avoid a + // leak + FreeHandle(); + } +}; const static mozilla::uniffi::UniFFIPointerType kRefcountsSingletonObjectPointerType { "refcounts::SingletonObject"_ns, uniffi_uniffi_fixture_refcounts_fn_clone_singletonobject, uniffi_uniffi_fixture_refcounts_fn_free_singletonobject, }; + +class FfiValueObjectHandleRefcountsSingletonObject { + private: + void* mValue = nullptr; + + public: + FfiValueObjectHandleRefcountsSingletonObject() = default; + explicit FfiValueObjectHandleRefcountsSingletonObject(void* aValue) : mValue(aValue) {} + + // Delete copy constructor and assignment as this type is non-copyable. + FfiValueObjectHandleRefcountsSingletonObject(const FfiValueObjectHandleRefcountsSingletonObject&) = delete; + FfiValueObjectHandleRefcountsSingletonObject& operator=(const FfiValueObjectHandleRefcountsSingletonObject&) = delete; + + FfiValueObjectHandleRefcountsSingletonObject& operator=(FfiValueObjectHandleRefcountsSingletonObject&& aOther) { + FreeHandle(); + mValue = aOther.mValue; + aOther.mValue = nullptr; + return *this; + } + + void Lower(const dom::OwningUniFFIScaffoldingValue& aValue, + ErrorResult& aError) { + if (!aValue.IsUniFFIPointer()) { + aError.ThrowTypeError("Expected UniFFI pointer argument"_ns); + return; + } + dom::UniFFIPointer& value = aValue.GetAsUniFFIPointer(); + if (!value.IsSamePtrType(&kRefcountsSingletonObjectPointerType)) { + aError.ThrowTypeError("Incorrect UniFFI pointer type"_ns); + return; + } + FreeHandle(); + mValue = value.ClonePtr(); + } + + void Lift(JSContext* aContext, dom::OwningUniFFIScaffoldingValue* aDest, + ErrorResult& aError) { + aDest->SetAsUniFFIPointer() = + dom::UniFFIPointer::Create(mValue, &kRefcountsSingletonObjectPointerType); + mValue = nullptr; + } + + void* IntoRust() { + auto temp = mValue; + mValue = nullptr; + return temp; + } + + static FfiValueObjectHandleRefcountsSingletonObject FromRust(void* aValue) { + return FfiValueObjectHandleRefcountsSingletonObject(aValue); + } + + void FreeHandle() { + if (mValue) { + RustCallStatus callStatus{}; + (uniffi_uniffi_fixture_refcounts_fn_free_singletonobject)(mValue, &callStatus); + // No need to check `RustCallStatus`, it's only part of the API to match + // other FFI calls. The free function can never fail. + } + } + + ~FfiValueObjectHandleRefcountsSingletonObject() { + // If the pointer is non-null, this means Lift/IntoRust was never called + // because there was some failure along the way. Free the pointer to avoid a + // leak + FreeHandle(); + } +}; const static mozilla::uniffi::UniFFIPointerType kRondpointOptionneurPointerType { "rondpoint::Optionneur"_ns, uniffi_uniffi_rondpoint_fn_clone_optionneur, uniffi_uniffi_rondpoint_fn_free_optionneur, }; + +class FfiValueObjectHandleRondpointOptionneur { + private: + void* mValue = nullptr; + + public: + FfiValueObjectHandleRondpointOptionneur() = default; + explicit FfiValueObjectHandleRondpointOptionneur(void* aValue) : mValue(aValue) {} + + // Delete copy constructor and assignment as this type is non-copyable. + FfiValueObjectHandleRondpointOptionneur(const FfiValueObjectHandleRondpointOptionneur&) = delete; + FfiValueObjectHandleRondpointOptionneur& operator=(const FfiValueObjectHandleRondpointOptionneur&) = delete; + + FfiValueObjectHandleRondpointOptionneur& operator=(FfiValueObjectHandleRondpointOptionneur&& aOther) { + FreeHandle(); + mValue = aOther.mValue; + aOther.mValue = nullptr; + return *this; + } + + void Lower(const dom::OwningUniFFIScaffoldingValue& aValue, + ErrorResult& aError) { + if (!aValue.IsUniFFIPointer()) { + aError.ThrowTypeError("Expected UniFFI pointer argument"_ns); + return; + } + dom::UniFFIPointer& value = aValue.GetAsUniFFIPointer(); + if (!value.IsSamePtrType(&kRondpointOptionneurPointerType)) { + aError.ThrowTypeError("Incorrect UniFFI pointer type"_ns); + return; + } + FreeHandle(); + mValue = value.ClonePtr(); + } + + void Lift(JSContext* aContext, dom::OwningUniFFIScaffoldingValue* aDest, + ErrorResult& aError) { + aDest->SetAsUniFFIPointer() = + dom::UniFFIPointer::Create(mValue, &kRondpointOptionneurPointerType); + mValue = nullptr; + } + + void* IntoRust() { + auto temp = mValue; + mValue = nullptr; + return temp; + } + + static FfiValueObjectHandleRondpointOptionneur FromRust(void* aValue) { + return FfiValueObjectHandleRondpointOptionneur(aValue); + } + + void FreeHandle() { + if (mValue) { + RustCallStatus callStatus{}; + (uniffi_uniffi_rondpoint_fn_free_optionneur)(mValue, &callStatus); + // No need to check `RustCallStatus`, it's only part of the API to match + // other FFI calls. The free function can never fail. + } + } + + ~FfiValueObjectHandleRondpointOptionneur() { + // If the pointer is non-null, this means Lift/IntoRust was never called + // because there was some failure along the way. Free the pointer to avoid a + // leak + FreeHandle(); + } +}; const static mozilla::uniffi::UniFFIPointerType kRondpointRetourneurPointerType { "rondpoint::Retourneur"_ns, uniffi_uniffi_rondpoint_fn_clone_retourneur, uniffi_uniffi_rondpoint_fn_free_retourneur, }; + +class FfiValueObjectHandleRondpointRetourneur { + private: + void* mValue = nullptr; + + public: + FfiValueObjectHandleRondpointRetourneur() = default; + explicit FfiValueObjectHandleRondpointRetourneur(void* aValue) : mValue(aValue) {} + + // Delete copy constructor and assignment as this type is non-copyable. + FfiValueObjectHandleRondpointRetourneur(const FfiValueObjectHandleRondpointRetourneur&) = delete; + FfiValueObjectHandleRondpointRetourneur& operator=(const FfiValueObjectHandleRondpointRetourneur&) = delete; + + FfiValueObjectHandleRondpointRetourneur& operator=(FfiValueObjectHandleRondpointRetourneur&& aOther) { + FreeHandle(); + mValue = aOther.mValue; + aOther.mValue = nullptr; + return *this; + } + + void Lower(const dom::OwningUniFFIScaffoldingValue& aValue, + ErrorResult& aError) { + if (!aValue.IsUniFFIPointer()) { + aError.ThrowTypeError("Expected UniFFI pointer argument"_ns); + return; + } + dom::UniFFIPointer& value = aValue.GetAsUniFFIPointer(); + if (!value.IsSamePtrType(&kRondpointRetourneurPointerType)) { + aError.ThrowTypeError("Incorrect UniFFI pointer type"_ns); + return; + } + FreeHandle(); + mValue = value.ClonePtr(); + } + + void Lift(JSContext* aContext, dom::OwningUniFFIScaffoldingValue* aDest, + ErrorResult& aError) { + aDest->SetAsUniFFIPointer() = + dom::UniFFIPointer::Create(mValue, &kRondpointRetourneurPointerType); + mValue = nullptr; + } + + void* IntoRust() { + auto temp = mValue; + mValue = nullptr; + return temp; + } + + static FfiValueObjectHandleRondpointRetourneur FromRust(void* aValue) { + return FfiValueObjectHandleRondpointRetourneur(aValue); + } + + void FreeHandle() { + if (mValue) { + RustCallStatus callStatus{}; + (uniffi_uniffi_rondpoint_fn_free_retourneur)(mValue, &callStatus); + // No need to check `RustCallStatus`, it's only part of the API to match + // other FFI calls. The free function can never fail. + } + } + + ~FfiValueObjectHandleRondpointRetourneur() { + // If the pointer is non-null, this means Lift/IntoRust was never called + // because there was some failure along the way. Free the pointer to avoid a + // leak + FreeHandle(); + } +}; const static mozilla::uniffi::UniFFIPointerType kRondpointStringifierPointerType { "rondpoint::Stringifier"_ns, uniffi_uniffi_rondpoint_fn_clone_stringifier, uniffi_uniffi_rondpoint_fn_free_stringifier, }; + +class FfiValueObjectHandleRondpointStringifier { + private: + void* mValue = nullptr; + + public: + FfiValueObjectHandleRondpointStringifier() = default; + explicit FfiValueObjectHandleRondpointStringifier(void* aValue) : mValue(aValue) {} + + // Delete copy constructor and assignment as this type is non-copyable. + FfiValueObjectHandleRondpointStringifier(const FfiValueObjectHandleRondpointStringifier&) = delete; + FfiValueObjectHandleRondpointStringifier& operator=(const FfiValueObjectHandleRondpointStringifier&) = delete; + + FfiValueObjectHandleRondpointStringifier& operator=(FfiValueObjectHandleRondpointStringifier&& aOther) { + FreeHandle(); + mValue = aOther.mValue; + aOther.mValue = nullptr; + return *this; + } + + void Lower(const dom::OwningUniFFIScaffoldingValue& aValue, + ErrorResult& aError) { + if (!aValue.IsUniFFIPointer()) { + aError.ThrowTypeError("Expected UniFFI pointer argument"_ns); + return; + } + dom::UniFFIPointer& value = aValue.GetAsUniFFIPointer(); + if (!value.IsSamePtrType(&kRondpointStringifierPointerType)) { + aError.ThrowTypeError("Incorrect UniFFI pointer type"_ns); + return; + } + FreeHandle(); + mValue = value.ClonePtr(); + } + + void Lift(JSContext* aContext, dom::OwningUniFFIScaffoldingValue* aDest, + ErrorResult& aError) { + aDest->SetAsUniFFIPointer() = + dom::UniFFIPointer::Create(mValue, &kRondpointStringifierPointerType); + mValue = nullptr; + } + + void* IntoRust() { + auto temp = mValue; + mValue = nullptr; + return temp; + } + + static FfiValueObjectHandleRondpointStringifier FromRust(void* aValue) { + return FfiValueObjectHandleRondpointStringifier(aValue); + } + + void FreeHandle() { + if (mValue) { + RustCallStatus callStatus{}; + (uniffi_uniffi_rondpoint_fn_free_stringifier)(mValue, &callStatus); + // No need to check `RustCallStatus`, it's only part of the API to match + // other FFI calls. The free function can never fail. + } + } + + ~FfiValueObjectHandleRondpointStringifier() { + // If the pointer is non-null, this means Lift/IntoRust was never called + // because there was some failure along the way. Free the pointer to avoid a + // leak + FreeHandle(); + } +}; const static mozilla::uniffi::UniFFIPointerType kSpritesSpritePointerType { "sprites::Sprite"_ns, uniffi_uniffi_sprites_fn_clone_sprite, uniffi_uniffi_sprites_fn_free_sprite, }; + +class FfiValueObjectHandleSpritesSprite { + private: + void* mValue = nullptr; + + public: + FfiValueObjectHandleSpritesSprite() = default; + explicit FfiValueObjectHandleSpritesSprite(void* aValue) : mValue(aValue) {} + + // Delete copy constructor and assignment as this type is non-copyable. + FfiValueObjectHandleSpritesSprite(const FfiValueObjectHandleSpritesSprite&) = delete; + FfiValueObjectHandleSpritesSprite& operator=(const FfiValueObjectHandleSpritesSprite&) = delete; + + FfiValueObjectHandleSpritesSprite& operator=(FfiValueObjectHandleSpritesSprite&& aOther) { + FreeHandle(); + mValue = aOther.mValue; + aOther.mValue = nullptr; + return *this; + } + + void Lower(const dom::OwningUniFFIScaffoldingValue& aValue, + ErrorResult& aError) { + if (!aValue.IsUniFFIPointer()) { + aError.ThrowTypeError("Expected UniFFI pointer argument"_ns); + return; + } + dom::UniFFIPointer& value = aValue.GetAsUniFFIPointer(); + if (!value.IsSamePtrType(&kSpritesSpritePointerType)) { + aError.ThrowTypeError("Incorrect UniFFI pointer type"_ns); + return; + } + FreeHandle(); + mValue = value.ClonePtr(); + } + + void Lift(JSContext* aContext, dom::OwningUniFFIScaffoldingValue* aDest, + ErrorResult& aError) { + aDest->SetAsUniFFIPointer() = + dom::UniFFIPointer::Create(mValue, &kSpritesSpritePointerType); + mValue = nullptr; + } + + void* IntoRust() { + auto temp = mValue; + mValue = nullptr; + return temp; + } + + static FfiValueObjectHandleSpritesSprite FromRust(void* aValue) { + return FfiValueObjectHandleSpritesSprite(aValue); + } + + void FreeHandle() { + if (mValue) { + RustCallStatus callStatus{}; + (uniffi_uniffi_sprites_fn_free_sprite)(mValue, &callStatus); + // No need to check `RustCallStatus`, it's only part of the API to match + // other FFI calls. The free function can never fail. + } + } + + ~FfiValueObjectHandleSpritesSprite() { + // If the pointer is non-null, this means Lift/IntoRust was never called + // because there was some failure along the way. Free the pointer to avoid a + // leak + FreeHandle(); + } +}; const static mozilla::uniffi::UniFFIPointerType kTodolistTodoListPointerType { "todolist::TodoList"_ns, uniffi_uniffi_todolist_fn_clone_todolist, uniffi_uniffi_todolist_fn_free_todolist, }; + +class FfiValueObjectHandleTodolistTodoList { + private: + void* mValue = nullptr; + + public: + FfiValueObjectHandleTodolistTodoList() = default; + explicit FfiValueObjectHandleTodolistTodoList(void* aValue) : mValue(aValue) {} + + // Delete copy constructor and assignment as this type is non-copyable. + FfiValueObjectHandleTodolistTodoList(const FfiValueObjectHandleTodolistTodoList&) = delete; + FfiValueObjectHandleTodolistTodoList& operator=(const FfiValueObjectHandleTodolistTodoList&) = delete; + + FfiValueObjectHandleTodolistTodoList& operator=(FfiValueObjectHandleTodolistTodoList&& aOther) { + FreeHandle(); + mValue = aOther.mValue; + aOther.mValue = nullptr; + return *this; + } + + void Lower(const dom::OwningUniFFIScaffoldingValue& aValue, + ErrorResult& aError) { + if (!aValue.IsUniFFIPointer()) { + aError.ThrowTypeError("Expected UniFFI pointer argument"_ns); + return; + } + dom::UniFFIPointer& value = aValue.GetAsUniFFIPointer(); + if (!value.IsSamePtrType(&kTodolistTodoListPointerType)) { + aError.ThrowTypeError("Incorrect UniFFI pointer type"_ns); + return; + } + FreeHandle(); + mValue = value.ClonePtr(); + } + + void Lift(JSContext* aContext, dom::OwningUniFFIScaffoldingValue* aDest, + ErrorResult& aError) { + aDest->SetAsUniFFIPointer() = + dom::UniFFIPointer::Create(mValue, &kTodolistTodoListPointerType); + mValue = nullptr; + } + + void* IntoRust() { + auto temp = mValue; + mValue = nullptr; + return temp; + } + + static FfiValueObjectHandleTodolistTodoList FromRust(void* aValue) { + return FfiValueObjectHandleTodolistTodoList(aValue); + } + + void FreeHandle() { + if (mValue) { + RustCallStatus callStatus{}; + (uniffi_uniffi_todolist_fn_free_todolist)(mValue, &callStatus); + // No need to check `RustCallStatus`, it's only part of the API to match + // other FFI calls. The free function can never fail. + } + } + + ~FfiValueObjectHandleTodolistTodoList() { + // If the pointer is non-null, this means Lift/IntoRust was never called + // because there was some failure along the way. Free the pointer to avoid a + // leak + FreeHandle(); + } +}; const static mozilla::uniffi::UniFFIPointerType kUniffiTraitInterfacesCalcPointerType { "uniffi_trait_interfaces::Calc"_ns, uniffi_uniffi_trait_interfaces_fn_clone_calc, uniffi_uniffi_trait_interfaces_fn_free_calc, }; + +class FfiValueObjectHandleUniffiTraitInterfacesCalc { + private: + void* mValue = nullptr; + + public: + FfiValueObjectHandleUniffiTraitInterfacesCalc() = default; + explicit FfiValueObjectHandleUniffiTraitInterfacesCalc(void* aValue) : mValue(aValue) {} + + // Delete copy constructor and assignment as this type is non-copyable. + FfiValueObjectHandleUniffiTraitInterfacesCalc(const FfiValueObjectHandleUniffiTraitInterfacesCalc&) = delete; + FfiValueObjectHandleUniffiTraitInterfacesCalc& operator=(const FfiValueObjectHandleUniffiTraitInterfacesCalc&) = delete; + + FfiValueObjectHandleUniffiTraitInterfacesCalc& operator=(FfiValueObjectHandleUniffiTraitInterfacesCalc&& aOther) { + FreeHandle(); + mValue = aOther.mValue; + aOther.mValue = nullptr; + return *this; + } + + void Lower(const dom::OwningUniFFIScaffoldingValue& aValue, + ErrorResult& aError) { + if (!aValue.IsUniFFIPointer()) { + aError.ThrowTypeError("Expected UniFFI pointer argument"_ns); + return; + } + dom::UniFFIPointer& value = aValue.GetAsUniFFIPointer(); + if (!value.IsSamePtrType(&kUniffiTraitInterfacesCalcPointerType)) { + aError.ThrowTypeError("Incorrect UniFFI pointer type"_ns); + return; + } + FreeHandle(); + mValue = value.ClonePtr(); + } + + void Lift(JSContext* aContext, dom::OwningUniFFIScaffoldingValue* aDest, + ErrorResult& aError) { + aDest->SetAsUniFFIPointer() = + dom::UniFFIPointer::Create(mValue, &kUniffiTraitInterfacesCalcPointerType); + mValue = nullptr; + } + + void* IntoRust() { + auto temp = mValue; + mValue = nullptr; + return temp; + } + + static FfiValueObjectHandleUniffiTraitInterfacesCalc FromRust(void* aValue) { + return FfiValueObjectHandleUniffiTraitInterfacesCalc(aValue); + } + + void FreeHandle() { + if (mValue) { + RustCallStatus callStatus{}; + (uniffi_uniffi_trait_interfaces_fn_free_calc)(mValue, &callStatus); + // No need to check `RustCallStatus`, it's only part of the API to match + // other FFI calls. The free function can never fail. + } + } + + ~FfiValueObjectHandleUniffiTraitInterfacesCalc() { + // If the pointer is non-null, this means Lift/IntoRust was never called + // because there was some failure along the way. Free the pointer to avoid a + // leak + FreeHandle(); + } +}; #endif /* MOZ_UNIFFI_FIXTURES */ // Callback interface method handlers, vtables, etc. @@ -1852,13 +3416,13 @@ static StaticRefPtr gCallbackInterfaceJsHandlerAppli class CallbackInterfaceMethodApplicationErrorReporterReportError : public UniffiCallbackMethodHandlerBase { private: - // Rust arguments, converted using ScaffoldingConverter::FromRust. - typename ScaffoldingConverter::IntermediateType type_name; - typename ScaffoldingConverter::IntermediateType message; + // Rust arguments + FfiValueRustBuffer type_name{}; + FfiValueRustBuffer message{}; public: CallbackInterfaceMethodApplicationErrorReporterReportError(size_t aObjectHandle, RustBuffer type_name, RustBuffer message) - : UniffiCallbackMethodHandlerBase("errorsupport:ApplicationErrorReporter", aObjectHandle), type_name(ScaffoldingConverter::FromRust(type_name)), message(ScaffoldingConverter::FromRust(message)) { + : UniffiCallbackMethodHandlerBase("errorsupport:ApplicationErrorReporter", aObjectHandle), type_name(FfiValueRustBuffer::FromRust(type_name)), message(FfiValueRustBuffer::FromRust(message)) { } MOZ_CAN_RUN_SCRIPT @@ -1871,17 +3435,15 @@ public: } // Convert each argument - ScaffoldingConverter::IntoJs( + type_name.Lift( aCx, - std::move(this->type_name), &uniffiArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::IntoJs( + message.Lift( aCx, - std::move(this->message), &uniffiArgs[1], aError); if (aError.Failed()) { @@ -1913,15 +3475,15 @@ extern "C" void callback_interface_application_error_reporter_report_error( class CallbackInterfaceMethodApplicationErrorReporterReportBreadcrumb : public UniffiCallbackMethodHandlerBase { private: - // Rust arguments, converted using ScaffoldingConverter::FromRust. - typename ScaffoldingConverter::IntermediateType message; - typename ScaffoldingConverter::IntermediateType module; - typename ScaffoldingConverter::IntermediateType line; - typename ScaffoldingConverter::IntermediateType column; + // Rust arguments + FfiValueRustBuffer message{}; + FfiValueRustBuffer module{}; + FfiValueInt line{}; + FfiValueInt column{}; public: CallbackInterfaceMethodApplicationErrorReporterReportBreadcrumb(size_t aObjectHandle, RustBuffer message, RustBuffer module, uint32_t line, uint32_t column) - : UniffiCallbackMethodHandlerBase("errorsupport:ApplicationErrorReporter", aObjectHandle), message(ScaffoldingConverter::FromRust(message)), module(ScaffoldingConverter::FromRust(module)), line(ScaffoldingConverter::FromRust(line)), column(ScaffoldingConverter::FromRust(column)) { + : UniffiCallbackMethodHandlerBase("errorsupport:ApplicationErrorReporter", aObjectHandle), message(FfiValueRustBuffer::FromRust(message)), module(FfiValueRustBuffer::FromRust(module)), line(FfiValueInt::FromRust(line)), column(FfiValueInt::FromRust(column)) { } MOZ_CAN_RUN_SCRIPT @@ -1934,33 +3496,29 @@ public: } // Convert each argument - ScaffoldingConverter::IntoJs( + message.Lift( aCx, - std::move(this->message), &uniffiArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::IntoJs( + module.Lift( aCx, - std::move(this->module), &uniffiArgs[1], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::IntoJs( + line.Lift( aCx, - std::move(this->line), &uniffiArgs[2], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::IntoJs( + column.Lift( aCx, - std::move(this->column), &uniffiArgs[3], aError); if (aError.Failed()) { @@ -2009,12 +3567,12 @@ static StaticRefPtr gCallbackInterfaceJsHandlerLogge class CallbackInterfaceMethodLoggerLog : public UniffiCallbackMethodHandlerBase { private: - // Rust arguments, converted using ScaffoldingConverter::FromRust. - typename ScaffoldingConverter::IntermediateType message; + // Rust arguments + FfiValueRustBuffer message{}; public: CallbackInterfaceMethodLoggerLog(size_t aObjectHandle, RustBuffer message) - : UniffiCallbackMethodHandlerBase("fixture_callbacks:Logger", aObjectHandle), message(ScaffoldingConverter::FromRust(message)) { + : UniffiCallbackMethodHandlerBase("fixture_callbacks:Logger", aObjectHandle), message(FfiValueRustBuffer::FromRust(message)) { } MOZ_CAN_RUN_SCRIPT @@ -2027,9 +3585,8 @@ public: } // Convert each argument - ScaffoldingConverter::IntoJs( + message.Lift( aCx, - std::move(this->message), &uniffiArgs[0], aError); if (aError.Failed()) { @@ -2061,14 +3618,14 @@ extern "C" void callback_interface_logger_log( class CallbackInterfaceMethodLoggerLogRepeat : public UniffiCallbackMethodHandlerBase { private: - // Rust arguments, converted using ScaffoldingConverter::FromRust. - typename ScaffoldingConverter::IntermediateType message; - typename ScaffoldingConverter::IntermediateType count; - typename ScaffoldingConverter::IntermediateType exclude; + // Rust arguments + FfiValueRustBuffer message{}; + FfiValueInt count{}; + FfiValueRustBuffer exclude{}; public: CallbackInterfaceMethodLoggerLogRepeat(size_t aObjectHandle, RustBuffer message, uint32_t count, RustBuffer exclude) - : UniffiCallbackMethodHandlerBase("fixture_callbacks:Logger", aObjectHandle), message(ScaffoldingConverter::FromRust(message)), count(ScaffoldingConverter::FromRust(count)), exclude(ScaffoldingConverter::FromRust(exclude)) { + : UniffiCallbackMethodHandlerBase("fixture_callbacks:Logger", aObjectHandle), message(FfiValueRustBuffer::FromRust(message)), count(FfiValueInt::FromRust(count)), exclude(FfiValueRustBuffer::FromRust(exclude)) { } MOZ_CAN_RUN_SCRIPT @@ -2081,25 +3638,22 @@ public: } // Convert each argument - ScaffoldingConverter::IntoJs( + message.Lift( aCx, - std::move(this->message), &uniffiArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::IntoJs( + count.Lift( aCx, - std::move(this->count), &uniffiArgs[1], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::IntoJs( + exclude.Lift( aCx, - std::move(this->exclude), &uniffiArgs[2], aError); if (aError.Failed()) { @@ -2131,7 +3685,7 @@ extern "C" void callback_interface_logger_log_repeat( class CallbackInterfaceMethodLoggerFinished : public UniffiCallbackMethodHandlerBase { private: - // Rust arguments, converted using ScaffoldingConverter::FromRust. + // Rust arguments public: CallbackInterfaceMethodLoggerFinished(size_t aObjectHandle) @@ -2251,13 +3805,13 @@ void DeregisterCallbackHandler(uint64_t aInterfaceId, ErrorResult& aError) { class ScaffoldingCallHandlerUniffiErrorSupportFnFuncSetApplicationErrorReporter : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingConverter::IntermediateType mErrorReporter; + FfiValueInt mErrorReporter{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingConverter::FromJs(aArgs[0], &mErrorReporter, aError); + mErrorReporter.Lower(aArgs[0], aError); if (aError.Failed()) { return; } @@ -2265,7 +3819,7 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_error_support_fn_func_set_application_error_reporter( - ScaffoldingConverter::IntoRust(std::move(mErrorReporter)), + mErrorReporter.IntoRust(), aOutStatus ); } @@ -2295,38 +3849,37 @@ public: class ScaffoldingCallHandlerUniffiRelevancyFnFuncScore : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingConverter::IntermediateType mInterestVector; - typename ScaffoldingConverter::IntermediateType mContentCategories; + FfiValueRustBuffer mInterestVector{}; + FfiValueRustBuffer mContentCategories{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueFloat mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingConverter::FromJs(aArgs[0], &mInterestVector, aError); + mInterestVector.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mContentCategories, aError); + mContentCategories.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueFloat::FromRust( uniffi_relevancy_fn_func_score( - ScaffoldingConverter::IntoRust(std::move(mInterestVector)), - ScaffoldingConverter::IntoRust(std::move(mContentCategories)), + mInterestVector.IntoRust(), + mContentCategories.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -2335,23 +3888,23 @@ public: class ScaffoldingCallHandlerUniffiRelevancyFnMethodRelevancystoreBanditInit : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mBandit; - typename ScaffoldingConverter::IntermediateType mArms; + FfiValueObjectHandleRelevancyRelevancyStore mPtr{}; + FfiValueRustBuffer mBandit{}; + FfiValueRustBuffer mArms{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mBandit, aError); + mBandit.Lower(aArgs[1], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[2], &mArms, aError); + mArms.Lower(aArgs[2], aError); if (aError.Failed()) { return; } @@ -2359,9 +3912,9 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_relevancy_fn_method_relevancystore_bandit_init( - ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mBandit)), - ScaffoldingConverter::IntoRust(std::move(mArms)), + mPtr.IntoRust(), + mBandit.IntoRust(), + mArms.IntoRust(), aOutStatus ); } @@ -2372,44 +3925,43 @@ public: class ScaffoldingCallHandlerUniffiRelevancyFnMethodRelevancystoreBanditSelect : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mBandit; - typename ScaffoldingConverter::IntermediateType mArms; + FfiValueObjectHandleRelevancyRelevancyStore mPtr{}; + FfiValueRustBuffer mBandit{}; + FfiValueRustBuffer mArms{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mBandit, aError); + mBandit.Lower(aArgs[1], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[2], &mArms, aError); + mArms.Lower(aArgs[2], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_relevancy_fn_method_relevancystore_bandit_select( - ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mBandit)), - ScaffoldingConverter::IntoRust(std::move(mArms)), + mPtr.IntoRust(), + mBandit.IntoRust(), + mArms.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -2418,28 +3970,28 @@ public: class ScaffoldingCallHandlerUniffiRelevancyFnMethodRelevancystoreBanditUpdate : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mBandit; - typename ScaffoldingConverter::IntermediateType mArm; - typename ScaffoldingConverter::IntermediateType mSelected; + FfiValueObjectHandleRelevancyRelevancyStore mPtr{}; + FfiValueRustBuffer mBandit{}; + FfiValueRustBuffer mArm{}; + FfiValueInt mSelected{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mBandit, aError); + mBandit.Lower(aArgs[1], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[2], &mArm, aError); + mArm.Lower(aArgs[2], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[3], &mSelected, aError); + mSelected.Lower(aArgs[3], aError); if (aError.Failed()) { return; } @@ -2447,10 +3999,10 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_relevancy_fn_method_relevancystore_bandit_update( - ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mBandit)), - ScaffoldingConverter::IntoRust(std::move(mArm)), - ScaffoldingConverter::IntoRust(std::move(mSelected)), + mPtr.IntoRust(), + mBandit.IntoRust(), + mArm.IntoRust(), + mSelected.IntoRust(), aOutStatus ); } @@ -2461,13 +4013,13 @@ public: class ScaffoldingCallHandlerUniffiRelevancyFnMethodRelevancystoreClose : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::IntermediateType mPtr; + FfiValueObjectHandleRelevancyRelevancyStore mPtr{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } @@ -2475,7 +4027,7 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_relevancy_fn_method_relevancystore_close( - ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ); } @@ -2486,13 +4038,13 @@ public: class ScaffoldingCallHandlerUniffiRelevancyFnMethodRelevancystoreEnsureInterestDataPopulated : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::IntermediateType mPtr; + FfiValueObjectHandleRelevancyRelevancyStore mPtr{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } @@ -2500,7 +4052,7 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_relevancy_fn_method_relevancystore_ensure_interest_data_populated( - ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ); } @@ -2511,44 +4063,43 @@ public: class ScaffoldingCallHandlerUniffiRelevancyFnMethodRelevancystoreGetBanditData : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mBandit; - typename ScaffoldingConverter::IntermediateType mArm; + FfiValueObjectHandleRelevancyRelevancyStore mPtr{}; + FfiValueRustBuffer mBandit{}; + FfiValueRustBuffer mArm{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mBandit, aError); + mBandit.Lower(aArgs[1], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[2], &mArm, aError); + mArm.Lower(aArgs[2], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_relevancy_fn_method_relevancystore_get_bandit_data( - ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mBandit)), - ScaffoldingConverter::IntoRust(std::move(mArm)), + mPtr.IntoRust(), + mBandit.IntoRust(), + mArm.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -2557,38 +4108,37 @@ public: class ScaffoldingCallHandlerUniffiRelevancyFnMethodRelevancystoreIngest : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mTopUrlsByFrecency; + FfiValueObjectHandleRelevancyRelevancyStore mPtr{}; + FfiValueRustBuffer mTopUrlsByFrecency{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mTopUrlsByFrecency, aError); + mTopUrlsByFrecency.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_relevancy_fn_method_relevancystore_ingest( - ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mTopUrlsByFrecency)), + mPtr.IntoRust(), + mTopUrlsByFrecency.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -2597,13 +4147,13 @@ public: class ScaffoldingCallHandlerUniffiRelevancyFnMethodRelevancystoreInterrupt : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::IntermediateType mPtr; + FfiValueObjectHandleRelevancyRelevancyStore mPtr{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } @@ -2611,7 +4161,7 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_relevancy_fn_method_relevancystore_interrupt( - ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ); } @@ -2622,32 +4172,31 @@ public: class ScaffoldingCallHandlerUniffiRelevancyFnMethodRelevancystoreUserInterestVector : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::IntermediateType mPtr; + FfiValueObjectHandleRelevancyRelevancyStore mPtr{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_relevancy_fn_method_relevancystore_user_interest_vector( - ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -2656,32 +4205,31 @@ public: class ScaffoldingCallHandlerUniffiRelevancyFnConstructorRelevancystoreNew : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingConverter::IntermediateType mDbPath; + FfiValueRustBuffer mDbPath{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::IntermediateType mUniffiReturnValue; + FfiValueObjectHandleRelevancyRelevancyStore mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingConverter::FromJs(aArgs[0], &mDbPath, aError); + mDbPath.Lower(aArgs[0], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::FromRust( + mUniffiReturnValue = FfiValueObjectHandleRelevancyRelevancyStore::FromRust( uniffi_relevancy_fn_constructor_relevancystore_new( - ScaffoldingConverter::IntoRust(std::move(mDbPath)), + mDbPath.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -2690,23 +4238,23 @@ public: class ScaffoldingCallHandlerUniffiRemoteSettingsFnMethodRemotesettingsDownloadAttachmentToPath : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mAttachmentId; - typename ScaffoldingConverter::IntermediateType mPath; + FfiValueObjectHandleRemoteSettingsRemoteSettings mPtr{}; + FfiValueRustBuffer mAttachmentId{}; + FfiValueRustBuffer mPath{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mAttachmentId, aError); + mAttachmentId.Lower(aArgs[1], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[2], &mPath, aError); + mPath.Lower(aArgs[2], aError); if (aError.Failed()) { return; } @@ -2714,9 +4262,9 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_remote_settings_fn_method_remotesettings_download_attachment_to_path( - ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mAttachmentId)), - ScaffoldingConverter::IntoRust(std::move(mPath)), + mPtr.IntoRust(), + mAttachmentId.IntoRust(), + mPath.IntoRust(), aOutStatus ); } @@ -2727,32 +4275,31 @@ public: class ScaffoldingCallHandlerUniffiRemoteSettingsFnMethodRemotesettingsGetRecords : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsPointerType>::IntermediateType mPtr; + FfiValueObjectHandleRemoteSettingsRemoteSettings mPtr{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_remote_settings_fn_method_remotesettings_get_records( - ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsPointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -2761,38 +4308,37 @@ public: class ScaffoldingCallHandlerUniffiRemoteSettingsFnMethodRemotesettingsGetRecordsSince : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mTimestamp; + FfiValueObjectHandleRemoteSettingsRemoteSettings mPtr{}; + FfiValueInt mTimestamp{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mTimestamp, aError); + mTimestamp.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_remote_settings_fn_method_remotesettings_get_records_since( - ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mTimestamp)), + mPtr.IntoRust(), + mTimestamp.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -2801,32 +4347,31 @@ public: class ScaffoldingCallHandlerUniffiRemoteSettingsFnConstructorRemotesettingsNew : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingConverter::IntermediateType mRemoteSettingsConfig; + FfiValueRustBuffer mRemoteSettingsConfig{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsPointerType>::IntermediateType mUniffiReturnValue; + FfiValueObjectHandleRemoteSettingsRemoteSettings mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingConverter::FromJs(aArgs[0], &mRemoteSettingsConfig, aError); + mRemoteSettingsConfig.Lower(aArgs[0], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsPointerType>::FromRust( + mUniffiReturnValue = FfiValueObjectHandleRemoteSettingsRemoteSettings::FromRust( uniffi_remote_settings_fn_constructor_remotesettings_new( - ScaffoldingConverter::IntoRust(std::move(mRemoteSettingsConfig)), + mRemoteSettingsConfig.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsPointerType>::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -2835,32 +4380,31 @@ public: class ScaffoldingCallHandlerUniffiRemoteSettingsFnMethodRemotesettingsclientCollectionName : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsClientPointerType>::IntermediateType mPtr; + FfiValueObjectHandleRemoteSettingsRemoteSettingsClient mPtr{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsClientPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_remote_settings_fn_method_remotesettingsclient_collection_name( - ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsClientPointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -2869,38 +4413,37 @@ public: class ScaffoldingCallHandlerUniffiRemoteSettingsFnMethodRemotesettingsclientGetAttachment : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsClientPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mRecord; + FfiValueObjectHandleRemoteSettingsRemoteSettingsClient mPtr{}; + FfiValueRustBuffer mRecord{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsClientPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mRecord, aError); + mRecord.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_remote_settings_fn_method_remotesettingsclient_get_attachment( - ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsClientPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mRecord)), + mPtr.IntoRust(), + mRecord.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -2909,38 +4452,37 @@ public: class ScaffoldingCallHandlerUniffiRemoteSettingsFnMethodRemotesettingsclientGetRecords : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsClientPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mSyncIfEmpty; + FfiValueObjectHandleRemoteSettingsRemoteSettingsClient mPtr{}; + FfiValueInt mSyncIfEmpty{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsClientPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mSyncIfEmpty, aError); + mSyncIfEmpty.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_remote_settings_fn_method_remotesettingsclient_get_records( - ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsClientPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mSyncIfEmpty)), + mPtr.IntoRust(), + mSyncIfEmpty.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -2949,38 +4491,37 @@ public: class ScaffoldingCallHandlerUniffiRemoteSettingsFnMethodRemotesettingsclientGetRecordsMap : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsClientPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mSyncIfEmpty; + FfiValueObjectHandleRemoteSettingsRemoteSettingsClient mPtr{}; + FfiValueInt mSyncIfEmpty{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsClientPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mSyncIfEmpty, aError); + mSyncIfEmpty.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_remote_settings_fn_method_remotesettingsclient_get_records_map( - ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsClientPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mSyncIfEmpty)), + mPtr.IntoRust(), + mSyncIfEmpty.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -2989,13 +4530,13 @@ public: class ScaffoldingCallHandlerUniffiRemoteSettingsFnMethodRemotesettingsclientSync : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsClientPointerType>::IntermediateType mPtr; + FfiValueObjectHandleRemoteSettingsRemoteSettingsClient mPtr{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsClientPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } @@ -3003,7 +4544,7 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_remote_settings_fn_method_remotesettingsclient_sync( - ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsClientPointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ); } @@ -3014,38 +4555,37 @@ public: class ScaffoldingCallHandlerUniffiRemoteSettingsFnMethodRemotesettingsserviceMakeClient : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsServicePointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mCollectionName; + FfiValueObjectHandleRemoteSettingsRemoteSettingsService mPtr{}; + FfiValueRustBuffer mCollectionName{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsClientPointerType>::IntermediateType mUniffiReturnValue; + FfiValueObjectHandleRemoteSettingsRemoteSettingsClient mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsServicePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mCollectionName, aError); + mCollectionName.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsClientPointerType>::FromRust( + mUniffiReturnValue = FfiValueObjectHandleRemoteSettingsRemoteSettingsClient::FromRust( uniffi_remote_settings_fn_method_remotesettingsservice_make_client( - ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsServicePointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mCollectionName)), + mPtr.IntoRust(), + mCollectionName.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsClientPointerType>::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -3054,32 +4594,31 @@ public: class ScaffoldingCallHandlerUniffiRemoteSettingsFnMethodRemotesettingsserviceSync : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsServicePointerType>::IntermediateType mPtr; + FfiValueObjectHandleRemoteSettingsRemoteSettingsService mPtr{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsServicePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_remote_settings_fn_method_remotesettingsservice_sync( - ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsServicePointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -3088,18 +4627,18 @@ public: class ScaffoldingCallHandlerUniffiRemoteSettingsFnMethodRemotesettingsserviceUpdateConfig : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsServicePointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mConfig; + FfiValueObjectHandleRemoteSettingsRemoteSettingsService mPtr{}; + FfiValueRustBuffer mConfig{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsServicePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mConfig, aError); + mConfig.Lower(aArgs[1], aError); if (aError.Failed()) { return; } @@ -3107,8 +4646,8 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_remote_settings_fn_method_remotesettingsservice_update_config( - ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsServicePointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mConfig)), + mPtr.IntoRust(), + mConfig.IntoRust(), aOutStatus ); } @@ -3119,38 +4658,37 @@ public: class ScaffoldingCallHandlerUniffiRemoteSettingsFnConstructorRemotesettingsserviceNew : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingConverter::IntermediateType mStorageDir; - typename ScaffoldingConverter::IntermediateType mConfig; + FfiValueRustBuffer mStorageDir{}; + FfiValueRustBuffer mConfig{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsServicePointerType>::IntermediateType mUniffiReturnValue; + FfiValueObjectHandleRemoteSettingsRemoteSettingsService mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingConverter::FromJs(aArgs[0], &mStorageDir, aError); + mStorageDir.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mConfig, aError); + mConfig.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsServicePointerType>::FromRust( + mUniffiReturnValue = FfiValueObjectHandleRemoteSettingsRemoteSettingsService::FromRust( uniffi_remote_settings_fn_constructor_remotesettingsservice_new( - ScaffoldingConverter::IntoRust(std::move(mStorageDir)), - ScaffoldingConverter::IntoRust(std::move(mConfig)), + mStorageDir.IntoRust(), + mConfig.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsServicePointerType>::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -3159,13 +4697,13 @@ public: class ScaffoldingCallHandlerUniffiSearchFnMethodSearchengineselectorClearSearchConfig : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kSearchSearchEngineSelectorPointerType>::IntermediateType mPtr; + FfiValueObjectHandleSearchSearchEngineSelector mPtr{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kSearchSearchEngineSelectorPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } @@ -3173,7 +4711,7 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_search_fn_method_searchengineselector_clear_search_config( - ScaffoldingObjectConverter<&kSearchSearchEngineSelectorPointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ); } @@ -3184,38 +4722,37 @@ public: class ScaffoldingCallHandlerUniffiSearchFnMethodSearchengineselectorFilterEngineConfiguration : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kSearchSearchEngineSelectorPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mUserEnvironment; + FfiValueObjectHandleSearchSearchEngineSelector mPtr{}; + FfiValueRustBuffer mUserEnvironment{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kSearchSearchEngineSelectorPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mUserEnvironment, aError); + mUserEnvironment.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_search_fn_method_searchengineselector_filter_engine_configuration( - ScaffoldingObjectConverter<&kSearchSearchEngineSelectorPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mUserEnvironment)), + mPtr.IntoRust(), + mUserEnvironment.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -3224,18 +4761,18 @@ public: class ScaffoldingCallHandlerUniffiSearchFnMethodSearchengineselectorSetConfigOverrides : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kSearchSearchEngineSelectorPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mOverrides; + FfiValueObjectHandleSearchSearchEngineSelector mPtr{}; + FfiValueRustBuffer mOverrides{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kSearchSearchEngineSelectorPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mOverrides, aError); + mOverrides.Lower(aArgs[1], aError); if (aError.Failed()) { return; } @@ -3243,8 +4780,8 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_search_fn_method_searchengineselector_set_config_overrides( - ScaffoldingObjectConverter<&kSearchSearchEngineSelectorPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mOverrides)), + mPtr.IntoRust(), + mOverrides.IntoRust(), aOutStatus ); } @@ -3255,18 +4792,18 @@ public: class ScaffoldingCallHandlerUniffiSearchFnMethodSearchengineselectorSetSearchConfig : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kSearchSearchEngineSelectorPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mConfiguration; + FfiValueObjectHandleSearchSearchEngineSelector mPtr{}; + FfiValueRustBuffer mConfiguration{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kSearchSearchEngineSelectorPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mConfiguration, aError); + mConfiguration.Lower(aArgs[1], aError); if (aError.Failed()) { return; } @@ -3274,8 +4811,8 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_search_fn_method_searchengineselector_set_search_config( - ScaffoldingObjectConverter<&kSearchSearchEngineSelectorPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mConfiguration)), + mPtr.IntoRust(), + mConfiguration.IntoRust(), aOutStatus ); } @@ -3286,23 +4823,23 @@ public: class ScaffoldingCallHandlerUniffiSearchFnMethodSearchengineselectorUseRemoteSettingsServer : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kSearchSearchEngineSelectorPointerType>::IntermediateType mPtr; - typename ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsServicePointerType>::IntermediateType mService; - typename ScaffoldingConverter::IntermediateType mApplyEngineOverrides; + FfiValueObjectHandleSearchSearchEngineSelector mPtr{}; + FfiValueObjectHandleRemoteSettingsRemoteSettingsService mService{}; + FfiValueInt mApplyEngineOverrides{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kSearchSearchEngineSelectorPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsServicePointerType>::FromJs(aArgs[1], &mService, aError); + mService.Lower(aArgs[1], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[2], &mApplyEngineOverrides, aError); + mApplyEngineOverrides.Lower(aArgs[2], aError); if (aError.Failed()) { return; } @@ -3310,9 +4847,9 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_search_fn_method_searchengineselector_use_remote_settings_server( - ScaffoldingObjectConverter<&kSearchSearchEngineSelectorPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsServicePointerType>::IntoRust(std::move(mService)), - ScaffoldingConverter::IntoRust(std::move(mApplyEngineOverrides)), + mPtr.IntoRust(), + mService.IntoRust(), + mApplyEngineOverrides.IntoRust(), aOutStatus ); } @@ -3325,14 +4862,14 @@ private: // PrepareRustArgs stores the resulting arguments in these fields // MakeRustCall stores the result of the call in these fields - typename ScaffoldingObjectConverter<&kSearchSearchEngineSelectorPointerType>::IntermediateType mUniffiReturnValue; + FfiValueObjectHandleSearchSearchEngineSelector mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingObjectConverter<&kSearchSearchEngineSelectorPointerType>::FromRust( + mUniffiReturnValue = FfiValueObjectHandleSearchSearchEngineSelector::FromRust( uniffi_search_fn_constructor_searchengineselector_new( aOutStatus ) @@ -3340,9 +4877,8 @@ public: } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kSearchSearchEngineSelectorPointerType>::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -3351,38 +4887,37 @@ public: class ScaffoldingCallHandlerUniffiSuggestFnFuncRawSuggestionUrlMatches : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingConverter::IntermediateType mRawUrl; - typename ScaffoldingConverter::IntermediateType mCookedUrl; + FfiValueRustBuffer mRawUrl{}; + FfiValueRustBuffer mCookedUrl{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingConverter::FromJs(aArgs[0], &mRawUrl, aError); + mRawUrl.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mCookedUrl, aError); + mCookedUrl.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( uniffi_suggest_fn_func_raw_suggestion_url_matches( - ScaffoldingConverter::IntoRust(std::move(mRawUrl)), - ScaffoldingConverter::IntoRust(std::move(mCookedUrl)), + mRawUrl.IntoRust(), + mCookedUrl.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -3391,13 +4926,13 @@ public: class ScaffoldingCallHandlerUniffiSuggestFnMethodSuggeststoreClear : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::IntermediateType mPtr; + FfiValueObjectHandleSuggestSuggestStore mPtr{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } @@ -3405,7 +4940,7 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_suggest_fn_method_suggeststore_clear( - ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ); } @@ -3416,13 +4951,13 @@ public: class ScaffoldingCallHandlerUniffiSuggestFnMethodSuggeststoreClearDismissedSuggestions : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::IntermediateType mPtr; + FfiValueObjectHandleSuggestSuggestStore mPtr{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } @@ -3430,7 +4965,7 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_suggest_fn_method_suggeststore_clear_dismissed_suggestions( - ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ); } @@ -3441,18 +4976,18 @@ public: class ScaffoldingCallHandlerUniffiSuggestFnMethodSuggeststoreDismissSuggestion : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mSuggestionUrl; + FfiValueObjectHandleSuggestSuggestStore mPtr{}; + FfiValueRustBuffer mSuggestionUrl{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mSuggestionUrl, aError); + mSuggestionUrl.Lower(aArgs[1], aError); if (aError.Failed()) { return; } @@ -3460,8 +4995,8 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_suggest_fn_method_suggeststore_dismiss_suggestion( - ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mSuggestionUrl)), + mPtr.IntoRust(), + mSuggestionUrl.IntoRust(), aOutStatus ); } @@ -3472,56 +5007,55 @@ public: class ScaffoldingCallHandlerUniffiSuggestFnMethodSuggeststoreFetchGeonames : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mQuery; - typename ScaffoldingConverter::IntermediateType mMatchNamePrefix; - typename ScaffoldingConverter::IntermediateType mGeonameType; - typename ScaffoldingConverter::IntermediateType mFilter; + FfiValueObjectHandleSuggestSuggestStore mPtr{}; + FfiValueRustBuffer mQuery{}; + FfiValueInt mMatchNamePrefix{}; + FfiValueRustBuffer mGeonameType{}; + FfiValueRustBuffer mFilter{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mQuery, aError); + mQuery.Lower(aArgs[1], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[2], &mMatchNamePrefix, aError); + mMatchNamePrefix.Lower(aArgs[2], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[3], &mGeonameType, aError); + mGeonameType.Lower(aArgs[3], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[4], &mFilter, aError); + mFilter.Lower(aArgs[4], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_suggest_fn_method_suggeststore_fetch_geonames( - ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mQuery)), - ScaffoldingConverter::IntoRust(std::move(mMatchNamePrefix)), - ScaffoldingConverter::IntoRust(std::move(mGeonameType)), - ScaffoldingConverter::IntoRust(std::move(mFilter)), + mPtr.IntoRust(), + mQuery.IntoRust(), + mMatchNamePrefix.IntoRust(), + mGeonameType.IntoRust(), + mFilter.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -3530,32 +5064,31 @@ public: class ScaffoldingCallHandlerUniffiSuggestFnMethodSuggeststoreFetchGlobalConfig : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::IntermediateType mPtr; + FfiValueObjectHandleSuggestSuggestStore mPtr{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_suggest_fn_method_suggeststore_fetch_global_config( - ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -3564,38 +5097,37 @@ public: class ScaffoldingCallHandlerUniffiSuggestFnMethodSuggeststoreFetchProviderConfig : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mProvider; + FfiValueObjectHandleSuggestSuggestStore mPtr{}; + FfiValueRustBuffer mProvider{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mProvider, aError); + mProvider.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_suggest_fn_method_suggeststore_fetch_provider_config( - ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mProvider)), + mPtr.IntoRust(), + mProvider.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -3604,38 +5136,37 @@ public: class ScaffoldingCallHandlerUniffiSuggestFnMethodSuggeststoreIngest : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mConstraints; + FfiValueObjectHandleSuggestSuggestStore mPtr{}; + FfiValueRustBuffer mConstraints{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mConstraints, aError); + mConstraints.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_suggest_fn_method_suggeststore_ingest( - ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mConstraints)), + mPtr.IntoRust(), + mConstraints.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -3644,18 +5175,18 @@ public: class ScaffoldingCallHandlerUniffiSuggestFnMethodSuggeststoreInterrupt : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mKind; + FfiValueObjectHandleSuggestSuggestStore mPtr{}; + FfiValueRustBuffer mKind{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mKind, aError); + mKind.Lower(aArgs[1], aError); if (aError.Failed()) { return; } @@ -3663,8 +5194,8 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_suggest_fn_method_suggeststore_interrupt( - ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mKind)), + mPtr.IntoRust(), + mKind.IntoRust(), aOutStatus ); } @@ -3675,38 +5206,37 @@ public: class ScaffoldingCallHandlerUniffiSuggestFnMethodSuggeststoreQuery : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mQuery; + FfiValueObjectHandleSuggestSuggestStore mPtr{}; + FfiValueRustBuffer mQuery{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mQuery, aError); + mQuery.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_suggest_fn_method_suggeststore_query( - ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mQuery)), + mPtr.IntoRust(), + mQuery.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -3715,38 +5245,37 @@ public: class ScaffoldingCallHandlerUniffiSuggestFnMethodSuggeststoreQueryWithMetrics : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mQuery; + FfiValueObjectHandleSuggestSuggestStore mPtr{}; + FfiValueRustBuffer mQuery{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mQuery, aError); + mQuery.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_suggest_fn_method_suggeststore_query_with_metrics( - ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mQuery)), + mPtr.IntoRust(), + mQuery.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -3755,38 +5284,37 @@ public: class ScaffoldingCallHandlerUniffiSuggestFnConstructorSuggeststoreNew : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingConverter::IntermediateType mPath; - typename ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsServicePointerType>::IntermediateType mRemoteSettingsService; + FfiValueRustBuffer mPath{}; + FfiValueObjectHandleRemoteSettingsRemoteSettingsService mRemoteSettingsService{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::IntermediateType mUniffiReturnValue; + FfiValueObjectHandleSuggestSuggestStore mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingConverter::FromJs(aArgs[0], &mPath, aError); + mPath.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsServicePointerType>::FromJs(aArgs[1], &mRemoteSettingsService, aError); + mRemoteSettingsService.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::FromRust( + mUniffiReturnValue = FfiValueObjectHandleSuggestSuggestStore::FromRust( uniffi_suggest_fn_constructor_suggeststore_new( - ScaffoldingConverter::IntoRust(std::move(mPath)), - ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsServicePointerType>::IntoRust(std::move(mRemoteSettingsService)), + mPath.IntoRust(), + mRemoteSettingsService.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -3795,32 +5323,31 @@ public: class ScaffoldingCallHandlerUniffiSuggestFnMethodSuggeststorebuilderBuild : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntermediateType mPtr; + FfiValueObjectHandleSuggestSuggestStoreBuilder mPtr{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::IntermediateType mUniffiReturnValue; + FfiValueObjectHandleSuggestSuggestStore mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::FromRust( + mUniffiReturnValue = FfiValueObjectHandleSuggestSuggestStore::FromRust( uniffi_suggest_fn_method_suggeststorebuilder_build( - ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -3829,38 +5356,37 @@ public: class ScaffoldingCallHandlerUniffiSuggestFnMethodSuggeststorebuilderCachePath : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mPath; + FfiValueObjectHandleSuggestSuggestStoreBuilder mPtr{}; + FfiValueRustBuffer mPath{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntermediateType mUniffiReturnValue; + FfiValueObjectHandleSuggestSuggestStoreBuilder mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mPath, aError); + mPath.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::FromRust( + mUniffiReturnValue = FfiValueObjectHandleSuggestSuggestStoreBuilder::FromRust( uniffi_suggest_fn_method_suggeststorebuilder_cache_path( - ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mPath)), + mPtr.IntoRust(), + mPath.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -3869,38 +5395,37 @@ public: class ScaffoldingCallHandlerUniffiSuggestFnMethodSuggeststorebuilderDataPath : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mPath; + FfiValueObjectHandleSuggestSuggestStoreBuilder mPtr{}; + FfiValueRustBuffer mPath{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntermediateType mUniffiReturnValue; + FfiValueObjectHandleSuggestSuggestStoreBuilder mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mPath, aError); + mPath.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::FromRust( + mUniffiReturnValue = FfiValueObjectHandleSuggestSuggestStoreBuilder::FromRust( uniffi_suggest_fn_method_suggeststorebuilder_data_path( - ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mPath)), + mPtr.IntoRust(), + mPath.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -3909,44 +5434,43 @@ public: class ScaffoldingCallHandlerUniffiSuggestFnMethodSuggeststorebuilderLoadExtension : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mLibrary; - typename ScaffoldingConverter::IntermediateType mEntryPoint; + FfiValueObjectHandleSuggestSuggestStoreBuilder mPtr{}; + FfiValueRustBuffer mLibrary{}; + FfiValueRustBuffer mEntryPoint{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntermediateType mUniffiReturnValue; + FfiValueObjectHandleSuggestSuggestStoreBuilder mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mLibrary, aError); + mLibrary.Lower(aArgs[1], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[2], &mEntryPoint, aError); + mEntryPoint.Lower(aArgs[2], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::FromRust( + mUniffiReturnValue = FfiValueObjectHandleSuggestSuggestStoreBuilder::FromRust( uniffi_suggest_fn_method_suggeststorebuilder_load_extension( - ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mLibrary)), - ScaffoldingConverter::IntoRust(std::move(mEntryPoint)), + mPtr.IntoRust(), + mLibrary.IntoRust(), + mEntryPoint.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -3955,38 +5479,37 @@ public: class ScaffoldingCallHandlerUniffiSuggestFnMethodSuggeststorebuilderRemoteSettingsBucketName : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mBucketName; + FfiValueObjectHandleSuggestSuggestStoreBuilder mPtr{}; + FfiValueRustBuffer mBucketName{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntermediateType mUniffiReturnValue; + FfiValueObjectHandleSuggestSuggestStoreBuilder mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mBucketName, aError); + mBucketName.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::FromRust( + mUniffiReturnValue = FfiValueObjectHandleSuggestSuggestStoreBuilder::FromRust( uniffi_suggest_fn_method_suggeststorebuilder_remote_settings_bucket_name( - ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mBucketName)), + mPtr.IntoRust(), + mBucketName.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -3995,38 +5518,37 @@ public: class ScaffoldingCallHandlerUniffiSuggestFnMethodSuggeststorebuilderRemoteSettingsServer : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mServer; + FfiValueObjectHandleSuggestSuggestStoreBuilder mPtr{}; + FfiValueRustBuffer mServer{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntermediateType mUniffiReturnValue; + FfiValueObjectHandleSuggestSuggestStoreBuilder mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mServer, aError); + mServer.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::FromRust( + mUniffiReturnValue = FfiValueObjectHandleSuggestSuggestStoreBuilder::FromRust( uniffi_suggest_fn_method_suggeststorebuilder_remote_settings_server( - ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mServer)), + mPtr.IntoRust(), + mServer.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -4035,38 +5557,37 @@ public: class ScaffoldingCallHandlerUniffiSuggestFnMethodSuggeststorebuilderRemoteSettingsService : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntermediateType mPtr; - typename ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsServicePointerType>::IntermediateType mRsService; + FfiValueObjectHandleSuggestSuggestStoreBuilder mPtr{}; + FfiValueObjectHandleRemoteSettingsRemoteSettingsService mRsService{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntermediateType mUniffiReturnValue; + FfiValueObjectHandleSuggestSuggestStoreBuilder mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsServicePointerType>::FromJs(aArgs[1], &mRsService, aError); + mRsService.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::FromRust( + mUniffiReturnValue = FfiValueObjectHandleSuggestSuggestStoreBuilder::FromRust( uniffi_suggest_fn_method_suggeststorebuilder_remote_settings_service( - ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsServicePointerType>::IntoRust(std::move(mRsService)), + mPtr.IntoRust(), + mRsService.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -4077,14 +5598,14 @@ private: // PrepareRustArgs stores the resulting arguments in these fields // MakeRustCall stores the result of the call in these fields - typename ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntermediateType mUniffiReturnValue; + FfiValueObjectHandleSuggestSuggestStoreBuilder mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::FromRust( + mUniffiReturnValue = FfiValueObjectHandleSuggestSuggestStoreBuilder::FromRust( uniffi_suggest_fn_constructor_suggeststorebuilder_new( aOutStatus ) @@ -4092,9 +5613,8 @@ public: } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -4103,44 +5623,43 @@ public: class ScaffoldingCallHandlerUniffiTabsFnMethodRemotecommandstoreAddRemoteCommand : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kTabsRemoteCommandStorePointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mDeviceId; - typename ScaffoldingConverter::IntermediateType mCommand; + FfiValueObjectHandleTabsRemoteCommandStore mPtr{}; + FfiValueRustBuffer mDeviceId{}; + FfiValueRustBuffer mCommand{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kTabsRemoteCommandStorePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mDeviceId, aError); + mDeviceId.Lower(aArgs[1], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[2], &mCommand, aError); + mCommand.Lower(aArgs[2], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( uniffi_tabs_fn_method_remotecommandstore_add_remote_command( - ScaffoldingObjectConverter<&kTabsRemoteCommandStorePointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mDeviceId)), - ScaffoldingConverter::IntoRust(std::move(mCommand)), + mPtr.IntoRust(), + mDeviceId.IntoRust(), + mCommand.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -4149,50 +5668,49 @@ public: class ScaffoldingCallHandlerUniffiTabsFnMethodRemotecommandstoreAddRemoteCommandAt : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kTabsRemoteCommandStorePointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mDeviceId; - typename ScaffoldingConverter::IntermediateType mCommand; - typename ScaffoldingConverter::IntermediateType mWhen; + FfiValueObjectHandleTabsRemoteCommandStore mPtr{}; + FfiValueRustBuffer mDeviceId{}; + FfiValueRustBuffer mCommand{}; + FfiValueInt mWhen{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kTabsRemoteCommandStorePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mDeviceId, aError); + mDeviceId.Lower(aArgs[1], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[2], &mCommand, aError); + mCommand.Lower(aArgs[2], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[3], &mWhen, aError); + mWhen.Lower(aArgs[3], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( uniffi_tabs_fn_method_remotecommandstore_add_remote_command_at( - ScaffoldingObjectConverter<&kTabsRemoteCommandStorePointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mDeviceId)), - ScaffoldingConverter::IntoRust(std::move(mCommand)), - ScaffoldingConverter::IntoRust(std::move(mWhen)), + mPtr.IntoRust(), + mDeviceId.IntoRust(), + mCommand.IntoRust(), + mWhen.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -4201,32 +5719,31 @@ public: class ScaffoldingCallHandlerUniffiTabsFnMethodRemotecommandstoreGetUnsentCommands : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kTabsRemoteCommandStorePointerType>::IntermediateType mPtr; + FfiValueObjectHandleTabsRemoteCommandStore mPtr{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kTabsRemoteCommandStorePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_tabs_fn_method_remotecommandstore_get_unsent_commands( - ScaffoldingObjectConverter<&kTabsRemoteCommandStorePointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -4235,44 +5752,43 @@ public: class ScaffoldingCallHandlerUniffiTabsFnMethodRemotecommandstoreRemoveRemoteCommand : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kTabsRemoteCommandStorePointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mDeviceId; - typename ScaffoldingConverter::IntermediateType mCommand; + FfiValueObjectHandleTabsRemoteCommandStore mPtr{}; + FfiValueRustBuffer mDeviceId{}; + FfiValueRustBuffer mCommand{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kTabsRemoteCommandStorePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mDeviceId, aError); + mDeviceId.Lower(aArgs[1], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[2], &mCommand, aError); + mCommand.Lower(aArgs[2], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( uniffi_tabs_fn_method_remotecommandstore_remove_remote_command( - ScaffoldingObjectConverter<&kTabsRemoteCommandStorePointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mDeviceId)), - ScaffoldingConverter::IntoRust(std::move(mCommand)), + mPtr.IntoRust(), + mDeviceId.IntoRust(), + mCommand.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -4281,38 +5797,37 @@ public: class ScaffoldingCallHandlerUniffiTabsFnMethodRemotecommandstoreSetPendingCommandSent : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kTabsRemoteCommandStorePointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mCommand; + FfiValueObjectHandleTabsRemoteCommandStore mPtr{}; + FfiValueRustBuffer mCommand{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kTabsRemoteCommandStorePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mCommand, aError); + mCommand.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( uniffi_tabs_fn_method_remotecommandstore_set_pending_command_sent( - ScaffoldingObjectConverter<&kTabsRemoteCommandStorePointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mCommand)), + mPtr.IntoRust(), + mCommand.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -4321,32 +5836,31 @@ public: class ScaffoldingCallHandlerUniffiTabsFnMethodTabsbridgedengineApply : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntermediateType mPtr; + FfiValueObjectHandleTabsTabsBridgedEngine mPtr{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_tabs_fn_method_tabsbridgedengine_apply( - ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -4355,38 +5869,37 @@ public: class ScaffoldingCallHandlerUniffiTabsFnMethodTabsbridgedengineEnsureCurrentSyncId : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mNewSyncId; + FfiValueObjectHandleTabsTabsBridgedEngine mPtr{}; + FfiValueRustBuffer mNewSyncId{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mNewSyncId, aError); + mNewSyncId.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_tabs_fn_method_tabsbridgedengine_ensure_current_sync_id( - ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mNewSyncId)), + mPtr.IntoRust(), + mNewSyncId.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -4395,32 +5908,31 @@ public: class ScaffoldingCallHandlerUniffiTabsFnMethodTabsbridgedengineLastSync : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntermediateType mPtr; + FfiValueObjectHandleTabsTabsBridgedEngine mPtr{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( uniffi_tabs_fn_method_tabsbridgedengine_last_sync( - ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -4429,18 +5941,18 @@ public: class ScaffoldingCallHandlerUniffiTabsFnMethodTabsbridgedenginePrepareForSync : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mClientData; + FfiValueObjectHandleTabsTabsBridgedEngine mPtr{}; + FfiValueRustBuffer mClientData{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mClientData, aError); + mClientData.Lower(aArgs[1], aError); if (aError.Failed()) { return; } @@ -4448,8 +5960,8 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_tabs_fn_method_tabsbridgedengine_prepare_for_sync( - ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mClientData)), + mPtr.IntoRust(), + mClientData.IntoRust(), aOutStatus ); } @@ -4460,13 +5972,13 @@ public: class ScaffoldingCallHandlerUniffiTabsFnMethodTabsbridgedengineReset : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntermediateType mPtr; + FfiValueObjectHandleTabsTabsBridgedEngine mPtr{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } @@ -4474,7 +5986,7 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_tabs_fn_method_tabsbridgedengine_reset( - ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ); } @@ -4485,32 +5997,31 @@ public: class ScaffoldingCallHandlerUniffiTabsFnMethodTabsbridgedengineResetSyncId : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntermediateType mPtr; + FfiValueObjectHandleTabsTabsBridgedEngine mPtr{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_tabs_fn_method_tabsbridgedengine_reset_sync_id( - ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -4519,18 +6030,18 @@ public: class ScaffoldingCallHandlerUniffiTabsFnMethodTabsbridgedengineSetLastSync : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mLastSync; + FfiValueObjectHandleTabsTabsBridgedEngine mPtr{}; + FfiValueInt mLastSync{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mLastSync, aError); + mLastSync.Lower(aArgs[1], aError); if (aError.Failed()) { return; } @@ -4538,8 +6049,8 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_tabs_fn_method_tabsbridgedengine_set_last_sync( - ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mLastSync)), + mPtr.IntoRust(), + mLastSync.IntoRust(), aOutStatus ); } @@ -4550,23 +6061,23 @@ public: class ScaffoldingCallHandlerUniffiTabsFnMethodTabsbridgedengineSetUploaded : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mNewTimestamp; - typename ScaffoldingConverter::IntermediateType mUploadedIds; + FfiValueObjectHandleTabsTabsBridgedEngine mPtr{}; + FfiValueInt mNewTimestamp{}; + FfiValueRustBuffer mUploadedIds{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mNewTimestamp, aError); + mNewTimestamp.Lower(aArgs[1], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[2], &mUploadedIds, aError); + mUploadedIds.Lower(aArgs[2], aError); if (aError.Failed()) { return; } @@ -4574,9 +6085,9 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_tabs_fn_method_tabsbridgedengine_set_uploaded( - ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mNewTimestamp)), - ScaffoldingConverter::IntoRust(std::move(mUploadedIds)), + mPtr.IntoRust(), + mNewTimestamp.IntoRust(), + mUploadedIds.IntoRust(), aOutStatus ); } @@ -4587,18 +6098,18 @@ public: class ScaffoldingCallHandlerUniffiTabsFnMethodTabsbridgedengineStoreIncoming : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mIncomingEnvelopesAsJson; + FfiValueObjectHandleTabsTabsBridgedEngine mPtr{}; + FfiValueRustBuffer mIncomingEnvelopesAsJson{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mIncomingEnvelopesAsJson, aError); + mIncomingEnvelopesAsJson.Lower(aArgs[1], aError); if (aError.Failed()) { return; } @@ -4606,8 +6117,8 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_tabs_fn_method_tabsbridgedengine_store_incoming( - ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mIncomingEnvelopesAsJson)), + mPtr.IntoRust(), + mIncomingEnvelopesAsJson.IntoRust(), aOutStatus ); } @@ -4618,13 +6129,13 @@ public: class ScaffoldingCallHandlerUniffiTabsFnMethodTabsbridgedengineSyncFinished : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntermediateType mPtr; + FfiValueObjectHandleTabsTabsBridgedEngine mPtr{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } @@ -4632,7 +6143,7 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_tabs_fn_method_tabsbridgedengine_sync_finished( - ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ); } @@ -4643,32 +6154,31 @@ public: class ScaffoldingCallHandlerUniffiTabsFnMethodTabsbridgedengineSyncId : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntermediateType mPtr; + FfiValueObjectHandleTabsTabsBridgedEngine mPtr{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_tabs_fn_method_tabsbridgedengine_sync_id( - ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -4677,13 +6187,13 @@ public: class ScaffoldingCallHandlerUniffiTabsFnMethodTabsbridgedengineSyncStarted : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntermediateType mPtr; + FfiValueObjectHandleTabsTabsBridgedEngine mPtr{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } @@ -4691,7 +6201,7 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_tabs_fn_method_tabsbridgedengine_sync_started( - ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ); } @@ -4702,13 +6212,13 @@ public: class ScaffoldingCallHandlerUniffiTabsFnMethodTabsbridgedengineWipe : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntermediateType mPtr; + FfiValueObjectHandleTabsTabsBridgedEngine mPtr{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } @@ -4716,7 +6226,7 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_tabs_fn_method_tabsbridgedengine_wipe( - ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ); } @@ -4727,32 +6237,31 @@ public: class ScaffoldingCallHandlerUniffiTabsFnMethodTabsstoreBridgedEngine : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kTabsTabsStorePointerType>::IntermediateType mPtr; + FfiValueObjectHandleTabsTabsStore mPtr{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntermediateType mUniffiReturnValue; + FfiValueObjectHandleTabsTabsBridgedEngine mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kTabsTabsStorePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::FromRust( + mUniffiReturnValue = FfiValueObjectHandleTabsTabsBridgedEngine::FromRust( uniffi_tabs_fn_method_tabsstore_bridged_engine( - ScaffoldingObjectConverter<&kTabsTabsStorePointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -4761,13 +6270,13 @@ public: class ScaffoldingCallHandlerUniffiTabsFnMethodTabsstoreCloseConnection : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kTabsTabsStorePointerType>::IntermediateType mPtr; + FfiValueObjectHandleTabsTabsStore mPtr{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kTabsTabsStorePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } @@ -4775,7 +6284,7 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_tabs_fn_method_tabsstore_close_connection( - ScaffoldingObjectConverter<&kTabsTabsStorePointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ); } @@ -4786,32 +6295,31 @@ public: class ScaffoldingCallHandlerUniffiTabsFnMethodTabsstoreGetAll : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kTabsTabsStorePointerType>::IntermediateType mPtr; + FfiValueObjectHandleTabsTabsStore mPtr{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kTabsTabsStorePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_tabs_fn_method_tabsstore_get_all( - ScaffoldingObjectConverter<&kTabsTabsStorePointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -4820,32 +6328,31 @@ public: class ScaffoldingCallHandlerUniffiTabsFnMethodTabsstoreNewRemoteCommandStore : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kTabsTabsStorePointerType>::IntermediateType mPtr; + FfiValueObjectHandleTabsTabsStore mPtr{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingObjectConverter<&kTabsRemoteCommandStorePointerType>::IntermediateType mUniffiReturnValue; + FfiValueObjectHandleTabsRemoteCommandStore mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kTabsTabsStorePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingObjectConverter<&kTabsRemoteCommandStorePointerType>::FromRust( + mUniffiReturnValue = FfiValueObjectHandleTabsRemoteCommandStore::FromRust( uniffi_tabs_fn_method_tabsstore_new_remote_command_store( - ScaffoldingObjectConverter<&kTabsTabsStorePointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kTabsRemoteCommandStorePointerType>::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -4854,13 +6361,13 @@ public: class ScaffoldingCallHandlerUniffiTabsFnMethodTabsstoreRegisterWithSyncManager : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kTabsTabsStorePointerType>::IntermediateType mPtr; + FfiValueObjectHandleTabsTabsStore mPtr{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kTabsTabsStorePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } @@ -4868,7 +6375,7 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_tabs_fn_method_tabsstore_register_with_sync_manager( - ScaffoldingObjectConverter<&kTabsTabsStorePointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ); } @@ -4879,18 +6386,18 @@ public: class ScaffoldingCallHandlerUniffiTabsFnMethodTabsstoreSetLocalTabs : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kTabsTabsStorePointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mRemoteTabs; + FfiValueObjectHandleTabsTabsStore mPtr{}; + FfiValueRustBuffer mRemoteTabs{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kTabsTabsStorePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mRemoteTabs, aError); + mRemoteTabs.Lower(aArgs[1], aError); if (aError.Failed()) { return; } @@ -4898,8 +6405,8 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_tabs_fn_method_tabsstore_set_local_tabs( - ScaffoldingObjectConverter<&kTabsTabsStorePointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mRemoteTabs)), + mPtr.IntoRust(), + mRemoteTabs.IntoRust(), aOutStatus ); } @@ -4910,32 +6417,31 @@ public: class ScaffoldingCallHandlerUniffiTabsFnConstructorTabsstoreNew : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingConverter::IntermediateType mPath; + FfiValueRustBuffer mPath{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingObjectConverter<&kTabsTabsStorePointerType>::IntermediateType mUniffiReturnValue; + FfiValueObjectHandleTabsTabsStore mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingConverter::FromJs(aArgs[0], &mPath, aError); + mPath.Lower(aArgs[0], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingObjectConverter<&kTabsTabsStorePointerType>::FromRust( + mUniffiReturnValue = FfiValueObjectHandleTabsTabsStore::FromRust( uniffi_tabs_fn_constructor_tabsstore_new( - ScaffoldingConverter::IntoRust(std::move(mPath)), + mPath.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kTabsTabsStorePointerType>::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -4944,32 +6450,31 @@ public: class ScaffoldingCallHandlerUniffiWebextStorageFnMethodWebextstoragebridgedengineApply : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntermediateType mPtr; + FfiValueObjectHandleWebextstorageWebExtStorageBridgedEngine mPtr{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_webext_storage_fn_method_webextstoragebridgedengine_apply( - ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -4978,38 +6483,37 @@ public: class ScaffoldingCallHandlerUniffiWebextStorageFnMethodWebextstoragebridgedengineEnsureCurrentSyncId : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mNewSyncId; + FfiValueObjectHandleWebextstorageWebExtStorageBridgedEngine mPtr{}; + FfiValueRustBuffer mNewSyncId{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mNewSyncId, aError); + mNewSyncId.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_webext_storage_fn_method_webextstoragebridgedengine_ensure_current_sync_id( - ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mNewSyncId)), + mPtr.IntoRust(), + mNewSyncId.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -5018,32 +6522,31 @@ public: class ScaffoldingCallHandlerUniffiWebextStorageFnMethodWebextstoragebridgedengineLastSync : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntermediateType mPtr; + FfiValueObjectHandleWebextstorageWebExtStorageBridgedEngine mPtr{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( uniffi_webext_storage_fn_method_webextstoragebridgedengine_last_sync( - ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -5052,18 +6555,18 @@ public: class ScaffoldingCallHandlerUniffiWebextStorageFnMethodWebextstoragebridgedenginePrepareForSync : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mClientData; + FfiValueObjectHandleWebextstorageWebExtStorageBridgedEngine mPtr{}; + FfiValueRustBuffer mClientData{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mClientData, aError); + mClientData.Lower(aArgs[1], aError); if (aError.Failed()) { return; } @@ -5071,8 +6574,8 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_webext_storage_fn_method_webextstoragebridgedengine_prepare_for_sync( - ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mClientData)), + mPtr.IntoRust(), + mClientData.IntoRust(), aOutStatus ); } @@ -5083,13 +6586,13 @@ public: class ScaffoldingCallHandlerUniffiWebextStorageFnMethodWebextstoragebridgedengineReset : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntermediateType mPtr; + FfiValueObjectHandleWebextstorageWebExtStorageBridgedEngine mPtr{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } @@ -5097,7 +6600,7 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_webext_storage_fn_method_webextstoragebridgedengine_reset( - ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ); } @@ -5108,32 +6611,31 @@ public: class ScaffoldingCallHandlerUniffiWebextStorageFnMethodWebextstoragebridgedengineResetSyncId : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntermediateType mPtr; + FfiValueObjectHandleWebextstorageWebExtStorageBridgedEngine mPtr{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_webext_storage_fn_method_webextstoragebridgedengine_reset_sync_id( - ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -5142,18 +6644,18 @@ public: class ScaffoldingCallHandlerUniffiWebextStorageFnMethodWebextstoragebridgedengineSetLastSync : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mLastSync; + FfiValueObjectHandleWebextstorageWebExtStorageBridgedEngine mPtr{}; + FfiValueInt mLastSync{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mLastSync, aError); + mLastSync.Lower(aArgs[1], aError); if (aError.Failed()) { return; } @@ -5161,8 +6663,8 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_webext_storage_fn_method_webextstoragebridgedengine_set_last_sync( - ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mLastSync)), + mPtr.IntoRust(), + mLastSync.IntoRust(), aOutStatus ); } @@ -5173,23 +6675,23 @@ public: class ScaffoldingCallHandlerUniffiWebextStorageFnMethodWebextstoragebridgedengineSetUploaded : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mServerModifiedMillis; - typename ScaffoldingConverter::IntermediateType mGuids; + FfiValueObjectHandleWebextstorageWebExtStorageBridgedEngine mPtr{}; + FfiValueInt mServerModifiedMillis{}; + FfiValueRustBuffer mGuids{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mServerModifiedMillis, aError); + mServerModifiedMillis.Lower(aArgs[1], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[2], &mGuids, aError); + mGuids.Lower(aArgs[2], aError); if (aError.Failed()) { return; } @@ -5197,9 +6699,9 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_webext_storage_fn_method_webextstoragebridgedengine_set_uploaded( - ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mServerModifiedMillis)), - ScaffoldingConverter::IntoRust(std::move(mGuids)), + mPtr.IntoRust(), + mServerModifiedMillis.IntoRust(), + mGuids.IntoRust(), aOutStatus ); } @@ -5210,18 +6712,18 @@ public: class ScaffoldingCallHandlerUniffiWebextStorageFnMethodWebextstoragebridgedengineStoreIncoming : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mIncoming; + FfiValueObjectHandleWebextstorageWebExtStorageBridgedEngine mPtr{}; + FfiValueRustBuffer mIncoming{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mIncoming, aError); + mIncoming.Lower(aArgs[1], aError); if (aError.Failed()) { return; } @@ -5229,8 +6731,8 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_webext_storage_fn_method_webextstoragebridgedengine_store_incoming( - ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mIncoming)), + mPtr.IntoRust(), + mIncoming.IntoRust(), aOutStatus ); } @@ -5241,13 +6743,13 @@ public: class ScaffoldingCallHandlerUniffiWebextStorageFnMethodWebextstoragebridgedengineSyncFinished : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntermediateType mPtr; + FfiValueObjectHandleWebextstorageWebExtStorageBridgedEngine mPtr{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } @@ -5255,7 +6757,7 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_webext_storage_fn_method_webextstoragebridgedengine_sync_finished( - ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ); } @@ -5266,32 +6768,31 @@ public: class ScaffoldingCallHandlerUniffiWebextStorageFnMethodWebextstoragebridgedengineSyncId : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntermediateType mPtr; + FfiValueObjectHandleWebextstorageWebExtStorageBridgedEngine mPtr{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_webext_storage_fn_method_webextstoragebridgedengine_sync_id( - ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -5300,13 +6801,13 @@ public: class ScaffoldingCallHandlerUniffiWebextStorageFnMethodWebextstoragebridgedengineSyncStarted : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntermediateType mPtr; + FfiValueObjectHandleWebextstorageWebExtStorageBridgedEngine mPtr{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } @@ -5314,7 +6815,7 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_webext_storage_fn_method_webextstoragebridgedengine_sync_started( - ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ); } @@ -5325,13 +6826,13 @@ public: class ScaffoldingCallHandlerUniffiWebextStorageFnMethodWebextstoragebridgedengineWipe : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntermediateType mPtr; + FfiValueObjectHandleWebextstorageWebExtStorageBridgedEngine mPtr{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } @@ -5339,7 +6840,7 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_webext_storage_fn_method_webextstoragebridgedengine_wipe( - ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ); } @@ -5350,32 +6851,31 @@ public: class ScaffoldingCallHandlerUniffiWebextStorageFnMethodWebextstoragestoreBridgedEngine : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::IntermediateType mPtr; + FfiValueObjectHandleWebextstorageWebExtStorageStore mPtr{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntermediateType mUniffiReturnValue; + FfiValueObjectHandleWebextstorageWebExtStorageBridgedEngine mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::FromRust( + mUniffiReturnValue = FfiValueObjectHandleWebextstorageWebExtStorageBridgedEngine::FromRust( uniffi_webext_storage_fn_method_webextstoragestore_bridged_engine( - ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -5384,38 +6884,37 @@ public: class ScaffoldingCallHandlerUniffiWebextStorageFnMethodWebextstoragestoreClear : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mExtId; + FfiValueObjectHandleWebextstorageWebExtStorageStore mPtr{}; + FfiValueRustBuffer mExtId{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mExtId, aError); + mExtId.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_webext_storage_fn_method_webextstoragestore_clear( - ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mExtId)), + mPtr.IntoRust(), + mExtId.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -5424,13 +6923,13 @@ public: class ScaffoldingCallHandlerUniffiWebextStorageFnMethodWebextstoragestoreClose : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::IntermediateType mPtr; + FfiValueObjectHandleWebextstorageWebExtStorageStore mPtr{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } @@ -5438,7 +6937,7 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_webext_storage_fn_method_webextstoragestore_close( - ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ); } @@ -5449,44 +6948,43 @@ public: class ScaffoldingCallHandlerUniffiWebextStorageFnMethodWebextstoragestoreGet : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mExtId; - typename ScaffoldingConverter::IntermediateType mKeys; + FfiValueObjectHandleWebextstorageWebExtStorageStore mPtr{}; + FfiValueRustBuffer mExtId{}; + FfiValueRustBuffer mKeys{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mExtId, aError); + mExtId.Lower(aArgs[1], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[2], &mKeys, aError); + mKeys.Lower(aArgs[2], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_webext_storage_fn_method_webextstoragestore_get( - ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mExtId)), - ScaffoldingConverter::IntoRust(std::move(mKeys)), + mPtr.IntoRust(), + mExtId.IntoRust(), + mKeys.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -5495,44 +6993,43 @@ public: class ScaffoldingCallHandlerUniffiWebextStorageFnMethodWebextstoragestoreGetBytesInUse : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mExtId; - typename ScaffoldingConverter::IntermediateType mKeys; + FfiValueObjectHandleWebextstorageWebExtStorageStore mPtr{}; + FfiValueRustBuffer mExtId{}; + FfiValueRustBuffer mKeys{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mExtId, aError); + mExtId.Lower(aArgs[1], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[2], &mKeys, aError); + mKeys.Lower(aArgs[2], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( uniffi_webext_storage_fn_method_webextstoragestore_get_bytes_in_use( - ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mExtId)), - ScaffoldingConverter::IntoRust(std::move(mKeys)), + mPtr.IntoRust(), + mExtId.IntoRust(), + mKeys.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -5541,32 +7038,31 @@ public: class ScaffoldingCallHandlerUniffiWebextStorageFnMethodWebextstoragestoreGetSyncedChanges : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::IntermediateType mPtr; + FfiValueObjectHandleWebextstorageWebExtStorageStore mPtr{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_webext_storage_fn_method_webextstoragestore_get_synced_changes( - ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -5575,44 +7071,43 @@ public: class ScaffoldingCallHandlerUniffiWebextStorageFnMethodWebextstoragestoreRemove : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mExtId; - typename ScaffoldingConverter::IntermediateType mKeys; + FfiValueObjectHandleWebextstorageWebExtStorageStore mPtr{}; + FfiValueRustBuffer mExtId{}; + FfiValueRustBuffer mKeys{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mExtId, aError); + mExtId.Lower(aArgs[1], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[2], &mKeys, aError); + mKeys.Lower(aArgs[2], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_webext_storage_fn_method_webextstoragestore_remove( - ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mExtId)), - ScaffoldingConverter::IntoRust(std::move(mKeys)), + mPtr.IntoRust(), + mExtId.IntoRust(), + mKeys.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -5621,44 +7116,43 @@ public: class ScaffoldingCallHandlerUniffiWebextStorageFnMethodWebextstoragestoreSet : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mExtId; - typename ScaffoldingConverter::IntermediateType mVal; + FfiValueObjectHandleWebextstorageWebExtStorageStore mPtr{}; + FfiValueRustBuffer mExtId{}; + FfiValueRustBuffer mVal{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mExtId, aError); + mExtId.Lower(aArgs[1], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[2], &mVal, aError); + mVal.Lower(aArgs[2], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_webext_storage_fn_method_webextstoragestore_set( - ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mExtId)), - ScaffoldingConverter::IntoRust(std::move(mVal)), + mPtr.IntoRust(), + mExtId.IntoRust(), + mVal.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -5667,32 +7161,31 @@ public: class ScaffoldingCallHandlerUniffiWebextStorageFnConstructorWebextstoragestoreNew : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingConverter::IntermediateType mPath; + FfiValueRustBuffer mPath{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::IntermediateType mUniffiReturnValue; + FfiValueObjectHandleWebextstorageWebExtStorageStore mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingConverter::FromJs(aArgs[0], &mPath, aError); + mPath.Lower(aArgs[0], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::FromRust( + mUniffiReturnValue = FfiValueObjectHandleWebextstorageWebExtStorageStore::FromRust( uniffi_webext_storage_fn_constructor_webextstoragestore_new( - ScaffoldingConverter::IntoRust(std::move(mPath)), + mPath.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -5703,38 +7196,37 @@ public: class ScaffoldingCallHandlerUniffiArithmeticalFnFuncAdd : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingConverter::IntermediateType mA; - typename ScaffoldingConverter::IntermediateType mB; + FfiValueInt mA{}; + FfiValueInt mB{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingConverter::FromJs(aArgs[0], &mA, aError); + mA.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mB, aError); + mB.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( uniffi_arithmetical_fn_func_add( - ScaffoldingConverter::IntoRust(std::move(mA)), - ScaffoldingConverter::IntoRust(std::move(mB)), + mA.IntoRust(), + mB.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -5743,38 +7235,37 @@ public: class ScaffoldingCallHandlerUniffiArithmeticalFnFuncDiv : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingConverter::IntermediateType mDividend; - typename ScaffoldingConverter::IntermediateType mDivisor; + FfiValueInt mDividend{}; + FfiValueInt mDivisor{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingConverter::FromJs(aArgs[0], &mDividend, aError); + mDividend.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mDivisor, aError); + mDivisor.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( uniffi_arithmetical_fn_func_div( - ScaffoldingConverter::IntoRust(std::move(mDividend)), - ScaffoldingConverter::IntoRust(std::move(mDivisor)), + mDividend.IntoRust(), + mDivisor.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -5783,38 +7274,37 @@ public: class ScaffoldingCallHandlerUniffiArithmeticalFnFuncEqual : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingConverter::IntermediateType mA; - typename ScaffoldingConverter::IntermediateType mB; + FfiValueInt mA{}; + FfiValueInt mB{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingConverter::FromJs(aArgs[0], &mA, aError); + mA.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mB, aError); + mB.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( uniffi_arithmetical_fn_func_equal( - ScaffoldingConverter::IntoRust(std::move(mA)), - ScaffoldingConverter::IntoRust(std::move(mB)), + mA.IntoRust(), + mB.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -5823,38 +7313,37 @@ public: class ScaffoldingCallHandlerUniffiArithmeticalFnFuncSub : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingConverter::IntermediateType mA; - typename ScaffoldingConverter::IntermediateType mB; + FfiValueInt mA{}; + FfiValueInt mB{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingConverter::FromJs(aArgs[0], &mA, aError); + mA.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mB, aError); + mB.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( uniffi_arithmetical_fn_func_sub( - ScaffoldingConverter::IntoRust(std::move(mA)), - ScaffoldingConverter::IntoRust(std::move(mB)), + mA.IntoRust(), + mB.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -5863,32 +7352,31 @@ public: class ScaffoldingCallHandlerUniffiUniffiCustomTypesFnFuncGetCustomTypesDemo : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingConverter::IntermediateType mDemo; + FfiValueRustBuffer mDemo{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingConverter::FromJs(aArgs[0], &mDemo, aError); + mDemo.Lower(aArgs[0], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_uniffi_custom_types_fn_func_get_custom_types_demo( - ScaffoldingConverter::IntoRust(std::move(mDemo)), + mDemo.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -5897,32 +7385,31 @@ public: class ScaffoldingCallHandlerUniffiUniffiFixtureExternalTypesFnFuncGradient : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueRustBuffer mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueFloat mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingConverter::FromJs(aArgs[0], &mValue, aError); + mValue.Lower(aArgs[0], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueFloat::FromRust( uniffi_uniffi_fixture_external_types_fn_func_gradient( - ScaffoldingConverter::IntoRust(std::move(mValue)), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -5931,38 +7418,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiFixtureExternalTypesFnFuncIntersection : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingConverter::IntermediateType mLn1; - typename ScaffoldingConverter::IntermediateType mLn2; + FfiValueRustBuffer mLn1{}; + FfiValueRustBuffer mLn2{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingConverter::FromJs(aArgs[0], &mLn1, aError); + mLn1.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mLn2, aError); + mLn2.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_uniffi_fixture_external_types_fn_func_intersection( - ScaffoldingConverter::IntoRust(std::move(mLn1)), - ScaffoldingConverter::IntoRust(std::move(mLn2)), + mLn1.IntoRust(), + mLn2.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -5971,13 +7457,13 @@ public: class ScaffoldingCallHandlerUniffiUniffiFixtureExternalTypesFnFuncMoveSpriteToOrigin : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kSpritesSpritePointerType>::IntermediateType mSprite; + FfiValueObjectHandleSpritesSprite mSprite{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kSpritesSpritePointerType>::FromJs(aArgs[0], &mSprite, aError); + mSprite.Lower(aArgs[0], aError); if (aError.Failed()) { return; } @@ -5985,7 +7471,7 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_uniffi_fixture_external_types_fn_func_move_sprite_to_origin( - ScaffoldingObjectConverter<&kSpritesSpritePointerType>::IntoRust(std::move(mSprite)), + mSprite.IntoRust(), aOutStatus ); } @@ -5996,28 +7482,28 @@ public: class ScaffoldingCallHandlerUniffiUniffiFixtureCallbacksFnFuncCallLogRepeat : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingConverter::IntermediateType mLogger; - typename ScaffoldingConverter::IntermediateType mMessage; - typename ScaffoldingConverter::IntermediateType mCount; - typename ScaffoldingConverter::IntermediateType mExclude; + FfiValueInt mLogger{}; + FfiValueRustBuffer mMessage{}; + FfiValueInt mCount{}; + FfiValueRustBuffer mExclude{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingConverter::FromJs(aArgs[0], &mLogger, aError); + mLogger.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mMessage, aError); + mMessage.Lower(aArgs[1], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[2], &mCount, aError); + mCount.Lower(aArgs[2], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[3], &mExclude, aError); + mExclude.Lower(aArgs[3], aError); if (aError.Failed()) { return; } @@ -6025,10 +7511,10 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_uniffi_fixture_callbacks_fn_func_call_log_repeat( - ScaffoldingConverter::IntoRust(std::move(mLogger)), - ScaffoldingConverter::IntoRust(std::move(mMessage)), - ScaffoldingConverter::IntoRust(std::move(mCount)), - ScaffoldingConverter::IntoRust(std::move(mExclude)), + mLogger.IntoRust(), + mMessage.IntoRust(), + mCount.IntoRust(), + mExclude.IntoRust(), aOutStatus ); } @@ -6039,18 +7525,18 @@ public: class ScaffoldingCallHandlerUniffiUniffiFixtureCallbacksFnFuncLogEvenNumbers : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingConverter::IntermediateType mLogger; - typename ScaffoldingConverter::IntermediateType mItems; + FfiValueInt mLogger{}; + FfiValueRustBuffer mItems{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingConverter::FromJs(aArgs[0], &mLogger, aError); + mLogger.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mItems, aError); + mItems.Lower(aArgs[1], aError); if (aError.Failed()) { return; } @@ -6058,8 +7544,8 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_uniffi_fixture_callbacks_fn_func_log_even_numbers( - ScaffoldingConverter::IntoRust(std::move(mLogger)), - ScaffoldingConverter::IntoRust(std::move(mItems)), + mLogger.IntoRust(), + mItems.IntoRust(), aOutStatus ); } @@ -6070,18 +7556,18 @@ public: class ScaffoldingCallHandlerUniffiUniffiFixtureCallbacksFnFuncLogEvenNumbersMainThread : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingConverter::IntermediateType mLogger; - typename ScaffoldingConverter::IntermediateType mItems; + FfiValueInt mLogger{}; + FfiValueRustBuffer mItems{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingConverter::FromJs(aArgs[0], &mLogger, aError); + mLogger.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mItems, aError); + mItems.Lower(aArgs[1], aError); if (aError.Failed()) { return; } @@ -6089,8 +7575,8 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_uniffi_fixture_callbacks_fn_func_log_even_numbers_main_thread( - ScaffoldingConverter::IntoRust(std::move(mLogger)), - ScaffoldingConverter::IntoRust(std::move(mItems)), + mLogger.IntoRust(), + mItems.IntoRust(), aOutStatus ); } @@ -6104,7 +7590,7 @@ public: private: // Complete stores the result of the call in mUniffiReturnValue - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; protected: // Convert a sequence of JS arguments and call the scaffolding function. @@ -6117,15 +7603,14 @@ protected: } void CallCompleteFn(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( ffi_uniffi_fixture_futures_rust_future_complete_u32(mFutureHandle, aOutStatus)); } public: void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -6153,13 +7638,13 @@ public: class ScaffoldingCallHandlerUniffiUniffiFixtureFuturesFnFuncInitializeGlobalWorkerQueue : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kFuturesWorkerQueuePointerType>::IntermediateType mWorkerQueue; + FfiValueObjectHandleFuturesWorkerQueue mWorkerQueue{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kFuturesWorkerQueuePointerType>::FromJs(aArgs[0], &mWorkerQueue, aError); + mWorkerQueue.Lower(aArgs[0], aError); if (aError.Failed()) { return; } @@ -6167,7 +7652,7 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_uniffi_fixture_futures_fn_func_initialize_global_worker_queue( - ScaffoldingObjectConverter<&kFuturesWorkerQueuePointerType>::IntoRust(std::move(mWorkerQueue)), + mWorkerQueue.IntoRust(), aOutStatus ); } @@ -6181,34 +7666,33 @@ public: private: // Complete stores the result of the call in mUniffiReturnValue - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueFloat mUniffiReturnValue{}; protected: // Convert a sequence of JS arguments and call the scaffolding function. // Always called on the main thread since async Rust calls don't block, they // return a future. void PrepareArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { - typename ScaffoldingConverter::IntermediateType mV; - ScaffoldingConverter::FromJs(aArgs[0], &mV, aError); + FfiValueFloat mV{}; + mV.Lower(aArgs[0], aError); if (aError.Failed()) { return; } mFutureHandle = uniffi_uniffi_fixture_futures_fn_func_roundtrip_f32( - ScaffoldingConverter::IntoRust(std::move(mV)) + mV.IntoRust() ); } void CallCompleteFn(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueFloat::FromRust( ffi_uniffi_fixture_futures_rust_future_complete_f32(mFutureHandle, aOutStatus)); } public: void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -6220,34 +7704,33 @@ public: private: // Complete stores the result of the call in mUniffiReturnValue - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueFloat mUniffiReturnValue{}; protected: // Convert a sequence of JS arguments and call the scaffolding function. // Always called on the main thread since async Rust calls don't block, they // return a future. void PrepareArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { - typename ScaffoldingConverter::IntermediateType mV; - ScaffoldingConverter::FromJs(aArgs[0], &mV, aError); + FfiValueFloat mV{}; + mV.Lower(aArgs[0], aError); if (aError.Failed()) { return; } mFutureHandle = uniffi_uniffi_fixture_futures_fn_func_roundtrip_f64( - ScaffoldingConverter::IntoRust(std::move(mV)) + mV.IntoRust() ); } void CallCompleteFn(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueFloat::FromRust( ffi_uniffi_fixture_futures_rust_future_complete_f64(mFutureHandle, aOutStatus)); } public: void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -6259,34 +7742,33 @@ public: private: // Complete stores the result of the call in mUniffiReturnValue - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; protected: // Convert a sequence of JS arguments and call the scaffolding function. // Always called on the main thread since async Rust calls don't block, they // return a future. void PrepareArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { - typename ScaffoldingConverter::IntermediateType mV; - ScaffoldingConverter::FromJs(aArgs[0], &mV, aError); + FfiValueInt mV{}; + mV.Lower(aArgs[0], aError); if (aError.Failed()) { return; } mFutureHandle = uniffi_uniffi_fixture_futures_fn_func_roundtrip_i16( - ScaffoldingConverter::IntoRust(std::move(mV)) + mV.IntoRust() ); } void CallCompleteFn(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( ffi_uniffi_fixture_futures_rust_future_complete_i16(mFutureHandle, aOutStatus)); } public: void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -6298,34 +7780,33 @@ public: private: // Complete stores the result of the call in mUniffiReturnValue - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; protected: // Convert a sequence of JS arguments and call the scaffolding function. // Always called on the main thread since async Rust calls don't block, they // return a future. void PrepareArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { - typename ScaffoldingConverter::IntermediateType mV; - ScaffoldingConverter::FromJs(aArgs[0], &mV, aError); + FfiValueInt mV{}; + mV.Lower(aArgs[0], aError); if (aError.Failed()) { return; } mFutureHandle = uniffi_uniffi_fixture_futures_fn_func_roundtrip_i32( - ScaffoldingConverter::IntoRust(std::move(mV)) + mV.IntoRust() ); } void CallCompleteFn(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( ffi_uniffi_fixture_futures_rust_future_complete_i32(mFutureHandle, aOutStatus)); } public: void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -6337,34 +7818,33 @@ public: private: // Complete stores the result of the call in mUniffiReturnValue - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; protected: // Convert a sequence of JS arguments and call the scaffolding function. // Always called on the main thread since async Rust calls don't block, they // return a future. void PrepareArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { - typename ScaffoldingConverter::IntermediateType mV; - ScaffoldingConverter::FromJs(aArgs[0], &mV, aError); + FfiValueInt mV{}; + mV.Lower(aArgs[0], aError); if (aError.Failed()) { return; } mFutureHandle = uniffi_uniffi_fixture_futures_fn_func_roundtrip_i64( - ScaffoldingConverter::IntoRust(std::move(mV)) + mV.IntoRust() ); } void CallCompleteFn(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( ffi_uniffi_fixture_futures_rust_future_complete_i64(mFutureHandle, aOutStatus)); } public: void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -6376,34 +7856,33 @@ public: private: // Complete stores the result of the call in mUniffiReturnValue - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; protected: // Convert a sequence of JS arguments and call the scaffolding function. // Always called on the main thread since async Rust calls don't block, they // return a future. void PrepareArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { - typename ScaffoldingConverter::IntermediateType mV; - ScaffoldingConverter::FromJs(aArgs[0], &mV, aError); + FfiValueInt mV{}; + mV.Lower(aArgs[0], aError); if (aError.Failed()) { return; } mFutureHandle = uniffi_uniffi_fixture_futures_fn_func_roundtrip_i8( - ScaffoldingConverter::IntoRust(std::move(mV)) + mV.IntoRust() ); } void CallCompleteFn(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( ffi_uniffi_fixture_futures_rust_future_complete_i8(mFutureHandle, aOutStatus)); } public: void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -6415,34 +7894,33 @@ public: private: // Complete stores the result of the call in mUniffiReturnValue - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; protected: // Convert a sequence of JS arguments and call the scaffolding function. // Always called on the main thread since async Rust calls don't block, they // return a future. void PrepareArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { - typename ScaffoldingConverter::IntermediateType mV; - ScaffoldingConverter::FromJs(aArgs[0], &mV, aError); + FfiValueRustBuffer mV{}; + mV.Lower(aArgs[0], aError); if (aError.Failed()) { return; } mFutureHandle = uniffi_uniffi_fixture_futures_fn_func_roundtrip_map( - ScaffoldingConverter::IntoRust(std::move(mV)) + mV.IntoRust() ); } void CallCompleteFn(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( ffi_uniffi_fixture_futures_rust_future_complete_rust_buffer(mFutureHandle, aOutStatus)); } public: void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -6454,34 +7932,33 @@ public: private: // Complete stores the result of the call in mUniffiReturnValue - typename ScaffoldingObjectConverter<&kFuturesTravellerPointerType>::IntermediateType mUniffiReturnValue; + FfiValueObjectHandleFuturesTraveller mUniffiReturnValue{}; protected: // Convert a sequence of JS arguments and call the scaffolding function. // Always called on the main thread since async Rust calls don't block, they // return a future. void PrepareArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { - typename ScaffoldingObjectConverter<&kFuturesTravellerPointerType>::IntermediateType mV; - ScaffoldingObjectConverter<&kFuturesTravellerPointerType>::FromJs(aArgs[0], &mV, aError); + FfiValueObjectHandleFuturesTraveller mV{}; + mV.Lower(aArgs[0], aError); if (aError.Failed()) { return; } mFutureHandle = uniffi_uniffi_fixture_futures_fn_func_roundtrip_obj( - ScaffoldingObjectConverter<&kFuturesTravellerPointerType>::IntoRust(std::move(mV)) + mV.IntoRust() ); } void CallCompleteFn(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingObjectConverter<&kFuturesTravellerPointerType>::FromRust( + mUniffiReturnValue = FfiValueObjectHandleFuturesTraveller::FromRust( ffi_uniffi_fixture_futures_rust_future_complete_pointer(mFutureHandle, aOutStatus)); } public: void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kFuturesTravellerPointerType>::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -6493,34 +7970,33 @@ public: private: // Complete stores the result of the call in mUniffiReturnValue - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; protected: // Convert a sequence of JS arguments and call the scaffolding function. // Always called on the main thread since async Rust calls don't block, they // return a future. void PrepareArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { - typename ScaffoldingConverter::IntermediateType mV; - ScaffoldingConverter::FromJs(aArgs[0], &mV, aError); + FfiValueRustBuffer mV{}; + mV.Lower(aArgs[0], aError); if (aError.Failed()) { return; } mFutureHandle = uniffi_uniffi_fixture_futures_fn_func_roundtrip_string( - ScaffoldingConverter::IntoRust(std::move(mV)) + mV.IntoRust() ); } void CallCompleteFn(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( ffi_uniffi_fixture_futures_rust_future_complete_rust_buffer(mFutureHandle, aOutStatus)); } public: void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -6532,34 +8008,33 @@ public: private: // Complete stores the result of the call in mUniffiReturnValue - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; protected: // Convert a sequence of JS arguments and call the scaffolding function. // Always called on the main thread since async Rust calls don't block, they // return a future. void PrepareArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { - typename ScaffoldingConverter::IntermediateType mV; - ScaffoldingConverter::FromJs(aArgs[0], &mV, aError); + FfiValueInt mV{}; + mV.Lower(aArgs[0], aError); if (aError.Failed()) { return; } mFutureHandle = uniffi_uniffi_fixture_futures_fn_func_roundtrip_u16( - ScaffoldingConverter::IntoRust(std::move(mV)) + mV.IntoRust() ); } void CallCompleteFn(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( ffi_uniffi_fixture_futures_rust_future_complete_u16(mFutureHandle, aOutStatus)); } public: void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -6571,34 +8046,33 @@ public: private: // Complete stores the result of the call in mUniffiReturnValue - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; protected: // Convert a sequence of JS arguments and call the scaffolding function. // Always called on the main thread since async Rust calls don't block, they // return a future. void PrepareArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { - typename ScaffoldingConverter::IntermediateType mV; - ScaffoldingConverter::FromJs(aArgs[0], &mV, aError); + FfiValueInt mV{}; + mV.Lower(aArgs[0], aError); if (aError.Failed()) { return; } mFutureHandle = uniffi_uniffi_fixture_futures_fn_func_roundtrip_u32( - ScaffoldingConverter::IntoRust(std::move(mV)) + mV.IntoRust() ); } void CallCompleteFn(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( ffi_uniffi_fixture_futures_rust_future_complete_u32(mFutureHandle, aOutStatus)); } public: void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -6610,34 +8084,33 @@ public: private: // Complete stores the result of the call in mUniffiReturnValue - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; protected: // Convert a sequence of JS arguments and call the scaffolding function. // Always called on the main thread since async Rust calls don't block, they // return a future. void PrepareArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { - typename ScaffoldingConverter::IntermediateType mV; - ScaffoldingConverter::FromJs(aArgs[0], &mV, aError); + FfiValueInt mV{}; + mV.Lower(aArgs[0], aError); if (aError.Failed()) { return; } mFutureHandle = uniffi_uniffi_fixture_futures_fn_func_roundtrip_u64( - ScaffoldingConverter::IntoRust(std::move(mV)) + mV.IntoRust() ); } void CallCompleteFn(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( ffi_uniffi_fixture_futures_rust_future_complete_u64(mFutureHandle, aOutStatus)); } public: void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -6649,34 +8122,33 @@ public: private: // Complete stores the result of the call in mUniffiReturnValue - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; protected: // Convert a sequence of JS arguments and call the scaffolding function. // Always called on the main thread since async Rust calls don't block, they // return a future. void PrepareArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { - typename ScaffoldingConverter::IntermediateType mV; - ScaffoldingConverter::FromJs(aArgs[0], &mV, aError); + FfiValueInt mV{}; + mV.Lower(aArgs[0], aError); if (aError.Failed()) { return; } mFutureHandle = uniffi_uniffi_fixture_futures_fn_func_roundtrip_u8( - ScaffoldingConverter::IntoRust(std::move(mV)) + mV.IntoRust() ); } void CallCompleteFn(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( ffi_uniffi_fixture_futures_rust_future_complete_u8(mFutureHandle, aOutStatus)); } public: void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -6688,34 +8160,33 @@ public: private: // Complete stores the result of the call in mUniffiReturnValue - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; protected: // Convert a sequence of JS arguments and call the scaffolding function. // Always called on the main thread since async Rust calls don't block, they // return a future. void PrepareArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { - typename ScaffoldingConverter::IntermediateType mV; - ScaffoldingConverter::FromJs(aArgs[0], &mV, aError); + FfiValueRustBuffer mV{}; + mV.Lower(aArgs[0], aError); if (aError.Failed()) { return; } mFutureHandle = uniffi_uniffi_fixture_futures_fn_func_roundtrip_vec( - ScaffoldingConverter::IntoRust(std::move(mV)) + mV.IntoRust() ); } void CallCompleteFn(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( ffi_uniffi_fixture_futures_rust_future_complete_rust_buffer(mFutureHandle, aOutStatus)); } public: void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -6724,38 +8195,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiFixtureFuturesFnMethodFuturetesterCompleteFutures : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kFuturesFutureTesterPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleFuturesFutureTester mPtr{}; + FfiValueInt mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kFuturesFutureTesterPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( uniffi_uniffi_fixture_futures_fn_method_futuretester_complete_futures( - ScaffoldingObjectConverter<&kFuturesFutureTesterPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -6767,34 +8237,33 @@ public: private: // Complete stores the result of the call in mUniffiReturnValue - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; protected: // Convert a sequence of JS arguments and call the scaffolding function. // Always called on the main thread since async Rust calls don't block, they // return a future. void PrepareArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { - typename ScaffoldingObjectConverter<&kFuturesFutureTesterPointerType>::IntermediateType mPtr; - ScaffoldingObjectConverter<&kFuturesFutureTesterPointerType>::FromJs(aArgs[0], &mPtr, aError); + FfiValueObjectHandleFuturesFutureTester mPtr{}; + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } mFutureHandle = uniffi_uniffi_fixture_futures_fn_method_futuretester_make_future( - ScaffoldingObjectConverter<&kFuturesFutureTesterPointerType>::IntoRust(std::move(mPtr)) + mPtr.IntoRust() ); } void CallCompleteFn(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( ffi_uniffi_fixture_futures_rust_future_complete_u8(mFutureHandle, aOutStatus)); } public: void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -6803,13 +8272,13 @@ public: class ScaffoldingCallHandlerUniffiUniffiFixtureFuturesFnMethodFuturetesterWakeFutures : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kFuturesFutureTesterPointerType>::IntermediateType mPtr; + FfiValueObjectHandleFuturesFutureTester mPtr{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kFuturesFutureTesterPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } @@ -6817,7 +8286,7 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_uniffi_fixture_futures_fn_method_futuretester_wake_futures( - ScaffoldingObjectConverter<&kFuturesFutureTesterPointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ); } @@ -6830,14 +8299,14 @@ private: // PrepareRustArgs stores the resulting arguments in these fields // MakeRustCall stores the result of the call in these fields - typename ScaffoldingObjectConverter<&kFuturesFutureTesterPointerType>::IntermediateType mUniffiReturnValue; + FfiValueObjectHandleFuturesFutureTester mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingObjectConverter<&kFuturesFutureTesterPointerType>::FromRust( + mUniffiReturnValue = FfiValueObjectHandleFuturesFutureTester::FromRust( uniffi_uniffi_fixture_futures_fn_constructor_futuretester_init( aOutStatus ) @@ -6845,9 +8314,8 @@ public: } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kFuturesFutureTesterPointerType>::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -6856,13 +8324,13 @@ public: class ScaffoldingCallHandlerUniffiUniffiFixtureFuturesFnMethodRusttaskRun : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kFuturesRustTaskPointerType>::IntermediateType mPtr; + FfiValueObjectHandleFuturesRustTask mPtr{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kFuturesRustTaskPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } @@ -6870,7 +8338,7 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_uniffi_fixture_futures_fn_method_rusttask_run( - ScaffoldingObjectConverter<&kFuturesRustTaskPointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ); } @@ -6881,32 +8349,31 @@ public: class ScaffoldingCallHandlerUniffiUniffiFixtureFuturesFnMethodTravellerName : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kFuturesTravellerPointerType>::IntermediateType mPtr; + FfiValueObjectHandleFuturesTraveller mPtr{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kFuturesTravellerPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_uniffi_fixture_futures_fn_method_traveller_name( - ScaffoldingObjectConverter<&kFuturesTravellerPointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -6915,32 +8382,31 @@ public: class ScaffoldingCallHandlerUniffiUniffiFixtureFuturesFnConstructorTravellerNew : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingConverter::IntermediateType mName; + FfiValueRustBuffer mName{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingObjectConverter<&kFuturesTravellerPointerType>::IntermediateType mUniffiReturnValue; + FfiValueObjectHandleFuturesTraveller mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingConverter::FromJs(aArgs[0], &mName, aError); + mName.Lower(aArgs[0], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingObjectConverter<&kFuturesTravellerPointerType>::FromRust( + mUniffiReturnValue = FfiValueObjectHandleFuturesTraveller::FromRust( uniffi_uniffi_fixture_futures_fn_constructor_traveller_new( - ScaffoldingConverter::IntoRust(std::move(mName)), + mName.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kFuturesTravellerPointerType>::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -6949,18 +8415,18 @@ public: class ScaffoldingCallHandlerUniffiUniffiFixtureFuturesFnMethodWorkerqueueAddTask : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kFuturesWorkerQueuePointerType>::IntermediateType mPtr; - typename ScaffoldingObjectConverter<&kFuturesRustTaskPointerType>::IntermediateType mTask; + FfiValueObjectHandleFuturesWorkerQueue mPtr{}; + FfiValueObjectHandleFuturesRustTask mTask{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kFuturesWorkerQueuePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingObjectConverter<&kFuturesRustTaskPointerType>::FromJs(aArgs[1], &mTask, aError); + mTask.Lower(aArgs[1], aError); if (aError.Failed()) { return; } @@ -6968,8 +8434,8 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_uniffi_fixture_futures_fn_method_workerqueue_add_task( - ScaffoldingObjectConverter<&kFuturesWorkerQueuePointerType>::IntoRust(std::move(mPtr)), - ScaffoldingObjectConverter<&kFuturesRustTaskPointerType>::IntoRust(std::move(mTask)), + mPtr.IntoRust(), + mTask.IntoRust(), aOutStatus ); } @@ -6980,32 +8446,31 @@ public: class ScaffoldingCallHandlerUniffiUniffiGeometryFnFuncGradient : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingConverter::IntermediateType mLn; + FfiValueRustBuffer mLn{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueFloat mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingConverter::FromJs(aArgs[0], &mLn, aError); + mLn.Lower(aArgs[0], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueFloat::FromRust( uniffi_uniffi_geometry_fn_func_gradient( - ScaffoldingConverter::IntoRust(std::move(mLn)), + mLn.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7014,38 +8479,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiGeometryFnFuncIntersection : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingConverter::IntermediateType mLn1; - typename ScaffoldingConverter::IntermediateType mLn2; + FfiValueRustBuffer mLn1{}; + FfiValueRustBuffer mLn2{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingConverter::FromJs(aArgs[0], &mLn1, aError); + mLn1.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mLn2, aError); + mLn2.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_uniffi_geometry_fn_func_intersection( - ScaffoldingConverter::IntoRust(std::move(mLn1)), - ScaffoldingConverter::IntoRust(std::move(mLn2)), + mLn1.IntoRust(), + mLn2.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7056,14 +8520,14 @@ private: // PrepareRustArgs stores the resulting arguments in these fields // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( uniffi_uniffi_fixture_refcounts_fn_func_get_js_refcount( aOutStatus ) @@ -7071,9 +8535,8 @@ public: } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7084,14 +8547,14 @@ private: // PrepareRustArgs stores the resulting arguments in these fields // MakeRustCall stores the result of the call in these fields - typename ScaffoldingObjectConverter<&kRefcountsSingletonObjectPointerType>::IntermediateType mUniffiReturnValue; + FfiValueObjectHandleRefcountsSingletonObject mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingObjectConverter<&kRefcountsSingletonObjectPointerType>::FromRust( + mUniffiReturnValue = FfiValueObjectHandleRefcountsSingletonObject::FromRust( uniffi_uniffi_fixture_refcounts_fn_func_get_singleton( aOutStatus ) @@ -7099,9 +8562,8 @@ public: } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRefcountsSingletonObjectPointerType>::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7110,13 +8572,13 @@ public: class ScaffoldingCallHandlerUniffiUniffiFixtureRefcountsFnMethodSingletonobjectMethod : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRefcountsSingletonObjectPointerType>::IntermediateType mPtr; + FfiValueObjectHandleRefcountsSingletonObject mPtr{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRefcountsSingletonObjectPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } @@ -7124,7 +8586,7 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_uniffi_fixture_refcounts_fn_method_singletonobject_method( - ScaffoldingObjectConverter<&kRefcountsSingletonObjectPointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ); } @@ -7135,32 +8597,31 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnFuncCopieCarte : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingConverter::IntermediateType mC; + FfiValueRustBuffer mC{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingConverter::FromJs(aArgs[0], &mC, aError); + mC.Lower(aArgs[0], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_uniffi_rondpoint_fn_func_copie_carte( - ScaffoldingConverter::IntoRust(std::move(mC)), + mC.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7169,32 +8630,31 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnFuncCopieDictionnaire : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingConverter::IntermediateType mD; + FfiValueRustBuffer mD{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingConverter::FromJs(aArgs[0], &mD, aError); + mD.Lower(aArgs[0], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_uniffi_rondpoint_fn_func_copie_dictionnaire( - ScaffoldingConverter::IntoRust(std::move(mD)), + mD.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7203,32 +8663,31 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnFuncCopieEnumeration : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingConverter::IntermediateType mE; + FfiValueRustBuffer mE{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingConverter::FromJs(aArgs[0], &mE, aError); + mE.Lower(aArgs[0], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_uniffi_rondpoint_fn_func_copie_enumeration( - ScaffoldingConverter::IntoRust(std::move(mE)), + mE.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7237,32 +8696,31 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnFuncCopieEnumerations : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingConverter::IntermediateType mE; + FfiValueRustBuffer mE{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingConverter::FromJs(aArgs[0], &mE, aError); + mE.Lower(aArgs[0], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_uniffi_rondpoint_fn_func_copie_enumerations( - ScaffoldingConverter::IntoRust(std::move(mE)), + mE.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7271,32 +8729,31 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnFuncSwitcheroo : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingConverter::IntermediateType mB; + FfiValueInt mB{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingConverter::FromJs(aArgs[0], &mB, aError); + mB.Lower(aArgs[0], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( uniffi_uniffi_rondpoint_fn_func_switcheroo( - ScaffoldingConverter::IntoRust(std::move(mB)), + mB.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7305,38 +8762,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonBoolean : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointOptionneur mPtr{}; + FfiValueInt mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_boolean( - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7345,38 +8801,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonEnum : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointOptionneur mPtr{}; + FfiValueRustBuffer mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_enum( - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7385,38 +8840,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonF32 : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointOptionneur mPtr{}; + FfiValueFloat mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueFloat mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueFloat::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_f32( - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7425,38 +8879,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonF64 : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointOptionneur mPtr{}; + FfiValueFloat mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueFloat mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueFloat::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_f64( - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7465,38 +8918,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonI16Dec : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointOptionneur mPtr{}; + FfiValueInt mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_i16_dec( - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7505,38 +8957,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonI16Hex : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointOptionneur mPtr{}; + FfiValueInt mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_i16_hex( - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7545,38 +8996,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonI32Dec : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointOptionneur mPtr{}; + FfiValueInt mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_i32_dec( - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7585,38 +9035,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonI32Hex : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointOptionneur mPtr{}; + FfiValueInt mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_i32_hex( - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7625,38 +9074,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonI64Dec : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointOptionneur mPtr{}; + FfiValueInt mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_i64_dec( - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7665,38 +9113,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonI64Hex : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointOptionneur mPtr{}; + FfiValueInt mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_i64_hex( - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7705,38 +9152,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonI8Dec : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointOptionneur mPtr{}; + FfiValueInt mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_i8_dec( - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7745,38 +9191,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonI8Hex : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointOptionneur mPtr{}; + FfiValueInt mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_i8_hex( - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7785,38 +9230,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonNull : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointOptionneur mPtr{}; + FfiValueRustBuffer mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_null( - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7825,38 +9269,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonSequence : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointOptionneur mPtr{}; + FfiValueRustBuffer mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_sequence( - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7865,38 +9308,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonString : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointOptionneur mPtr{}; + FfiValueRustBuffer mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_string( - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7905,38 +9347,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonU16Dec : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointOptionneur mPtr{}; + FfiValueInt mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_u16_dec( - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7945,38 +9386,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonU16Hex : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointOptionneur mPtr{}; + FfiValueInt mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_u16_hex( - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7985,38 +9425,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonU32Dec : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointOptionneur mPtr{}; + FfiValueInt mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_u32_dec( - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8025,38 +9464,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonU32Hex : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointOptionneur mPtr{}; + FfiValueInt mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_u32_hex( - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8065,38 +9503,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonU32Oct : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointOptionneur mPtr{}; + FfiValueInt mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_u32_oct( - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8105,38 +9542,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonU64Dec : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointOptionneur mPtr{}; + FfiValueInt mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_u64_dec( - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8145,38 +9581,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonU64Hex : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointOptionneur mPtr{}; + FfiValueInt mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_u64_hex( - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8185,38 +9620,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonU8Dec : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointOptionneur mPtr{}; + FfiValueInt mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_u8_dec( - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8225,38 +9659,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonU8Hex : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointOptionneur mPtr{}; + FfiValueInt mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_u8_hex( - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8265,38 +9698,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonZero : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointOptionneur mPtr{}; + FfiValueRustBuffer mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_zero( - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8307,14 +9739,14 @@ private: // PrepareRustArgs stores the resulting arguments in these fields // MakeRustCall stores the result of the call in these fields - typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mUniffiReturnValue; + FfiValueObjectHandleRondpointOptionneur mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromRust( + mUniffiReturnValue = FfiValueObjectHandleRondpointOptionneur::FromRust( uniffi_uniffi_rondpoint_fn_constructor_optionneur_new( aOutStatus ) @@ -8322,9 +9754,8 @@ public: } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8333,38 +9764,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodRetourneurIdentiqueBoolean : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointRetourneur mPtr{}; + FfiValueInt mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( uniffi_uniffi_rondpoint_fn_method_retourneur_identique_boolean( - ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8373,38 +9803,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodRetourneurIdentiqueDouble : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointRetourneur mPtr{}; + FfiValueFloat mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueFloat mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueFloat::FromRust( uniffi_uniffi_rondpoint_fn_method_retourneur_identique_double( - ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8413,38 +9842,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodRetourneurIdentiqueFloat : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointRetourneur mPtr{}; + FfiValueFloat mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueFloat mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueFloat::FromRust( uniffi_uniffi_rondpoint_fn_method_retourneur_identique_float( - ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8453,38 +9881,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodRetourneurIdentiqueI16 : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointRetourneur mPtr{}; + FfiValueInt mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( uniffi_uniffi_rondpoint_fn_method_retourneur_identique_i16( - ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8493,38 +9920,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodRetourneurIdentiqueI32 : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointRetourneur mPtr{}; + FfiValueInt mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( uniffi_uniffi_rondpoint_fn_method_retourneur_identique_i32( - ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8533,38 +9959,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodRetourneurIdentiqueI64 : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointRetourneur mPtr{}; + FfiValueInt mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( uniffi_uniffi_rondpoint_fn_method_retourneur_identique_i64( - ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8573,38 +9998,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodRetourneurIdentiqueI8 : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointRetourneur mPtr{}; + FfiValueInt mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( uniffi_uniffi_rondpoint_fn_method_retourneur_identique_i8( - ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8613,38 +10037,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodRetourneurIdentiqueNombres : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointRetourneur mPtr{}; + FfiValueRustBuffer mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_uniffi_rondpoint_fn_method_retourneur_identique_nombres( - ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8653,38 +10076,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodRetourneurIdentiqueNombresSignes : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointRetourneur mPtr{}; + FfiValueRustBuffer mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_uniffi_rondpoint_fn_method_retourneur_identique_nombres_signes( - ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8693,38 +10115,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodRetourneurIdentiqueOptionneurDictionnaire : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointRetourneur mPtr{}; + FfiValueRustBuffer mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_uniffi_rondpoint_fn_method_retourneur_identique_optionneur_dictionnaire( - ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8733,38 +10154,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodRetourneurIdentiqueString : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointRetourneur mPtr{}; + FfiValueRustBuffer mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_uniffi_rondpoint_fn_method_retourneur_identique_string( - ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8773,38 +10193,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodRetourneurIdentiqueU16 : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointRetourneur mPtr{}; + FfiValueInt mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( uniffi_uniffi_rondpoint_fn_method_retourneur_identique_u16( - ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8813,38 +10232,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodRetourneurIdentiqueU32 : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointRetourneur mPtr{}; + FfiValueInt mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( uniffi_uniffi_rondpoint_fn_method_retourneur_identique_u32( - ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8853,38 +10271,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodRetourneurIdentiqueU64 : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointRetourneur mPtr{}; + FfiValueInt mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( uniffi_uniffi_rondpoint_fn_method_retourneur_identique_u64( - ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8893,38 +10310,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodRetourneurIdentiqueU8 : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointRetourneur mPtr{}; + FfiValueInt mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( uniffi_uniffi_rondpoint_fn_method_retourneur_identique_u8( - ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8935,14 +10351,14 @@ private: // PrepareRustArgs stores the resulting arguments in these fields // MakeRustCall stores the result of the call in these fields - typename ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntermediateType mUniffiReturnValue; + FfiValueObjectHandleRondpointRetourneur mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::FromRust( + mUniffiReturnValue = FfiValueObjectHandleRondpointRetourneur::FromRust( uniffi_uniffi_rondpoint_fn_constructor_retourneur_new( aOutStatus ) @@ -8950,9 +10366,8 @@ public: } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8961,38 +10376,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodStringifierToStringBoolean : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointStringifier mPtr{}; + FfiValueInt mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_uniffi_rondpoint_fn_method_stringifier_to_string_boolean( - ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -9001,38 +10415,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodStringifierToStringDouble : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointStringifier mPtr{}; + FfiValueFloat mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_uniffi_rondpoint_fn_method_stringifier_to_string_double( - ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -9041,38 +10454,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodStringifierToStringFloat : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointStringifier mPtr{}; + FfiValueFloat mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_uniffi_rondpoint_fn_method_stringifier_to_string_float( - ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -9081,38 +10493,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodStringifierToStringI16 : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointStringifier mPtr{}; + FfiValueInt mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_uniffi_rondpoint_fn_method_stringifier_to_string_i16( - ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -9121,38 +10532,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodStringifierToStringI32 : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointStringifier mPtr{}; + FfiValueInt mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_uniffi_rondpoint_fn_method_stringifier_to_string_i32( - ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -9161,38 +10571,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodStringifierToStringI64 : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointStringifier mPtr{}; + FfiValueInt mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_uniffi_rondpoint_fn_method_stringifier_to_string_i64( - ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -9201,38 +10610,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodStringifierToStringI8 : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointStringifier mPtr{}; + FfiValueInt mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_uniffi_rondpoint_fn_method_stringifier_to_string_i8( - ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -9241,38 +10649,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodStringifierToStringU16 : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointStringifier mPtr{}; + FfiValueInt mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_uniffi_rondpoint_fn_method_stringifier_to_string_u16( - ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -9281,38 +10688,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodStringifierToStringU32 : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointStringifier mPtr{}; + FfiValueInt mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_uniffi_rondpoint_fn_method_stringifier_to_string_u32( - ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -9321,38 +10727,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodStringifierToStringU64 : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointStringifier mPtr{}; + FfiValueInt mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_uniffi_rondpoint_fn_method_stringifier_to_string_u64( - ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -9361,38 +10766,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodStringifierToStringU8 : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointStringifier mPtr{}; + FfiValueInt mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_uniffi_rondpoint_fn_method_stringifier_to_string_u8( - ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -9401,38 +10805,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodStringifierWellKnownString : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mValue; + FfiValueObjectHandleRondpointStringifier mPtr{}; + FfiValueRustBuffer mValue{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); + mValue.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_uniffi_rondpoint_fn_method_stringifier_well_known_string( - ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mValue)), + mPtr.IntoRust(), + mValue.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -9443,14 +10846,14 @@ private: // PrepareRustArgs stores the resulting arguments in these fields // MakeRustCall stores the result of the call in these fields - typename ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntermediateType mUniffiReturnValue; + FfiValueObjectHandleRondpointStringifier mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::FromRust( + mUniffiReturnValue = FfiValueObjectHandleRondpointStringifier::FromRust( uniffi_uniffi_rondpoint_fn_constructor_stringifier_new( aOutStatus ) @@ -9458,9 +10861,8 @@ public: } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -9469,38 +10871,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiSpritesFnFuncTranslate : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingConverter::IntermediateType mP; - typename ScaffoldingConverter::IntermediateType mV; + FfiValueRustBuffer mP{}; + FfiValueRustBuffer mV{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingConverter::FromJs(aArgs[0], &mP, aError); + mP.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mV, aError); + mV.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_uniffi_sprites_fn_func_translate( - ScaffoldingConverter::IntoRust(std::move(mP)), - ScaffoldingConverter::IntoRust(std::move(mV)), + mP.IntoRust(), + mV.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -9509,32 +10910,31 @@ public: class ScaffoldingCallHandlerUniffiUniffiSpritesFnMethodSpriteGetPosition : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kSpritesSpritePointerType>::IntermediateType mPtr; + FfiValueObjectHandleSpritesSprite mPtr{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kSpritesSpritePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_uniffi_sprites_fn_method_sprite_get_position( - ScaffoldingObjectConverter<&kSpritesSpritePointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -9543,18 +10943,18 @@ public: class ScaffoldingCallHandlerUniffiUniffiSpritesFnMethodSpriteMoveBy : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kSpritesSpritePointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mDirection; + FfiValueObjectHandleSpritesSprite mPtr{}; + FfiValueRustBuffer mDirection{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kSpritesSpritePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mDirection, aError); + mDirection.Lower(aArgs[1], aError); if (aError.Failed()) { return; } @@ -9562,8 +10962,8 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_uniffi_sprites_fn_method_sprite_move_by( - ScaffoldingObjectConverter<&kSpritesSpritePointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mDirection)), + mPtr.IntoRust(), + mDirection.IntoRust(), aOutStatus ); } @@ -9574,18 +10974,18 @@ public: class ScaffoldingCallHandlerUniffiUniffiSpritesFnMethodSpriteMoveTo : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kSpritesSpritePointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mPosition; + FfiValueObjectHandleSpritesSprite mPtr{}; + FfiValueRustBuffer mPosition{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kSpritesSpritePointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mPosition, aError); + mPosition.Lower(aArgs[1], aError); if (aError.Failed()) { return; } @@ -9593,8 +10993,8 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_uniffi_sprites_fn_method_sprite_move_to( - ScaffoldingObjectConverter<&kSpritesSpritePointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mPosition)), + mPtr.IntoRust(), + mPosition.IntoRust(), aOutStatus ); } @@ -9605,32 +11005,31 @@ public: class ScaffoldingCallHandlerUniffiUniffiSpritesFnConstructorSpriteNew : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingConverter::IntermediateType mInitialPosition; + FfiValueRustBuffer mInitialPosition{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingObjectConverter<&kSpritesSpritePointerType>::IntermediateType mUniffiReturnValue; + FfiValueObjectHandleSpritesSprite mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingConverter::FromJs(aArgs[0], &mInitialPosition, aError); + mInitialPosition.Lower(aArgs[0], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingObjectConverter<&kSpritesSpritePointerType>::FromRust( + mUniffiReturnValue = FfiValueObjectHandleSpritesSprite::FromRust( uniffi_uniffi_sprites_fn_constructor_sprite_new( - ScaffoldingConverter::IntoRust(std::move(mInitialPosition)), + mInitialPosition.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kSpritesSpritePointerType>::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -9639,38 +11038,37 @@ public: class ScaffoldingCallHandlerUniffiUniffiSpritesFnConstructorSpriteNewRelativeTo : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingConverter::IntermediateType mReference; - typename ScaffoldingConverter::IntermediateType mDirection; + FfiValueRustBuffer mReference{}; + FfiValueRustBuffer mDirection{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingObjectConverter<&kSpritesSpritePointerType>::IntermediateType mUniffiReturnValue; + FfiValueObjectHandleSpritesSprite mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingConverter::FromJs(aArgs[0], &mReference, aError); + mReference.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mDirection, aError); + mDirection.Lower(aArgs[1], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingObjectConverter<&kSpritesSpritePointerType>::FromRust( + mUniffiReturnValue = FfiValueObjectHandleSpritesSprite::FromRust( uniffi_uniffi_sprites_fn_constructor_sprite_new_relative_to( - ScaffoldingConverter::IntoRust(std::move(mReference)), - ScaffoldingConverter::IntoRust(std::move(mDirection)), + mReference.IntoRust(), + mDirection.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kSpritesSpritePointerType>::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -9679,32 +11077,31 @@ public: class ScaffoldingCallHandlerUniffiUniffiTodolistFnFuncCreateEntryWith : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingConverter::IntermediateType mTodo; + FfiValueRustBuffer mTodo{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingConverter::FromJs(aArgs[0], &mTodo, aError); + mTodo.Lower(aArgs[0], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_uniffi_todolist_fn_func_create_entry_with( - ScaffoldingConverter::IntoRust(std::move(mTodo)), + mTodo.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -9715,14 +11112,14 @@ private: // PrepareRustArgs stores the resulting arguments in these fields // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_uniffi_todolist_fn_func_get_default_list( aOutStatus ) @@ -9730,9 +11127,8 @@ public: } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -9741,13 +11137,13 @@ public: class ScaffoldingCallHandlerUniffiUniffiTodolistFnFuncSetDefaultList : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntermediateType mList; + FfiValueObjectHandleTodolistTodoList mList{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::FromJs(aArgs[0], &mList, aError); + mList.Lower(aArgs[0], aError); if (aError.Failed()) { return; } @@ -9755,7 +11151,7 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_uniffi_todolist_fn_func_set_default_list( - ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntoRust(std::move(mList)), + mList.IntoRust(), aOutStatus ); } @@ -9766,18 +11162,18 @@ public: class ScaffoldingCallHandlerUniffiUniffiTodolistFnMethodTodolistAddEntries : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mEntries; + FfiValueObjectHandleTodolistTodoList mPtr{}; + FfiValueRustBuffer mEntries{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mEntries, aError); + mEntries.Lower(aArgs[1], aError); if (aError.Failed()) { return; } @@ -9785,8 +11181,8 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_uniffi_todolist_fn_method_todolist_add_entries( - ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mEntries)), + mPtr.IntoRust(), + mEntries.IntoRust(), aOutStatus ); } @@ -9797,18 +11193,18 @@ public: class ScaffoldingCallHandlerUniffiUniffiTodolistFnMethodTodolistAddEntry : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mEntry; + FfiValueObjectHandleTodolistTodoList mPtr{}; + FfiValueRustBuffer mEntry{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mEntry, aError); + mEntry.Lower(aArgs[1], aError); if (aError.Failed()) { return; } @@ -9816,8 +11212,8 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_uniffi_todolist_fn_method_todolist_add_entry( - ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mEntry)), + mPtr.IntoRust(), + mEntry.IntoRust(), aOutStatus ); } @@ -9828,18 +11224,18 @@ public: class ScaffoldingCallHandlerUniffiUniffiTodolistFnMethodTodolistAddItem : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mTodo; + FfiValueObjectHandleTodolistTodoList mPtr{}; + FfiValueRustBuffer mTodo{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mTodo, aError); + mTodo.Lower(aArgs[1], aError); if (aError.Failed()) { return; } @@ -9847,8 +11243,8 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_uniffi_todolist_fn_method_todolist_add_item( - ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mTodo)), + mPtr.IntoRust(), + mTodo.IntoRust(), aOutStatus ); } @@ -9859,18 +11255,18 @@ public: class ScaffoldingCallHandlerUniffiUniffiTodolistFnMethodTodolistAddItems : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mItems; + FfiValueObjectHandleTodolistTodoList mPtr{}; + FfiValueRustBuffer mItems{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mItems, aError); + mItems.Lower(aArgs[1], aError); if (aError.Failed()) { return; } @@ -9878,8 +11274,8 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_uniffi_todolist_fn_method_todolist_add_items( - ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mItems)), + mPtr.IntoRust(), + mItems.IntoRust(), aOutStatus ); } @@ -9890,18 +11286,18 @@ public: class ScaffoldingCallHandlerUniffiUniffiTodolistFnMethodTodolistClearItem : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mTodo; + FfiValueObjectHandleTodolistTodoList mPtr{}; + FfiValueRustBuffer mTodo{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mTodo, aError); + mTodo.Lower(aArgs[1], aError); if (aError.Failed()) { return; } @@ -9909,8 +11305,8 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_uniffi_todolist_fn_method_todolist_clear_item( - ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mTodo)), + mPtr.IntoRust(), + mTodo.IntoRust(), aOutStatus ); } @@ -9921,32 +11317,31 @@ public: class ScaffoldingCallHandlerUniffiUniffiTodolistFnMethodTodolistGetEntries : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntermediateType mPtr; + FfiValueObjectHandleTodolistTodoList mPtr{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_uniffi_todolist_fn_method_todolist_get_entries( - ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -9955,32 +11350,31 @@ public: class ScaffoldingCallHandlerUniffiUniffiTodolistFnMethodTodolistGetFirst : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntermediateType mPtr; + FfiValueObjectHandleTodolistTodoList mPtr{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_uniffi_todolist_fn_method_todolist_get_first( - ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -9989,32 +11383,31 @@ public: class ScaffoldingCallHandlerUniffiUniffiTodolistFnMethodTodolistGetItems : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntermediateType mPtr; + FfiValueObjectHandleTodolistTodoList mPtr{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_uniffi_todolist_fn_method_todolist_get_items( - ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -10023,32 +11416,31 @@ public: class ScaffoldingCallHandlerUniffiUniffiTodolistFnMethodTodolistGetLast : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntermediateType mPtr; + FfiValueObjectHandleTodolistTodoList mPtr{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_uniffi_todolist_fn_method_todolist_get_last( - ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -10057,32 +11449,31 @@ public: class ScaffoldingCallHandlerUniffiUniffiTodolistFnMethodTodolistGetLastEntry : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntermediateType mPtr; + FfiValueObjectHandleTodolistTodoList mPtr{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueRustBuffer mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueRustBuffer::FromRust( uniffi_uniffi_todolist_fn_method_todolist_get_last_entry( - ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -10091,13 +11482,13 @@ public: class ScaffoldingCallHandlerUniffiUniffiTodolistFnMethodTodolistMakeDefault : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntermediateType mPtr; + FfiValueObjectHandleTodolistTodoList mPtr{}; // MakeRustCall stores the result of the call in these fields public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } @@ -10105,7 +11496,7 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_uniffi_todolist_fn_method_todolist_make_default( - ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntoRust(std::move(mPtr)), + mPtr.IntoRust(), aOutStatus ); } @@ -10118,14 +11509,14 @@ private: // PrepareRustArgs stores the resulting arguments in these fields // MakeRustCall stores the result of the call in these fields - typename ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntermediateType mUniffiReturnValue; + FfiValueObjectHandleTodolistTodoList mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::FromRust( + mUniffiReturnValue = FfiValueObjectHandleTodolistTodoList::FromRust( uniffi_uniffi_todolist_fn_constructor_todolist_new( aOutStatus ) @@ -10133,9 +11524,8 @@ public: } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -10146,14 +11536,14 @@ private: // PrepareRustArgs stores the resulting arguments in these fields // MakeRustCall stores the result of the call in these fields - typename ScaffoldingObjectConverter<&kUniffiTraitInterfacesCalcPointerType>::IntermediateType mUniffiReturnValue; + FfiValueObjectHandleUniffiTraitInterfacesCalc mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingObjectConverter<&kUniffiTraitInterfacesCalcPointerType>::FromRust( + mUniffiReturnValue = FfiValueObjectHandleUniffiTraitInterfacesCalc::FromRust( uniffi_uniffi_trait_interfaces_fn_func_make_buggy_calculator( aOutStatus ) @@ -10161,9 +11551,8 @@ public: } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kUniffiTraitInterfacesCalcPointerType>::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -10174,14 +11563,14 @@ private: // PrepareRustArgs stores the resulting arguments in these fields // MakeRustCall stores the result of the call in these fields - typename ScaffoldingObjectConverter<&kUniffiTraitInterfacesCalcPointerType>::IntermediateType mUniffiReturnValue; + FfiValueObjectHandleUniffiTraitInterfacesCalc mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingObjectConverter<&kUniffiTraitInterfacesCalcPointerType>::FromRust( + mUniffiReturnValue = FfiValueObjectHandleUniffiTraitInterfacesCalc::FromRust( uniffi_uniffi_trait_interfaces_fn_func_make_calculator( aOutStatus ) @@ -10189,9 +11578,8 @@ public: } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kUniffiTraitInterfacesCalcPointerType>::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -10200,44 +11588,43 @@ public: class ScaffoldingCallHandlerUniffiUniffiTraitInterfacesFnMethodCalcAdd : public UniffiSyncCallHandler { private: // PrepareRustArgs stores the resulting arguments in these fields - typename ScaffoldingObjectConverter<&kUniffiTraitInterfacesCalcPointerType>::IntermediateType mPtr; - typename ScaffoldingConverter::IntermediateType mA; - typename ScaffoldingConverter::IntermediateType mB; + FfiValueObjectHandleUniffiTraitInterfacesCalc mPtr{}; + FfiValueInt mA{}; + FfiValueInt mB{}; // MakeRustCall stores the result of the call in these fields - typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; + FfiValueInt mUniffiReturnValue{}; public: void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - ScaffoldingObjectConverter<&kUniffiTraitInterfacesCalcPointerType>::FromJs(aArgs[0], &mPtr, aError); + mPtr.Lower(aArgs[0], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[1], &mA, aError); + mA.Lower(aArgs[1], aError); if (aError.Failed()) { return; } - ScaffoldingConverter::FromJs(aArgs[2], &mB, aError); + mB.Lower(aArgs[2], aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = ScaffoldingConverter::FromRust( + mUniffiReturnValue = FfiValueInt::FromRust( uniffi_uniffi_trait_interfaces_fn_method_calc_add( - ScaffoldingObjectConverter<&kUniffiTraitInterfacesCalcPointerType>::IntoRust(std::move(mPtr)), - ScaffoldingConverter::IntoRust(std::move(mA)), - ScaffoldingConverter::IntoRust(std::move(mB)), + mPtr.IntoRust(), + mA.IntoRust(), + mB.IntoRust(), aOutStatus ) ); } virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - ScaffoldingConverter::IntoJs( + mUniffiReturnValue.Lift( aCx, - std::move(mUniffiReturnValue), &aDest.Construct(), aError ); diff --git a/toolkit/components/uniffi-js/OwnedRustBuffer.cpp b/toolkit/components/uniffi-js/OwnedRustBuffer.cpp index 05d84f5897a2..2a45dc5c003a 100644 --- a/toolkit/components/uniffi-js/OwnedRustBuffer.cpp +++ b/toolkit/components/uniffi-js/OwnedRustBuffer.cpp @@ -5,7 +5,7 @@ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ #include "nsString.h" -#include "mozilla/dom/OwnedRustBuffer.h" +#include "mozilla/uniffi/OwnedRustBuffer.h" namespace mozilla::uniffi { diff --git a/toolkit/components/uniffi-js/OwnedRustBuffer.h b/toolkit/components/uniffi-js/OwnedRustBuffer.h index 46d61d32a47e..23bf7466d782 100644 --- a/toolkit/components/uniffi-js/OwnedRustBuffer.h +++ b/toolkit/components/uniffi-js/OwnedRustBuffer.h @@ -9,7 +9,7 @@ #include "mozilla/ErrorResult.h" #include "mozilla/dom/TypedArray.h" -#include "mozilla/dom/UniFFIRust.h" +#include "mozilla/uniffi/Rust.h" namespace mozilla::uniffi { diff --git a/toolkit/components/uniffi-js/UniFFIPointerType.h b/toolkit/components/uniffi-js/PointerType.h similarity index 96% rename from toolkit/components/uniffi-js/UniFFIPointerType.h rename to toolkit/components/uniffi-js/PointerType.h index 25294cfc9de1..f997cdb6e29c 100644 --- a/toolkit/components/uniffi-js/UniFFIPointerType.h +++ b/toolkit/components/uniffi-js/PointerType.h @@ -10,7 +10,7 @@ #include "nsISupports.h" #include "nsWrapperCache.h" #include "nsLiteralString.h" -#include "UniFFIRust.h" +#include "mozilla/uniffi/Rust.h" namespace mozilla::uniffi { diff --git a/toolkit/components/uniffi-js/README.md b/toolkit/components/uniffi-js/README.md index 3bf8d9de7a9f..922675860079 100644 --- a/toolkit/components/uniffi-js/README.md +++ b/toolkit/components/uniffi-js/README.md @@ -10,8 +10,7 @@ This directory contains C++ helper code for the UniFFI Rust library - UniFFIScaffolding.cpp is a facade that wraps UniFFIFixtureScaffolding, and UniFFIGeneratedScaffolding if enabled, to implement the interface. -- `ScaffoldingConverter.h` contain helper code to convert values between JS and Rust. This is used - by the generated code to make scaffolding calls. +- `UniFFIFfiConverter.h` Lifts/Lowers JS values into FFI values. - `OwnedRustBuffer.*` implements a C++ class to help manager ownership of a RustBuffer. diff --git a/toolkit/components/uniffi-js/UniFFIRust.h b/toolkit/components/uniffi-js/Rust.h similarity index 100% rename from toolkit/components/uniffi-js/UniFFIRust.h rename to toolkit/components/uniffi-js/Rust.h diff --git a/toolkit/components/uniffi-js/ScaffoldingConverter.h b/toolkit/components/uniffi-js/ScaffoldingConverter.h deleted file mode 100644 index 05cde4b13835..000000000000 --- a/toolkit/components/uniffi-js/ScaffoldingConverter.h +++ /dev/null @@ -1,211 +0,0 @@ -/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ -/* vim:set ts=2 sw=2 sts=2 et cindent: */ -/* This Source Code Form is subject to the terms of the Mozilla Public - * License, v. 2.0. If a copy of the MPL was not distributed with this - * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ - -#ifndef mozilla_ScaffoldingConverter_h -#define mozilla_ScaffoldingConverter_h - -#include -#include -#include "nsString.h" -#include "mozilla/ResultVariant.h" -#include "mozilla/dom/OwnedRustBuffer.h" -#include "mozilla/dom/PrimitiveConversions.h" -#include "mozilla/dom/TypedArray.h" -#include "mozilla/dom/UniFFIBinding.h" -#include "mozilla/dom/UniFFIPointer.h" -#include "mozilla/dom/UniFFIPointerType.h" -#include "mozilla/dom/UniFFIRust.h" -#include "mozilla/dom/UniFFIScaffolding.h" - -namespace mozilla::uniffi { - -// Handle converting types between JS and Rust -// -// Scaffolding conversions are done using a 2 step process: -// - Call FromJs/FromRust to convert to an intermediate type -// - Call IntoJs/IntoRust to convert from that type to the target type -// -// The main reason for this is handling RustBuffers when other arguments fail -// to convert. By using OwnedRustBuffer as the intermediate type, we can -// ensure those buffers get freed in that case. Note that we can't use -// OwnedRustBuffer as the Rust type. Passing the buffer into Rust transfers -// ownership so we shouldn't free the buffer in this case. -// -// For most other types, we just use the Rust type as the intermediate type. -template -class ScaffoldingConverter { - public: - using RustType = T; - using IntermediateType = T; - - // Convert a JS value to an intermedate type - // - // This inputs a const ref, because that's what the WebIDL bindings send to - // us. - // - // If this succeeds then IntoRust is also guaranteed to succeed - static void FromJs(const dom::OwningUniFFIScaffoldingValue& aValue, - IntermediateType* aResult, ErrorResult& aError) { - if (!aValue.IsDouble()) { - aError.ThrowTypeError("Bad argument type"_ns); - return; - } - double value = aValue.GetAsDouble(); - - if (std::isnan(value)) { - aError.ThrowUnknownError("NaN not allowed"_ns); - return; - } - - if constexpr (std::is_integral::value) { - // Use PrimitiveConversionTraits_Limits rather than std::numeric_limits, - // since it handles JS-specific bounds like the 64-bit integer limits. - // (see Number.MAX_SAFE_INTEGER and Number.MIN_SAFE_INTEGER) - if (value < dom::PrimitiveConversionTraits_Limits::min() || - value > dom::PrimitiveConversionTraits_Limits::max()) { - aError.ThrowRangeError( - "UniFFI return value cannot be precisely represented in JS"_ns); - return; - } - } - - // Don't check float bounds for a few reasons. - // - It's difficult because - // PrimitiveConversionTraits_Limits::min() is the smallest - // positive value, rather than the most negative. - // - A float value unlikely to overflow - // - It's also likely that we can't do an exact conversion because the - // float doesn't have enough precision, but it doesn't seem correct - // to error out in that case. - - IntermediateType rv = static_cast(value); - if constexpr (std::is_integral::value) { - if (rv != value) { - aError.ThrowTypeError("Not an integer"_ns); - return; - } - } - *aResult = rv; - } - - // Convert an intermediate type to a Rust type - // - // IntoRust doesn't touch the JS data, so it's safe to call in a worker thread - static RustType IntoRust(IntermediateType aValue) { return aValue; } - - // Convert an Rust type to an intermediate type - // - // This inputs a value since Rust types are POD types - static IntermediateType FromRust(RustType aValue) { return aValue; } - - // Convert an intermedate type to a JS type - // - // This inputs an r-value reference since we may want to move data out of - // this type. - static void IntoJs(JSContext* aContext, IntermediateType&& aValue, - dom::OwningUniFFIScaffoldingValue* aDest, - ErrorResult& aError) { - if constexpr (std::is_same::value || - std::is_same::value) { - // Check that the value can fit in a double (only needed for 64 bit types) - if (aValue < dom::PrimitiveConversionTraits_Limits::min() || - aValue > dom::PrimitiveConversionTraits_Limits::max()) { - aError.ThrowRangeError( - "UniFFI return value cannot be precisely represented in JS"_ns); - return; - } - } - if constexpr (std::is_floating_point::value) { - if (std::isnan(aValue)) { - aError.ThrowUnknownError("NaN not allowed"_ns); - return; - } - } - aDest->SetAsDouble() = aValue; - } -}; - -template <> -class ScaffoldingConverter { - public: - using RustType = RustBuffer; - using IntermediateType = OwnedRustBuffer; - - static void FromJs(const dom::OwningUniFFIScaffoldingValue& aValue, - OwnedRustBuffer* aResult, ErrorResult& aError) { - if (!aValue.IsArrayBuffer()) { - aError.ThrowTypeError("Expected ArrayBuffer argument"_ns); - return; - } - *aResult = OwnedRustBuffer::FromArrayBuffer(aValue.GetAsArrayBuffer()); - } - - static RustBuffer IntoRust(OwnedRustBuffer&& aValue) { - return aValue.IntoRustBuffer(); - } - - static OwnedRustBuffer FromRust(RustBuffer aValue) { - return OwnedRustBuffer(aValue); - } - - static void IntoJs(JSContext* aContext, OwnedRustBuffer&& aValue, - dom::OwningUniFFIScaffoldingValue* aDest, - ErrorResult& aError) { - JS::Rooted obj(aContext); - aValue.IntoArrayBuffer(aContext, &obj, aError); - if (aError.Failed()) { - return; - } - aDest->SetAsArrayBuffer().Init(obj); - } -}; - -// ScaffoldingConverter for object pointers -template -class ScaffoldingObjectConverter { - public: - using RustType = void*; - using IntermediateType = void*; - - static void FromJs(const dom::OwningUniFFIScaffoldingValue& aValue, - void** aResult, ErrorResult& aError) { - if (!aValue.IsUniFFIPointer()) { - aError.ThrowTypeError("Expected UniFFI pointer argument"_ns); - return; - } - dom::UniFFIPointer& value = aValue.GetAsUniFFIPointer(); - if (!value.IsSamePtrType(PointerType)) { - aError.ThrowTypeError("Incorrect UniFFI pointer type"_ns); - return; - } - *aResult = value.ClonePtr(); - } - - static void* IntoRust(void* aValue) { return aValue; } - - static void* FromRust(void* aValue) { return aValue; } - - static void IntoJs(JSContext* aContext, void* aValue, - dom::OwningUniFFIScaffoldingValue* aDest, - ErrorResult& aError) { - aDest->SetAsUniFFIPointer() = - dom::UniFFIPointer::Create(aValue, PointerType); - } -}; - -// ScaffoldingConverter for void returns -// -// This doesn't implement the normal interface, it's only use is a the -// ReturnConverter parameter of ScaffoldingCallHandler. -template <> -class ScaffoldingConverter { - public: - using RustType = void; -}; - -} // namespace mozilla::uniffi - -#endif // mozilla_ScaffoldingConverter_h diff --git a/toolkit/components/uniffi-js/UniFFIPointer.cpp b/toolkit/components/uniffi-js/UniFFIPointer.cpp index cb5342eb4086..9aeb91dfcd58 100644 --- a/toolkit/components/uniffi-js/UniFFIPointer.cpp +++ b/toolkit/components/uniffi-js/UniFFIPointer.cpp @@ -7,10 +7,10 @@ #include "nsPrintfCString.h" #include "js/GCAPI.h" #include "mozilla/EndianUtils.h" +#include "mozilla/Logging.h" #include "mozilla/dom/UniFFIPointer.h" #include "mozilla/dom/UniFFIBinding.h" -#include "mozilla/Logging.h" -#include "UniFFIRust.h" +#include "mozilla/uniffi/Rust.h" namespace mozilla::uniffi { extern mozilla::LazyLogModule gUniffiLogger; diff --git a/toolkit/components/uniffi-js/UniFFIPointer.h b/toolkit/components/uniffi-js/UniFFIPointer.h index 24a7b80eedf2..40aa72a0a032 100644 --- a/toolkit/components/uniffi-js/UniFFIPointer.h +++ b/toolkit/components/uniffi-js/UniFFIPointer.h @@ -12,7 +12,7 @@ #include "nsString.h" #include "mozilla/ErrorResult.h" #include "mozilla/dom/TypedArray.h" -#include "mozilla/dom/UniFFIPointerType.h" +#include "mozilla/uniffi/PointerType.h" namespace mozilla::dom { diff --git a/toolkit/components/uniffi-js/UniFFIScaffolding.cpp b/toolkit/components/uniffi-js/UniFFIScaffolding.cpp index 9129b6ea62db..0dd1de1e9c21 100644 --- a/toolkit/components/uniffi-js/UniFFIScaffolding.cpp +++ b/toolkit/components/uniffi-js/UniFFIScaffolding.cpp @@ -12,14 +12,14 @@ #include "mozilla/Maybe.h" #include "mozilla/UniquePtr.h" #include "mozilla/dom/Promise.h" -#include "mozilla/dom/UniFFICall.h" -#include "mozilla/dom/UniFFICallbacks.h" +#include "mozilla/uniffi/Call.h" +#include "mozilla/uniffi/Callbacks.h" #include "mozilla/dom/UniFFIScaffolding.h" // This file implements the UniFFI WebIDL interface by leveraging the generate -// code in UniFFIScaffolding.cpp and UniFFIFixtureScaffolding.cpp. It's main -// purpose is to check if MOZ_UNIFFI_FIXTURES is set and only try calling the -// scaffolding code if it is. +// code in UniFFIScaffolding.cpp. It's main purpose is to check if +// MOZ_UNIFFI_FIXTURES is set and only try calling the scaffolding code if it +// is. using mozilla::dom::ArrayBuffer; using mozilla::dom::GlobalObject; @@ -35,7 +35,7 @@ using mozilla::uniffi::UniffiSyncCallHandler; namespace mozilla::uniffi { mozilla::LazyLogModule gUniffiLogger("uniffi"); -// Implemented in UniFFIGeneratedScaffolding.cpp +// Implemented in GeneratedScaffolding.cpp UniquePtr GetSyncCallHandler(uint64_t aId); UniquePtr GetAsyncCallHandler(uint64_t aId); Maybe> ReadPointer( diff --git a/toolkit/components/uniffi-js/moz.build b/toolkit/components/uniffi-js/moz.build index a1c0d9e197f5..ac9750e8c5cd 100644 --- a/toolkit/components/uniffi-js/moz.build +++ b/toolkit/components/uniffi-js/moz.build @@ -7,10 +7,10 @@ FINAL_LIBRARY = "xul" UNIFIED_SOURCES += [ + "Call.cpp", + "Callbacks.cpp", + "GeneratedScaffolding.cpp", "OwnedRustBuffer.cpp", - "UniFFICall.cpp", - "UniFFICallbacks.cpp", - "UniFFIGeneratedScaffolding.cpp", "UniFFIPointer.cpp", "UniFFIScaffolding.cpp", ] @@ -19,16 +19,19 @@ if CONFIG["MOZ_UNIFFI_FIXTURES"]: DEFINES["MOZ_UNIFFI_FIXTURES"] = True EXPORTS.mozilla.dom += [ - "OwnedRustBuffer.h", - "ScaffoldingConverter.h", - "UniFFICall.h", - "UniFFICallbacks.h", "UniFFIPointer.h", - "UniFFIPointerType.h", - "UniFFIRust.h", "UniFFIScaffolding.h", ] +EXPORTS.mozilla.uniffi += [ + "Call.h", + "Callbacks.h", + "FfiValue.h", + "OwnedRustBuffer.h", + "PointerType.h", + "Rust.h", +] + EXTRA_JS_MODULES += [ "js/UniFFI.sys.mjs", ] diff --git a/tools/rewriting/Generated.txt b/tools/rewriting/Generated.txt index 3ec15688f6eb..4621649703df 100644 --- a/tools/rewriting/Generated.txt +++ b/tools/rewriting/Generated.txt @@ -215,8 +215,7 @@ toolkit/components/nimbus/schemas/ExperimentFeatureManifest.schema.json toolkit/components/nimbus/schemas/NimbusExperiment.schema.json toolkit/components/pdfjs/PdfJsDefaultPrefs.js toolkit/components/pdfjs/PdfJsOverridePrefs.js -toolkit/components/uniffi-js/UniFFIGeneratedScaffolding.cpp -toolkit/components/uniffi-js/UniFFIFixtureScaffolding.cpp +toolkit/components/uniffi-js/GeneratedScaffolding.cpp toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated tools/@types/tspaths.json tools/browsertime/package.json