diff --git a/.clang-format-ignore b/.clang-format-ignore index bb19da090c57..9ffc9a09e9da 100644 --- a/.clang-format-ignore +++ b/.clang-format-ignore @@ -69,7 +69,8 @@ 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/GeneratedScaffolding.cpp +toolkit/components/uniffi-js/UniFFIGeneratedScaffolding.cpp +toolkit/components/uniffi-js/UniFFIFixtureScaffolding.cpp # Generated from ./tools/rewriting/ThirdPartyPaths.txt # awk '{print ""$1".*"}' ./tools/rewriting/ThirdPartyPaths.txt diff --git a/.prettierignore b/.prettierignore index 0fdcd9b6d58f..8281c52e2385 100644 --- a/.prettierignore +++ b/.prettierignore @@ -1563,7 +1563,8 @@ 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/GeneratedScaffolding.cpp +toolkit/components/uniffi-js/UniFFIGeneratedScaffolding.cpp +toolkit/components/uniffi-js/UniFFIFixtureScaffolding.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 da469fc97869..f532d3d39e23 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2524,7 +2524,6 @@ 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 46d1ea0ef352..0c27a6747c37 100644 --- a/toolkit/components/uniffi-bindgen-gecko-js/components/Cargo.toml +++ b/toolkit/components/uniffi-bindgen-gecko-js/components/Cargo.toml @@ -22,8 +22,6 @@ 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 c72d09a1928a..e1af82350d01 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/GeneratedScaffolding.cpp" +CPP_PATH = "toolkit/components/uniffi-js/UniFFIGeneratedScaffolding.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 a3384822d126..2bc575ccfb0f 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| ffi_type_name(&a.type_())) + .map(|a| cpp_type(&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| ffi_type_name(&a.type_())) + .map(|a| cpp_type(&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_: ffi_type_name(&f.type_()), + type_: cpp_type(&f.type_()), }) .collect(), }), @@ -182,7 +182,7 @@ impl CPPScaffoldingTemplate { let cbi_name_snake = cbi.name().to_snake_case(); CallbackInterfaceVTable { - type_: ffi_type_name(&cbi.vtable()), + type_: cpp_type(&cbi.vtable()), var_name: format!("kCallbackInterfaceVtable{cbi_name}"), method_handlers: cbi .vtable_methods() @@ -196,13 +196,13 @@ impl CPPScaffoldingTemplate { arguments: method .arguments() .iter() - .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), - } + .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(), + ), }) .collect(), } @@ -337,8 +337,8 @@ struct CallbackMethodHandler { struct CallbackMethodArgument { name: String, - ffi_type: String, - ffi_value_class: String, + type_: String, + scaffolding_converter: String, } struct ScaffoldingCall { @@ -366,7 +366,7 @@ impl ScaffoldingCall { .into_iter() .map(|a| ScaffoldingCallArgument { var_name: format!("m{}", a.name().to_upper_camel_case()), - ffi_value_class: ffi_value_class(ci, &a.type_()), + scaffolding_converter: scaffolding_converter(ci, &a.type_()), }) .collect::>(); @@ -384,9 +384,8 @@ impl ScaffoldingCall { // function always returns a handle. return_type: callable .return_type() - .map(|return_type| FfiType::from(return_type)) .map(|return_type| ScaffoldingCallReturnType { - ffi_value_class: ffi_value_class(ci, &return_type), + scaffolding_converter: scaffolding_converter(ci, &return_type.into()), }), arguments, async_info, @@ -399,12 +398,12 @@ impl ScaffoldingCall { } struct ScaffoldingCallReturnType { - ffi_value_class: String, + scaffolding_converter: String, } struct ScaffoldingCallArgument { var_name: String, - ffi_value_class: String, + scaffolding_converter: String, } struct ScaffoldingCallAsyncInfo { @@ -413,7 +412,7 @@ struct ScaffoldingCallAsyncInfo { free_fn: String, } -fn ffi_value_class(ci: &ComponentInterface, ffi_type: &FfiType) -> String { +fn scaffolding_converter(ci: &ComponentInterface, ffi_type: &FfiType) -> String { match ffi_type { FfiType::RustArcPtr(name) => { // Check if this is an external type @@ -422,29 +421,17 @@ fn ffi_value_class(ci: &ComponentInterface, ffi_type: &FfiType) -> String { let crate_name = ty.module_path().expect("External type without module path"); if external_ty_name == name { return format!( - "FfiValueObjectHandle<&{}>", + "ScaffoldingObjectConverter<&{}>", pointer_type(crate_name_to_namespace(&crate_name), name), ); } } format!( - "FfiValueObjectHandle<&{}>", + "ScaffoldingObjectConverter<&{}>", pointer_type(ci.namespace(), name), ) } - 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)), + _ => format!("ScaffoldingConverter<{}>", cpp_type(ffi_type)), } } @@ -456,8 +443,8 @@ fn pointer_type(namespace: &str, name: &str) -> String { ) } -// C++ type for an FFI value -fn ffi_type_name(ffi_type: &FfiType) -> String { +// Type for the Rust scaffolding code +fn cpp_type(ffi_type: &FfiType) -> String { match ffi_type { FfiType::UInt8 => "uint8_t".to_owned(), FfiType::Int8 => "int8_t".to_owned(), @@ -477,14 +464,14 @@ fn ffi_type_name(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!("{}*", ffi_type_name(inner.as_ref())) + format!("{}*", cpp_type(inner.as_ref())) } } } fn return_type(ffi_type: Option<&FfiType>) -> String { match ffi_type { - Some(t) => ffi_type_name(t), + Some(t) => cpp_type(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 21af397ae33c..a4839eec9d09 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/dom/UniFFIScaffolding.h" -#include "mozilla/uniffi/Call.h" -#include "mozilla/uniffi/Callbacks.h" -#include "mozilla/uniffi/FfiValue.h" -#include "mozilla/uniffi/PointerType.h" -#include "mozilla/uniffi/Rust.h" +#include "mozilla/dom/UniFFIRust.h" namespace mozilla::uniffi { @@ -78,15 +78,15 @@ static StaticRefPtr {{ cbi.js_handler_var }}; class {{ handler.class_name }} : public UniffiCallbackMethodHandlerBase { private: - // Rust arguments + // Rust arguments, converted using ScaffoldingConverter::FromRust. {%- for a in handler.arguments %} - {{ a.ffi_value_class }} {{ a.name }}{}; + typename {{ a.scaffolding_converter }}::IntermediateType {{ a.name }}; {%- endfor %} public: - {{ handler.class_name }}(size_t aObjectHandle{%- for a in handler.arguments %}, {{ a.ffi_type }} {{ a.name }}{%- endfor %}) + {{ handler.class_name }}(size_t aObjectHandle{%- for a in handler.arguments %}, {{ a.type_ }} {{ a.name }}{%- endfor %}) : UniffiCallbackMethodHandlerBase("{{ cbi.name }}", aObjectHandle) - {%- for a in handler.arguments %}, {{ a.name }}({{ a.ffi_value_class }}::FromRust({{ a.name }})){% endfor %} { + {%- for a in handler.arguments %}, {{ a.name }}({{ a.scaffolding_converter }}::FromRust({{ a.name }})){% endfor %} { } MOZ_CAN_RUN_SCRIPT @@ -102,8 +102,9 @@ public: // Convert each argument {%- for a in handler.arguments %} - {{ a.name }}.Lift( + {{ a.scaffolding_converter }}::IntoJs( aCx, + std::move(this->{{ a.name }}), &uniffiArgs[{{ loop.index0 }}], aError); if (aError.Failed()) { @@ -122,7 +123,7 @@ public: extern "C" void {{ handler.fn_name }}( uint64_t uniffiHandle, - {% for a in handler.arguments %}{{ a.ffi_type }} {{ a.name }}, {% endfor %} + {% for a in handler.arguments %}{{ a.type_ }} {{ a.name }}, {% endfor %} void* uniffiOutReturn, RustCallStatus* uniffiCallStatus ) { @@ -220,22 +221,22 @@ void DeregisterCallbackHandler(uint64_t aInterfaceId, ErrorResult& aError) { {%- when None %} class {{ scaffolding_call.handler_class_name }} : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields + // PrepareRustArgs stores the resulting arguments in these fields {%- for arg in scaffolding_call.arguments %} - {{ arg.ffi_value_class }} {{ arg.var_name }}{}; + typename {{ arg.scaffolding_converter }}::IntermediateType {{ arg.var_name }}; {%- endfor %} // MakeRustCall stores the result of the call in these fields {%- match scaffolding_call.return_type %} {%- when Some(return_type) %} - {{ return_type.ffi_value_class }} mUniffiReturnValue{}; + typename {{ return_type.scaffolding_converter }}::IntermediateType mUniffiReturnValue; {%- else %} {%- endmatch %} public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { {%- for arg in scaffolding_call.arguments %} - {{ arg.var_name }}.Lower(aArgs[{{ loop.index0 }}], aError); + {{ arg.scaffolding_converter }}::FromJs(aArgs[{{ loop.index0 }}], &{{ arg.var_name }}, aError); if (aError.Failed()) { return; } @@ -245,10 +246,10 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { {%- match scaffolding_call.return_type %} {%- when Some(return_type) %} - mUniffiReturnValue = {{ return_type.ffi_value_class }}::FromRust( + mUniffiReturnValue = {{ return_type.scaffolding_converter }}::FromRust( {{ scaffolding_call.ffi_func_name }}( {%- for arg in scaffolding_call.arguments %} - {{ arg.var_name }}.IntoRust(), + {{ arg.scaffolding_converter }}::IntoRust(std::move({{ arg.var_name }})), {%- endfor %} aOutStatus ) @@ -256,18 +257,19 @@ public: {%- else %} {{ scaffolding_call.ffi_func_name }}( {%- for arg in scaffolding_call.arguments %} - {{ arg.var_name }}.IntoRust(), + {{ arg.scaffolding_converter }}::IntoRust(std::move({{ arg.var_name }})), {%- endfor %} aOutStatus ); {%- endmatch %} } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { {%- match scaffolding_call.return_type %} {%- when Some(return_type) %} - mUniffiReturnValue.Lift( + {{ return_type.scaffolding_converter }}::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -284,7 +286,7 @@ private: // Complete stores the result of the call in mUniffiReturnValue {%- match scaffolding_call.return_type %} {%- when Some(return_type) %} - {{ return_type.ffi_value_class }} mUniffiReturnValue{}; + typename {{ return_type.scaffolding_converter }}::IntermediateType mUniffiReturnValue; {%- else %} {%- endmatch %} @@ -292,10 +294,10 @@ 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 LowerArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { + void PrepareArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { {%- for arg in scaffolding_call.arguments %} - {{ arg.ffi_value_class }} {{ arg.var_name }}{}; - {{ arg.var_name }}.Lower(aArgs[{{ loop.index0 }}], aError); + typename {{ arg.scaffolding_converter }}::IntermediateType {{ arg.var_name }}; + {{ arg.scaffolding_converter }}::FromJs(aArgs[{{ loop.index0 }}], &{{ arg.var_name }}, aError); if (aError.Failed()) { return; } @@ -303,7 +305,7 @@ protected: mFutureHandle = {{ scaffolding_call.ffi_func_name }}( {%- for arg in scaffolding_call.arguments %} - {{ arg.var_name }}.IntoRust(){% if !loop.last %},{% endif %} + {{ arg.scaffolding_converter }}::IntoRust(std::move({{ arg.var_name }})){% if !loop.last %},{% endif %} {%- endfor %} ); } @@ -311,7 +313,7 @@ protected: void CallCompleteFn(RustCallStatus* aOutStatus) override { {%- match scaffolding_call.return_type %} {%- when Some(return_type) %} - mUniffiReturnValue = {{ return_type.ffi_value_class }}::FromRust( + mUniffiReturnValue = {{ return_type.scaffolding_converter }}::FromRust( {{ async_info.complete_fn }}(mFutureHandle, aOutStatus)); {%- else %} {{ async_info.complete_fn }}(mFutureHandle, aOutStatus); @@ -319,11 +321,12 @@ protected: } public: - void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { {%- match scaffolding_call.return_type %} {%- when Some(return_type) %} - mUniffiReturnValue.Lift( + {{ return_type.scaffolding_converter }}::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); diff --git a/toolkit/components/uniffi-js/Call.cpp b/toolkit/components/uniffi-js/Call.cpp deleted file mode 100644 index 11c4d5ec0068..000000000000 --- a/toolkit/components/uniffi-js/Call.cpp +++ /dev/null @@ -1,226 +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/. */ - -#include "nsThreadUtils.h" -#include "mozilla/dom/Promise.h" -#include "mozilla/dom/RootedDictionary.h" -#include "mozilla/uniffi/Call.h" -#include "mozilla/uniffi/ResultPromise.h" - -namespace mozilla::uniffi { -extern mozilla::LazyLogModule gUniffiLogger; - -using dom::GlobalObject; -using dom::OwningUniFFIScaffoldingValue; -using dom::RootedDictionary; -using dom::Sequence; -using dom::UniFFIScaffoldingCallResult; - -void UniffiSyncCallHandler::CallSync( - UniquePtr aHandler, const GlobalObject& aGlobal, - const Sequence& aArgs, - RootedDictionary& aReturnValue, - ErrorResult& aError) { - MOZ_ASSERT(NS_IsMainThread()); - aHandler->LowerRustArgs(aArgs, aError); - if (aError.Failed()) { - return; - } - RustCallStatus callStatus{}; - aHandler->MakeRustCall(&callStatus); - aHandler->mUniffiCallStatusCode = callStatus.code; - if (callStatus.error_buf.data) { - aHandler->mUniffiCallStatusErrorBuf = - FfiValueRustBuffer(callStatus.error_buf); - } - aHandler->LiftCallResult(aGlobal.Context(), aReturnValue, aError); -} - -already_AddRefed UniffiSyncCallHandler::CallAsyncWrapper( - UniquePtr aHandler, const dom::GlobalObject& aGlobal, - const dom::Sequence& aArgs, - ErrorResult& aError) { - MOZ_ASSERT(NS_IsMainThread()); - aHandler->LowerRustArgs(aArgs, aError); - if (aError.Failed()) { - return nullptr; - } - - uniffi::ResultPromise resultPromise; - resultPromise.Init(aGlobal, aError); - if (aError.Failed()) { - return nullptr; - } - - nsresult dispatchResult = NS_DispatchBackgroundTask( - NS_NewRunnableFunction("UniffiSyncCallHandler::CallAsyncWrapper", - [handler = std::move(aHandler), - resultPromise = resultPromise]() mutable { - RustCallStatus callStatus{}; - handler->MakeRustCall(&callStatus); - handler->mUniffiCallStatusCode = callStatus.code; - if (callStatus.error_buf.data) { - handler->mUniffiCallStatusErrorBuf = - FfiValueRustBuffer(callStatus.error_buf); - } - - resultPromise.Complete(std::move(handler)); - }), - NS_DISPATCH_EVENT_MAY_BLOCK); - if (NS_FAILED(dispatchResult)) { - MOZ_LOG(gUniffiLogger, LogLevel::Error, - ("[UniFFI] NS_DispatchBackgroundTask failed")); - resultPromise.RejectWithUnexpectedError(); - } - - return do_AddRef(resultPromise.GetPromise()); -} - -void UniffiCallHandlerBase::LiftCallResult( - JSContext* aCx, - dom::RootedDictionary& aDest, - ErrorResult& aError) { - switch (mUniffiCallStatusCode) { - case RUST_CALL_SUCCESS: { - aDest.mCode = dom::UniFFIScaffoldingCallCode::Success; - LiftSuccessfulCallResult(aCx, aDest.mData, aError); - break; - } - - case RUST_CALL_ERROR: { - // Rust Err() value. Populate data with the `RustBuffer` containing the - // error - aDest.mCode = dom::UniFFIScaffoldingCallCode::Error; - mUniffiCallStatusErrorBuf.Lift(aCx, &aDest.mData.Construct(), aError); - break; - } - - default: { - // 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.IsSet()) { - mUniffiCallStatusErrorBuf.Lift(aCx, &aDest.mData.Construct(), aError); - } - - break; - } - } -} - -already_AddRefed UniffiAsyncCallHandler::CallAsync( - UniquePtr aHandler, - const dom::GlobalObject& aGlobal, - const dom::Sequence& aArgs, - ErrorResult& aError) { - MOZ_ASSERT(NS_IsMainThread()); - // Async calls return a Future rather than doing any work. This means we can - // make the call right now on the JS main thread without fear of blocking it. - aHandler->LowerArgsAndMakeRustCall(aArgs, aError); - if (aError.Failed()) { - return nullptr; - } - - aHandler->mPromise.Init(aGlobal, aError); - if (aError.Failed()) { - return nullptr; - } - - ResultPromise returnPromise(aHandler->mPromise); - - // Schedule a poll for the future in a background thread. - nsresult dispatchResult = NS_DispatchBackgroundTask( - NS_NewRunnableFunction("UniffiAsyncCallHandler::CallAsync", - [handler = std::move(aHandler)]() mutable { - UniffiAsyncCallHandler::Poll(std::move(handler)); - })); - if (NS_FAILED(dispatchResult)) { - MOZ_LOG(gUniffiLogger, LogLevel::Error, - ("[UniFFI] NS_DispatchBackgroundTask failed")); - aHandler->mPromise.RejectWithUnexpectedError(); - } - - return do_AddRef(returnPromise.GetPromise()); -} - -// Callback function for async calls -// -// This is passed to Rust when we poll the future alongside a 64-bit handle that -// represents the callback data. For uniffi-bindgen-gecko-js, the handle is a -// `UniffiAsyncCallHandler*` casted to an int. -// -// Rust calls this when either the future is ready or when it's time to poll it -// again. -void UniffiAsyncCallHandler::FutureCallback(uint64_t aCallHandlerHandle, - int8_t aCode) { - // Recreate the UniquePtr we previously released - UniquePtr handler( - reinterpret_cast( - static_cast(aCallHandlerHandle))); - - switch (aCode) { - case UNIFFI_FUTURE_READY: { - // `Future::poll` returned a `Ready` value on the Rust side. - // Complete the future - RustCallStatus callStatus{}; - handler->CallCompleteFn(&callStatus); - handler->mUniffiCallStatusCode = callStatus.code; - if (callStatus.error_buf.data) { - handler->mUniffiCallStatusErrorBuf = - FfiValueRustBuffer(callStatus.error_buf); - } - // Copy of the ResultPromise before moving the handler that contains it. - ResultPromise promise(handler->mPromise); - promise.Complete(std::move(handler)); - break; - } - - case UNIFFI_FUTURE_MAYBE_READY: { - // The Rust waker was invoked after `poll` returned a `Pending` value. - // Poll the future again soon in a background task. - - nsresult dispatchResult = - NS_DispatchBackgroundTask(NS_NewRunnableFunction( - "UniffiAsyncCallHandler::FutureCallback", - [handler = std::move(handler)]() mutable { - UniffiAsyncCallHandler::Poll(std::move(handler)); - })); - if (NS_FAILED(dispatchResult)) { - MOZ_LOG(gUniffiLogger, LogLevel::Error, - ("[UniFFI] NS_DispatchBackgroundTask failed")); - handler->mPromise.RejectWithUnexpectedError(); - } - break; - } - - default: { - // Invalid poll code, this should never happen, but if it does log an - // error and reject the promise. - MOZ_LOG(gUniffiLogger, LogLevel::Error, - ("[UniFFI] Invalid poll code in " - "UniffiAsyncCallHandler::FutureCallback %d", - aCode)); - handler->mPromise.RejectWithUnexpectedError(); - break; - } - }; -} - -void UniffiAsyncCallHandler::Poll(UniquePtr aHandler) { - auto futureHandle = aHandler->mFutureHandle; - auto pollFn = aHandler->mPollFn; - // Release the UniquePtr into a raw pointer and convert it to a handle - // so that we can pass it as a handle to the UniFFI code. It gets converted - // back in `UniffiAsyncCallHandler::FutureCallback()`, which the Rust code - // guarentees will be called if the future makes progress. - uint64_t selfHandle = - static_cast(reinterpret_cast(aHandler.release())); - pollFn(futureHandle, UniffiAsyncCallHandler::FutureCallback, selfHandle); -} - -UniffiAsyncCallHandler::~UniffiAsyncCallHandler() { mFreeFn(mFutureHandle); } - -} // namespace mozilla::uniffi diff --git a/toolkit/components/uniffi-js/FfiValue.h b/toolkit/components/uniffi-js/FfiValue.h deleted file mode 100644 index 6b0be928e4aa..000000000000 --- a/toolkit/components/uniffi-js/FfiValue.h +++ /dev/null @@ -1,231 +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_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(); } -}; - -template -class FfiValueObjectHandle { - private: - void* mValue = nullptr; - - public: - FfiValueObjectHandle() = default; - explicit FfiValueObjectHandle(void* aValue) : mValue(aValue) {} - - // Delete copy constructor and assignment as this type is non-copyable. - FfiValueObjectHandle(const FfiValueObjectHandle&) = delete; - FfiValueObjectHandle& operator=(const FfiValueObjectHandle&) = delete; - - FfiValueObjectHandle& operator=(FfiValueObjectHandle&& aOther) { - if (mValue && mValue != aOther.mValue) { - 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(PointerType)) { - 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, PointerType); - mValue = nullptr; - } - - void* IntoRust() { - auto temp = mValue; - mValue = nullptr; - return temp; - } - - static FfiValueObjectHandle FromRust(void* aValue) { - return FfiValueObjectHandle(aValue); - } - - void FreeHandle() { - if (mValue) { - RustCallStatus callStatus{}; - (PointerType->destructor)(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. - } - } - - ~FfiValueObjectHandle() { - // 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(); - } -}; - -} // namespace mozilla::uniffi - -#endif // mozilla_UniFFIFfiConverter_h diff --git a/toolkit/components/uniffi-js/OwnedRustBuffer.cpp b/toolkit/components/uniffi-js/OwnedRustBuffer.cpp index 2a45dc5c003a..05d84f5897a2 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/uniffi/OwnedRustBuffer.h" +#include "mozilla/dom/OwnedRustBuffer.h" namespace mozilla::uniffi { diff --git a/toolkit/components/uniffi-js/OwnedRustBuffer.h b/toolkit/components/uniffi-js/OwnedRustBuffer.h index 23bf7466d782..46d61d32a47e 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/uniffi/Rust.h" +#include "mozilla/dom/UniFFIRust.h" namespace mozilla::uniffi { diff --git a/toolkit/components/uniffi-js/README.md b/toolkit/components/uniffi-js/README.md index df4a826b4e2d..3bf8d9de7a9f 100644 --- a/toolkit/components/uniffi-js/README.md +++ b/toolkit/components/uniffi-js/README.md @@ -2,3 +2,17 @@ This directory contains C++ helper code for the UniFFI Rust library (https://github.com/mozilla/uniffi-rs/). + + - `UniFFIPointer.*` and `UniFFIPointerType.*` implement the `UniFFIPointer` WebIDL class + + - `UniFFI*Scaffolding.cpp` implements the `UniFFIScaffolding` WebIDL class. + - UniFFIGeneratedScaffolding.cpp contains the generated C++ code + - 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. + +- `OwnedRustBuffer.*` implements a C++ class to help manager ownership of a RustBuffer. + +- `UniFFIRust.h` contains definitions for the C functions that UniFFI exports. diff --git a/toolkit/components/uniffi-js/ResultPromise.cpp b/toolkit/components/uniffi-js/ResultPromise.cpp deleted file mode 100644 index 38461723a3a9..000000000000 --- a/toolkit/components/uniffi-js/ResultPromise.cpp +++ /dev/null @@ -1,54 +0,0 @@ -/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ -/* vim: set ts=8 sts=2 et sw=2 tw=80: */ -/* 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/. */ - -#include "mozilla/uniffi/Call.h" -#include "mozilla/uniffi/ResultPromise.h" - -namespace mozilla::uniffi { - -void ResultPromise::Init(const dom::GlobalObject& aGlobal, - ErrorResult& aError) { - nsCOMPtr xpcomGlobal = - do_QueryInterface(aGlobal.GetAsSupports()); - RefPtr promise = dom::Promise::Create(xpcomGlobal, aError); - if (aError.Failed()) { - return; - } - mPromise = - new nsMainThreadPtrHolder("uniffi::ResultPromise", promise); -} - -void ResultPromise::Complete(UniquePtr aHandler) { - MOZ_ASSERT(mPromise); - NS_DispatchToMainThread(NS_NewRunnableFunction( - "uniffi::ResultPromise::Complete", - [promise = mPromise, handler = std::move(aHandler)]() { - dom::AutoEntryScript aes(promise->GetGlobalObject(), - "uniffi::ResultPromise::Complete"); - dom::RootedDictionary returnValue( - aes.cx()); - - ErrorResult error; - handler->LiftCallResult(aes.cx(), returnValue, error); - error.WouldReportJSException(); - if (error.Failed()) { - promise->MaybeReject(std::move(error)); - } else { - promise->MaybeResolve(returnValue); - } - })); -} - -void ResultPromise::RejectWithUnexpectedError() { - MOZ_ASSERT(mPromise); - NS_DispatchToMainThread(NS_NewRunnableFunction( - "uniffi::ResultPromise::RejectWithUnexpectedError", [promise = mPromise] { - promise->MaybeRejectWithUnknownError( - "UniFFI Unexpected Internal Error"); - })); -} - -} // namespace mozilla::uniffi diff --git a/toolkit/components/uniffi-js/ResultPromise.h b/toolkit/components/uniffi-js/ResultPromise.h deleted file mode 100644 index 5e853e618821..000000000000 --- a/toolkit/components/uniffi-js/ResultPromise.h +++ /dev/null @@ -1,68 +0,0 @@ -/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ -/* vim: set ts=8 sts=2 et sw=2 tw=80: */ -/* 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_dom_UniFFIResultPromise_h -#define mozilla_dom_UniFFIResultPromise_h - -#include "nsThreadUtils.h" -#include "mozilla/MozPromise.h" -#include "mozilla/RefPtr.h" -#include "mozilla/UniquePtr.h" -#include "mozilla/dom/Promise.h" -#include "mozilla/dom/UniFFIBinding.h" - -namespace mozilla::uniffi { -extern mozilla::LazyLogModule gUniffiLogger; - -class UniffiAsyncCallHandler; -class UniffiCallHandlerBase; - -/** - * JS "bridge" for UniFFI - * - * This module intefaces with the SpiderMonkey JS API so that other code can - * focus on the core UniFFI logic. - */ - -class ResultPromise { - public: - ResultPromise() = default; - - // Initialize a ResultPromise, this must be done before calling any other - // methods. - // - // This must be called on the main thread. - void Init(const dom::GlobalObject& aGlobal, ErrorResult& aError); - - // Get a raw `dom::Promise` pointer - // - // Use this to return the promise from a webidl-generated function. - // May only be called on the main thread. - dom::Promise* GetPromise() { return mPromise; } - - // Complete the promise using a call handler, this can be called from any - // thread. - // - // After a promise is completed, it must not be used anymore. - void Complete(UniquePtr aHandler); - - // Reject the promise with an unexpected error. - // - // Use this as a last resort, when something has gone very wrong in the FFI. - // - // After a promise is rejected, it must not be used anymore. - void RejectWithUnexpectedError(); - - private: - // The `nsMainThreadPtrHandle` ensures that if this type is destroyed - // from off-main-thread, it'll actually be released on the main thread. - // This is important because the promise is a main-thread-only object. - nsMainThreadPtrHandle mPromise; -}; - -} // namespace mozilla::uniffi - -#endif // mozilla_dom_UniFFIResultPromise_h diff --git a/toolkit/components/uniffi-js/ScaffoldingConverter.h b/toolkit/components/uniffi-js/ScaffoldingConverter.h new file mode 100644 index 000000000000..05cde4b13835 --- /dev/null +++ b/toolkit/components/uniffi-js/ScaffoldingConverter.h @@ -0,0 +1,211 @@ +/* -*- 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/UniFFICall.cpp b/toolkit/components/uniffi-js/UniFFICall.cpp new file mode 100644 index 000000000000..e09a24920204 --- /dev/null +++ b/toolkit/components/uniffi-js/UniFFICall.cpp @@ -0,0 +1,299 @@ +/* -*- 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/. */ + +#include "nsThreadUtils.h" +#include "mozilla/dom/Promise.h" +#include "mozilla/dom/RootedDictionary.h" +#include "mozilla/dom/UniFFICall.h" + +namespace mozilla::uniffi { +extern mozilla::LazyLogModule gUniffiLogger; + +using dom::GlobalObject; +using dom::OwningUniFFIScaffoldingValue; +using dom::RootedDictionary; +using dom::Sequence; +using dom::UniFFIScaffoldingCallResult; + +void UniffiSyncCallHandler::CallSync( + UniquePtr aHandler, const GlobalObject& aGlobal, + const Sequence& aArgs, + RootedDictionary& aReturnValue, + ErrorResult& aError) { + MOZ_ASSERT(NS_IsMainThread()); + aHandler->PrepareRustArgs(aArgs, aError); + if (aError.Failed()) { + return; + } + RustCallStatus callStatus{}; + aHandler->MakeRustCall(&callStatus); + aHandler->mUniffiCallStatusCode = callStatus.code; + if (callStatus.error_buf.data) { + aHandler->mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf); + } + aHandler->ExtractCallResult(aGlobal.Context(), aReturnValue, aError); +} + +already_AddRefed UniffiSyncCallHandler::CallAsyncWrapper( + UniquePtr aHandler, const dom::GlobalObject& aGlobal, + const dom::Sequence& aArgs, + ErrorResult& aError) { + MOZ_ASSERT(NS_IsMainThread()); + aHandler->PrepareRustArgs(aArgs, aError); + if (aError.Failed()) { + return nullptr; + } + + // Create the promise that we return to JS + nsCOMPtr xpcomGlobal = + do_QueryInterface(aGlobal.GetAsSupports()); + RefPtr returnPromise = + dom::Promise::Create(xpcomGlobal, aError); + if (aError.Failed()) { + return nullptr; + } + + // Create a second promise that gets resolved by a background task that + // calls the scaffolding function + RefPtr taskPromise = + new MozPromise, nsresult, true>::Private( + __func__); + + nsresult dispatchResult = NS_DispatchBackgroundTask( + NS_NewRunnableFunction( + __func__, + [handler = std::move(aHandler), taskPromise]() mutable { + RustCallStatus callStatus{}; + handler->MakeRustCall(&callStatus); + handler->mUniffiCallStatusCode = callStatus.code; + if (callStatus.error_buf.data) { + handler->mUniffiCallStatusErrorBuf = + OwnedRustBuffer(callStatus.error_buf); + } + taskPromise->Resolve(std::move(handler), __func__); + }), + NS_DISPATCH_EVENT_MAY_BLOCK); + if (NS_FAILED(dispatchResult)) { + taskPromise->Reject(dispatchResult, __func__); + } + + // When the background task promise completes, resolve the JS promise + taskPromise->Then( + GetCurrentSerialEventTarget(), __func__, + [xpcomGlobal, returnPromise]( + typename MozPromise, nsresult, + true>::ResolveOrRejectValue&& aResult) { + if (!aResult.IsResolve()) { + returnPromise->MaybeRejectWithUnknownError(__func__); + return; + } + auto handler = std::move(aResult.ResolveValue()); + dom::AutoEntryScript aes(xpcomGlobal, + "UniffiSyncCallHandler::CallAsyncWrapper"); + dom::RootedDictionary returnValue( + aes.cx()); + + ErrorResult error; + handler->ExtractCallResult(aes.cx(), returnValue, error); + error.WouldReportJSException(); + if (error.Failed()) { + returnPromise->MaybeReject(std::move(error)); + } else { + returnPromise->MaybeResolve(returnValue); + } + }); + + // Return the JS promise, using forget() to convert it to already_AddRefed + return returnPromise.forget(); +} + +void UniffiCallHandlerBase::ExtractCallResult( + JSContext* aCx, + dom::RootedDictionary& aDest, + ErrorResult& aError) { + switch (mUniffiCallStatusCode) { + case RUST_CALL_SUCCESS: { + aDest.mCode = dom::UniFFIScaffoldingCallCode::Success; + ExtractSuccessfulCallResult(aCx, aDest.mData, aError); + break; + } + + case RUST_CALL_ERROR: { + // 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); + break; + } + + default: { + // 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); + } + + break; + } + } +} + +already_AddRefed UniffiAsyncCallHandler::CallAsync( + UniquePtr aHandler, + const dom::GlobalObject& aGlobal, + const dom::Sequence& aArgs, + ErrorResult& aError) { + MOZ_ASSERT(NS_IsMainThread()); + // Async calls return a Future rather than doing any work. This means we can + // make the call right now on the JS main thread without fear of blocking it. + aHandler->PrepareArgsAndMakeRustCall(aArgs, aError); + if (aError.Failed()) { + return nullptr; + } + + // Create the promise that the handler will resolve + nsCOMPtr global(do_QueryInterface(aGlobal.GetAsSupports())); + aHandler->mPromise = dom::Promise::Create(global, aError); + // Also get a copy to return to JS + RefPtr returnPromise(aHandler->mPromise); + + if (aError.Failed()) { + aError.ThrowUnknownError("[UniFFI] dom::Promise::Create failed"_ns); + return nullptr; + } + + // Schedule a poll for the future in a background thread. + nsresult dispatchResult = NS_DispatchBackgroundTask(NS_NewRunnableFunction( + __func__, [handler = std::move(aHandler)]() mutable { + UniffiAsyncCallHandler::Poll(std::move(handler)); + })); + if (NS_FAILED(dispatchResult)) { + aError.ThrowUnknownError( + "[UniFFI] UniffiAsyncCallHandler::CallAsync - Error scheduling background task"_ns); + return nullptr; + } + + // Return a copy of the JS promise, using forget() to convert it to + // already_AddRefed + return returnPromise.forget(); +} + +// Callback function for async calls +// +// This is passed to Rust when we poll the future alongside a 64-bit handle that +// represents the callback data. For uniffi-bindgen-gecko-js, the handle is a +// `UniffiAsyncCallHandler*` casted to an int. +// +// Rust calls this when either the future is ready or when it's time to poll it +// again. +void UniffiAsyncCallHandler::FutureCallback(uint64_t aCallHandlerHandle, + int8_t aCode) { + // Recreate the UniquePtr we previously released + UniquePtr handler( + reinterpret_cast( + static_cast(aCallHandlerHandle))); + + switch (aCode) { + case UNIFFI_FUTURE_READY: { + // `Future::poll` returned a `Ready` value on the Rust side. + nsresult dispatchResult = NS_DispatchToMainThread(NS_NewRunnableFunction( + __func__, [handler = std::move(handler)]() mutable { + UniffiAsyncCallHandler::Finish(std::move(handler)); + })); + if (NS_FAILED(dispatchResult)) { + MOZ_LOG(gUniffiLogger, LogLevel::Error, + ("[UniFFI] NS_DispatchToMainThread failed in " + "UniffiAsyncCallHandler::FutureCallback")); + } + break; + } + + case UNIFFI_FUTURE_MAYBE_READY: { + // The Rust waker was invoked after `poll` returned a `Pending` value. + // Poll the future again soon in a background task. + nsresult dispatchResult = NS_DispatchBackgroundTask( + NS_NewRunnableFunction(__func__, + [handler = std::move(handler)]() mutable { + UniffiAsyncCallHandler::Poll( + std::move(handler)); + }), + NS_DISPATCH_NORMAL); + if (NS_FAILED(dispatchResult)) { + MOZ_LOG(gUniffiLogger, LogLevel::Error, + ("[UniFFI] NS_DispatchBackgroundTask failed in " + "UniffiAsyncCallHandler::FutureCallback")); + } + break; + } + + default: { + // Invalid poll code, this should never happen, but if it does log an + // error and reject the promise. + MOZ_LOG(gUniffiLogger, LogLevel::Error, + ("[UniFFI] Invalid poll code in " + "UniffiAsyncCallHandler::FutureCallback %d", + aCode)); + handler->mPromise->MaybeRejectWithUndefined(); + break; + } + }; +} + +void UniffiAsyncCallHandler::Poll(UniquePtr aHandler) { + auto futureHandle = aHandler->mFutureHandle; + auto pollFn = aHandler->mPollFn; + // Release the UniquePtr into a raw pointer and convert it to a handle + // so that we can pass it as a handle to the UniFFI code. It gets converted + // back in `UniffiAsyncCallHandler::FutureCallback()`, which the Rust code + // guarentees will be called if the future makes progress. + uint64_t selfHandle = + static_cast(reinterpret_cast(aHandler.release())); + pollFn(futureHandle, UniffiAsyncCallHandler::FutureCallback, selfHandle); +} + +// Complete the Rust future, extract the call result and resolve/reject the JS +// promise +void UniffiAsyncCallHandler::Finish( + UniquePtr aHandler) { + RefPtr promise = aHandler->mPromise; + if (!promise) { + return; + } + dom::AutoEntryScript aes(promise->GetGlobalObject(), + "UniffiAsyncCallHandler::Finish"); + dom::RootedDictionary returnValue(aes.cx()); + ErrorResult error; + + RustCallStatus callStatus{}; + aHandler->CallCompleteFn(&callStatus); + aHandler->mUniffiCallStatusCode = callStatus.code; + if (callStatus.error_buf.data) { + aHandler->mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf); + } + aHandler->ExtractCallResult(aes.cx(), returnValue, error); + error.WouldReportJSException(); + if (error.Failed()) { + aHandler->mPromise->MaybeReject(std::move(error)); + } else { + aHandler->mPromise->MaybeResolve(returnValue); + } +} + +UniffiAsyncCallHandler::~UniffiAsyncCallHandler() { mFreeFn(mFutureHandle); } + +} // namespace mozilla::uniffi diff --git a/toolkit/components/uniffi-js/Call.h b/toolkit/components/uniffi-js/UniFFICall.h similarity index 91% rename from toolkit/components/uniffi-js/Call.h rename to toolkit/components/uniffi-js/UniFFICall.h index 1c62b63ef150..d10c1eeaf8bb 100644 --- a/toolkit/components/uniffi-js/Call.h +++ b/toolkit/components/uniffi-js/UniFFICall.h @@ -9,11 +9,9 @@ #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/ResultPromise.h" -#include "mozilla/uniffi/Rust.h" namespace mozilla::uniffi { @@ -30,7 +28,7 @@ namespace mozilla::uniffi { // In all cases, a new instance is created each time the scaffolding function // is called. class UniffiCallHandlerBase { - public: + protected: // Extract the call result when the status code is `RUST_CALL_SUCCESS`. // // On success, set aDest with the converted return value. If there is a @@ -38,7 +36,7 @@ class UniffiCallHandlerBase { // value doesn't fit into a JS number. // // Called on the main thread. - virtual void LiftSuccessfulCallResult( + virtual void ExtractSuccessfulCallResult( JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) = 0; @@ -54,17 +52,14 @@ class UniffiCallHandlerBase { // panic=abort. // - If some other error happens in the C++ layer, then `aError` will be set // to the error. - void LiftCallResult( + void ExtractCallResult( JSContext* aCx, dom::RootedDictionary& aDest, ErrorResult& aError); - virtual ~UniffiCallHandlerBase() = default; - - protected: // Call status from the rust call int8_t mUniffiCallStatusCode = RUST_CALL_SUCCESS; - FfiValueRustBuffer mUniffiCallStatusErrorBuf; + OwnedRustBuffer mUniffiCallStatusErrorBuf; }; // Call scaffolding functions for synchronous Rust calls @@ -74,7 +69,7 @@ class UniffiSyncCallHandler : public UniffiCallHandlerBase { // Convert a sequence of JS arguments and store them in this // UniffiSyncCallHandler. Called on the main thread. - virtual void LowerRustArgs( + virtual void PrepareRustArgs( const dom::Sequence& aArgs, ErrorResult& aError) = 0; @@ -121,9 +116,9 @@ class UniffiAsyncCallHandler : public UniffiCallHandlerBase { // // Always called on the main thread since async Rust calls don't block, they // return a future. Because of this, there's no reason to split out the - // `LowerRustArgs` and `MakeRustCall` like in the sync + // `PrepareRustArgs` and `PrepareArgs` and `MakeRustCall` like in the sync // case. - virtual void LowerArgsAndMakeRustCall( + virtual void PrepareArgsAndMakeRustCall( const dom::Sequence& aArgs, ErrorResult& aError) = 0; @@ -145,6 +140,11 @@ class UniffiAsyncCallHandler : public UniffiCallHandlerBase { // Call mPollFn to poll the future static void Poll(UniquePtr aHandler); + // Complete the async call and resolve the promise returned by CallAsync + // + // Called in the main thread. + static void Finish(UniquePtr aHandler); + public: virtual ~UniffiAsyncCallHandler(); @@ -159,7 +159,7 @@ class UniffiAsyncCallHandler : public UniffiCallHandlerBase { private: // Promise created by CallAsync - ResultPromise mPromise; + RefPtr mPromise; // Callback function for Rust async calls // diff --git a/toolkit/components/uniffi-js/Callbacks.cpp b/toolkit/components/uniffi-js/UniFFICallbacks.cpp similarity index 96% rename from toolkit/components/uniffi-js/Callbacks.cpp rename to toolkit/components/uniffi-js/UniFFICallbacks.cpp index 0cc8c4935172..14b5ab5ab31a 100644 --- a/toolkit/components/uniffi-js/Callbacks.cpp +++ b/toolkit/components/uniffi-js/UniFFICallbacks.cpp @@ -7,10 +7,10 @@ #include "nsPrintfCString.h" #include "nsString.h" #include "nsThreadUtils.h" -#include "mozilla/uniffi/OwnedRustBuffer.h" +#include "mozilla/dom/OwnedRustBuffer.h" #include "mozilla/dom/RootedDictionary.h" #include "mozilla/dom/UniFFIBinding.h" -#include "mozilla/uniffi/Callbacks.h" +#include "mozilla/dom/UniFFICallbacks.h" #include "mozilla/Maybe.h" #include "mozilla/Logging.h" #include "mozilla/RefPtr.h" diff --git a/toolkit/components/uniffi-js/Callbacks.h b/toolkit/components/uniffi-js/UniFFICallbacks.h similarity index 99% rename from toolkit/components/uniffi-js/Callbacks.h rename to toolkit/components/uniffi-js/UniFFICallbacks.h index 67f49786ce6b..6fba413f891f 100644 --- a/toolkit/components/uniffi-js/Callbacks.h +++ b/toolkit/components/uniffi-js/UniFFICallbacks.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/GeneratedScaffolding.cpp b/toolkit/components/uniffi-js/UniFFIGeneratedScaffolding.cpp similarity index 58% rename from toolkit/components/uniffi-js/GeneratedScaffolding.cpp rename to toolkit/components/uniffi-js/UniFFIGeneratedScaffolding.cpp index 6c3f1e8c6e5f..582dc3ac06e4 100644 --- a/toolkit/components/uniffi-js/GeneratedScaffolding.cpp +++ b/toolkit/components/uniffi-js/UniFFIGeneratedScaffolding.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/dom/UniFFIScaffolding.h" -#include "mozilla/uniffi/Call.h" -#include "mozilla/uniffi/Callbacks.h" -#include "mozilla/uniffi/FfiValue.h" -#include "mozilla/uniffi/PointerType.h" -#include "mozilla/uniffi/Rust.h" +#include "mozilla/dom/UniFFIRust.h" namespace mozilla::uniffi { @@ -1852,13 +1852,13 @@ static StaticRefPtr gCallbackInterfaceJsHandlerAppli class CallbackInterfaceMethodApplicationErrorReporterReportError : public UniffiCallbackMethodHandlerBase { private: - // Rust arguments - FfiValueRustBuffer type_name{}; - FfiValueRustBuffer message{}; + // Rust arguments, converted using ScaffoldingConverter::FromRust. + typename ScaffoldingConverter::IntermediateType type_name; + typename ScaffoldingConverter::IntermediateType message; public: CallbackInterfaceMethodApplicationErrorReporterReportError(size_t aObjectHandle, RustBuffer type_name, RustBuffer message) - : UniffiCallbackMethodHandlerBase("errorsupport:ApplicationErrorReporter", aObjectHandle), type_name(FfiValueRustBuffer::FromRust(type_name)), message(FfiValueRustBuffer::FromRust(message)) { + : UniffiCallbackMethodHandlerBase("errorsupport:ApplicationErrorReporter", aObjectHandle), type_name(ScaffoldingConverter::FromRust(type_name)), message(ScaffoldingConverter::FromRust(message)) { } MOZ_CAN_RUN_SCRIPT @@ -1871,15 +1871,17 @@ public: } // Convert each argument - type_name.Lift( + ScaffoldingConverter::IntoJs( aCx, + std::move(this->type_name), &uniffiArgs[0], aError); if (aError.Failed()) { return; } - message.Lift( + ScaffoldingConverter::IntoJs( aCx, + std::move(this->message), &uniffiArgs[1], aError); if (aError.Failed()) { @@ -1911,15 +1913,15 @@ extern "C" void callback_interface_application_error_reporter_report_error( class CallbackInterfaceMethodApplicationErrorReporterReportBreadcrumb : public UniffiCallbackMethodHandlerBase { private: - // Rust arguments - FfiValueRustBuffer message{}; - FfiValueRustBuffer module{}; - FfiValueInt line{}; - FfiValueInt column{}; + // Rust arguments, converted using ScaffoldingConverter::FromRust. + typename ScaffoldingConverter::IntermediateType message; + typename ScaffoldingConverter::IntermediateType module; + typename ScaffoldingConverter::IntermediateType line; + typename ScaffoldingConverter::IntermediateType column; public: CallbackInterfaceMethodApplicationErrorReporterReportBreadcrumb(size_t aObjectHandle, RustBuffer message, RustBuffer module, uint32_t line, uint32_t column) - : UniffiCallbackMethodHandlerBase("errorsupport:ApplicationErrorReporter", aObjectHandle), message(FfiValueRustBuffer::FromRust(message)), module(FfiValueRustBuffer::FromRust(module)), line(FfiValueInt::FromRust(line)), column(FfiValueInt::FromRust(column)) { + : UniffiCallbackMethodHandlerBase("errorsupport:ApplicationErrorReporter", aObjectHandle), message(ScaffoldingConverter::FromRust(message)), module(ScaffoldingConverter::FromRust(module)), line(ScaffoldingConverter::FromRust(line)), column(ScaffoldingConverter::FromRust(column)) { } MOZ_CAN_RUN_SCRIPT @@ -1932,29 +1934,33 @@ public: } // Convert each argument - message.Lift( + ScaffoldingConverter::IntoJs( aCx, + std::move(this->message), &uniffiArgs[0], aError); if (aError.Failed()) { return; } - module.Lift( + ScaffoldingConverter::IntoJs( aCx, + std::move(this->module), &uniffiArgs[1], aError); if (aError.Failed()) { return; } - line.Lift( + ScaffoldingConverter::IntoJs( aCx, + std::move(this->line), &uniffiArgs[2], aError); if (aError.Failed()) { return; } - column.Lift( + ScaffoldingConverter::IntoJs( aCx, + std::move(this->column), &uniffiArgs[3], aError); if (aError.Failed()) { @@ -2003,12 +2009,12 @@ static StaticRefPtr gCallbackInterfaceJsHandlerLogge class CallbackInterfaceMethodLoggerLog : public UniffiCallbackMethodHandlerBase { private: - // Rust arguments - FfiValueRustBuffer message{}; + // Rust arguments, converted using ScaffoldingConverter::FromRust. + typename ScaffoldingConverter::IntermediateType message; public: CallbackInterfaceMethodLoggerLog(size_t aObjectHandle, RustBuffer message) - : UniffiCallbackMethodHandlerBase("fixture_callbacks:Logger", aObjectHandle), message(FfiValueRustBuffer::FromRust(message)) { + : UniffiCallbackMethodHandlerBase("fixture_callbacks:Logger", aObjectHandle), message(ScaffoldingConverter::FromRust(message)) { } MOZ_CAN_RUN_SCRIPT @@ -2021,8 +2027,9 @@ public: } // Convert each argument - message.Lift( + ScaffoldingConverter::IntoJs( aCx, + std::move(this->message), &uniffiArgs[0], aError); if (aError.Failed()) { @@ -2054,14 +2061,14 @@ extern "C" void callback_interface_logger_log( class CallbackInterfaceMethodLoggerLogRepeat : public UniffiCallbackMethodHandlerBase { private: - // Rust arguments - FfiValueRustBuffer message{}; - FfiValueInt count{}; - FfiValueRustBuffer exclude{}; + // Rust arguments, converted using ScaffoldingConverter::FromRust. + typename ScaffoldingConverter::IntermediateType message; + typename ScaffoldingConverter::IntermediateType count; + typename ScaffoldingConverter::IntermediateType exclude; public: CallbackInterfaceMethodLoggerLogRepeat(size_t aObjectHandle, RustBuffer message, uint32_t count, RustBuffer exclude) - : UniffiCallbackMethodHandlerBase("fixture_callbacks:Logger", aObjectHandle), message(FfiValueRustBuffer::FromRust(message)), count(FfiValueInt::FromRust(count)), exclude(FfiValueRustBuffer::FromRust(exclude)) { + : UniffiCallbackMethodHandlerBase("fixture_callbacks:Logger", aObjectHandle), message(ScaffoldingConverter::FromRust(message)), count(ScaffoldingConverter::FromRust(count)), exclude(ScaffoldingConverter::FromRust(exclude)) { } MOZ_CAN_RUN_SCRIPT @@ -2074,22 +2081,25 @@ public: } // Convert each argument - message.Lift( + ScaffoldingConverter::IntoJs( aCx, + std::move(this->message), &uniffiArgs[0], aError); if (aError.Failed()) { return; } - count.Lift( + ScaffoldingConverter::IntoJs( aCx, + std::move(this->count), &uniffiArgs[1], aError); if (aError.Failed()) { return; } - exclude.Lift( + ScaffoldingConverter::IntoJs( aCx, + std::move(this->exclude), &uniffiArgs[2], aError); if (aError.Failed()) { @@ -2121,7 +2131,7 @@ extern "C" void callback_interface_logger_log_repeat( class CallbackInterfaceMethodLoggerFinished : public UniffiCallbackMethodHandlerBase { private: - // Rust arguments + // Rust arguments, converted using ScaffoldingConverter::FromRust. public: CallbackInterfaceMethodLoggerFinished(size_t aObjectHandle) @@ -2240,14 +2250,14 @@ void DeregisterCallbackHandler(uint64_t aInterfaceId, ErrorResult& aError) { class ScaffoldingCallHandlerUniffiErrorSupportFnFuncSetApplicationErrorReporter : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueInt mErrorReporter{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingConverter::IntermediateType mErrorReporter; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mErrorReporter.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingConverter::FromJs(aArgs[0], &mErrorReporter, aError); if (aError.Failed()) { return; } @@ -2255,22 +2265,22 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_error_support_fn_func_set_application_error_reporter( - mErrorReporter.IntoRust(), + ScaffoldingConverter::IntoRust(std::move(mErrorReporter)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiErrorSupportFnFuncUnsetApplicationErrorReporter : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields + // PrepareRustArgs stores the resulting arguments in these fields // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { } void MakeRustCall(RustCallStatus* aOutStatus) override { @@ -2279,43 +2289,44 @@ public: ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiRelevancyFnFuncScore : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueRustBuffer mInterestVector{}; - FfiValueRustBuffer mContentCategories{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingConverter::IntermediateType mInterestVector; + typename ScaffoldingConverter::IntermediateType mContentCategories; // MakeRustCall stores the result of the call in these fields - FfiValueFloat mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mInterestVector.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingConverter::FromJs(aArgs[0], &mInterestVector, aError); if (aError.Failed()) { return; } - mContentCategories.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mContentCategories, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueFloat::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_relevancy_fn_func_score( - mInterestVector.IntoRust(), - mContentCategories.IntoRust(), + ScaffoldingConverter::IntoRust(std::move(mInterestVector)), + ScaffoldingConverter::IntoRust(std::move(mContentCategories)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -2323,24 +2334,24 @@ public: }; class ScaffoldingCallHandlerUniffiRelevancyFnMethodRelevancystoreBanditInit : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRelevancyRelevancyStorePointerType> mPtr{}; - FfiValueRustBuffer mBandit{}; - FfiValueRustBuffer mArms{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mBandit; + typename ScaffoldingConverter::IntermediateType mArms; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mBandit.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mBandit, aError); if (aError.Failed()) { return; } - mArms.Lower(aArgs[2], aError); + ScaffoldingConverter::FromJs(aArgs[2], &mArms, aError); if (aError.Failed()) { return; } @@ -2348,56 +2359,57 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_relevancy_fn_method_relevancystore_bandit_init( - mPtr.IntoRust(), - mBandit.IntoRust(), - mArms.IntoRust(), + ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mBandit)), + ScaffoldingConverter::IntoRust(std::move(mArms)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiRelevancyFnMethodRelevancystoreBanditSelect : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRelevancyRelevancyStorePointerType> mPtr{}; - FfiValueRustBuffer mBandit{}; - FfiValueRustBuffer mArms{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mBandit; + typename ScaffoldingConverter::IntermediateType mArms; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mBandit.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mBandit, aError); if (aError.Failed()) { return; } - mArms.Lower(aArgs[2], aError); + ScaffoldingConverter::FromJs(aArgs[2], &mArms, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_relevancy_fn_method_relevancystore_bandit_select( - mPtr.IntoRust(), - mBandit.IntoRust(), - mArms.IntoRust(), + ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mBandit)), + ScaffoldingConverter::IntoRust(std::move(mArms)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -2405,29 +2417,29 @@ public: }; class ScaffoldingCallHandlerUniffiRelevancyFnMethodRelevancystoreBanditUpdate : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRelevancyRelevancyStorePointerType> mPtr{}; - FfiValueRustBuffer mBandit{}; - FfiValueRustBuffer mArm{}; - FfiValueInt mSelected{}; + // 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; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mBandit.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mBandit, aError); if (aError.Failed()) { return; } - mArm.Lower(aArgs[2], aError); + ScaffoldingConverter::FromJs(aArgs[2], &mArm, aError); if (aError.Failed()) { return; } - mSelected.Lower(aArgs[3], aError); + ScaffoldingConverter::FromJs(aArgs[3], &mSelected, aError); if (aError.Failed()) { return; } @@ -2435,27 +2447,27 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_relevancy_fn_method_relevancystore_bandit_update( - mPtr.IntoRust(), - mBandit.IntoRust(), - mArm.IntoRust(), - mSelected.IntoRust(), + ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mBandit)), + ScaffoldingConverter::IntoRust(std::move(mArm)), + ScaffoldingConverter::IntoRust(std::move(mSelected)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiRelevancyFnMethodRelevancystoreClose : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRelevancyRelevancyStorePointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } @@ -2463,24 +2475,24 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_relevancy_fn_method_relevancystore_close( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::IntoRust(std::move(mPtr)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiRelevancyFnMethodRelevancystoreEnsureInterestDataPopulated : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRelevancyRelevancyStorePointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } @@ -2488,54 +2500,55 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_relevancy_fn_method_relevancystore_ensure_interest_data_populated( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::IntoRust(std::move(mPtr)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiRelevancyFnMethodRelevancystoreGetBanditData : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRelevancyRelevancyStorePointerType> mPtr{}; - FfiValueRustBuffer mBandit{}; - FfiValueRustBuffer mArm{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mBandit; + typename ScaffoldingConverter::IntermediateType mArm; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mBandit.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mBandit, aError); if (aError.Failed()) { return; } - mArm.Lower(aArgs[2], aError); + ScaffoldingConverter::FromJs(aArgs[2], &mArm, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_relevancy_fn_method_relevancystore_get_bandit_data( - mPtr.IntoRust(), - mBandit.IntoRust(), - mArm.IntoRust(), + ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mBandit)), + ScaffoldingConverter::IntoRust(std::move(mArm)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -2543,38 +2556,39 @@ public: }; class ScaffoldingCallHandlerUniffiRelevancyFnMethodRelevancystoreIngest : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRelevancyRelevancyStorePointerType> mPtr{}; - FfiValueRustBuffer mTopUrlsByFrecency{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mTopUrlsByFrecency; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mTopUrlsByFrecency.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mTopUrlsByFrecency, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_relevancy_fn_method_relevancystore_ingest( - mPtr.IntoRust(), - mTopUrlsByFrecency.IntoRust(), + ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mTopUrlsByFrecency)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -2582,14 +2596,14 @@ public: }; class ScaffoldingCallHandlerUniffiRelevancyFnMethodRelevancystoreInterrupt : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRelevancyRelevancyStorePointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } @@ -2597,42 +2611,43 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_relevancy_fn_method_relevancystore_interrupt( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::IntoRust(std::move(mPtr)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiRelevancyFnMethodRelevancystoreUserInterestVector : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRelevancyRelevancyStorePointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_relevancy_fn_method_relevancystore_user_interest_vector( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::IntoRust(std::move(mPtr)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -2640,32 +2655,33 @@ public: }; class ScaffoldingCallHandlerUniffiRelevancyFnConstructorRelevancystoreNew : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueRustBuffer mDbPath{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingConverter::IntermediateType mDbPath; // MakeRustCall stores the result of the call in these fields - FfiValueObjectHandle<&kRelevancyRelevancyStorePointerType> mUniffiReturnValue{}; + typename ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mDbPath.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingConverter::FromJs(aArgs[0], &mDbPath, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueObjectHandle<&kRelevancyRelevancyStorePointerType>::FromRust( + mUniffiReturnValue = ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::FromRust( uniffi_relevancy_fn_constructor_relevancystore_new( - mDbPath.IntoRust(), + ScaffoldingConverter::IntoRust(std::move(mDbPath)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRelevancyRelevancyStorePointerType>::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -2673,24 +2689,24 @@ public: }; class ScaffoldingCallHandlerUniffiRemoteSettingsFnMethodRemotesettingsDownloadAttachmentToPath : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRemoteSettingsRemoteSettingsPointerType> mPtr{}; - FfiValueRustBuffer mAttachmentId{}; - FfiValueRustBuffer mPath{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mAttachmentId; + typename ScaffoldingConverter::IntermediateType mPath; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mAttachmentId.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mAttachmentId, aError); if (aError.Failed()) { return; } - mPath.Lower(aArgs[2], aError); + ScaffoldingConverter::FromJs(aArgs[2], &mPath, aError); if (aError.Failed()) { return; } @@ -2698,44 +2714,45 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_remote_settings_fn_method_remotesettings_download_attachment_to_path( - mPtr.IntoRust(), - mAttachmentId.IntoRust(), - mPath.IntoRust(), + ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mAttachmentId)), + ScaffoldingConverter::IntoRust(std::move(mPath)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiRemoteSettingsFnMethodRemotesettingsGetRecords : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRemoteSettingsRemoteSettingsPointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsPointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_remote_settings_fn_method_remotesettings_get_records( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsPointerType>::IntoRust(std::move(mPtr)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -2743,38 +2760,39 @@ public: }; class ScaffoldingCallHandlerUniffiRemoteSettingsFnMethodRemotesettingsGetRecordsSince : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRemoteSettingsRemoteSettingsPointerType> mPtr{}; - FfiValueInt mTimestamp{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mTimestamp; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mTimestamp.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mTimestamp, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_remote_settings_fn_method_remotesettings_get_records_since( - mPtr.IntoRust(), - mTimestamp.IntoRust(), + ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mTimestamp)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -2782,32 +2800,33 @@ public: }; class ScaffoldingCallHandlerUniffiRemoteSettingsFnConstructorRemotesettingsNew : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueRustBuffer mRemoteSettingsConfig{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingConverter::IntermediateType mRemoteSettingsConfig; // MakeRustCall stores the result of the call in these fields - FfiValueObjectHandle<&kRemoteSettingsRemoteSettingsPointerType> mUniffiReturnValue{}; + typename ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsPointerType>::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mRemoteSettingsConfig.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingConverter::FromJs(aArgs[0], &mRemoteSettingsConfig, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueObjectHandle<&kRemoteSettingsRemoteSettingsPointerType>::FromRust( + mUniffiReturnValue = ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsPointerType>::FromRust( uniffi_remote_settings_fn_constructor_remotesettings_new( - mRemoteSettingsConfig.IntoRust(), + ScaffoldingConverter::IntoRust(std::move(mRemoteSettingsConfig)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsPointerType>::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -2815,32 +2834,33 @@ public: }; class ScaffoldingCallHandlerUniffiRemoteSettingsFnMethodRemotesettingsclientCollectionName : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRemoteSettingsRemoteSettingsClientPointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsClientPointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsClientPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_remote_settings_fn_method_remotesettingsclient_collection_name( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsClientPointerType>::IntoRust(std::move(mPtr)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -2848,38 +2868,39 @@ public: }; class ScaffoldingCallHandlerUniffiRemoteSettingsFnMethodRemotesettingsclientGetAttachment : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRemoteSettingsRemoteSettingsClientPointerType> mPtr{}; - FfiValueRustBuffer mRecord{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsClientPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mRecord; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsClientPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mRecord.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mRecord, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_remote_settings_fn_method_remotesettingsclient_get_attachment( - mPtr.IntoRust(), - mRecord.IntoRust(), + ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsClientPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mRecord)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -2887,38 +2908,39 @@ public: }; class ScaffoldingCallHandlerUniffiRemoteSettingsFnMethodRemotesettingsclientGetRecords : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRemoteSettingsRemoteSettingsClientPointerType> mPtr{}; - FfiValueInt mSyncIfEmpty{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsClientPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mSyncIfEmpty; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsClientPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mSyncIfEmpty.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mSyncIfEmpty, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_remote_settings_fn_method_remotesettingsclient_get_records( - mPtr.IntoRust(), - mSyncIfEmpty.IntoRust(), + ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsClientPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mSyncIfEmpty)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -2926,38 +2948,39 @@ public: }; class ScaffoldingCallHandlerUniffiRemoteSettingsFnMethodRemotesettingsclientGetRecordsMap : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRemoteSettingsRemoteSettingsClientPointerType> mPtr{}; - FfiValueInt mSyncIfEmpty{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsClientPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mSyncIfEmpty; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsClientPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mSyncIfEmpty.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mSyncIfEmpty, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_remote_settings_fn_method_remotesettingsclient_get_records_map( - mPtr.IntoRust(), - mSyncIfEmpty.IntoRust(), + ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsClientPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mSyncIfEmpty)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -2965,14 +2988,14 @@ public: }; class ScaffoldingCallHandlerUniffiRemoteSettingsFnMethodRemotesettingsclientSync : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRemoteSettingsRemoteSettingsClientPointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsClientPointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsClientPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } @@ -2980,48 +3003,49 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_remote_settings_fn_method_remotesettingsclient_sync( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsClientPointerType>::IntoRust(std::move(mPtr)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiRemoteSettingsFnMethodRemotesettingsserviceMakeClient : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRemoteSettingsRemoteSettingsServicePointerType> mPtr{}; - FfiValueRustBuffer mCollectionName{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsServicePointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mCollectionName; // MakeRustCall stores the result of the call in these fields - FfiValueObjectHandle<&kRemoteSettingsRemoteSettingsClientPointerType> mUniffiReturnValue{}; + typename ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsClientPointerType>::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsServicePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mCollectionName.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mCollectionName, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueObjectHandle<&kRemoteSettingsRemoteSettingsClientPointerType>::FromRust( + mUniffiReturnValue = ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsClientPointerType>::FromRust( uniffi_remote_settings_fn_method_remotesettingsservice_make_client( - mPtr.IntoRust(), - mCollectionName.IntoRust(), + ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsServicePointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mCollectionName)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsClientPointerType>::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -3029,32 +3053,33 @@ public: }; class ScaffoldingCallHandlerUniffiRemoteSettingsFnMethodRemotesettingsserviceSync : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRemoteSettingsRemoteSettingsServicePointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsServicePointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsServicePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_remote_settings_fn_method_remotesettingsservice_sync( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsServicePointerType>::IntoRust(std::move(mPtr)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -3062,19 +3087,19 @@ public: }; class ScaffoldingCallHandlerUniffiRemoteSettingsFnMethodRemotesettingsserviceUpdateConfig : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRemoteSettingsRemoteSettingsServicePointerType> mPtr{}; - FfiValueRustBuffer mConfig{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsServicePointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mConfig; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsServicePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mConfig.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mConfig, aError); if (aError.Failed()) { return; } @@ -3082,49 +3107,50 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_remote_settings_fn_method_remotesettingsservice_update_config( - mPtr.IntoRust(), - mConfig.IntoRust(), + ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsServicePointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mConfig)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiRemoteSettingsFnConstructorRemotesettingsserviceNew : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueRustBuffer mStorageDir{}; - FfiValueRustBuffer mConfig{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingConverter::IntermediateType mStorageDir; + typename ScaffoldingConverter::IntermediateType mConfig; // MakeRustCall stores the result of the call in these fields - FfiValueObjectHandle<&kRemoteSettingsRemoteSettingsServicePointerType> mUniffiReturnValue{}; + typename ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsServicePointerType>::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mStorageDir.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingConverter::FromJs(aArgs[0], &mStorageDir, aError); if (aError.Failed()) { return; } - mConfig.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mConfig, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueObjectHandle<&kRemoteSettingsRemoteSettingsServicePointerType>::FromRust( + mUniffiReturnValue = ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsServicePointerType>::FromRust( uniffi_remote_settings_fn_constructor_remotesettingsservice_new( - mStorageDir.IntoRust(), - mConfig.IntoRust(), + ScaffoldingConverter::IntoRust(std::move(mStorageDir)), + ScaffoldingConverter::IntoRust(std::move(mConfig)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsServicePointerType>::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -3132,14 +3158,14 @@ public: }; class ScaffoldingCallHandlerUniffiSearchFnMethodSearchengineselectorClearSearchConfig : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kSearchSearchEngineSelectorPointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kSearchSearchEngineSelectorPointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kSearchSearchEngineSelectorPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } @@ -3147,48 +3173,49 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_search_fn_method_searchengineselector_clear_search_config( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kSearchSearchEngineSelectorPointerType>::IntoRust(std::move(mPtr)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiSearchFnMethodSearchengineselectorFilterEngineConfiguration : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kSearchSearchEngineSelectorPointerType> mPtr{}; - FfiValueRustBuffer mUserEnvironment{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kSearchSearchEngineSelectorPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mUserEnvironment; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kSearchSearchEngineSelectorPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mUserEnvironment.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mUserEnvironment, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_search_fn_method_searchengineselector_filter_engine_configuration( - mPtr.IntoRust(), - mUserEnvironment.IntoRust(), + ScaffoldingObjectConverter<&kSearchSearchEngineSelectorPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mUserEnvironment)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -3196,19 +3223,19 @@ public: }; class ScaffoldingCallHandlerUniffiSearchFnMethodSearchengineselectorSetConfigOverrides : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kSearchSearchEngineSelectorPointerType> mPtr{}; - FfiValueRustBuffer mOverrides{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kSearchSearchEngineSelectorPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mOverrides; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kSearchSearchEngineSelectorPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mOverrides.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mOverrides, aError); if (aError.Failed()) { return; } @@ -3216,30 +3243,30 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_search_fn_method_searchengineselector_set_config_overrides( - mPtr.IntoRust(), - mOverrides.IntoRust(), + ScaffoldingObjectConverter<&kSearchSearchEngineSelectorPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mOverrides)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiSearchFnMethodSearchengineselectorSetSearchConfig : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kSearchSearchEngineSelectorPointerType> mPtr{}; - FfiValueRustBuffer mConfiguration{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kSearchSearchEngineSelectorPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mConfiguration; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kSearchSearchEngineSelectorPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mConfiguration.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mConfiguration, aError); if (aError.Failed()) { return; } @@ -3247,35 +3274,35 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_search_fn_method_searchengineselector_set_search_config( - mPtr.IntoRust(), - mConfiguration.IntoRust(), + ScaffoldingObjectConverter<&kSearchSearchEngineSelectorPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mConfiguration)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiSearchFnMethodSearchengineselectorUseRemoteSettingsServer : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kSearchSearchEngineSelectorPointerType> mPtr{}; - FfiValueObjectHandle<&kRemoteSettingsRemoteSettingsServicePointerType> mService{}; - FfiValueInt mApplyEngineOverrides{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kSearchSearchEngineSelectorPointerType>::IntermediateType mPtr; + typename ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsServicePointerType>::IntermediateType mService; + typename ScaffoldingConverter::IntermediateType mApplyEngineOverrides; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kSearchSearchEngineSelectorPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mService.Lower(aArgs[1], aError); + ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsServicePointerType>::FromJs(aArgs[1], &mService, aError); if (aError.Failed()) { return; } - mApplyEngineOverrides.Lower(aArgs[2], aError); + ScaffoldingConverter::FromJs(aArgs[2], &mApplyEngineOverrides, aError); if (aError.Failed()) { return; } @@ -3283,38 +3310,39 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_search_fn_method_searchengineselector_use_remote_settings_server( - mPtr.IntoRust(), - mService.IntoRust(), - mApplyEngineOverrides.IntoRust(), + ScaffoldingObjectConverter<&kSearchSearchEngineSelectorPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsServicePointerType>::IntoRust(std::move(mService)), + ScaffoldingConverter::IntoRust(std::move(mApplyEngineOverrides)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiSearchFnConstructorSearchengineselectorNew : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields + // PrepareRustArgs stores the resulting arguments in these fields // MakeRustCall stores the result of the call in these fields - FfiValueObjectHandle<&kSearchSearchEngineSelectorPointerType> mUniffiReturnValue{}; + typename ScaffoldingObjectConverter<&kSearchSearchEngineSelectorPointerType>::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueObjectHandle<&kSearchSearchEngineSelectorPointerType>::FromRust( + mUniffiReturnValue = ScaffoldingObjectConverter<&kSearchSearchEngineSelectorPointerType>::FromRust( uniffi_search_fn_constructor_searchengineselector_new( aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kSearchSearchEngineSelectorPointerType>::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -3322,38 +3350,39 @@ public: }; class ScaffoldingCallHandlerUniffiSuggestFnFuncRawSuggestionUrlMatches : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueRustBuffer mRawUrl{}; - FfiValueRustBuffer mCookedUrl{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingConverter::IntermediateType mRawUrl; + typename ScaffoldingConverter::IntermediateType mCookedUrl; // MakeRustCall stores the result of the call in these fields - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mRawUrl.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingConverter::FromJs(aArgs[0], &mRawUrl, aError); if (aError.Failed()) { return; } - mCookedUrl.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mCookedUrl, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_suggest_fn_func_raw_suggestion_url_matches( - mRawUrl.IntoRust(), - mCookedUrl.IntoRust(), + ScaffoldingConverter::IntoRust(std::move(mRawUrl)), + ScaffoldingConverter::IntoRust(std::move(mCookedUrl)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -3361,14 +3390,14 @@ public: }; class ScaffoldingCallHandlerUniffiSuggestFnMethodSuggeststoreClear : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kSuggestSuggestStorePointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } @@ -3376,24 +3405,24 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_suggest_fn_method_suggeststore_clear( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::IntoRust(std::move(mPtr)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiSuggestFnMethodSuggeststoreClearDismissedSuggestions : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kSuggestSuggestStorePointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } @@ -3401,29 +3430,29 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_suggest_fn_method_suggeststore_clear_dismissed_suggestions( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::IntoRust(std::move(mPtr)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiSuggestFnMethodSuggeststoreDismissSuggestion : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kSuggestSuggestStorePointerType> mPtr{}; - FfiValueRustBuffer mSuggestionUrl{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mSuggestionUrl; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mSuggestionUrl.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mSuggestionUrl, aError); if (aError.Failed()) { return; } @@ -3431,67 +3460,68 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_suggest_fn_method_suggeststore_dismiss_suggestion( - mPtr.IntoRust(), - mSuggestionUrl.IntoRust(), + ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mSuggestionUrl)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiSuggestFnMethodSuggeststoreFetchGeonames : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kSuggestSuggestStorePointerType> mPtr{}; - FfiValueRustBuffer mQuery{}; - FfiValueInt mMatchNamePrefix{}; - FfiValueRustBuffer mGeonameType{}; - FfiValueRustBuffer mFilter{}; + // 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; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mQuery.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mQuery, aError); if (aError.Failed()) { return; } - mMatchNamePrefix.Lower(aArgs[2], aError); + ScaffoldingConverter::FromJs(aArgs[2], &mMatchNamePrefix, aError); if (aError.Failed()) { return; } - mGeonameType.Lower(aArgs[3], aError); + ScaffoldingConverter::FromJs(aArgs[3], &mGeonameType, aError); if (aError.Failed()) { return; } - mFilter.Lower(aArgs[4], aError); + ScaffoldingConverter::FromJs(aArgs[4], &mFilter, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_suggest_fn_method_suggeststore_fetch_geonames( - mPtr.IntoRust(), - mQuery.IntoRust(), - mMatchNamePrefix.IntoRust(), - mGeonameType.IntoRust(), - mFilter.IntoRust(), + 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)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -3499,32 +3529,33 @@ public: }; class ScaffoldingCallHandlerUniffiSuggestFnMethodSuggeststoreFetchGlobalConfig : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kSuggestSuggestStorePointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_suggest_fn_method_suggeststore_fetch_global_config( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::IntoRust(std::move(mPtr)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -3532,38 +3563,39 @@ public: }; class ScaffoldingCallHandlerUniffiSuggestFnMethodSuggeststoreFetchProviderConfig : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kSuggestSuggestStorePointerType> mPtr{}; - FfiValueRustBuffer mProvider{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mProvider; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mProvider.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mProvider, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_suggest_fn_method_suggeststore_fetch_provider_config( - mPtr.IntoRust(), - mProvider.IntoRust(), + ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mProvider)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -3571,38 +3603,39 @@ public: }; class ScaffoldingCallHandlerUniffiSuggestFnMethodSuggeststoreIngest : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kSuggestSuggestStorePointerType> mPtr{}; - FfiValueRustBuffer mConstraints{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mConstraints; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mConstraints.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mConstraints, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_suggest_fn_method_suggeststore_ingest( - mPtr.IntoRust(), - mConstraints.IntoRust(), + ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mConstraints)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -3610,19 +3643,19 @@ public: }; class ScaffoldingCallHandlerUniffiSuggestFnMethodSuggeststoreInterrupt : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kSuggestSuggestStorePointerType> mPtr{}; - FfiValueRustBuffer mKind{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mKind; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mKind.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mKind, aError); if (aError.Failed()) { return; } @@ -3630,49 +3663,50 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_suggest_fn_method_suggeststore_interrupt( - mPtr.IntoRust(), - mKind.IntoRust(), + ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mKind)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiSuggestFnMethodSuggeststoreQuery : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kSuggestSuggestStorePointerType> mPtr{}; - FfiValueRustBuffer mQuery{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mQuery; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mQuery.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mQuery, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_suggest_fn_method_suggeststore_query( - mPtr.IntoRust(), - mQuery.IntoRust(), + ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mQuery)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -3680,38 +3714,39 @@ public: }; class ScaffoldingCallHandlerUniffiSuggestFnMethodSuggeststoreQueryWithMetrics : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kSuggestSuggestStorePointerType> mPtr{}; - FfiValueRustBuffer mQuery{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mQuery; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mQuery.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mQuery, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_suggest_fn_method_suggeststore_query_with_metrics( - mPtr.IntoRust(), - mQuery.IntoRust(), + ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mQuery)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -3719,38 +3754,39 @@ public: }; class ScaffoldingCallHandlerUniffiSuggestFnConstructorSuggeststoreNew : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueRustBuffer mPath{}; - FfiValueObjectHandle<&kRemoteSettingsRemoteSettingsServicePointerType> mRemoteSettingsService{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingConverter::IntermediateType mPath; + typename ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsServicePointerType>::IntermediateType mRemoteSettingsService; // MakeRustCall stores the result of the call in these fields - FfiValueObjectHandle<&kSuggestSuggestStorePointerType> mUniffiReturnValue{}; + typename ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPath.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingConverter::FromJs(aArgs[0], &mPath, aError); if (aError.Failed()) { return; } - mRemoteSettingsService.Lower(aArgs[1], aError); + ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsServicePointerType>::FromJs(aArgs[1], &mRemoteSettingsService, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueObjectHandle<&kSuggestSuggestStorePointerType>::FromRust( + mUniffiReturnValue = ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::FromRust( uniffi_suggest_fn_constructor_suggeststore_new( - mPath.IntoRust(), - mRemoteSettingsService.IntoRust(), + ScaffoldingConverter::IntoRust(std::move(mPath)), + ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsServicePointerType>::IntoRust(std::move(mRemoteSettingsService)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -3758,32 +3794,33 @@ public: }; class ScaffoldingCallHandlerUniffiSuggestFnMethodSuggeststorebuilderBuild : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kSuggestSuggestStoreBuilderPointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields - FfiValueObjectHandle<&kSuggestSuggestStorePointerType> mUniffiReturnValue{}; + typename ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueObjectHandle<&kSuggestSuggestStorePointerType>::FromRust( + mUniffiReturnValue = ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::FromRust( uniffi_suggest_fn_method_suggeststorebuilder_build( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntoRust(std::move(mPtr)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kSuggestSuggestStorePointerType>::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -3791,38 +3828,39 @@ public: }; class ScaffoldingCallHandlerUniffiSuggestFnMethodSuggeststorebuilderCachePath : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kSuggestSuggestStoreBuilderPointerType> mPtr{}; - FfiValueRustBuffer mPath{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mPath; // MakeRustCall stores the result of the call in these fields - FfiValueObjectHandle<&kSuggestSuggestStoreBuilderPointerType> mUniffiReturnValue{}; + typename ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mPath.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mPath, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueObjectHandle<&kSuggestSuggestStoreBuilderPointerType>::FromRust( + mUniffiReturnValue = ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::FromRust( uniffi_suggest_fn_method_suggeststorebuilder_cache_path( - mPtr.IntoRust(), - mPath.IntoRust(), + ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mPath)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -3830,38 +3868,39 @@ public: }; class ScaffoldingCallHandlerUniffiSuggestFnMethodSuggeststorebuilderDataPath : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kSuggestSuggestStoreBuilderPointerType> mPtr{}; - FfiValueRustBuffer mPath{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mPath; // MakeRustCall stores the result of the call in these fields - FfiValueObjectHandle<&kSuggestSuggestStoreBuilderPointerType> mUniffiReturnValue{}; + typename ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mPath.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mPath, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueObjectHandle<&kSuggestSuggestStoreBuilderPointerType>::FromRust( + mUniffiReturnValue = ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::FromRust( uniffi_suggest_fn_method_suggeststorebuilder_data_path( - mPtr.IntoRust(), - mPath.IntoRust(), + ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mPath)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -3869,44 +3908,45 @@ public: }; class ScaffoldingCallHandlerUniffiSuggestFnMethodSuggeststorebuilderLoadExtension : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kSuggestSuggestStoreBuilderPointerType> mPtr{}; - FfiValueRustBuffer mLibrary{}; - FfiValueRustBuffer mEntryPoint{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mLibrary; + typename ScaffoldingConverter::IntermediateType mEntryPoint; // MakeRustCall stores the result of the call in these fields - FfiValueObjectHandle<&kSuggestSuggestStoreBuilderPointerType> mUniffiReturnValue{}; + typename ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mLibrary.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mLibrary, aError); if (aError.Failed()) { return; } - mEntryPoint.Lower(aArgs[2], aError); + ScaffoldingConverter::FromJs(aArgs[2], &mEntryPoint, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueObjectHandle<&kSuggestSuggestStoreBuilderPointerType>::FromRust( + mUniffiReturnValue = ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::FromRust( uniffi_suggest_fn_method_suggeststorebuilder_load_extension( - mPtr.IntoRust(), - mLibrary.IntoRust(), - mEntryPoint.IntoRust(), + ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mLibrary)), + ScaffoldingConverter::IntoRust(std::move(mEntryPoint)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -3914,38 +3954,39 @@ public: }; class ScaffoldingCallHandlerUniffiSuggestFnMethodSuggeststorebuilderRemoteSettingsBucketName : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kSuggestSuggestStoreBuilderPointerType> mPtr{}; - FfiValueRustBuffer mBucketName{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mBucketName; // MakeRustCall stores the result of the call in these fields - FfiValueObjectHandle<&kSuggestSuggestStoreBuilderPointerType> mUniffiReturnValue{}; + typename ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mBucketName.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mBucketName, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueObjectHandle<&kSuggestSuggestStoreBuilderPointerType>::FromRust( + mUniffiReturnValue = ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::FromRust( uniffi_suggest_fn_method_suggeststorebuilder_remote_settings_bucket_name( - mPtr.IntoRust(), - mBucketName.IntoRust(), + ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mBucketName)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -3953,38 +3994,39 @@ public: }; class ScaffoldingCallHandlerUniffiSuggestFnMethodSuggeststorebuilderRemoteSettingsServer : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kSuggestSuggestStoreBuilderPointerType> mPtr{}; - FfiValueRustBuffer mServer{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mServer; // MakeRustCall stores the result of the call in these fields - FfiValueObjectHandle<&kSuggestSuggestStoreBuilderPointerType> mUniffiReturnValue{}; + typename ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mServer.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mServer, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueObjectHandle<&kSuggestSuggestStoreBuilderPointerType>::FromRust( + mUniffiReturnValue = ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::FromRust( uniffi_suggest_fn_method_suggeststorebuilder_remote_settings_server( - mPtr.IntoRust(), - mServer.IntoRust(), + ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mServer)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -3992,38 +4034,39 @@ public: }; class ScaffoldingCallHandlerUniffiSuggestFnMethodSuggeststorebuilderRemoteSettingsService : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kSuggestSuggestStoreBuilderPointerType> mPtr{}; - FfiValueObjectHandle<&kRemoteSettingsRemoteSettingsServicePointerType> mRsService{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntermediateType mPtr; + typename ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsServicePointerType>::IntermediateType mRsService; // MakeRustCall stores the result of the call in these fields - FfiValueObjectHandle<&kSuggestSuggestStoreBuilderPointerType> mUniffiReturnValue{}; + typename ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mRsService.Lower(aArgs[1], aError); + ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsServicePointerType>::FromJs(aArgs[1], &mRsService, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueObjectHandle<&kSuggestSuggestStoreBuilderPointerType>::FromRust( + mUniffiReturnValue = ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::FromRust( uniffi_suggest_fn_method_suggeststorebuilder_remote_settings_service( - mPtr.IntoRust(), - mRsService.IntoRust(), + ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingObjectConverter<&kRemoteSettingsRemoteSettingsServicePointerType>::IntoRust(std::move(mRsService)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -4031,26 +4074,27 @@ public: }; class ScaffoldingCallHandlerUniffiSuggestFnConstructorSuggeststorebuilderNew : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields + // PrepareRustArgs stores the resulting arguments in these fields // MakeRustCall stores the result of the call in these fields - FfiValueObjectHandle<&kSuggestSuggestStoreBuilderPointerType> mUniffiReturnValue{}; + typename ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueObjectHandle<&kSuggestSuggestStoreBuilderPointerType>::FromRust( + mUniffiReturnValue = ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::FromRust( uniffi_suggest_fn_constructor_suggeststorebuilder_new( aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kSuggestSuggestStoreBuilderPointerType>::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -4058,44 +4102,45 @@ public: }; class ScaffoldingCallHandlerUniffiTabsFnMethodRemotecommandstoreAddRemoteCommand : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kTabsRemoteCommandStorePointerType> mPtr{}; - FfiValueRustBuffer mDeviceId{}; - FfiValueRustBuffer mCommand{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kTabsRemoteCommandStorePointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mDeviceId; + typename ScaffoldingConverter::IntermediateType mCommand; // MakeRustCall stores the result of the call in these fields - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kTabsRemoteCommandStorePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mDeviceId.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mDeviceId, aError); if (aError.Failed()) { return; } - mCommand.Lower(aArgs[2], aError); + ScaffoldingConverter::FromJs(aArgs[2], &mCommand, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_tabs_fn_method_remotecommandstore_add_remote_command( - mPtr.IntoRust(), - mDeviceId.IntoRust(), - mCommand.IntoRust(), + ScaffoldingObjectConverter<&kTabsRemoteCommandStorePointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mDeviceId)), + ScaffoldingConverter::IntoRust(std::move(mCommand)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -4103,50 +4148,51 @@ public: }; class ScaffoldingCallHandlerUniffiTabsFnMethodRemotecommandstoreAddRemoteCommandAt : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kTabsRemoteCommandStorePointerType> mPtr{}; - FfiValueRustBuffer mDeviceId{}; - FfiValueRustBuffer mCommand{}; - FfiValueInt mWhen{}; + // 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; // MakeRustCall stores the result of the call in these fields - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kTabsRemoteCommandStorePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mDeviceId.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mDeviceId, aError); if (aError.Failed()) { return; } - mCommand.Lower(aArgs[2], aError); + ScaffoldingConverter::FromJs(aArgs[2], &mCommand, aError); if (aError.Failed()) { return; } - mWhen.Lower(aArgs[3], aError); + ScaffoldingConverter::FromJs(aArgs[3], &mWhen, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_tabs_fn_method_remotecommandstore_add_remote_command_at( - mPtr.IntoRust(), - mDeviceId.IntoRust(), - mCommand.IntoRust(), - mWhen.IntoRust(), + ScaffoldingObjectConverter<&kTabsRemoteCommandStorePointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mDeviceId)), + ScaffoldingConverter::IntoRust(std::move(mCommand)), + ScaffoldingConverter::IntoRust(std::move(mWhen)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -4154,32 +4200,33 @@ public: }; class ScaffoldingCallHandlerUniffiTabsFnMethodRemotecommandstoreGetUnsentCommands : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kTabsRemoteCommandStorePointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kTabsRemoteCommandStorePointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kTabsRemoteCommandStorePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_tabs_fn_method_remotecommandstore_get_unsent_commands( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kTabsRemoteCommandStorePointerType>::IntoRust(std::move(mPtr)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -4187,44 +4234,45 @@ public: }; class ScaffoldingCallHandlerUniffiTabsFnMethodRemotecommandstoreRemoveRemoteCommand : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kTabsRemoteCommandStorePointerType> mPtr{}; - FfiValueRustBuffer mDeviceId{}; - FfiValueRustBuffer mCommand{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kTabsRemoteCommandStorePointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mDeviceId; + typename ScaffoldingConverter::IntermediateType mCommand; // MakeRustCall stores the result of the call in these fields - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kTabsRemoteCommandStorePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mDeviceId.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mDeviceId, aError); if (aError.Failed()) { return; } - mCommand.Lower(aArgs[2], aError); + ScaffoldingConverter::FromJs(aArgs[2], &mCommand, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_tabs_fn_method_remotecommandstore_remove_remote_command( - mPtr.IntoRust(), - mDeviceId.IntoRust(), - mCommand.IntoRust(), + ScaffoldingObjectConverter<&kTabsRemoteCommandStorePointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mDeviceId)), + ScaffoldingConverter::IntoRust(std::move(mCommand)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -4232,38 +4280,39 @@ public: }; class ScaffoldingCallHandlerUniffiTabsFnMethodRemotecommandstoreSetPendingCommandSent : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kTabsRemoteCommandStorePointerType> mPtr{}; - FfiValueRustBuffer mCommand{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kTabsRemoteCommandStorePointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mCommand; // MakeRustCall stores the result of the call in these fields - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kTabsRemoteCommandStorePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mCommand.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mCommand, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_tabs_fn_method_remotecommandstore_set_pending_command_sent( - mPtr.IntoRust(), - mCommand.IntoRust(), + ScaffoldingObjectConverter<&kTabsRemoteCommandStorePointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mCommand)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -4271,32 +4320,33 @@ public: }; class ScaffoldingCallHandlerUniffiTabsFnMethodTabsbridgedengineApply : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kTabsTabsBridgedEnginePointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_tabs_fn_method_tabsbridgedengine_apply( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntoRust(std::move(mPtr)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -4304,38 +4354,39 @@ public: }; class ScaffoldingCallHandlerUniffiTabsFnMethodTabsbridgedengineEnsureCurrentSyncId : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kTabsTabsBridgedEnginePointerType> mPtr{}; - FfiValueRustBuffer mNewSyncId{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mNewSyncId; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mNewSyncId.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mNewSyncId, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_tabs_fn_method_tabsbridgedengine_ensure_current_sync_id( - mPtr.IntoRust(), - mNewSyncId.IntoRust(), + ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mNewSyncId)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -4343,32 +4394,33 @@ public: }; class ScaffoldingCallHandlerUniffiTabsFnMethodTabsbridgedengineLastSync : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kTabsTabsBridgedEnginePointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_tabs_fn_method_tabsbridgedengine_last_sync( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntoRust(std::move(mPtr)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -4376,19 +4428,19 @@ public: }; class ScaffoldingCallHandlerUniffiTabsFnMethodTabsbridgedenginePrepareForSync : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kTabsTabsBridgedEnginePointerType> mPtr{}; - FfiValueRustBuffer mClientData{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mClientData; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mClientData.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mClientData, aError); if (aError.Failed()) { return; } @@ -4396,25 +4448,25 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_tabs_fn_method_tabsbridgedengine_prepare_for_sync( - mPtr.IntoRust(), - mClientData.IntoRust(), + ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mClientData)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiTabsFnMethodTabsbridgedengineReset : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kTabsTabsBridgedEnginePointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } @@ -4422,42 +4474,43 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_tabs_fn_method_tabsbridgedengine_reset( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntoRust(std::move(mPtr)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiTabsFnMethodTabsbridgedengineResetSyncId : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kTabsTabsBridgedEnginePointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_tabs_fn_method_tabsbridgedengine_reset_sync_id( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntoRust(std::move(mPtr)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -4465,19 +4518,19 @@ public: }; class ScaffoldingCallHandlerUniffiTabsFnMethodTabsbridgedengineSetLastSync : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kTabsTabsBridgedEnginePointerType> mPtr{}; - FfiValueInt mLastSync{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mLastSync; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mLastSync.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mLastSync, aError); if (aError.Failed()) { return; } @@ -4485,35 +4538,35 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_tabs_fn_method_tabsbridgedengine_set_last_sync( - mPtr.IntoRust(), - mLastSync.IntoRust(), + ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mLastSync)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiTabsFnMethodTabsbridgedengineSetUploaded : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kTabsTabsBridgedEnginePointerType> mPtr{}; - FfiValueInt mNewTimestamp{}; - FfiValueRustBuffer mUploadedIds{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mNewTimestamp; + typename ScaffoldingConverter::IntermediateType mUploadedIds; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mNewTimestamp.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mNewTimestamp, aError); if (aError.Failed()) { return; } - mUploadedIds.Lower(aArgs[2], aError); + ScaffoldingConverter::FromJs(aArgs[2], &mUploadedIds, aError); if (aError.Failed()) { return; } @@ -4521,31 +4574,31 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_tabs_fn_method_tabsbridgedengine_set_uploaded( - mPtr.IntoRust(), - mNewTimestamp.IntoRust(), - mUploadedIds.IntoRust(), + ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mNewTimestamp)), + ScaffoldingConverter::IntoRust(std::move(mUploadedIds)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiTabsFnMethodTabsbridgedengineStoreIncoming : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kTabsTabsBridgedEnginePointerType> mPtr{}; - FfiValueRustBuffer mIncomingEnvelopesAsJson{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mIncomingEnvelopesAsJson; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mIncomingEnvelopesAsJson.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mIncomingEnvelopesAsJson, aError); if (aError.Failed()) { return; } @@ -4553,25 +4606,25 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_tabs_fn_method_tabsbridgedengine_store_incoming( - mPtr.IntoRust(), - mIncomingEnvelopesAsJson.IntoRust(), + ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mIncomingEnvelopesAsJson)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiTabsFnMethodTabsbridgedengineSyncFinished : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kTabsTabsBridgedEnginePointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } @@ -4579,42 +4632,43 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_tabs_fn_method_tabsbridgedengine_sync_finished( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntoRust(std::move(mPtr)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiTabsFnMethodTabsbridgedengineSyncId : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kTabsTabsBridgedEnginePointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_tabs_fn_method_tabsbridgedengine_sync_id( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntoRust(std::move(mPtr)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -4622,14 +4676,14 @@ public: }; class ScaffoldingCallHandlerUniffiTabsFnMethodTabsbridgedengineSyncStarted : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kTabsTabsBridgedEnginePointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } @@ -4637,24 +4691,24 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_tabs_fn_method_tabsbridgedengine_sync_started( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntoRust(std::move(mPtr)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiTabsFnMethodTabsbridgedengineWipe : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kTabsTabsBridgedEnginePointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } @@ -4662,42 +4716,43 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_tabs_fn_method_tabsbridgedengine_wipe( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntoRust(std::move(mPtr)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiTabsFnMethodTabsstoreBridgedEngine : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kTabsTabsStorePointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kTabsTabsStorePointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields - FfiValueObjectHandle<&kTabsTabsBridgedEnginePointerType> mUniffiReturnValue{}; + typename ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kTabsTabsStorePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueObjectHandle<&kTabsTabsBridgedEnginePointerType>::FromRust( + mUniffiReturnValue = ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::FromRust( uniffi_tabs_fn_method_tabsstore_bridged_engine( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kTabsTabsStorePointerType>::IntoRust(std::move(mPtr)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -4705,14 +4760,14 @@ public: }; class ScaffoldingCallHandlerUniffiTabsFnMethodTabsstoreCloseConnection : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kTabsTabsStorePointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kTabsTabsStorePointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kTabsTabsStorePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } @@ -4720,42 +4775,43 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_tabs_fn_method_tabsstore_close_connection( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kTabsTabsStorePointerType>::IntoRust(std::move(mPtr)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiTabsFnMethodTabsstoreGetAll : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kTabsTabsStorePointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kTabsTabsStorePointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kTabsTabsStorePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_tabs_fn_method_tabsstore_get_all( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kTabsTabsStorePointerType>::IntoRust(std::move(mPtr)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -4763,32 +4819,33 @@ public: }; class ScaffoldingCallHandlerUniffiTabsFnMethodTabsstoreNewRemoteCommandStore : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kTabsTabsStorePointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kTabsTabsStorePointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields - FfiValueObjectHandle<&kTabsRemoteCommandStorePointerType> mUniffiReturnValue{}; + typename ScaffoldingObjectConverter<&kTabsRemoteCommandStorePointerType>::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kTabsTabsStorePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueObjectHandle<&kTabsRemoteCommandStorePointerType>::FromRust( + mUniffiReturnValue = ScaffoldingObjectConverter<&kTabsRemoteCommandStorePointerType>::FromRust( uniffi_tabs_fn_method_tabsstore_new_remote_command_store( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kTabsTabsStorePointerType>::IntoRust(std::move(mPtr)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kTabsRemoteCommandStorePointerType>::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -4796,14 +4853,14 @@ public: }; class ScaffoldingCallHandlerUniffiTabsFnMethodTabsstoreRegisterWithSyncManager : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kTabsTabsStorePointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kTabsTabsStorePointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kTabsTabsStorePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } @@ -4811,29 +4868,29 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_tabs_fn_method_tabsstore_register_with_sync_manager( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kTabsTabsStorePointerType>::IntoRust(std::move(mPtr)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiTabsFnMethodTabsstoreSetLocalTabs : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kTabsTabsStorePointerType> mPtr{}; - FfiValueRustBuffer mRemoteTabs{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kTabsTabsStorePointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mRemoteTabs; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kTabsTabsStorePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mRemoteTabs.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mRemoteTabs, aError); if (aError.Failed()) { return; } @@ -4841,43 +4898,44 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_tabs_fn_method_tabsstore_set_local_tabs( - mPtr.IntoRust(), - mRemoteTabs.IntoRust(), + ScaffoldingObjectConverter<&kTabsTabsStorePointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mRemoteTabs)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiTabsFnConstructorTabsstoreNew : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueRustBuffer mPath{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingConverter::IntermediateType mPath; // MakeRustCall stores the result of the call in these fields - FfiValueObjectHandle<&kTabsTabsStorePointerType> mUniffiReturnValue{}; + typename ScaffoldingObjectConverter<&kTabsTabsStorePointerType>::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPath.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingConverter::FromJs(aArgs[0], &mPath, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueObjectHandle<&kTabsTabsStorePointerType>::FromRust( + mUniffiReturnValue = ScaffoldingObjectConverter<&kTabsTabsStorePointerType>::FromRust( uniffi_tabs_fn_constructor_tabsstore_new( - mPath.IntoRust(), + ScaffoldingConverter::IntoRust(std::move(mPath)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kTabsTabsStorePointerType>::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -4885,32 +4943,33 @@ public: }; class ScaffoldingCallHandlerUniffiWebextStorageFnMethodWebextstoragebridgedengineApply : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kWebextstorageWebExtStorageBridgedEnginePointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_webext_storage_fn_method_webextstoragebridgedengine_apply( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntoRust(std::move(mPtr)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -4918,38 +4977,39 @@ public: }; class ScaffoldingCallHandlerUniffiWebextStorageFnMethodWebextstoragebridgedengineEnsureCurrentSyncId : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kWebextstorageWebExtStorageBridgedEnginePointerType> mPtr{}; - FfiValueRustBuffer mNewSyncId{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mNewSyncId; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mNewSyncId.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mNewSyncId, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_webext_storage_fn_method_webextstoragebridgedengine_ensure_current_sync_id( - mPtr.IntoRust(), - mNewSyncId.IntoRust(), + ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mNewSyncId)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -4957,32 +5017,33 @@ public: }; class ScaffoldingCallHandlerUniffiWebextStorageFnMethodWebextstoragebridgedengineLastSync : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kWebextstorageWebExtStorageBridgedEnginePointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_webext_storage_fn_method_webextstoragebridgedengine_last_sync( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntoRust(std::move(mPtr)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -4990,19 +5051,19 @@ public: }; class ScaffoldingCallHandlerUniffiWebextStorageFnMethodWebextstoragebridgedenginePrepareForSync : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kWebextstorageWebExtStorageBridgedEnginePointerType> mPtr{}; - FfiValueRustBuffer mClientData{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mClientData; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mClientData.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mClientData, aError); if (aError.Failed()) { return; } @@ -5010,25 +5071,25 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_webext_storage_fn_method_webextstoragebridgedengine_prepare_for_sync( - mPtr.IntoRust(), - mClientData.IntoRust(), + ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mClientData)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiWebextStorageFnMethodWebextstoragebridgedengineReset : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kWebextstorageWebExtStorageBridgedEnginePointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } @@ -5036,42 +5097,43 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_webext_storage_fn_method_webextstoragebridgedengine_reset( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntoRust(std::move(mPtr)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiWebextStorageFnMethodWebextstoragebridgedengineResetSyncId : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kWebextstorageWebExtStorageBridgedEnginePointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_webext_storage_fn_method_webextstoragebridgedengine_reset_sync_id( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntoRust(std::move(mPtr)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -5079,19 +5141,19 @@ public: }; class ScaffoldingCallHandlerUniffiWebextStorageFnMethodWebextstoragebridgedengineSetLastSync : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kWebextstorageWebExtStorageBridgedEnginePointerType> mPtr{}; - FfiValueInt mLastSync{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mLastSync; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mLastSync.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mLastSync, aError); if (aError.Failed()) { return; } @@ -5099,35 +5161,35 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_webext_storage_fn_method_webextstoragebridgedengine_set_last_sync( - mPtr.IntoRust(), - mLastSync.IntoRust(), + ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mLastSync)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiWebextStorageFnMethodWebextstoragebridgedengineSetUploaded : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kWebextstorageWebExtStorageBridgedEnginePointerType> mPtr{}; - FfiValueInt mServerModifiedMillis{}; - FfiValueRustBuffer mGuids{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mServerModifiedMillis; + typename ScaffoldingConverter::IntermediateType mGuids; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mServerModifiedMillis.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mServerModifiedMillis, aError); if (aError.Failed()) { return; } - mGuids.Lower(aArgs[2], aError); + ScaffoldingConverter::FromJs(aArgs[2], &mGuids, aError); if (aError.Failed()) { return; } @@ -5135,31 +5197,31 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_webext_storage_fn_method_webextstoragebridgedengine_set_uploaded( - mPtr.IntoRust(), - mServerModifiedMillis.IntoRust(), - mGuids.IntoRust(), + ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mServerModifiedMillis)), + ScaffoldingConverter::IntoRust(std::move(mGuids)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiWebextStorageFnMethodWebextstoragebridgedengineStoreIncoming : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kWebextstorageWebExtStorageBridgedEnginePointerType> mPtr{}; - FfiValueRustBuffer mIncoming{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mIncoming; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mIncoming.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mIncoming, aError); if (aError.Failed()) { return; } @@ -5167,25 +5229,25 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_webext_storage_fn_method_webextstoragebridgedengine_store_incoming( - mPtr.IntoRust(), - mIncoming.IntoRust(), + ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mIncoming)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiWebextStorageFnMethodWebextstoragebridgedengineSyncFinished : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kWebextstorageWebExtStorageBridgedEnginePointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } @@ -5193,42 +5255,43 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_webext_storage_fn_method_webextstoragebridgedengine_sync_finished( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntoRust(std::move(mPtr)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiWebextStorageFnMethodWebextstoragebridgedengineSyncId : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kWebextstorageWebExtStorageBridgedEnginePointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_webext_storage_fn_method_webextstoragebridgedengine_sync_id( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntoRust(std::move(mPtr)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -5236,14 +5299,14 @@ public: }; class ScaffoldingCallHandlerUniffiWebextStorageFnMethodWebextstoragebridgedengineSyncStarted : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kWebextstorageWebExtStorageBridgedEnginePointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } @@ -5251,24 +5314,24 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_webext_storage_fn_method_webextstoragebridgedengine_sync_started( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntoRust(std::move(mPtr)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiWebextStorageFnMethodWebextstoragebridgedengineWipe : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kWebextstorageWebExtStorageBridgedEnginePointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } @@ -5276,42 +5339,43 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_webext_storage_fn_method_webextstoragebridgedengine_wipe( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntoRust(std::move(mPtr)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiWebextStorageFnMethodWebextstoragestoreBridgedEngine : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kWebextstorageWebExtStorageStorePointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields - FfiValueObjectHandle<&kWebextstorageWebExtStorageBridgedEnginePointerType> mUniffiReturnValue{}; + typename ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueObjectHandle<&kWebextstorageWebExtStorageBridgedEnginePointerType>::FromRust( + mUniffiReturnValue = ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::FromRust( uniffi_webext_storage_fn_method_webextstoragestore_bridged_engine( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::IntoRust(std::move(mPtr)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kWebextstorageWebExtStorageBridgedEnginePointerType>::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -5319,38 +5383,39 @@ public: }; class ScaffoldingCallHandlerUniffiWebextStorageFnMethodWebextstoragestoreClear : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kWebextstorageWebExtStorageStorePointerType> mPtr{}; - FfiValueRustBuffer mExtId{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mExtId; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mExtId.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mExtId, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_webext_storage_fn_method_webextstoragestore_clear( - mPtr.IntoRust(), - mExtId.IntoRust(), + ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mExtId)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -5358,14 +5423,14 @@ public: }; class ScaffoldingCallHandlerUniffiWebextStorageFnMethodWebextstoragestoreClose : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kWebextstorageWebExtStorageStorePointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } @@ -5373,54 +5438,55 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_webext_storage_fn_method_webextstoragestore_close( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::IntoRust(std::move(mPtr)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiWebextStorageFnMethodWebextstoragestoreGet : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kWebextstorageWebExtStorageStorePointerType> mPtr{}; - FfiValueRustBuffer mExtId{}; - FfiValueRustBuffer mKeys{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mExtId; + typename ScaffoldingConverter::IntermediateType mKeys; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mExtId.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mExtId, aError); if (aError.Failed()) { return; } - mKeys.Lower(aArgs[2], aError); + ScaffoldingConverter::FromJs(aArgs[2], &mKeys, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_webext_storage_fn_method_webextstoragestore_get( - mPtr.IntoRust(), - mExtId.IntoRust(), - mKeys.IntoRust(), + ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mExtId)), + ScaffoldingConverter::IntoRust(std::move(mKeys)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -5428,44 +5494,45 @@ public: }; class ScaffoldingCallHandlerUniffiWebextStorageFnMethodWebextstoragestoreGetBytesInUse : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kWebextstorageWebExtStorageStorePointerType> mPtr{}; - FfiValueRustBuffer mExtId{}; - FfiValueRustBuffer mKeys{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mExtId; + typename ScaffoldingConverter::IntermediateType mKeys; // MakeRustCall stores the result of the call in these fields - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mExtId.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mExtId, aError); if (aError.Failed()) { return; } - mKeys.Lower(aArgs[2], aError); + ScaffoldingConverter::FromJs(aArgs[2], &mKeys, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_webext_storage_fn_method_webextstoragestore_get_bytes_in_use( - mPtr.IntoRust(), - mExtId.IntoRust(), - mKeys.IntoRust(), + ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mExtId)), + ScaffoldingConverter::IntoRust(std::move(mKeys)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -5473,32 +5540,33 @@ public: }; class ScaffoldingCallHandlerUniffiWebextStorageFnMethodWebextstoragestoreGetSyncedChanges : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kWebextstorageWebExtStorageStorePointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_webext_storage_fn_method_webextstoragestore_get_synced_changes( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::IntoRust(std::move(mPtr)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -5506,44 +5574,45 @@ public: }; class ScaffoldingCallHandlerUniffiWebextStorageFnMethodWebextstoragestoreRemove : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kWebextstorageWebExtStorageStorePointerType> mPtr{}; - FfiValueRustBuffer mExtId{}; - FfiValueRustBuffer mKeys{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mExtId; + typename ScaffoldingConverter::IntermediateType mKeys; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mExtId.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mExtId, aError); if (aError.Failed()) { return; } - mKeys.Lower(aArgs[2], aError); + ScaffoldingConverter::FromJs(aArgs[2], &mKeys, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_webext_storage_fn_method_webextstoragestore_remove( - mPtr.IntoRust(), - mExtId.IntoRust(), - mKeys.IntoRust(), + ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mExtId)), + ScaffoldingConverter::IntoRust(std::move(mKeys)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -5551,44 +5620,45 @@ public: }; class ScaffoldingCallHandlerUniffiWebextStorageFnMethodWebextstoragestoreSet : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kWebextstorageWebExtStorageStorePointerType> mPtr{}; - FfiValueRustBuffer mExtId{}; - FfiValueRustBuffer mVal{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mExtId; + typename ScaffoldingConverter::IntermediateType mVal; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mExtId.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mExtId, aError); if (aError.Failed()) { return; } - mVal.Lower(aArgs[2], aError); + ScaffoldingConverter::FromJs(aArgs[2], &mVal, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_webext_storage_fn_method_webextstoragestore_set( - mPtr.IntoRust(), - mExtId.IntoRust(), - mVal.IntoRust(), + ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mExtId)), + ScaffoldingConverter::IntoRust(std::move(mVal)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -5596,32 +5666,33 @@ public: }; class ScaffoldingCallHandlerUniffiWebextStorageFnConstructorWebextstoragestoreNew : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueRustBuffer mPath{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingConverter::IntermediateType mPath; // MakeRustCall stores the result of the call in these fields - FfiValueObjectHandle<&kWebextstorageWebExtStorageStorePointerType> mUniffiReturnValue{}; + typename ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPath.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingConverter::FromJs(aArgs[0], &mPath, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueObjectHandle<&kWebextstorageWebExtStorageStorePointerType>::FromRust( + mUniffiReturnValue = ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::FromRust( uniffi_webext_storage_fn_constructor_webextstoragestore_new( - mPath.IntoRust(), + ScaffoldingConverter::IntoRust(std::move(mPath)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kWebextstorageWebExtStorageStorePointerType>::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -5631,38 +5702,39 @@ public: #ifdef MOZ_UNIFFI_FIXTURES class ScaffoldingCallHandlerUniffiArithmeticalFnFuncAdd : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueInt mA{}; - FfiValueInt mB{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingConverter::IntermediateType mA; + typename ScaffoldingConverter::IntermediateType mB; // MakeRustCall stores the result of the call in these fields - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mA.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingConverter::FromJs(aArgs[0], &mA, aError); if (aError.Failed()) { return; } - mB.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mB, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_arithmetical_fn_func_add( - mA.IntoRust(), - mB.IntoRust(), + ScaffoldingConverter::IntoRust(std::move(mA)), + ScaffoldingConverter::IntoRust(std::move(mB)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -5670,38 +5742,39 @@ public: }; class ScaffoldingCallHandlerUniffiArithmeticalFnFuncDiv : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueInt mDividend{}; - FfiValueInt mDivisor{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingConverter::IntermediateType mDividend; + typename ScaffoldingConverter::IntermediateType mDivisor; // MakeRustCall stores the result of the call in these fields - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mDividend.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingConverter::FromJs(aArgs[0], &mDividend, aError); if (aError.Failed()) { return; } - mDivisor.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mDivisor, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_arithmetical_fn_func_div( - mDividend.IntoRust(), - mDivisor.IntoRust(), + ScaffoldingConverter::IntoRust(std::move(mDividend)), + ScaffoldingConverter::IntoRust(std::move(mDivisor)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -5709,38 +5782,39 @@ public: }; class ScaffoldingCallHandlerUniffiArithmeticalFnFuncEqual : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueInt mA{}; - FfiValueInt mB{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingConverter::IntermediateType mA; + typename ScaffoldingConverter::IntermediateType mB; // MakeRustCall stores the result of the call in these fields - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mA.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingConverter::FromJs(aArgs[0], &mA, aError); if (aError.Failed()) { return; } - mB.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mB, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_arithmetical_fn_func_equal( - mA.IntoRust(), - mB.IntoRust(), + ScaffoldingConverter::IntoRust(std::move(mA)), + ScaffoldingConverter::IntoRust(std::move(mB)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -5748,38 +5822,39 @@ public: }; class ScaffoldingCallHandlerUniffiArithmeticalFnFuncSub : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueInt mA{}; - FfiValueInt mB{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingConverter::IntermediateType mA; + typename ScaffoldingConverter::IntermediateType mB; // MakeRustCall stores the result of the call in these fields - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mA.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingConverter::FromJs(aArgs[0], &mA, aError); if (aError.Failed()) { return; } - mB.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mB, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_arithmetical_fn_func_sub( - mA.IntoRust(), - mB.IntoRust(), + ScaffoldingConverter::IntoRust(std::move(mA)), + ScaffoldingConverter::IntoRust(std::move(mB)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -5787,32 +5862,33 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiCustomTypesFnFuncGetCustomTypesDemo : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueRustBuffer mDemo{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingConverter::IntermediateType mDemo; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mDemo.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingConverter::FromJs(aArgs[0], &mDemo, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_custom_types_fn_func_get_custom_types_demo( - mDemo.IntoRust(), + ScaffoldingConverter::IntoRust(std::move(mDemo)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -5820,32 +5896,33 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiFixtureExternalTypesFnFuncGradient : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueRustBuffer mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueFloat mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mValue.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingConverter::FromJs(aArgs[0], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueFloat::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_fixture_external_types_fn_func_gradient( - mValue.IntoRust(), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -5853,38 +5930,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiFixtureExternalTypesFnFuncIntersection : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueRustBuffer mLn1{}; - FfiValueRustBuffer mLn2{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingConverter::IntermediateType mLn1; + typename ScaffoldingConverter::IntermediateType mLn2; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mLn1.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingConverter::FromJs(aArgs[0], &mLn1, aError); if (aError.Failed()) { return; } - mLn2.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mLn2, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_fixture_external_types_fn_func_intersection( - mLn1.IntoRust(), - mLn2.IntoRust(), + ScaffoldingConverter::IntoRust(std::move(mLn1)), + ScaffoldingConverter::IntoRust(std::move(mLn2)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -5892,14 +5970,14 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiFixtureExternalTypesFnFuncMoveSpriteToOrigin : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kSpritesSpritePointerType> mSprite{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kSpritesSpritePointerType>::IntermediateType mSprite; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mSprite.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kSpritesSpritePointerType>::FromJs(aArgs[0], &mSprite, aError); if (aError.Failed()) { return; } @@ -5907,39 +5985,39 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_uniffi_fixture_external_types_fn_func_move_sprite_to_origin( - mSprite.IntoRust(), + ScaffoldingObjectConverter<&kSpritesSpritePointerType>::IntoRust(std::move(mSprite)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiUniffiFixtureCallbacksFnFuncCallLogRepeat : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueInt mLogger{}; - FfiValueRustBuffer mMessage{}; - FfiValueInt mCount{}; - FfiValueRustBuffer mExclude{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingConverter::IntermediateType mLogger; + typename ScaffoldingConverter::IntermediateType mMessage; + typename ScaffoldingConverter::IntermediateType mCount; + typename ScaffoldingConverter::IntermediateType mExclude; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mLogger.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingConverter::FromJs(aArgs[0], &mLogger, aError); if (aError.Failed()) { return; } - mMessage.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mMessage, aError); if (aError.Failed()) { return; } - mCount.Lower(aArgs[2], aError); + ScaffoldingConverter::FromJs(aArgs[2], &mCount, aError); if (aError.Failed()) { return; } - mExclude.Lower(aArgs[3], aError); + ScaffoldingConverter::FromJs(aArgs[3], &mExclude, aError); if (aError.Failed()) { return; } @@ -5947,32 +6025,32 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_uniffi_fixture_callbacks_fn_func_call_log_repeat( - mLogger.IntoRust(), - mMessage.IntoRust(), - mCount.IntoRust(), - mExclude.IntoRust(), + ScaffoldingConverter::IntoRust(std::move(mLogger)), + ScaffoldingConverter::IntoRust(std::move(mMessage)), + ScaffoldingConverter::IntoRust(std::move(mCount)), + ScaffoldingConverter::IntoRust(std::move(mExclude)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiUniffiFixtureCallbacksFnFuncLogEvenNumbers : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueInt mLogger{}; - FfiValueRustBuffer mItems{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingConverter::IntermediateType mLogger; + typename ScaffoldingConverter::IntermediateType mItems; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mLogger.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingConverter::FromJs(aArgs[0], &mLogger, aError); if (aError.Failed()) { return; } - mItems.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mItems, aError); if (aError.Failed()) { return; } @@ -5980,30 +6058,30 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_uniffi_fixture_callbacks_fn_func_log_even_numbers( - mLogger.IntoRust(), - mItems.IntoRust(), + ScaffoldingConverter::IntoRust(std::move(mLogger)), + ScaffoldingConverter::IntoRust(std::move(mItems)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiUniffiFixtureCallbacksFnFuncLogEvenNumbersMainThread : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueInt mLogger{}; - FfiValueRustBuffer mItems{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingConverter::IntermediateType mLogger; + typename ScaffoldingConverter::IntermediateType mItems; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mLogger.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingConverter::FromJs(aArgs[0], &mLogger, aError); if (aError.Failed()) { return; } - mItems.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mItems, aError); if (aError.Failed()) { return; } @@ -6011,13 +6089,13 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_uniffi_fixture_callbacks_fn_func_log_even_numbers_main_thread( - mLogger.IntoRust(), - mItems.IntoRust(), + ScaffoldingConverter::IntoRust(std::move(mLogger)), + ScaffoldingConverter::IntoRust(std::move(mItems)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiUniffiFixtureFuturesFnFuncExpensiveComputation : public UniffiAsyncCallHandler { @@ -6026,27 +6104,28 @@ public: private: // Complete stores the result of the call in mUniffiReturnValue - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType 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 LowerArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { + void PrepareArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { mFutureHandle = uniffi_uniffi_fixture_futures_fn_func_expensive_computation( ); } void CallCompleteFn(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( ffi_uniffi_fixture_futures_rust_future_complete_u32(mFutureHandle, aOutStatus)); } public: - void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -6054,12 +6133,12 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiFixtureFuturesFnFuncInitializeGeckoGlobalWorkerQueue : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields + // PrepareRustArgs stores the resulting arguments in these fields // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { } void MakeRustCall(RustCallStatus* aOutStatus) override { @@ -6068,19 +6147,19 @@ public: ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiUniffiFixtureFuturesFnFuncInitializeGlobalWorkerQueue : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kFuturesWorkerQueuePointerType> mWorkerQueue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kFuturesWorkerQueuePointerType>::IntermediateType mWorkerQueue; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mWorkerQueue.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kFuturesWorkerQueuePointerType>::FromJs(aArgs[0], &mWorkerQueue, aError); if (aError.Failed()) { return; } @@ -6088,12 +6167,12 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_uniffi_fixture_futures_fn_func_initialize_global_worker_queue( - mWorkerQueue.IntoRust(), + ScaffoldingObjectConverter<&kFuturesWorkerQueuePointerType>::IntoRust(std::move(mWorkerQueue)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiUniffiFixtureFuturesFnFuncRoundtripF32 : public UniffiAsyncCallHandler { @@ -6102,33 +6181,34 @@ public: private: // Complete stores the result of the call in mUniffiReturnValue - FfiValueFloat mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType 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 LowerArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { - FfiValueFloat mV{}; - mV.Lower(aArgs[0], aError); + void PrepareArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { + typename ScaffoldingConverter::IntermediateType mV; + ScaffoldingConverter::FromJs(aArgs[0], &mV, aError); if (aError.Failed()) { return; } mFutureHandle = uniffi_uniffi_fixture_futures_fn_func_roundtrip_f32( - mV.IntoRust() + ScaffoldingConverter::IntoRust(std::move(mV)) ); } void CallCompleteFn(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueFloat::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( ffi_uniffi_fixture_futures_rust_future_complete_f32(mFutureHandle, aOutStatus)); } public: - void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -6140,33 +6220,34 @@ public: private: // Complete stores the result of the call in mUniffiReturnValue - FfiValueFloat mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType 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 LowerArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { - FfiValueFloat mV{}; - mV.Lower(aArgs[0], aError); + void PrepareArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { + typename ScaffoldingConverter::IntermediateType mV; + ScaffoldingConverter::FromJs(aArgs[0], &mV, aError); if (aError.Failed()) { return; } mFutureHandle = uniffi_uniffi_fixture_futures_fn_func_roundtrip_f64( - mV.IntoRust() + ScaffoldingConverter::IntoRust(std::move(mV)) ); } void CallCompleteFn(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueFloat::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( ffi_uniffi_fixture_futures_rust_future_complete_f64(mFutureHandle, aOutStatus)); } public: - void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -6178,33 +6259,34 @@ public: private: // Complete stores the result of the call in mUniffiReturnValue - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType 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 LowerArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { - FfiValueInt mV{}; - mV.Lower(aArgs[0], aError); + void PrepareArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { + typename ScaffoldingConverter::IntermediateType mV; + ScaffoldingConverter::FromJs(aArgs[0], &mV, aError); if (aError.Failed()) { return; } mFutureHandle = uniffi_uniffi_fixture_futures_fn_func_roundtrip_i16( - mV.IntoRust() + ScaffoldingConverter::IntoRust(std::move(mV)) ); } void CallCompleteFn(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( ffi_uniffi_fixture_futures_rust_future_complete_i16(mFutureHandle, aOutStatus)); } public: - void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -6216,33 +6298,34 @@ public: private: // Complete stores the result of the call in mUniffiReturnValue - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType 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 LowerArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { - FfiValueInt mV{}; - mV.Lower(aArgs[0], aError); + void PrepareArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { + typename ScaffoldingConverter::IntermediateType mV; + ScaffoldingConverter::FromJs(aArgs[0], &mV, aError); if (aError.Failed()) { return; } mFutureHandle = uniffi_uniffi_fixture_futures_fn_func_roundtrip_i32( - mV.IntoRust() + ScaffoldingConverter::IntoRust(std::move(mV)) ); } void CallCompleteFn(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( ffi_uniffi_fixture_futures_rust_future_complete_i32(mFutureHandle, aOutStatus)); } public: - void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -6254,33 +6337,34 @@ public: private: // Complete stores the result of the call in mUniffiReturnValue - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType 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 LowerArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { - FfiValueInt mV{}; - mV.Lower(aArgs[0], aError); + void PrepareArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { + typename ScaffoldingConverter::IntermediateType mV; + ScaffoldingConverter::FromJs(aArgs[0], &mV, aError); if (aError.Failed()) { return; } mFutureHandle = uniffi_uniffi_fixture_futures_fn_func_roundtrip_i64( - mV.IntoRust() + ScaffoldingConverter::IntoRust(std::move(mV)) ); } void CallCompleteFn(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( ffi_uniffi_fixture_futures_rust_future_complete_i64(mFutureHandle, aOutStatus)); } public: - void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -6292,33 +6376,34 @@ public: private: // Complete stores the result of the call in mUniffiReturnValue - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType 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 LowerArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { - FfiValueInt mV{}; - mV.Lower(aArgs[0], aError); + void PrepareArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { + typename ScaffoldingConverter::IntermediateType mV; + ScaffoldingConverter::FromJs(aArgs[0], &mV, aError); if (aError.Failed()) { return; } mFutureHandle = uniffi_uniffi_fixture_futures_fn_func_roundtrip_i8( - mV.IntoRust() + ScaffoldingConverter::IntoRust(std::move(mV)) ); } void CallCompleteFn(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( ffi_uniffi_fixture_futures_rust_future_complete_i8(mFutureHandle, aOutStatus)); } public: - void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -6330,33 +6415,34 @@ public: private: // Complete stores the result of the call in mUniffiReturnValue - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType 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 LowerArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { - FfiValueRustBuffer mV{}; - mV.Lower(aArgs[0], aError); + void PrepareArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { + typename ScaffoldingConverter::IntermediateType mV; + ScaffoldingConverter::FromJs(aArgs[0], &mV, aError); if (aError.Failed()) { return; } mFutureHandle = uniffi_uniffi_fixture_futures_fn_func_roundtrip_map( - mV.IntoRust() + ScaffoldingConverter::IntoRust(std::move(mV)) ); } void CallCompleteFn(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( ffi_uniffi_fixture_futures_rust_future_complete_rust_buffer(mFutureHandle, aOutStatus)); } public: - void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -6368,33 +6454,34 @@ public: private: // Complete stores the result of the call in mUniffiReturnValue - FfiValueObjectHandle<&kFuturesTravellerPointerType> mUniffiReturnValue{}; + typename ScaffoldingObjectConverter<&kFuturesTravellerPointerType>::IntermediateType 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 LowerArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { - FfiValueObjectHandle<&kFuturesTravellerPointerType> mV{}; - mV.Lower(aArgs[0], aError); + void PrepareArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { + typename ScaffoldingObjectConverter<&kFuturesTravellerPointerType>::IntermediateType mV; + ScaffoldingObjectConverter<&kFuturesTravellerPointerType>::FromJs(aArgs[0], &mV, aError); if (aError.Failed()) { return; } mFutureHandle = uniffi_uniffi_fixture_futures_fn_func_roundtrip_obj( - mV.IntoRust() + ScaffoldingObjectConverter<&kFuturesTravellerPointerType>::IntoRust(std::move(mV)) ); } void CallCompleteFn(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueObjectHandle<&kFuturesTravellerPointerType>::FromRust( + mUniffiReturnValue = ScaffoldingObjectConverter<&kFuturesTravellerPointerType>::FromRust( ffi_uniffi_fixture_futures_rust_future_complete_pointer(mFutureHandle, aOutStatus)); } public: - void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kFuturesTravellerPointerType>::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -6406,33 +6493,34 @@ public: private: // Complete stores the result of the call in mUniffiReturnValue - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType 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 LowerArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { - FfiValueRustBuffer mV{}; - mV.Lower(aArgs[0], aError); + void PrepareArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { + typename ScaffoldingConverter::IntermediateType mV; + ScaffoldingConverter::FromJs(aArgs[0], &mV, aError); if (aError.Failed()) { return; } mFutureHandle = uniffi_uniffi_fixture_futures_fn_func_roundtrip_string( - mV.IntoRust() + ScaffoldingConverter::IntoRust(std::move(mV)) ); } void CallCompleteFn(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( ffi_uniffi_fixture_futures_rust_future_complete_rust_buffer(mFutureHandle, aOutStatus)); } public: - void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -6444,33 +6532,34 @@ public: private: // Complete stores the result of the call in mUniffiReturnValue - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType 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 LowerArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { - FfiValueInt mV{}; - mV.Lower(aArgs[0], aError); + void PrepareArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { + typename ScaffoldingConverter::IntermediateType mV; + ScaffoldingConverter::FromJs(aArgs[0], &mV, aError); if (aError.Failed()) { return; } mFutureHandle = uniffi_uniffi_fixture_futures_fn_func_roundtrip_u16( - mV.IntoRust() + ScaffoldingConverter::IntoRust(std::move(mV)) ); } void CallCompleteFn(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( ffi_uniffi_fixture_futures_rust_future_complete_u16(mFutureHandle, aOutStatus)); } public: - void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -6482,33 +6571,34 @@ public: private: // Complete stores the result of the call in mUniffiReturnValue - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType 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 LowerArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { - FfiValueInt mV{}; - mV.Lower(aArgs[0], aError); + void PrepareArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { + typename ScaffoldingConverter::IntermediateType mV; + ScaffoldingConverter::FromJs(aArgs[0], &mV, aError); if (aError.Failed()) { return; } mFutureHandle = uniffi_uniffi_fixture_futures_fn_func_roundtrip_u32( - mV.IntoRust() + ScaffoldingConverter::IntoRust(std::move(mV)) ); } void CallCompleteFn(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( ffi_uniffi_fixture_futures_rust_future_complete_u32(mFutureHandle, aOutStatus)); } public: - void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -6520,33 +6610,34 @@ public: private: // Complete stores the result of the call in mUniffiReturnValue - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType 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 LowerArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { - FfiValueInt mV{}; - mV.Lower(aArgs[0], aError); + void PrepareArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { + typename ScaffoldingConverter::IntermediateType mV; + ScaffoldingConverter::FromJs(aArgs[0], &mV, aError); if (aError.Failed()) { return; } mFutureHandle = uniffi_uniffi_fixture_futures_fn_func_roundtrip_u64( - mV.IntoRust() + ScaffoldingConverter::IntoRust(std::move(mV)) ); } void CallCompleteFn(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( ffi_uniffi_fixture_futures_rust_future_complete_u64(mFutureHandle, aOutStatus)); } public: - void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -6558,33 +6649,34 @@ public: private: // Complete stores the result of the call in mUniffiReturnValue - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType 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 LowerArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { - FfiValueInt mV{}; - mV.Lower(aArgs[0], aError); + void PrepareArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { + typename ScaffoldingConverter::IntermediateType mV; + ScaffoldingConverter::FromJs(aArgs[0], &mV, aError); if (aError.Failed()) { return; } mFutureHandle = uniffi_uniffi_fixture_futures_fn_func_roundtrip_u8( - mV.IntoRust() + ScaffoldingConverter::IntoRust(std::move(mV)) ); } void CallCompleteFn(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( ffi_uniffi_fixture_futures_rust_future_complete_u8(mFutureHandle, aOutStatus)); } public: - void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -6596,33 +6688,34 @@ public: private: // Complete stores the result of the call in mUniffiReturnValue - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType 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 LowerArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { - FfiValueRustBuffer mV{}; - mV.Lower(aArgs[0], aError); + void PrepareArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { + typename ScaffoldingConverter::IntermediateType mV; + ScaffoldingConverter::FromJs(aArgs[0], &mV, aError); if (aError.Failed()) { return; } mFutureHandle = uniffi_uniffi_fixture_futures_fn_func_roundtrip_vec( - mV.IntoRust() + ScaffoldingConverter::IntoRust(std::move(mV)) ); } void CallCompleteFn(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( ffi_uniffi_fixture_futures_rust_future_complete_rust_buffer(mFutureHandle, aOutStatus)); } public: - void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -6630,38 +6723,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiFixtureFuturesFnMethodFuturetesterCompleteFutures : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kFuturesFutureTesterPointerType> mPtr{}; - FfiValueInt mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kFuturesFutureTesterPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kFuturesFutureTesterPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_fixture_futures_fn_method_futuretester_complete_futures( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kFuturesFutureTesterPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -6673,33 +6767,34 @@ public: private: // Complete stores the result of the call in mUniffiReturnValue - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType 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 LowerArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { - FfiValueObjectHandle<&kFuturesFutureTesterPointerType> mPtr{}; - mPtr.Lower(aArgs[0], aError); + void PrepareArgsAndMakeRustCall(const dom::Sequence& aArgs, ErrorResult& aError) override { + typename ScaffoldingObjectConverter<&kFuturesFutureTesterPointerType>::IntermediateType mPtr; + ScaffoldingObjectConverter<&kFuturesFutureTesterPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } mFutureHandle = uniffi_uniffi_fixture_futures_fn_method_futuretester_make_future( - mPtr.IntoRust() + ScaffoldingObjectConverter<&kFuturesFutureTesterPointerType>::IntoRust(std::move(mPtr)) ); } void CallCompleteFn(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( ffi_uniffi_fixture_futures_rust_future_complete_u8(mFutureHandle, aOutStatus)); } public: - void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -6707,14 +6802,14 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiFixtureFuturesFnMethodFuturetesterWakeFutures : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kFuturesFutureTesterPointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kFuturesFutureTesterPointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kFuturesFutureTesterPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } @@ -6722,36 +6817,37 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_uniffi_fixture_futures_fn_method_futuretester_wake_futures( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kFuturesFutureTesterPointerType>::IntoRust(std::move(mPtr)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiUniffiFixtureFuturesFnConstructorFuturetesterInit : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields + // PrepareRustArgs stores the resulting arguments in these fields // MakeRustCall stores the result of the call in these fields - FfiValueObjectHandle<&kFuturesFutureTesterPointerType> mUniffiReturnValue{}; + typename ScaffoldingObjectConverter<&kFuturesFutureTesterPointerType>::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueObjectHandle<&kFuturesFutureTesterPointerType>::FromRust( + mUniffiReturnValue = ScaffoldingObjectConverter<&kFuturesFutureTesterPointerType>::FromRust( uniffi_uniffi_fixture_futures_fn_constructor_futuretester_init( aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kFuturesFutureTesterPointerType>::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -6759,14 +6855,14 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiFixtureFuturesFnMethodRusttaskRun : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kFuturesRustTaskPointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kFuturesRustTaskPointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kFuturesRustTaskPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } @@ -6774,42 +6870,43 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_uniffi_fixture_futures_fn_method_rusttask_run( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kFuturesRustTaskPointerType>::IntoRust(std::move(mPtr)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiUniffiFixtureFuturesFnMethodTravellerName : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kFuturesTravellerPointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kFuturesTravellerPointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kFuturesTravellerPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_fixture_futures_fn_method_traveller_name( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kFuturesTravellerPointerType>::IntoRust(std::move(mPtr)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -6817,32 +6914,33 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiFixtureFuturesFnConstructorTravellerNew : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueRustBuffer mName{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingConverter::IntermediateType mName; // MakeRustCall stores the result of the call in these fields - FfiValueObjectHandle<&kFuturesTravellerPointerType> mUniffiReturnValue{}; + typename ScaffoldingObjectConverter<&kFuturesTravellerPointerType>::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mName.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingConverter::FromJs(aArgs[0], &mName, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueObjectHandle<&kFuturesTravellerPointerType>::FromRust( + mUniffiReturnValue = ScaffoldingObjectConverter<&kFuturesTravellerPointerType>::FromRust( uniffi_uniffi_fixture_futures_fn_constructor_traveller_new( - mName.IntoRust(), + ScaffoldingConverter::IntoRust(std::move(mName)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kFuturesTravellerPointerType>::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -6850,19 +6948,19 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiFixtureFuturesFnMethodWorkerqueueAddTask : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kFuturesWorkerQueuePointerType> mPtr{}; - FfiValueObjectHandle<&kFuturesRustTaskPointerType> mTask{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kFuturesWorkerQueuePointerType>::IntermediateType mPtr; + typename ScaffoldingObjectConverter<&kFuturesRustTaskPointerType>::IntermediateType mTask; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kFuturesWorkerQueuePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mTask.Lower(aArgs[1], aError); + ScaffoldingObjectConverter<&kFuturesRustTaskPointerType>::FromJs(aArgs[1], &mTask, aError); if (aError.Failed()) { return; } @@ -6870,43 +6968,44 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_uniffi_fixture_futures_fn_method_workerqueue_add_task( - mPtr.IntoRust(), - mTask.IntoRust(), + ScaffoldingObjectConverter<&kFuturesWorkerQueuePointerType>::IntoRust(std::move(mPtr)), + ScaffoldingObjectConverter<&kFuturesRustTaskPointerType>::IntoRust(std::move(mTask)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiUniffiGeometryFnFuncGradient : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueRustBuffer mLn{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingConverter::IntermediateType mLn; // MakeRustCall stores the result of the call in these fields - FfiValueFloat mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mLn.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingConverter::FromJs(aArgs[0], &mLn, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueFloat::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_geometry_fn_func_gradient( - mLn.IntoRust(), + ScaffoldingConverter::IntoRust(std::move(mLn)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -6914,38 +7013,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiGeometryFnFuncIntersection : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueRustBuffer mLn1{}; - FfiValueRustBuffer mLn2{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingConverter::IntermediateType mLn1; + typename ScaffoldingConverter::IntermediateType mLn2; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mLn1.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingConverter::FromJs(aArgs[0], &mLn1, aError); if (aError.Failed()) { return; } - mLn2.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mLn2, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_geometry_fn_func_intersection( - mLn1.IntoRust(), - mLn2.IntoRust(), + ScaffoldingConverter::IntoRust(std::move(mLn1)), + ScaffoldingConverter::IntoRust(std::move(mLn2)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -6953,26 +7053,27 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiFixtureRefcountsFnFuncGetJsRefcount : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields + // PrepareRustArgs stores the resulting arguments in these fields // MakeRustCall stores the result of the call in these fields - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_fixture_refcounts_fn_func_get_js_refcount( aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -6980,26 +7081,27 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiFixtureRefcountsFnFuncGetSingleton : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields + // PrepareRustArgs stores the resulting arguments in these fields // MakeRustCall stores the result of the call in these fields - FfiValueObjectHandle<&kRefcountsSingletonObjectPointerType> mUniffiReturnValue{}; + typename ScaffoldingObjectConverter<&kRefcountsSingletonObjectPointerType>::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueObjectHandle<&kRefcountsSingletonObjectPointerType>::FromRust( + mUniffiReturnValue = ScaffoldingObjectConverter<&kRefcountsSingletonObjectPointerType>::FromRust( uniffi_uniffi_fixture_refcounts_fn_func_get_singleton( aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRefcountsSingletonObjectPointerType>::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7007,14 +7109,14 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiFixtureRefcountsFnMethodSingletonobjectMethod : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRefcountsSingletonObjectPointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRefcountsSingletonObjectPointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRefcountsSingletonObjectPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } @@ -7022,42 +7124,43 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_uniffi_fixture_refcounts_fn_method_singletonobject_method( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kRefcountsSingletonObjectPointerType>::IntoRust(std::move(mPtr)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnFuncCopieCarte : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueRustBuffer mC{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingConverter::IntermediateType mC; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mC.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingConverter::FromJs(aArgs[0], &mC, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_func_copie_carte( - mC.IntoRust(), + ScaffoldingConverter::IntoRust(std::move(mC)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7065,32 +7168,33 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnFuncCopieDictionnaire : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueRustBuffer mD{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingConverter::IntermediateType mD; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mD.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingConverter::FromJs(aArgs[0], &mD, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_func_copie_dictionnaire( - mD.IntoRust(), + ScaffoldingConverter::IntoRust(std::move(mD)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7098,32 +7202,33 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnFuncCopieEnumeration : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueRustBuffer mE{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingConverter::IntermediateType mE; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mE.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingConverter::FromJs(aArgs[0], &mE, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_func_copie_enumeration( - mE.IntoRust(), + ScaffoldingConverter::IntoRust(std::move(mE)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7131,32 +7236,33 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnFuncCopieEnumerations : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueRustBuffer mE{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingConverter::IntermediateType mE; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mE.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingConverter::FromJs(aArgs[0], &mE, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_func_copie_enumerations( - mE.IntoRust(), + ScaffoldingConverter::IntoRust(std::move(mE)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7164,32 +7270,33 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnFuncSwitcheroo : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueInt mB{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingConverter::IntermediateType mB; // MakeRustCall stores the result of the call in these fields - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mB.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingConverter::FromJs(aArgs[0], &mB, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_func_switcheroo( - mB.IntoRust(), + ScaffoldingConverter::IntoRust(std::move(mB)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7197,38 +7304,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonBoolean : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointOptionneurPointerType> mPtr{}; - FfiValueInt mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_boolean( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7236,38 +7344,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonEnum : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointOptionneurPointerType> mPtr{}; - FfiValueRustBuffer mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_enum( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7275,38 +7384,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonF32 : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointOptionneurPointerType> mPtr{}; - FfiValueFloat mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueFloat mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueFloat::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_f32( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7314,38 +7424,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonF64 : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointOptionneurPointerType> mPtr{}; - FfiValueFloat mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueFloat mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueFloat::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_f64( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7353,38 +7464,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonI16Dec : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointOptionneurPointerType> mPtr{}; - FfiValueInt mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_i16_dec( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7392,38 +7504,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonI16Hex : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointOptionneurPointerType> mPtr{}; - FfiValueInt mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_i16_hex( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7431,38 +7544,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonI32Dec : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointOptionneurPointerType> mPtr{}; - FfiValueInt mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_i32_dec( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7470,38 +7584,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonI32Hex : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointOptionneurPointerType> mPtr{}; - FfiValueInt mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_i32_hex( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7509,38 +7624,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonI64Dec : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointOptionneurPointerType> mPtr{}; - FfiValueInt mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_i64_dec( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7548,38 +7664,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonI64Hex : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointOptionneurPointerType> mPtr{}; - FfiValueInt mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_i64_hex( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7587,38 +7704,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonI8Dec : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointOptionneurPointerType> mPtr{}; - FfiValueInt mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_i8_dec( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7626,38 +7744,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonI8Hex : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointOptionneurPointerType> mPtr{}; - FfiValueInt mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_i8_hex( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7665,38 +7784,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonNull : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointOptionneurPointerType> mPtr{}; - FfiValueRustBuffer mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_null( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7704,38 +7824,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonSequence : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointOptionneurPointerType> mPtr{}; - FfiValueRustBuffer mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_sequence( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7743,38 +7864,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonString : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointOptionneurPointerType> mPtr{}; - FfiValueRustBuffer mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_string( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7782,38 +7904,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonU16Dec : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointOptionneurPointerType> mPtr{}; - FfiValueInt mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_u16_dec( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7821,38 +7944,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonU16Hex : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointOptionneurPointerType> mPtr{}; - FfiValueInt mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_u16_hex( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7860,38 +7984,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonU32Dec : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointOptionneurPointerType> mPtr{}; - FfiValueInt mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_u32_dec( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7899,38 +8024,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonU32Hex : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointOptionneurPointerType> mPtr{}; - FfiValueInt mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_u32_hex( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7938,38 +8064,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonU32Oct : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointOptionneurPointerType> mPtr{}; - FfiValueInt mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_u32_oct( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -7977,38 +8104,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonU64Dec : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointOptionneurPointerType> mPtr{}; - FfiValueInt mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_u64_dec( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8016,38 +8144,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonU64Hex : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointOptionneurPointerType> mPtr{}; - FfiValueInt mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_u64_hex( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8055,38 +8184,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonU8Dec : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointOptionneurPointerType> mPtr{}; - FfiValueInt mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_u8_dec( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8094,38 +8224,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonU8Hex : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointOptionneurPointerType> mPtr{}; - FfiValueInt mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_u8_hex( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8133,38 +8264,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodOptionneurSinonZero : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointOptionneurPointerType> mPtr{}; - FfiValueRustBuffer mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_zero( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8172,26 +8304,27 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnConstructorOptionneurNew : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields + // PrepareRustArgs stores the resulting arguments in these fields // MakeRustCall stores the result of the call in these fields - FfiValueObjectHandle<&kRondpointOptionneurPointerType> mUniffiReturnValue{}; + typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueObjectHandle<&kRondpointOptionneurPointerType>::FromRust( + mUniffiReturnValue = ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromRust( uniffi_uniffi_rondpoint_fn_constructor_optionneur_new( aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8199,38 +8332,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodRetourneurIdentiqueBoolean : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointRetourneurPointerType> mPtr{}; - FfiValueInt mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_retourneur_identique_boolean( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8238,38 +8372,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodRetourneurIdentiqueDouble : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointRetourneurPointerType> mPtr{}; - FfiValueFloat mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueFloat mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueFloat::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_retourneur_identique_double( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8277,38 +8412,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodRetourneurIdentiqueFloat : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointRetourneurPointerType> mPtr{}; - FfiValueFloat mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueFloat mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueFloat::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_retourneur_identique_float( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8316,38 +8452,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodRetourneurIdentiqueI16 : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointRetourneurPointerType> mPtr{}; - FfiValueInt mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_retourneur_identique_i16( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8355,38 +8492,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodRetourneurIdentiqueI32 : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointRetourneurPointerType> mPtr{}; - FfiValueInt mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_retourneur_identique_i32( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8394,38 +8532,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodRetourneurIdentiqueI64 : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointRetourneurPointerType> mPtr{}; - FfiValueInt mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_retourneur_identique_i64( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8433,38 +8572,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodRetourneurIdentiqueI8 : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointRetourneurPointerType> mPtr{}; - FfiValueInt mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_retourneur_identique_i8( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8472,38 +8612,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodRetourneurIdentiqueNombres : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointRetourneurPointerType> mPtr{}; - FfiValueRustBuffer mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_retourneur_identique_nombres( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8511,38 +8652,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodRetourneurIdentiqueNombresSignes : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointRetourneurPointerType> mPtr{}; - FfiValueRustBuffer mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_retourneur_identique_nombres_signes( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8550,38 +8692,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodRetourneurIdentiqueOptionneurDictionnaire : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointRetourneurPointerType> mPtr{}; - FfiValueRustBuffer mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_retourneur_identique_optionneur_dictionnaire( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8589,38 +8732,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodRetourneurIdentiqueString : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointRetourneurPointerType> mPtr{}; - FfiValueRustBuffer mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_retourneur_identique_string( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8628,38 +8772,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodRetourneurIdentiqueU16 : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointRetourneurPointerType> mPtr{}; - FfiValueInt mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_retourneur_identique_u16( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8667,38 +8812,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodRetourneurIdentiqueU32 : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointRetourneurPointerType> mPtr{}; - FfiValueInt mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_retourneur_identique_u32( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8706,38 +8852,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodRetourneurIdentiqueU64 : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointRetourneurPointerType> mPtr{}; - FfiValueInt mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_retourneur_identique_u64( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8745,38 +8892,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodRetourneurIdentiqueU8 : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointRetourneurPointerType> mPtr{}; - FfiValueInt mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_retourneur_identique_u8( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8784,26 +8932,27 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnConstructorRetourneurNew : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields + // PrepareRustArgs stores the resulting arguments in these fields // MakeRustCall stores the result of the call in these fields - FfiValueObjectHandle<&kRondpointRetourneurPointerType> mUniffiReturnValue{}; + typename ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueObjectHandle<&kRondpointRetourneurPointerType>::FromRust( + mUniffiReturnValue = ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::FromRust( uniffi_uniffi_rondpoint_fn_constructor_retourneur_new( aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8811,38 +8960,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodStringifierToStringBoolean : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointStringifierPointerType> mPtr{}; - FfiValueInt mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_stringifier_to_string_boolean( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8850,38 +9000,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodStringifierToStringDouble : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointStringifierPointerType> mPtr{}; - FfiValueFloat mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_stringifier_to_string_double( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8889,38 +9040,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodStringifierToStringFloat : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointStringifierPointerType> mPtr{}; - FfiValueFloat mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_stringifier_to_string_float( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8928,38 +9080,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodStringifierToStringI16 : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointStringifierPointerType> mPtr{}; - FfiValueInt mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_stringifier_to_string_i16( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -8967,38 +9120,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodStringifierToStringI32 : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointStringifierPointerType> mPtr{}; - FfiValueInt mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_stringifier_to_string_i32( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -9006,38 +9160,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodStringifierToStringI64 : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointStringifierPointerType> mPtr{}; - FfiValueInt mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_stringifier_to_string_i64( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -9045,38 +9200,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodStringifierToStringI8 : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointStringifierPointerType> mPtr{}; - FfiValueInt mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_stringifier_to_string_i8( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -9084,38 +9240,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodStringifierToStringU16 : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointStringifierPointerType> mPtr{}; - FfiValueInt mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_stringifier_to_string_u16( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -9123,38 +9280,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodStringifierToStringU32 : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointStringifierPointerType> mPtr{}; - FfiValueInt mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_stringifier_to_string_u32( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -9162,38 +9320,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodStringifierToStringU64 : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointStringifierPointerType> mPtr{}; - FfiValueInt mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_stringifier_to_string_u64( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -9201,38 +9360,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodStringifierToStringU8 : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointStringifierPointerType> mPtr{}; - FfiValueInt mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_stringifier_to_string_u8( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -9240,38 +9400,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnMethodStringifierWellKnownString : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kRondpointStringifierPointerType> mPtr{}; - FfiValueRustBuffer mValue{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mValue; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mValue.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mValue, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_rondpoint_fn_method_stringifier_well_known_string( - mPtr.IntoRust(), - mValue.IntoRust(), + ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mValue)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -9279,26 +9440,27 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiRondpointFnConstructorStringifierNew : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields + // PrepareRustArgs stores the resulting arguments in these fields // MakeRustCall stores the result of the call in these fields - FfiValueObjectHandle<&kRondpointStringifierPointerType> mUniffiReturnValue{}; + typename ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueObjectHandle<&kRondpointStringifierPointerType>::FromRust( + mUniffiReturnValue = ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::FromRust( uniffi_uniffi_rondpoint_fn_constructor_stringifier_new( aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -9306,38 +9468,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiSpritesFnFuncTranslate : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueRustBuffer mP{}; - FfiValueRustBuffer mV{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingConverter::IntermediateType mP; + typename ScaffoldingConverter::IntermediateType mV; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mP.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingConverter::FromJs(aArgs[0], &mP, aError); if (aError.Failed()) { return; } - mV.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mV, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_sprites_fn_func_translate( - mP.IntoRust(), - mV.IntoRust(), + ScaffoldingConverter::IntoRust(std::move(mP)), + ScaffoldingConverter::IntoRust(std::move(mV)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -9345,32 +9508,33 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiSpritesFnMethodSpriteGetPosition : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kSpritesSpritePointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kSpritesSpritePointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kSpritesSpritePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_sprites_fn_method_sprite_get_position( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kSpritesSpritePointerType>::IntoRust(std::move(mPtr)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -9378,19 +9542,19 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiSpritesFnMethodSpriteMoveBy : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kSpritesSpritePointerType> mPtr{}; - FfiValueRustBuffer mDirection{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kSpritesSpritePointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mDirection; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kSpritesSpritePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mDirection.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mDirection, aError); if (aError.Failed()) { return; } @@ -9398,30 +9562,30 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_uniffi_sprites_fn_method_sprite_move_by( - mPtr.IntoRust(), - mDirection.IntoRust(), + ScaffoldingObjectConverter<&kSpritesSpritePointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mDirection)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiUniffiSpritesFnMethodSpriteMoveTo : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kSpritesSpritePointerType> mPtr{}; - FfiValueRustBuffer mPosition{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kSpritesSpritePointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mPosition; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kSpritesSpritePointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mPosition.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mPosition, aError); if (aError.Failed()) { return; } @@ -9429,43 +9593,44 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_uniffi_sprites_fn_method_sprite_move_to( - mPtr.IntoRust(), - mPosition.IntoRust(), + ScaffoldingObjectConverter<&kSpritesSpritePointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mPosition)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiUniffiSpritesFnConstructorSpriteNew : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueRustBuffer mInitialPosition{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingConverter::IntermediateType mInitialPosition; // MakeRustCall stores the result of the call in these fields - FfiValueObjectHandle<&kSpritesSpritePointerType> mUniffiReturnValue{}; + typename ScaffoldingObjectConverter<&kSpritesSpritePointerType>::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mInitialPosition.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingConverter::FromJs(aArgs[0], &mInitialPosition, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueObjectHandle<&kSpritesSpritePointerType>::FromRust( + mUniffiReturnValue = ScaffoldingObjectConverter<&kSpritesSpritePointerType>::FromRust( uniffi_uniffi_sprites_fn_constructor_sprite_new( - mInitialPosition.IntoRust(), + ScaffoldingConverter::IntoRust(std::move(mInitialPosition)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kSpritesSpritePointerType>::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -9473,38 +9638,39 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiSpritesFnConstructorSpriteNewRelativeTo : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueRustBuffer mReference{}; - FfiValueRustBuffer mDirection{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingConverter::IntermediateType mReference; + typename ScaffoldingConverter::IntermediateType mDirection; // MakeRustCall stores the result of the call in these fields - FfiValueObjectHandle<&kSpritesSpritePointerType> mUniffiReturnValue{}; + typename ScaffoldingObjectConverter<&kSpritesSpritePointerType>::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mReference.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingConverter::FromJs(aArgs[0], &mReference, aError); if (aError.Failed()) { return; } - mDirection.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mDirection, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueObjectHandle<&kSpritesSpritePointerType>::FromRust( + mUniffiReturnValue = ScaffoldingObjectConverter<&kSpritesSpritePointerType>::FromRust( uniffi_uniffi_sprites_fn_constructor_sprite_new_relative_to( - mReference.IntoRust(), - mDirection.IntoRust(), + ScaffoldingConverter::IntoRust(std::move(mReference)), + ScaffoldingConverter::IntoRust(std::move(mDirection)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kSpritesSpritePointerType>::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -9512,32 +9678,33 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiTodolistFnFuncCreateEntryWith : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueRustBuffer mTodo{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingConverter::IntermediateType mTodo; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mTodo.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingConverter::FromJs(aArgs[0], &mTodo, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_todolist_fn_func_create_entry_with( - mTodo.IntoRust(), + ScaffoldingConverter::IntoRust(std::move(mTodo)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -9545,26 +9712,27 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiTodolistFnFuncGetDefaultList : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields + // PrepareRustArgs stores the resulting arguments in these fields // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_todolist_fn_func_get_default_list( aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -9572,14 +9740,14 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiTodolistFnFuncSetDefaultList : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kTodolistTodoListPointerType> mList{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntermediateType mList; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mList.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::FromJs(aArgs[0], &mList, aError); if (aError.Failed()) { return; } @@ -9587,29 +9755,29 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_uniffi_todolist_fn_func_set_default_list( - mList.IntoRust(), + ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntoRust(std::move(mList)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiUniffiTodolistFnMethodTodolistAddEntries : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kTodolistTodoListPointerType> mPtr{}; - FfiValueRustBuffer mEntries{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mEntries; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mEntries.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mEntries, aError); if (aError.Failed()) { return; } @@ -9617,30 +9785,30 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_uniffi_todolist_fn_method_todolist_add_entries( - mPtr.IntoRust(), - mEntries.IntoRust(), + ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mEntries)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiUniffiTodolistFnMethodTodolistAddEntry : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kTodolistTodoListPointerType> mPtr{}; - FfiValueRustBuffer mEntry{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mEntry; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mEntry.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mEntry, aError); if (aError.Failed()) { return; } @@ -9648,30 +9816,30 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_uniffi_todolist_fn_method_todolist_add_entry( - mPtr.IntoRust(), - mEntry.IntoRust(), + ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mEntry)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiUniffiTodolistFnMethodTodolistAddItem : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kTodolistTodoListPointerType> mPtr{}; - FfiValueRustBuffer mTodo{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mTodo; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mTodo.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mTodo, aError); if (aError.Failed()) { return; } @@ -9679,30 +9847,30 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_uniffi_todolist_fn_method_todolist_add_item( - mPtr.IntoRust(), - mTodo.IntoRust(), + ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mTodo)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiUniffiTodolistFnMethodTodolistAddItems : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kTodolistTodoListPointerType> mPtr{}; - FfiValueRustBuffer mItems{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mItems; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mItems.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mItems, aError); if (aError.Failed()) { return; } @@ -9710,30 +9878,30 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_uniffi_todolist_fn_method_todolist_add_items( - mPtr.IntoRust(), - mItems.IntoRust(), + ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mItems)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiUniffiTodolistFnMethodTodolistClearItem : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kTodolistTodoListPointerType> mPtr{}; - FfiValueRustBuffer mTodo{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mTodo; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mTodo.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mTodo, aError); if (aError.Failed()) { return; } @@ -9741,43 +9909,44 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_uniffi_todolist_fn_method_todolist_clear_item( - mPtr.IntoRust(), - mTodo.IntoRust(), + ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mTodo)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiUniffiTodolistFnMethodTodolistGetEntries : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kTodolistTodoListPointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_todolist_fn_method_todolist_get_entries( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntoRust(std::move(mPtr)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -9785,32 +9954,33 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiTodolistFnMethodTodolistGetFirst : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kTodolistTodoListPointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_todolist_fn_method_todolist_get_first( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntoRust(std::move(mPtr)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -9818,32 +9988,33 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiTodolistFnMethodTodolistGetItems : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kTodolistTodoListPointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_todolist_fn_method_todolist_get_items( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntoRust(std::move(mPtr)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -9851,32 +10022,33 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiTodolistFnMethodTodolistGetLast : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kTodolistTodoListPointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_todolist_fn_method_todolist_get_last( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntoRust(std::move(mPtr)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -9884,32 +10056,33 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiTodolistFnMethodTodolistGetLastEntry : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kTodolistTodoListPointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields - FfiValueRustBuffer mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueRustBuffer::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_todolist_fn_method_todolist_get_last_entry( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntoRust(std::move(mPtr)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -9917,14 +10090,14 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiTodolistFnMethodTodolistMakeDefault : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kTodolistTodoListPointerType> mPtr{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntermediateType mPtr; // MakeRustCall stores the result of the call in these fields public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } @@ -9932,36 +10105,37 @@ public: void MakeRustCall(RustCallStatus* aOutStatus) override { uniffi_uniffi_todolist_fn_method_todolist_make_default( - mPtr.IntoRust(), + ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntoRust(std::move(mPtr)), aOutStatus ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { } }; class ScaffoldingCallHandlerUniffiUniffiTodolistFnConstructorTodolistNew : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields + // PrepareRustArgs stores the resulting arguments in these fields // MakeRustCall stores the result of the call in these fields - FfiValueObjectHandle<&kTodolistTodoListPointerType> mUniffiReturnValue{}; + typename ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueObjectHandle<&kTodolistTodoListPointerType>::FromRust( + mUniffiReturnValue = ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::FromRust( uniffi_uniffi_todolist_fn_constructor_todolist_new( aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -9969,26 +10143,27 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiTraitInterfacesFnFuncMakeBuggyCalculator : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields + // PrepareRustArgs stores the resulting arguments in these fields // MakeRustCall stores the result of the call in these fields - FfiValueObjectHandle<&kUniffiTraitInterfacesCalcPointerType> mUniffiReturnValue{}; + typename ScaffoldingObjectConverter<&kUniffiTraitInterfacesCalcPointerType>::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueObjectHandle<&kUniffiTraitInterfacesCalcPointerType>::FromRust( + mUniffiReturnValue = ScaffoldingObjectConverter<&kUniffiTraitInterfacesCalcPointerType>::FromRust( uniffi_uniffi_trait_interfaces_fn_func_make_buggy_calculator( aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kUniffiTraitInterfacesCalcPointerType>::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -9996,26 +10171,27 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiTraitInterfacesFnFuncMakeCalculator : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields + // PrepareRustArgs stores the resulting arguments in these fields // MakeRustCall stores the result of the call in these fields - FfiValueObjectHandle<&kUniffiTraitInterfacesCalcPointerType> mUniffiReturnValue{}; + typename ScaffoldingObjectConverter<&kUniffiTraitInterfacesCalcPointerType>::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueObjectHandle<&kUniffiTraitInterfacesCalcPointerType>::FromRust( + mUniffiReturnValue = ScaffoldingObjectConverter<&kUniffiTraitInterfacesCalcPointerType>::FromRust( uniffi_uniffi_trait_interfaces_fn_func_make_calculator( aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kUniffiTraitInterfacesCalcPointerType>::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); @@ -10023,44 +10199,45 @@ public: }; class ScaffoldingCallHandlerUniffiUniffiTraitInterfacesFnMethodCalcAdd : public UniffiSyncCallHandler { private: - // LowerRustArgs stores the resulting arguments in these fields - FfiValueObjectHandle<&kUniffiTraitInterfacesCalcPointerType> mPtr{}; - FfiValueInt mA{}; - FfiValueInt mB{}; + // PrepareRustArgs stores the resulting arguments in these fields + typename ScaffoldingObjectConverter<&kUniffiTraitInterfacesCalcPointerType>::IntermediateType mPtr; + typename ScaffoldingConverter::IntermediateType mA; + typename ScaffoldingConverter::IntermediateType mB; // MakeRustCall stores the result of the call in these fields - FfiValueInt mUniffiReturnValue{}; + typename ScaffoldingConverter::IntermediateType mUniffiReturnValue; public: - void LowerRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { - mPtr.Lower(aArgs[0], aError); + void PrepareRustArgs(const dom::Sequence& aArgs, ErrorResult& aError) override { + ScaffoldingObjectConverter<&kUniffiTraitInterfacesCalcPointerType>::FromJs(aArgs[0], &mPtr, aError); if (aError.Failed()) { return; } - mA.Lower(aArgs[1], aError); + ScaffoldingConverter::FromJs(aArgs[1], &mA, aError); if (aError.Failed()) { return; } - mB.Lower(aArgs[2], aError); + ScaffoldingConverter::FromJs(aArgs[2], &mB, aError); if (aError.Failed()) { return; } } void MakeRustCall(RustCallStatus* aOutStatus) override { - mUniffiReturnValue = FfiValueInt::FromRust( + mUniffiReturnValue = ScaffoldingConverter::FromRust( uniffi_uniffi_trait_interfaces_fn_method_calc_add( - mPtr.IntoRust(), - mA.IntoRust(), - mB.IntoRust(), + ScaffoldingObjectConverter<&kUniffiTraitInterfacesCalcPointerType>::IntoRust(std::move(mPtr)), + ScaffoldingConverter::IntoRust(std::move(mA)), + ScaffoldingConverter::IntoRust(std::move(mB)), aOutStatus ) ); } - virtual void LiftSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { - mUniffiReturnValue.Lift( + virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional& aDest, ErrorResult& aError) override { + ScaffoldingConverter::IntoJs( aCx, + std::move(mUniffiReturnValue), &aDest.Construct(), aError ); diff --git a/toolkit/components/uniffi-js/UniFFIPointer.cpp b/toolkit/components/uniffi-js/UniFFIPointer.cpp index f772b85f9257..cb5342eb4086 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/UniFFIBinding.h" #include "mozilla/dom/UniFFIPointer.h" -#include "mozilla/uniffi/Rust.h" +#include "mozilla/dom/UniFFIBinding.h" +#include "mozilla/Logging.h" +#include "UniFFIRust.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 40aa72a0a032..24a7b80eedf2 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/uniffi/PointerType.h" +#include "mozilla/dom/UniFFIPointerType.h" namespace mozilla::dom { diff --git a/toolkit/components/uniffi-js/PointerType.h b/toolkit/components/uniffi-js/UniFFIPointerType.h similarity index 96% rename from toolkit/components/uniffi-js/PointerType.h rename to toolkit/components/uniffi-js/UniFFIPointerType.h index f997cdb6e29c..25294cfc9de1 100644 --- a/toolkit/components/uniffi-js/PointerType.h +++ b/toolkit/components/uniffi-js/UniFFIPointerType.h @@ -10,7 +10,7 @@ #include "nsISupports.h" #include "nsWrapperCache.h" #include "nsLiteralString.h" -#include "mozilla/uniffi/Rust.h" +#include "UniFFIRust.h" namespace mozilla::uniffi { diff --git a/toolkit/components/uniffi-js/Rust.h b/toolkit/components/uniffi-js/UniFFIRust.h similarity index 100% rename from toolkit/components/uniffi-js/Rust.h rename to toolkit/components/uniffi-js/UniFFIRust.h diff --git a/toolkit/components/uniffi-js/UniFFIScaffolding.cpp b/toolkit/components/uniffi-js/UniFFIScaffolding.cpp index b90e7727641f..9129b6ea62db 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/dom/UniFFIScaffolding.h" -#include "mozilla/uniffi/Call.h" -#include "mozilla/uniffi/Callbacks.h" // This file implements the UniFFI WebIDL interface by leveraging the generate -// 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. +// 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. 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 GeneratedScaffolding.cpp +// Implemented in UniFFIGeneratedScaffolding.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 8334b1d63db2..a1c0d9e197f5 100644 --- a/toolkit/components/uniffi-js/moz.build +++ b/toolkit/components/uniffi-js/moz.build @@ -7,11 +7,10 @@ FINAL_LIBRARY = "xul" UNIFIED_SOURCES += [ - "Call.cpp", - "Callbacks.cpp", - "GeneratedScaffolding.cpp", "OwnedRustBuffer.cpp", - "ResultPromise.cpp", + "UniFFICall.cpp", + "UniFFICallbacks.cpp", + "UniFFIGeneratedScaffolding.cpp", "UniFFIPointer.cpp", "UniFFIScaffolding.cpp", ] @@ -20,18 +19,14 @@ if CONFIG["MOZ_UNIFFI_FIXTURES"]: DEFINES["MOZ_UNIFFI_FIXTURES"] = True EXPORTS.mozilla.dom += [ - "UniFFIPointer.h", - "UniFFIScaffolding.h", -] - -EXPORTS.mozilla.uniffi += [ - "Call.h", - "Callbacks.h", - "FfiValue.h", "OwnedRustBuffer.h", - "PointerType.h", - "ResultPromise.h", - "Rust.h", + "ScaffoldingConverter.h", + "UniFFICall.h", + "UniFFICallbacks.h", + "UniFFIPointer.h", + "UniFFIPointerType.h", + "UniFFIRust.h", + "UniFFIScaffolding.h", ] EXTRA_JS_MODULES += [ diff --git a/tools/rewriting/Generated.txt b/tools/rewriting/Generated.txt index 4621649703df..3ec15688f6eb 100644 --- a/tools/rewriting/Generated.txt +++ b/tools/rewriting/Generated.txt @@ -215,7 +215,8 @@ 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/GeneratedScaffolding.cpp +toolkit/components/uniffi-js/UniFFIGeneratedScaffolding.cpp +toolkit/components/uniffi-js/UniFFIFixtureScaffolding.cpp toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated tools/@types/tspaths.json tools/browsertime/package.json