diff options
author | Patrick J Volkerding <volkerdi@slackware.com> | 2022-12-16 04:46:51 +0000 |
---|---|---|
committer | Eric Hameleers <alien@slackware.com> | 2022-12-16 06:38:01 +0100 |
commit | 7852409378db9d911b949481c914726d20a97408 (patch) | |
tree | 8ae38346ec10f5a9a082dc13140dda93d05cdcc4 /source | |
parent | fc0ff5a5d7c45f929eb214b3147aa538e736e2aa (diff) | |
download | current-7852409378db9d911b949481c914726d20a97408.tar.gz current-7852409378db9d911b949481c914726d20a97408.tar.xz |
Fri Dec 16 04:46:51 UTC 202220221216044651
d/help2man-1.49.3-x86_64-1.txz: Upgraded.
l/pipewire-0.3.63-x86_64-1.txz: Upgraded.
x/libX11-1.8.3-x86_64-1.txz: Upgraded.
x/mesa-22.3.1-x86_64-1.txz: Upgraded.
xap/mozilla-firefox-108.0-x86_64-1.txz: Upgraded.
This update contains security fixes and improvements.
Thanks to marav for the build help.
For more information, see:
https://www.mozilla.org/en-US/firefox/108.0/releasenotes/
https://www.mozilla.org/en-US/security/advisories/mfsa2022-51/
https://www.cve.org/CVERecord?id=CVE-2022-46871
https://www.cve.org/CVERecord?id=CVE-2022-46872
https://www.cve.org/CVERecord?id=CVE-2022-46873
https://www.cve.org/CVERecord?id=CVE-2022-46874
https://www.cve.org/CVERecord?id=CVE-2022-46875
https://www.cve.org/CVERecord?id=CVE-2022-46877
https://www.cve.org/CVERecord?id=CVE-2022-46878
https://www.cve.org/CVERecord?id=CVE-2022-46879
(* Security fix *)
Diffstat (limited to 'source')
4 files changed, 3584 insertions, 41 deletions
diff --git a/source/xap/mozilla-firefox/8f889cf198ae7ffa9341423cb5a07ed39c07463a.patch b/source/xap/mozilla-firefox/8f889cf198ae7ffa9341423cb5a07ed39c07463a.patch new file mode 100644 index 000000000..89e7c12b8 --- /dev/null +++ b/source/xap/mozilla-firefox/8f889cf198ae7ffa9341423cb5a07ed39c07463a.patch @@ -0,0 +1,801 @@ +From 8f889cf198ae7ffa9341423cb5a07ed39c07463a Mon Sep 17 00:00:00 2001 +From: Mike Hommey <mh@glandium.org> +Date: Thu, 15 Dec 2022 16:36:52 +0900 +Subject: [PATCH] Replace the use of Hash with a custom trait + +The custom trait is expected to consistently give the result that Hash +gives on 64-bits little-endian, but on all platforms +--- + uniffi_bindgen/src/interface/attributes.rs | 19 ++-- + uniffi_bindgen/src/interface/callbacks.rs | 11 +- + uniffi_bindgen/src/interface/enum_.rs | 5 +- + uniffi_bindgen/src/interface/error.rs | 3 +- + uniffi_bindgen/src/interface/function.rs | 17 ++-- + uniffi_bindgen/src/interface/literal.rs | 11 +- + uniffi_bindgen/src/interface/mod.rs | 28 +++--- + uniffi_bindgen/src/interface/object.rs | 37 +++---- + uniffi_bindgen/src/interface/record.rs | 5 +- + uniffi_bindgen/src/interface/types/mod.rs | 3 +- + uniffi_checksum_derive/Cargo.toml | 22 ++++ + uniffi_checksum_derive/src/lib.rs | 111 +++++++++++++++++++++ + uniffi_meta/Cargo.toml | 1 + + uniffi_meta/src/lib.rs | 89 +++++++++++++++-- + 14 files changed, 288 insertions(+), 74 deletions(-) + create mode 100644 uniffi_checksum_derive/Cargo.toml + create mode 100644 uniffi_checksum_derive/src/lib.rs + +diff --git a/uniffi_bindgen/src/interface/attributes.rs b/uniffi_bindgen/src/interface/attributes.rs +index 49b885520..3c9bd522b 100644 +--- a/uniffi_bindgen/src/interface/attributes.rs ++++ b/uniffi_bindgen/src/interface/attributes.rs +@@ -15,13 +15,14 @@ + //! if we grow significantly more complicated attribute handling. + + use anyhow::{bail, Result}; ++use uniffi_meta::Checksum; + + /// Represents an attribute parsed from UDL, like `[ByRef]` or `[Throws]`. + /// + /// This is a convenience enum for parsing UDL attributes and erroring out if we encounter + /// any unsupported ones. These don't convert directly into parts of a `ComponentInterface`, but + /// may influence the properties of things like functions and arguments. +-#[derive(Debug, Clone, Hash)] ++#[derive(Debug, Clone, Checksum)] + pub(super) enum Attribute { + ByRef, + Enum, +@@ -119,7 +120,7 @@ where + + /// Attributes that can be attached to an `enum` definition in the UDL. + /// There's only one case here: using `[Error]` to mark an enum as an error class. +-#[derive(Debug, Clone, Hash, Default)] ++#[derive(Debug, Clone, Checksum, Default)] + pub(super) struct EnumAttributes(Vec<Attribute>); + + impl EnumAttributes { +@@ -155,7 +156,7 @@ impl<T: TryInto<EnumAttributes, Error = anyhow::Error>> TryFrom<Option<T>> for E + /// + /// This supports the `[Throws=ErrorName]` attribute for functions that + /// can produce an error. +-#[derive(Debug, Clone, Hash, Default)] ++#[derive(Debug, Clone, Checksum, Default)] + pub(super) struct FunctionAttributes(Vec<Attribute>); + + impl FunctionAttributes { +@@ -198,7 +199,7 @@ impl<T: TryInto<FunctionAttributes, Error = anyhow::Error>> TryFrom<Option<T>> + /// + /// This supports the `[ByRef]` attribute for arguments that should be passed + /// by reference in the generated Rust scaffolding. +-#[derive(Debug, Clone, Hash, Default)] ++#[derive(Debug, Clone, Checksum, Default)] + pub(super) struct ArgumentAttributes(Vec<Attribute>); + + impl ArgumentAttributes { +@@ -233,7 +234,7 @@ impl<T: TryInto<ArgumentAttributes, Error = anyhow::Error>> TryFrom<Option<T>> + } + + /// Represents UDL attributes that might appear on an `interface` definition. +-#[derive(Debug, Clone, Hash, Default)] ++#[derive(Debug, Clone, Checksum, Default)] + pub(super) struct InterfaceAttributes(Vec<Attribute>); + + impl InterfaceAttributes { +@@ -287,7 +288,7 @@ impl<T: TryInto<InterfaceAttributes, Error = anyhow::Error>> TryFrom<Option<T>> + /// + /// This supports the `[Throws=ErrorName]` attribute for constructors that can produce + /// an error, and the `[Name=MethodName]` for non-default constructors. +-#[derive(Debug, Clone, Hash, Default)] ++#[derive(Debug, Clone, Checksum, Default)] + pub(super) struct ConstructorAttributes(Vec<Attribute>); + + impl ConstructorAttributes { +@@ -326,7 +327,7 @@ impl TryFrom<&weedle::attribute::ExtendedAttributeList<'_>> for ConstructorAttri + /// + /// This supports the `[Throws=ErrorName]` attribute for methods that can produce + /// an error, and the `[Self=ByArc]` attribute for methods that take `Arc<Self>` as receiver. +-#[derive(Debug, Clone, Hash, Default)] ++#[derive(Debug, Clone, Checksum, Default)] + pub(super) struct MethodAttributes(Vec<Attribute>); + + impl MethodAttributes { +@@ -375,7 +376,7 @@ impl<T: TryInto<MethodAttributes, Error = anyhow::Error>> TryFrom<Option<T>> for + /// Actually we only support one of these right now, `[Self=ByArc]`. + /// We might add more in future, e.g. a `[Self=ByRef]` if there are cases + /// where we need to force the receiver to be taken by reference. +-#[derive(Debug, Clone, Hash)] ++#[derive(Debug, Clone, Checksum)] + pub(super) enum SelfType { + ByArc, // Method receiver is `Arc<Self>`. + } +@@ -398,7 +399,7 @@ impl TryFrom<&weedle::attribute::IdentifierOrString<'_>> for SelfType { + /// Represents UDL attributes that might appear on a typedef + /// + /// This supports the `[External="crate_name"]` and `[Custom]` attributes for types. +-#[derive(Debug, Clone, Hash, Default)] ++#[derive(Debug, Clone, Checksum, Default)] + pub(super) struct TypedefAttributes(Vec<Attribute>); + + impl TypedefAttributes { +diff --git a/uniffi_bindgen/src/interface/callbacks.rs b/uniffi_bindgen/src/interface/callbacks.rs +index 654652afe..886f02b29 100644 +--- a/uniffi_bindgen/src/interface/callbacks.rs ++++ b/uniffi_bindgen/src/interface/callbacks.rs +@@ -33,9 +33,10 @@ + //! # Ok::<(), anyhow::Error>(()) + //! ``` + +-use std::hash::{Hash, Hasher}; ++use std::hash::Hasher; + + use anyhow::{bail, Result}; ++use uniffi_meta::Checksum; + + use super::ffi::{FFIArgument, FFIFunction, FFIType}; + use super::object::Method; +@@ -88,16 +89,16 @@ impl CallbackInterface { + } + } + +-impl Hash for CallbackInterface { +- fn hash<H: Hasher>(&self, state: &mut H) { ++impl Checksum for CallbackInterface { ++ fn checksum<H: Hasher>(&self, state: &mut H) { + // We don't include the FFIFunc in the hash calculation, because: + // - it is entirely determined by the other fields, + // so excluding it is safe. + // - its `name` property includes a checksum derived from the very + // hash value we're trying to calculate here, so excluding it + // avoids a weird circular depenendency in the calculation. +- self.name.hash(state); +- self.methods.hash(state); ++ self.name.checksum(state); ++ self.methods.checksum(state); + } + } + +diff --git a/uniffi_bindgen/src/interface/enum_.rs b/uniffi_bindgen/src/interface/enum_.rs +index 04eba0d25..b8fe0ddd7 100644 +--- a/uniffi_bindgen/src/interface/enum_.rs ++++ b/uniffi_bindgen/src/interface/enum_.rs +@@ -77,6 +77,7 @@ + //! ``` + + use anyhow::{bail, Result}; ++use uniffi_meta::Checksum; + + use super::record::Field; + use super::types::{Type, TypeIterator}; +@@ -87,7 +88,7 @@ use super::{APIConverter, ComponentInterface}; + /// + /// Enums are passed across the FFI by serializing to a bytebuffer, with a + /// i32 indicating the variant followed by the serialization of each field. +-#[derive(Debug, Clone, Hash)] ++#[derive(Debug, Clone, Checksum)] + pub struct Enum { + pub(super) name: String, + pub(super) variants: Vec<Variant>, +@@ -174,7 +175,7 @@ impl APIConverter<Enum> for weedle::InterfaceDefinition<'_> { + /// Represents an individual variant in an Enum. + /// + /// Each variant has a name and zero or more fields. +-#[derive(Debug, Clone, Default, Hash)] ++#[derive(Debug, Clone, Default, Checksum)] + pub struct Variant { + pub(super) name: String, + pub(super) fields: Vec<Field>, +diff --git a/uniffi_bindgen/src/interface/error.rs b/uniffi_bindgen/src/interface/error.rs +index 7e9b571a1..adae769f0 100644 +--- a/uniffi_bindgen/src/interface/error.rs ++++ b/uniffi_bindgen/src/interface/error.rs +@@ -83,6 +83,7 @@ + //! ``` + + use anyhow::Result; ++use uniffi_meta::Checksum; + + use super::enum_::{Enum, Variant}; + use super::types::{Type, TypeIterator}; +@@ -94,7 +95,7 @@ use super::{APIConverter, ComponentInterface}; + /// they're handled in the FFI very differently. We create them in `uniffi::call_with_result()` if + /// the wrapped function returns an `Err` value + /// struct and assign an integer error code to each variant. +-#[derive(Debug, Clone, Hash)] ++#[derive(Debug, Clone, Checksum)] + pub struct Error { + pub name: String, + enum_: Enum, +diff --git a/uniffi_bindgen/src/interface/function.rs b/uniffi_bindgen/src/interface/function.rs +index 4eff0795c..869c1b59b 100644 +--- a/uniffi_bindgen/src/interface/function.rs ++++ b/uniffi_bindgen/src/interface/function.rs +@@ -32,9 +32,10 @@ + //! # Ok::<(), anyhow::Error>(()) + //! ``` + use std::convert::TryFrom; +-use std::hash::{Hash, Hasher}; ++use std::hash::Hasher; + + use anyhow::{bail, Result}; ++use uniffi_meta::Checksum; + + use super::ffi::{FFIArgument, FFIFunction}; + use super::literal::{convert_default_value, Literal}; +@@ -142,18 +143,18 @@ impl From<uniffi_meta::FnMetadata> for Function { + } + } + +-impl Hash for Function { +- fn hash<H: Hasher>(&self, state: &mut H) { ++impl Checksum for Function { ++ fn checksum<H: Hasher>(&self, state: &mut H) { + // We don't include the FFIFunc in the hash calculation, because: + // - it is entirely determined by the other fields, + // so excluding it is safe. + // - its `name` property includes a checksum derived from the very + // hash value we're trying to calculate here, so excluding it + // avoids a weird circular depenendency in the calculation. +- self.name.hash(state); +- self.arguments.hash(state); +- self.return_type.hash(state); +- self.attributes.hash(state); ++ self.name.checksum(state); ++ self.arguments.checksum(state); ++ self.return_type.checksum(state); ++ self.attributes.checksum(state); + } + } + +@@ -185,7 +186,7 @@ impl APIConverter<Function> for weedle::namespace::OperationNamespaceMember<'_> + /// Represents an argument to a function/constructor/method call. + /// + /// Each argument has a name and a type, along with some optional metadata. +-#[derive(Debug, Clone, Hash)] ++#[derive(Debug, Clone, Checksum)] + pub struct Argument { + pub(super) name: String, + pub(super) type_: Type, +diff --git a/uniffi_bindgen/src/interface/literal.rs b/uniffi_bindgen/src/interface/literal.rs +index 8b333c614..1aa1c8785 100644 +--- a/uniffi_bindgen/src/interface/literal.rs ++++ b/uniffi_bindgen/src/interface/literal.rs +@@ -8,12 +8,13 @@ + //! which appear in places such as default arguments. + + use anyhow::{bail, Result}; ++use uniffi_meta::Checksum; + + use super::types::Type; + + // Represents a literal value. + // Used for e.g. default argument values. +-#[derive(Debug, Clone, Hash)] ++#[derive(Debug, Clone, Checksum)] + pub enum Literal { + Boolean(bool), + String(String), +@@ -35,13 +36,19 @@ pub enum Literal { + + // Represent the radix of integer literal values. + // We preserve the radix into the generated bindings for readability reasons. +-#[derive(Debug, Clone, Copy, Hash)] ++#[derive(Debug, Clone, Copy)] + pub enum Radix { + Decimal = 10, + Octal = 8, + Hexadecimal = 16, + } + ++impl Checksum for Radix { ++ fn checksum<H: ::core::hash::Hasher>(&self, state: &mut H) { ++ state.write(&(*self as u64).to_le_bytes()); ++ } ++} ++ + pub(super) fn convert_default_value( + default_value: &weedle::literal::DefaultValue<'_>, + type_: &Type, +diff --git a/uniffi_bindgen/src/interface/mod.rs b/uniffi_bindgen/src/interface/mod.rs +index 9aa92e9b0..eb40ea3fd 100644 +--- a/uniffi_bindgen/src/interface/mod.rs ++++ b/uniffi_bindgen/src/interface/mod.rs +@@ -47,7 +47,7 @@ + use std::{ + collections::HashSet, + convert::TryFrom, +- hash::{Hash, Hasher}, ++ hash::Hasher, + iter, + }; + +@@ -77,7 +77,7 @@ pub use record::{Field, Record}; + + pub mod ffi; + pub use ffi::{FFIArgument, FFIFunction, FFIType}; +-use uniffi_meta::{MethodMetadata, ObjectMetadata}; ++use uniffi_meta::{Checksum, MethodMetadata, ObjectMetadata}; + + /// The main public interface for this module, representing the complete details of an interface exposed + /// by a rust component and the details of consuming it via an extern-C FFI layer. +@@ -672,20 +672,16 @@ impl ComponentInterface { + } + } + +-/// `ComponentInterface` structs can be hashed, but this is mostly a convenient way to +-/// produce a checksum of their contents. They're not really intended to live in a hashtable. +-impl Hash for ComponentInterface { +- fn hash<H: Hasher>(&self, state: &mut H) { +- // We can't hash `self.types`, but its contents are implied by the other fields +- // anyway, so it's safe to ignore it. +- self.uniffi_version.hash(state); +- self.namespace.hash(state); +- self.enums.hash(state); +- self.records.hash(state); +- self.functions.hash(state); +- self.objects.hash(state); +- self.callback_interfaces.hash(state); +- self.errors.hash(state); ++impl Checksum for ComponentInterface { ++ fn checksum<H: Hasher>(&self, state: &mut H) { ++ Checksum::checksum(&self.uniffi_version, state); ++ Checksum::checksum(&self.namespace, state); ++ Checksum::checksum(&self.enums, state); ++ Checksum::checksum(&self.records, state); ++ Checksum::checksum(&self.functions, state); ++ Checksum::checksum(&self.objects, state); ++ Checksum::checksum(&self.callback_interfaces, state); ++ Checksum::checksum(&self.errors, state); + } + } + +diff --git a/uniffi_bindgen/src/interface/object.rs b/uniffi_bindgen/src/interface/object.rs +index e366123b5..3bd6bfabe 100644 +--- a/uniffi_bindgen/src/interface/object.rs ++++ b/uniffi_bindgen/src/interface/object.rs +@@ -58,10 +58,11 @@ + //! ``` + + use std::convert::TryFrom; +-use std::hash::{Hash, Hasher}; ++use std::hash::Hasher; + use std::{collections::HashSet, iter}; + + use anyhow::{bail, Result}; ++use uniffi_meta::Checksum; + + use super::ffi::{FFIArgument, FFIFunction, FFIType}; + use super::function::Argument; +@@ -190,17 +191,17 @@ impl Object { + } + } + +-impl Hash for Object { +- fn hash<H: Hasher>(&self, state: &mut H) { ++impl Checksum for Object { ++ fn checksum<H: Hasher>(&self, state: &mut H) { + // We don't include the FFIFunc in the hash calculation, because: + // - it is entirely determined by the other fields, + // so excluding it is safe. + // - its `name` property includes a checksum derived from the very + // hash value we're trying to calculate here, so excluding it + // avoids a weird circular depenendency in the calculation. +- self.name.hash(state); +- self.constructors.hash(state); +- self.methods.hash(state); ++ self.name.checksum(state); ++ self.constructors.checksum(state); ++ self.methods.checksum(state); + } + } + +@@ -299,17 +300,17 @@ impl Constructor { + } + } + +-impl Hash for Constructor { +- fn hash<H: Hasher>(&self, state: &mut H) { ++impl Checksum for Constructor { ++ fn checksum<H: Hasher>(&self, state: &mut H) { + // We don't include the FFIFunc in the hash calculation, because: + // - it is entirely determined by the other fields, + // so excluding it is safe. + // - its `name` property includes a checksum derived from the very + // hash value we're trying to calculate here, so excluding it + // avoids a weird circular depenendency in the calculation. +- self.name.hash(state); +- self.arguments.hash(state); +- self.attributes.hash(state); ++ self.name.checksum(state); ++ self.arguments.checksum(state); ++ self.attributes.checksum(state); + } + } + +@@ -450,19 +451,19 @@ impl From<uniffi_meta::MethodMetadata> for Method { + } + } + +-impl Hash for Method { +- fn hash<H: Hasher>(&self, state: &mut H) { ++impl Checksum for Method { ++ fn checksum<H: Hasher>(&self, state: &mut H) { + // We don't include the FFIFunc in the hash calculation, because: + // - it is entirely determined by the other fields, + // so excluding it is safe. + // - its `name` property includes a checksum derived from the very + // hash value we're trying to calculate here, so excluding it + // avoids a weird circular depenendency in the calculation. +- self.name.hash(state); +- self.object_name.hash(state); +- self.arguments.hash(state); +- self.return_type.hash(state); +- self.attributes.hash(state); ++ self.name.checksum(state); ++ self.object_name.checksum(state); ++ self.arguments.checksum(state); ++ self.return_type.checksum(state); ++ self.attributes.checksum(state); + } + } + +diff --git a/uniffi_bindgen/src/interface/record.rs b/uniffi_bindgen/src/interface/record.rs +index c55200eb1..dd6a48e2c 100644 +--- a/uniffi_bindgen/src/interface/record.rs ++++ b/uniffi_bindgen/src/interface/record.rs +@@ -45,6 +45,7 @@ + //! ``` + + use anyhow::{bail, Result}; ++use uniffi_meta::Checksum; + + use super::types::{Type, TypeIterator}; + use super::{ +@@ -58,7 +59,7 @@ use super::{APIConverter, ComponentInterface}; + /// In the FFI these are represented as a byte buffer, which one side explicitly + /// serializes the data into and the other serializes it out of. So I guess they're + /// kind of like "pass by clone" values. +-#[derive(Debug, Clone, Hash)] ++#[derive(Debug, Clone, Checksum)] + pub struct Record { + pub(super) name: String, + pub(super) fields: Vec<Field>, +@@ -109,7 +110,7 @@ impl APIConverter<Record> for weedle::DictionaryDefinition<'_> { + } + + // Represents an individual field on a Record. +-#[derive(Debug, Clone, Hash)] ++#[derive(Debug, Clone, Checksum)] + pub struct Field { + pub(super) name: String, + pub(super) type_: Type, +diff --git a/uniffi_bindgen/src/interface/types/mod.rs b/uniffi_bindgen/src/interface/types/mod.rs +index 8a0131c9f..65426926f 100644 +--- a/uniffi_bindgen/src/interface/types/mod.rs ++++ b/uniffi_bindgen/src/interface/types/mod.rs +@@ -25,6 +25,7 @@ use std::{collections::hash_map::Entry, collections::BTreeSet, collections::Hash + + use anyhow::{bail, Result}; + use heck::ToUpperCamelCase; ++use uniffi_meta::Checksum; + + use super::ffi::FFIType; + +@@ -36,7 +37,7 @@ pub(super) use resolver::{resolve_builtin_type, TypeResolver}; + /// Represents all the different high-level types that can be used in a component interface. + /// At this level we identify user-defined types by name, without knowing any details + /// of their internal structure apart from what type of thing they are (record, enum, etc). +-#[derive(Debug, Clone, Eq, PartialEq, Hash, Ord, PartialOrd)] ++#[derive(Debug, Clone, Eq, PartialEq, Checksum, Ord, PartialOrd)] + pub enum Type { + // Primitive types. + UInt8, +diff --git a/uniffi_checksum_derive/Cargo.toml b/uniffi_checksum_derive/Cargo.toml +new file mode 100644 +index 000000000..a04c31aab +--- /dev/null ++++ b/uniffi_checksum_derive/Cargo.toml +@@ -0,0 +1,22 @@ ++[package] ++name = "uniffi_checksum_derive" ++version = "0.21.0" ++authors = ["Firefox Sync Team <sync-team@mozilla.com>"] ++description = "a multi-language bindings generator for rust (checksum custom derive)" ++documentation = "https://mozilla.github.io/uniffi-rs" ++homepage = "https://mozilla.github.io/uniffi-rs" ++repository = "https://github.com/mozilla/uniffi-rs" ++license = "MPL-2.0" ++edition = "2021" ++keywords = ["ffi", "bindgen"] ++ ++[lib] ++proc-macro = true ++ ++[dependencies] ++quote = "1.0" ++syn = { version = "1.0", features = ["derive"] } ++ ++[features] ++default = [] ++nightly = [] +diff --git a/uniffi_checksum_derive/src/lib.rs b/uniffi_checksum_derive/src/lib.rs +new file mode 100644 +index 000000000..c79064d8b +--- /dev/null ++++ b/uniffi_checksum_derive/src/lib.rs +@@ -0,0 +1,111 @@ ++/* 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/. */ ++#![cfg_attr(feature = "nightly", feature(proc_macro_expand))] ++ ++//! Custom derive for uniffi_meta::Checksum ++ ++use proc_macro::TokenStream; ++use quote::{format_ident, quote}; ++use syn::{parse_macro_input, Data, DeriveInput, Fields, Index}; ++ ++#[proc_macro_derive(Checksum)] ++pub fn checksum_derive(input: TokenStream) -> TokenStream { ++ let input: DeriveInput = parse_macro_input!(input); ++ ++ let name = input.ident; ++ ++ let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl(); ++ ++ let code = match input.data { ++ Data::Enum(enum_) ++ if enum_.variants.len() == 1 ++ && enum_ ++ .variants ++ .iter() ++ .all(|variant| matches!(variant.fields, Fields::Unit)) => ++ { ++ quote!() ++ } ++ Data::Enum(enum_) => { ++ let match_inner = enum_.variants.iter().enumerate().map(|(num, variant)| { ++ let num = num as u64; ++ let ident = &variant.ident; ++ if variant.discriminant.is_some() { ++ panic!("#[derive(Checksum)] doesn't support explicit discriminants in enums"); ++ } ++ let discriminant = quote! { state.write(&#num.to_le_bytes()) }; ++ match &variant.fields { ++ Fields::Unnamed(fields) => { ++ let field_idents = fields ++ .unnamed ++ .iter() ++ .enumerate() ++ .map(|(num, _)| format_ident!("__self_{}", num)) ++ .collect::<Vec<_>>(); ++ let field_stmts = field_idents ++ .iter() ++ .map(|ident| quote! { Checksum::checksum(#ident, state); }); ++ quote! { ++ Self::#ident(#(#field_idents,)*) => { ++ #discriminant; ++ #(#field_stmts)* ++ } ++ } ++ } ++ Fields::Named(fields) => { ++ let field_idents = fields ++ .named ++ .iter() ++ .map(|field| field.ident.as_ref().unwrap()) ++ .collect::<Vec<_>>(); ++ let field_stmts = field_idents ++ .iter() ++ .map(|ident| quote! { Checksum::checksum(#ident, state); }); ++ quote! { ++ Self::#ident { #(#field_idents,)* } => { ++ #discriminant; ++ #(#field_stmts)* ++ } ++ } ++ } ++ Fields::Unit => quote! { Self::#ident => #discriminant, }, ++ } ++ }); ++ quote! { ++ match self { ++ #(#match_inner)* ++ } ++ } ++ } ++ Data::Struct(struct_) => { ++ let stmts = ++ struct_ ++ .fields ++ .iter() ++ .enumerate() ++ .map(|(num, field)| match field.ident.as_ref() { ++ Some(ident) => quote! { Checksum::checksum(&self.#ident, state); }, ++ None => { ++ let i = Index::from(num); ++ quote! { Checksum::checksum(&self.#i, state); } ++ } ++ }); ++ quote! { ++ #(#stmts)* ++ } ++ } ++ Data::Union(_) => { ++ panic!("#[derive(Checksum)] is not supported for unions"); ++ } ++ }; ++ ++ quote! { ++ impl #impl_generics Checksum for #name #ty_generics #where_clause { ++ fn checksum<__H: ::core::hash::Hasher>(&self, state: &mut __H) { ++ #code ++ } ++ } ++ } ++ .into() ++} +diff --git a/uniffi_meta/Cargo.toml b/uniffi_meta/Cargo.toml +index ca33156df..358b6ef4c 100644 +--- a/uniffi_meta/Cargo.toml ++++ b/uniffi_meta/Cargo.toml +@@ -10,3 +10,4 @@ keywords = ["ffi", "bindgen"] + + [dependencies] + serde = { version = "1.0.136", features = ["derive"] } ++uniffi_checksum_derive = { version = "0.21.0", path = "../uniffi_checksum_derive" } +diff --git a/uniffi_meta/src/lib.rs b/uniffi_meta/src/lib.rs +index 6cfa733e9..2555ae19c 100644 +--- a/uniffi_meta/src/lib.rs ++++ b/uniffi_meta/src/lib.rs +@@ -6,10 +6,79 @@ use std::{ + collections::hash_map::DefaultHasher, + hash::{Hash, Hasher}, + }; ++pub use uniffi_checksum_derive::Checksum; + + use serde::{Deserialize, Serialize}; + +-#[derive(Clone, Debug, Hash, Deserialize, Serialize)] ++pub trait Checksum { ++ fn checksum<H: Hasher>(&self, state: &mut H); ++} ++ ++impl Checksum for bool { ++ fn checksum<H: Hasher>(&self, state: &mut H) { ++ Hash::hash(self, state); ++ } ++} ++ ++impl Checksum for u64 { ++ fn checksum<H: Hasher>(&self, state: &mut H) { ++ state.write(&self.to_le_bytes()); ++ } ++} ++ ++impl Checksum for i64 { ++ fn checksum<H: Hasher>(&self, state: &mut H) { ++ state.write(&self.to_le_bytes()); ++ } ++} ++ ++impl<T: Checksum> Checksum for Box<T> { ++ fn checksum<H: Hasher>(&self, state: &mut H) { ++ (**self).checksum(state) ++ } ++} ++ ++impl<T: Checksum> Checksum for [T] { ++ fn checksum<H: Hasher>(&self, state: &mut H) { ++ state.write(&(self.len() as u64).to_le_bytes()); ++ for item in self { ++ Checksum::checksum(item, state); ++ } ++ } ++} ++ ++impl<T: Checksum> Checksum for Vec<T> { ++ fn checksum<H: Hasher>(&self, state: &mut H) { ++ Checksum::checksum(&**self, state); ++ } ++} ++ ++impl<T: Checksum> Checksum for Option<T> { ++ fn checksum<H: Hasher>(&self, state: &mut H) { ++ match self { ++ None => state.write(&0u64.to_le_bytes()), ++ Some(value) => { ++ state.write(&1u64.to_le_bytes()); ++ Checksum::checksum(value, state) ++ } ++ } ++ } ++} ++ ++impl Checksum for str { ++ fn checksum<H: Hasher>(&self, state: &mut H) { ++ state.write(self.as_bytes()); ++ state.write_u8(0xff); ++ } ++} ++ ++impl Checksum for String { ++ fn checksum<H: Hasher>(&self, state: &mut H) { ++ (**self).checksum(state) ++ } ++} ++ ++#[derive(Clone, Debug, Checksum, Deserialize, Serialize)] + pub struct FnMetadata { + pub module_path: Vec<String>, + pub name: String, +@@ -23,7 +92,7 @@ impl FnMetadata { + } + } + +-#[derive(Clone, Debug, Hash, Deserialize, Serialize)] ++#[derive(Clone, Debug, Checksum, Deserialize, Serialize)] + pub struct MethodMetadata { + pub module_path: Vec<String>, + pub self_name: String, +@@ -39,14 +108,14 @@ impl MethodMetadata { + } + } + +-#[derive(Clone, Debug, Hash, Deserialize, Serialize)] ++#[derive(Clone, Debug, Checksum, Deserialize, Serialize)] + pub struct FnParamMetadata { + pub name: String, + #[serde(rename = "type")] + pub ty: Type, + } + +-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Deserialize, Serialize)] ++#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Checksum, Deserialize, Serialize)] + pub enum Type { + U8, + U16, +@@ -78,21 +147,21 @@ pub enum Type { + }, + } + +-#[derive(Clone, Debug, Hash, Deserialize, Serialize)] ++#[derive(Clone, Debug, Checksum, Deserialize, Serialize)] + pub struct RecordMetadata { + pub module_path: Vec<String>, + pub name: String, + pub fields: Vec<FieldMetadata>, + } + +-#[derive(Clone, Debug, Hash, Deserialize, Serialize)] ++#[derive(Clone, Debug, Checksum, Deserialize, Serialize)] + pub struct FieldMetadata { + pub name: String, + #[serde(rename = "type")] + pub ty: Type, + } + +-#[derive(Clone, Debug, Hash, Deserialize, Serialize)] ++#[derive(Clone, Debug, Checksum, Deserialize, Serialize)] + pub struct ObjectMetadata { + pub module_path: Vec<String>, + pub name: String, +@@ -112,9 +181,9 @@ impl ObjectMetadata { + /// + /// To be used as a checksum of FFI symbols, as a safeguard against different UniFFI versions being + /// used for scaffolding and bindings generation. +-pub fn checksum<T: Hash>(val: &T) -> u16 { ++pub fn checksum<T: Checksum>(val: &T) -> u16 { + let mut hasher = DefaultHasher::new(); +- val.hash(&mut hasher); ++ val.checksum(&mut hasher); + (hasher.finish() & 0x000000000000FFFF) as u16 + } + +@@ -124,7 +193,7 @@ pub fn fn_ffi_symbol_name(mod_path: &[String], name: &str, checksum: u16) -> Str + } + + /// Enum covering all the possible metadata types +-#[derive(Clone, Debug, Hash, Deserialize, Serialize)] ++#[derive(Clone, Debug, Checksum, Deserialize, Serialize)] + pub enum Metadata { + Func(FnMetadata), + Method(MethodMetadata), diff --git a/source/xap/mozilla-firefox/mozilla-firefox.SlackBuild b/source/xap/mozilla-firefox/mozilla-firefox.SlackBuild index 9ce487e29..6796c101f 100755 --- a/source/xap/mozilla-firefox/mozilla-firefox.SlackBuild +++ b/source/xap/mozilla-firefox/mozilla-firefox.SlackBuild @@ -317,6 +317,28 @@ fi # Add the $OPTIONS above to .mozconfig: for option in $OPTIONS; do echo "ac_add_options $option" >> .mozconfig; done +# Patch to match ./toolkit/components/ that have been regenerated with: +# ./mach uniffi generate +# This works around a build failure with 108.0 on i686. It also seems to break +# the previously working x86_64 build, so we'll only apply it for i686. +# Hopefully we can drop this when 108.0.1 ships. +if [ "$ARCH" = "i686" ]; then + zcat $CWD/regenerated-uniffi-toolkit-components.diff.gz | patch -p1 --verbose || exit 1 +fi + +# This is the upstream patch to fix the above issue, but unfortunately it +# doesn't apply completely and also causes an additional crate to be downloaded +# at build time, which won't do. I'll leave it here for reference in case +# anyone is interested, but we'll use the above kludge instead and wait for +# a proper fixed release from upstream for this to be correctly handled. +# +# [PATCH] Replace the use of Hash with a custom trait +# The custom trait is expected to consistently give the result that Hash +# gives on 64-bits little-endian, but on all platforms +#( cd ./third_party/rust +# zcat $CWD/8f889cf198ae7ffa9341423cb5a07ed39c07463a.patch.gz | patch -p1 --verbose || exit 1 +#) + # https://developer.mozilla.org/en-US/docs/Building_with_Profile-Guided_Optimization # Thanks to ArchLinux and Gentoo for the additional hints. if [ "$PGO" = "yes" ]; then @@ -349,38 +371,25 @@ rm -rf $PKG/usr/lib${LIBDIRSUFFIX}/firefox-devel-$RELEASEVER # Nor these: rm -rf $PKG/usr/include -( cd $PKG/usr/lib${LIBDIRSUFFIX}/firefox-$RELEASEVER - #mv defaults/profile/mimeTypes.rdf defaults/profile/mimeTypes.rdf.orig || exit 1 - if [ -d defaults/profile ]; then - zcat $CWD/mimeTypes.rdf > defaults/profile/mimeTypes.rdf || exit 1 - fi - # OK, this patch is useless on 7.x. We'll float without it and see what happens. - # Perhaps it won't make a difference or should be worked around elsewhere. - #zcat $CWD/firefox.moz_plugin_path.diff.gz \ - # | sed -e "s#usr/lib#usr/lib${LIBDIRSUFFIX}#g" \ - # | patch -p1 --verbose --backup --suffix=.orig || exit 1 - # Clean up if the above patch was successful: - #rm -f firefox.orig -) || exit +# 2022-12, COMMENTING OUT AS OBSOLETE +#( cd $PKG/usr/lib${LIBDIRSUFFIX}/firefox +# #mv defaults/profile/mimeTypes.rdf defaults/profile/mimeTypes.rdf.orig || exit 1 +# if [ -d defaults/profile ]; then +# zcat $CWD/mimeTypes.rdf > defaults/profile/mimeTypes.rdf || exit 1 +# fi +# # OK, this patch is useless on 7.x. We'll float without it and see what happens. +# # Perhaps it won't make a difference or should be worked around elsewhere. +# #zcat $CWD/firefox.moz_plugin_path.diff.gz \ +# # | sed -e "s#usr/lib#usr/lib${LIBDIRSUFFIX}#g" \ +# # | patch -p1 --verbose --backup --suffix=.orig || exit 1 +# # Clean up if the above patch was successful: +# #rm -f firefox.orig +#) || exit mkdir -p $PKG/usr/lib${LIBDIRSUFFIX}/mozilla/plugins mkdir -p $PKG/usr/share/applications cat $CWD/mozilla-firefox.desktop > $PKG/usr/share/applications/mozilla-firefox.desktop -# These files/directories are usually created if Firefox is run as root, -# which on many systems might (and possibly should) be never. Therefore, if we -# don't see them we'll put stubs in place to prevent startup errors. -( cd $PKG/usr/lib${LIBDIRSUFFIX}/firefox-$RELEASEVER - if [ -d extensions/talkback\@mozilla.org ]; then - if [ ! -r extensions/talkback\@mozilla.org/chrome.manifest ]; then - echo > extensions/talkback\@mozilla.org/chrome.manifest - fi - fi - if [ ! -d updates ]; then - mkdir -p updates/0 - fi -) - # Need some default icons in the right place: for i in 16 22 24 32 48 256; do install -m 0644 -D browser/branding/official/default${i}.png \ diff --git a/source/xap/mozilla-firefox/regenerated-uniffi-toolkit-components.diff b/source/xap/mozilla-firefox/regenerated-uniffi-toolkit-components.diff new file mode 100644 index 000000000..f65a456c5 --- /dev/null +++ b/source/xap/mozilla-firefox/regenerated-uniffi-toolkit-components.diff @@ -0,0 +1,2747 @@ +Whee... here's some fun! ;-) Firefox-108.0 would not compile on 32-bit i686, +but compiled fine on x86_64. My good friend marav provided a link to a bug +discussion that said running ./mach uniffi generate would work around the +problem, and indeed it does. However, that is not suitable for packaging +since it downloads a bunch of stuff and we want the sources to be self- +contained. The important changes seemed to land in ./toolkit/components so +I generated a diff, and applying that prior to the build also works around +the compile failure. + +marav also proposed this minimal sed that produces the same changes: + +sed -i 's/4d51/1c79/g' \ + toolkit/components/uniffi-bindgen-gecko-js/components/generated/RustTabs.jsm \ + toolkit/components/uniffi-js/UniFFIGeneratedScaffolding.cpp + +However, I think we'll use this generated diff instead since it'll be more +obvious when we no longer need it. + +diff -u -r --new-file firefox-108.0.orig/toolkit/components/uniffi-bindgen-gecko-js/components/generated/RustTabs.jsm firefox-108.0/toolkit/components/uniffi-bindgen-gecko-js/components/generated/RustTabs.jsm +--- firefox-108.0.orig/toolkit/components/uniffi-bindgen-gecko-js/components/generated/RustTabs.jsm 2022-12-08 10:27:29.000000000 -0600 ++++ firefox-108.0/toolkit/components/uniffi-bindgen-gecko-js/components/generated/RustTabs.jsm 2022-12-15 13:20:01.333880947 -0600 +@@ -328,7 +328,7 @@ + const liftError = (data) => FfiConverterTypeTabsError.lift(data); + const functionCall = () => { + return UniFFIScaffolding.callAsync( +- 7, // tabs:tabs_4d51_TabsBridgedEngine_last_sync ++ 7, // tabs:tabs_1c79_TabsBridgedEngine_last_sync + FfiConverterTypeTabsBridgedEngine.lower(this), + ) + } +@@ -343,7 +343,7 @@ + const functionCall = () => { + FfiConverterI64.checkType("lastSync", lastSync); + return UniFFIScaffolding.callAsync( +- 8, // tabs:tabs_4d51_TabsBridgedEngine_set_last_sync ++ 8, // tabs:tabs_1c79_TabsBridgedEngine_set_last_sync + FfiConverterTypeTabsBridgedEngine.lower(this), + FfiConverterI64.lower(lastSync), + ) +@@ -358,7 +358,7 @@ + const liftError = (data) => FfiConverterTypeTabsError.lift(data); + const functionCall = () => { + return UniFFIScaffolding.callAsync( +- 9, // tabs:tabs_4d51_TabsBridgedEngine_sync_id ++ 9, // tabs:tabs_1c79_TabsBridgedEngine_sync_id + FfiConverterTypeTabsBridgedEngine.lower(this), + ) + } +@@ -372,7 +372,7 @@ + const liftError = (data) => FfiConverterTypeTabsError.lift(data); + const functionCall = () => { + return UniFFIScaffolding.callAsync( +- 10, // tabs:tabs_4d51_TabsBridgedEngine_reset_sync_id ++ 10, // tabs:tabs_1c79_TabsBridgedEngine_reset_sync_id + FfiConverterTypeTabsBridgedEngine.lower(this), + ) + } +@@ -387,7 +387,7 @@ + const functionCall = () => { + FfiConverterString.checkType("newSyncId", newSyncId); + return UniFFIScaffolding.callAsync( +- 11, // tabs:tabs_4d51_TabsBridgedEngine_ensure_current_sync_id ++ 11, // tabs:tabs_1c79_TabsBridgedEngine_ensure_current_sync_id + FfiConverterTypeTabsBridgedEngine.lower(this), + FfiConverterString.lower(newSyncId), + ) +@@ -403,7 +403,7 @@ + const functionCall = () => { + FfiConverterString.checkType("clientData", clientData); + return UniFFIScaffolding.callAsync( +- 12, // tabs:tabs_4d51_TabsBridgedEngine_prepare_for_sync ++ 12, // tabs:tabs_1c79_TabsBridgedEngine_prepare_for_sync + FfiConverterTypeTabsBridgedEngine.lower(this), + FfiConverterString.lower(clientData), + ) +@@ -418,7 +418,7 @@ + const liftError = (data) => FfiConverterTypeTabsError.lift(data); + const functionCall = () => { + return UniFFIScaffolding.callAsync( +- 13, // tabs:tabs_4d51_TabsBridgedEngine_sync_started ++ 13, // tabs:tabs_1c79_TabsBridgedEngine_sync_started + FfiConverterTypeTabsBridgedEngine.lower(this), + ) + } +@@ -433,7 +433,7 @@ + const functionCall = () => { + FfiConverterSequencestring.checkType("incomingEnvelopesAsJson", incomingEnvelopesAsJson); + return UniFFIScaffolding.callAsync( +- 14, // tabs:tabs_4d51_TabsBridgedEngine_store_incoming ++ 14, // tabs:tabs_1c79_TabsBridgedEngine_store_incoming + FfiConverterTypeTabsBridgedEngine.lower(this), + FfiConverterSequencestring.lower(incomingEnvelopesAsJson), + ) +@@ -448,7 +448,7 @@ + const liftError = (data) => FfiConverterTypeTabsError.lift(data); + const functionCall = () => { + return UniFFIScaffolding.callAsync( +- 15, // tabs:tabs_4d51_TabsBridgedEngine_apply ++ 15, // tabs:tabs_1c79_TabsBridgedEngine_apply + FfiConverterTypeTabsBridgedEngine.lower(this), + ) + } +@@ -464,7 +464,7 @@ + FfiConverterI64.checkType("newTimestamp", newTimestamp); + FfiConverterSequenceTypeTabsGuid.checkType("uploadedIds", uploadedIds); + return UniFFIScaffolding.callAsync( +- 16, // tabs:tabs_4d51_TabsBridgedEngine_set_uploaded ++ 16, // tabs:tabs_1c79_TabsBridgedEngine_set_uploaded + FfiConverterTypeTabsBridgedEngine.lower(this), + FfiConverterI64.lower(newTimestamp), + FfiConverterSequenceTypeTabsGuid.lower(uploadedIds), +@@ -480,7 +480,7 @@ + const liftError = (data) => FfiConverterTypeTabsError.lift(data); + const functionCall = () => { + return UniFFIScaffolding.callAsync( +- 17, // tabs:tabs_4d51_TabsBridgedEngine_sync_finished ++ 17, // tabs:tabs_1c79_TabsBridgedEngine_sync_finished + FfiConverterTypeTabsBridgedEngine.lower(this), + ) + } +@@ -494,7 +494,7 @@ + const liftError = (data) => FfiConverterTypeTabsError.lift(data); + const functionCall = () => { + return UniFFIScaffolding.callAsync( +- 18, // tabs:tabs_4d51_TabsBridgedEngine_reset ++ 18, // tabs:tabs_1c79_TabsBridgedEngine_reset + FfiConverterTypeTabsBridgedEngine.lower(this), + ) + } +@@ -508,7 +508,7 @@ + const liftError = (data) => FfiConverterTypeTabsError.lift(data); + const functionCall = () => { + return UniFFIScaffolding.callAsync( +- 19, // tabs:tabs_4d51_TabsBridgedEngine_wipe ++ 19, // tabs:tabs_1c79_TabsBridgedEngine_wipe + FfiConverterTypeTabsBridgedEngine.lower(this), + ) + } +@@ -574,7 +574,7 @@ + const functionCall = () => { + FfiConverterString.checkType("path", path); + return UniFFIScaffolding.callAsync( +- 0, // tabs:tabs_4d51_TabsStore_new ++ 0, // tabs:tabs_1c79_TabsStore_new + FfiConverterString.lower(path), + ) + } +@@ -588,7 +588,7 @@ + const liftError = null; + const functionCall = () => { + return UniFFIScaffolding.callAsync( +- 1, // tabs:tabs_4d51_TabsStore_get_all ++ 1, // tabs:tabs_1c79_TabsStore_get_all + FfiConverterTypeTabsStore.lower(this), + ) + } +@@ -603,7 +603,7 @@ + const functionCall = () => { + FfiConverterSequenceTypeRemoteTabRecord.checkType("remoteTabs", remoteTabs); + return UniFFIScaffolding.callAsync( +- 2, // tabs:tabs_4d51_TabsStore_set_local_tabs ++ 2, // tabs:tabs_1c79_TabsStore_set_local_tabs + FfiConverterTypeTabsStore.lower(this), + FfiConverterSequenceTypeRemoteTabRecord.lower(remoteTabs), + ) +@@ -618,7 +618,7 @@ + const liftError = null; + const functionCall = () => { + return UniFFIScaffolding.callAsync( +- 3, // tabs:tabs_4d51_TabsStore_register_with_sync_manager ++ 3, // tabs:tabs_1c79_TabsStore_register_with_sync_manager + FfiConverterTypeTabsStore.lower(this), + ) + } +@@ -632,7 +632,7 @@ + const liftError = (data) => FfiConverterTypeTabsError.lift(data); + const functionCall = () => { + return UniFFIScaffolding.callAsync( +- 4, // tabs:tabs_4d51_TabsStore_reset ++ 4, // tabs:tabs_1c79_TabsStore_reset + FfiConverterTypeTabsStore.lower(this), + ) + } +@@ -651,7 +651,7 @@ + FfiConverterString.checkType("tokenserverUrl", tokenserverUrl); + FfiConverterString.checkType("localId", localId); + return UniFFIScaffolding.callAsync( +- 5, // tabs:tabs_4d51_TabsStore_sync ++ 5, // tabs:tabs_1c79_TabsStore_sync + FfiConverterTypeTabsStore.lower(this), + FfiConverterString.lower(keyId), + FfiConverterString.lower(accessToken), +@@ -670,7 +670,7 @@ + const liftError = null; + const functionCall = () => { + return UniFFIScaffolding.callAsync( +- 6, // tabs:tabs_4d51_TabsStore_bridged_engine ++ 6, // tabs:tabs_1c79_TabsStore_bridged_engine + FfiConverterTypeTabsStore.lower(this), + ) + } +diff -u -r --new-file firefox-108.0.orig/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustArithmetic.jsm firefox-108.0/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustArithmetic.jsm +--- firefox-108.0.orig/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustArithmetic.jsm 2022-12-08 10:27:29.000000000 -0600 ++++ firefox-108.0/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustArithmetic.jsm 2022-12-15 13:20:01.334880947 -0600 +@@ -338,7 +338,7 @@ + FfiConverterU64.checkType("a", a); + FfiConverterU64.checkType("b", b); + return UniFFIScaffolding.callAsync( +- 22, // arithmetic:arithmetic_906c_add ++ 22, // arithmetic:arithmetic_be49_add + FfiConverterU64.lower(a), + FfiConverterU64.lower(b), + ) +@@ -359,7 +359,7 @@ + FfiConverterU64.checkType("a", a); + FfiConverterU64.checkType("b", b); + return UniFFIScaffolding.callAsync( +- 23, // arithmetic:arithmetic_906c_sub ++ 23, // arithmetic:arithmetic_be49_sub + FfiConverterU64.lower(a), + FfiConverterU64.lower(b), + ) +@@ -380,7 +380,7 @@ + FfiConverterU64.checkType("dividend", dividend); + FfiConverterU64.checkType("divisor", divisor); + return UniFFIScaffolding.callAsync( +- 24, // arithmetic:arithmetic_906c_div ++ 24, // arithmetic:arithmetic_be49_div + FfiConverterU64.lower(dividend), + FfiConverterU64.lower(divisor), + ) +@@ -401,7 +401,7 @@ + FfiConverterU64.checkType("a", a); + FfiConverterU64.checkType("b", b); + return UniFFIScaffolding.callAsync( +- 25, // arithmetic:arithmetic_906c_equal ++ 25, // arithmetic:arithmetic_be49_equal + FfiConverterU64.lower(a), + FfiConverterU64.lower(b), + ) +diff -u -r --new-file firefox-108.0.orig/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustCustomTypes.jsm firefox-108.0/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustCustomTypes.jsm +--- firefox-108.0.orig/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustCustomTypes.jsm 2022-12-08 10:27:29.000000000 -0600 ++++ firefox-108.0/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustCustomTypes.jsm 2022-12-15 13:20:01.336880947 -0600 +@@ -422,7 +422,7 @@ + const functionCall = () => { + FfiConverterOptionalTypeCustomTypesDemo.checkType("demo", demo); + return UniFFIScaffolding.callAsync( +- 107, // custom_types:custom_types_8ecd_get_custom_types_demo ++ 107, // custom_types:custom_types_41fc_get_custom_types_demo + FfiConverterOptionalTypeCustomTypesDemo.lower(demo), + ) + } +diff -u -r --new-file firefox-108.0.orig/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustExternalTypes.jsm firefox-108.0/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustExternalTypes.jsm +--- firefox-108.0.orig/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustExternalTypes.jsm 2022-12-08 10:27:28.000000000 -0600 ++++ firefox-108.0/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustExternalTypes.jsm 2022-12-15 13:20:01.336880947 -0600 +@@ -329,7 +329,7 @@ + const functionCall = () => { + FfiConverterOptionalTypeLine.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 108, // external_types:external_types_54cc_gradient ++ 108, // external_types:external_types_4cd4_gradient + FfiConverterOptionalTypeLine.lower(value), + ) + } +diff -u -r --new-file firefox-108.0.orig/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustGeometry.jsm firefox-108.0/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustGeometry.jsm +--- firefox-108.0.orig/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustGeometry.jsm 2022-12-08 10:27:29.000000000 -0600 ++++ firefox-108.0/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustGeometry.jsm 2022-12-15 13:20:01.334880947 -0600 +@@ -411,7 +411,7 @@ + const functionCall = () => { + FfiConverterTypeLine.checkType("ln", ln); + return UniFFIScaffolding.callAsync( +- 20, // geometry:geometry_1cce_gradient ++ 20, // geometry:geometry_deb7_gradient + FfiConverterTypeLine.lower(ln), + ) + } +@@ -431,7 +431,7 @@ + FfiConverterTypeLine.checkType("ln1", ln1); + FfiConverterTypeLine.checkType("ln2", ln2); + return UniFFIScaffolding.callAsync( +- 21, // geometry:geometry_1cce_intersection ++ 21, // geometry:geometry_deb7_intersection + FfiConverterTypeLine.lower(ln1), + FfiConverterTypeLine.lower(ln2), + ) +diff -u -r --new-file firefox-108.0.orig/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustRondpoint.jsm firefox-108.0/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustRondpoint.jsm +--- firefox-108.0.orig/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustRondpoint.jsm 2022-12-08 10:27:28.000000000 -0600 ++++ firefox-108.0/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustRondpoint.jsm 2022-12-15 13:20:01.335880947 -0600 +@@ -631,7 +631,7 @@ + const liftError = null; + const functionCall = () => { + return UniFFIScaffolding.callAsync( +- 55, // rondpoint:rondpoint_c6ef_Optionneur_new ++ 55, // rondpoint:rondpoint_33e7_Optionneur_new + ) + } + try { +@@ -645,7 +645,7 @@ + const functionCall = () => { + FfiConverterBool.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 56, // rondpoint:rondpoint_c6ef_Optionneur_sinon_boolean ++ 56, // rondpoint:rondpoint_33e7_Optionneur_sinon_boolean + FfiConverterTypeOptionneur.lower(this), + FfiConverterBool.lower(value), + ) +@@ -661,7 +661,7 @@ + const functionCall = () => { + FfiConverterString.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 57, // rondpoint:rondpoint_c6ef_Optionneur_sinon_string ++ 57, // rondpoint:rondpoint_33e7_Optionneur_sinon_string + FfiConverterTypeOptionneur.lower(this), + FfiConverterString.lower(value), + ) +@@ -677,7 +677,7 @@ + const functionCall = () => { + FfiConverterSequencestring.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 58, // rondpoint:rondpoint_c6ef_Optionneur_sinon_sequence ++ 58, // rondpoint:rondpoint_33e7_Optionneur_sinon_sequence + FfiConverterTypeOptionneur.lower(this), + FfiConverterSequencestring.lower(value), + ) +@@ -693,7 +693,7 @@ + const functionCall = () => { + FfiConverterOptionalstring.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 59, // rondpoint:rondpoint_c6ef_Optionneur_sinon_null ++ 59, // rondpoint:rondpoint_33e7_Optionneur_sinon_null + FfiConverterTypeOptionneur.lower(this), + FfiConverterOptionalstring.lower(value), + ) +@@ -709,7 +709,7 @@ + const functionCall = () => { + FfiConverterOptionali32.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 60, // rondpoint:rondpoint_c6ef_Optionneur_sinon_zero ++ 60, // rondpoint:rondpoint_33e7_Optionneur_sinon_zero + FfiConverterTypeOptionneur.lower(this), + FfiConverterOptionali32.lower(value), + ) +@@ -725,7 +725,7 @@ + const functionCall = () => { + FfiConverterU8.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 61, // rondpoint:rondpoint_c6ef_Optionneur_sinon_u8_dec ++ 61, // rondpoint:rondpoint_33e7_Optionneur_sinon_u8_dec + FfiConverterTypeOptionneur.lower(this), + FfiConverterU8.lower(value), + ) +@@ -741,7 +741,7 @@ + const functionCall = () => { + FfiConverterI8.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 62, // rondpoint:rondpoint_c6ef_Optionneur_sinon_i8_dec ++ 62, // rondpoint:rondpoint_33e7_Optionneur_sinon_i8_dec + FfiConverterTypeOptionneur.lower(this), + FfiConverterI8.lower(value), + ) +@@ -757,7 +757,7 @@ + const functionCall = () => { + FfiConverterU16.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 63, // rondpoint:rondpoint_c6ef_Optionneur_sinon_u16_dec ++ 63, // rondpoint:rondpoint_33e7_Optionneur_sinon_u16_dec + FfiConverterTypeOptionneur.lower(this), + FfiConverterU16.lower(value), + ) +@@ -773,7 +773,7 @@ + const functionCall = () => { + FfiConverterI16.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 64, // rondpoint:rondpoint_c6ef_Optionneur_sinon_i16_dec ++ 64, // rondpoint:rondpoint_33e7_Optionneur_sinon_i16_dec + FfiConverterTypeOptionneur.lower(this), + FfiConverterI16.lower(value), + ) +@@ -789,7 +789,7 @@ + const functionCall = () => { + FfiConverterU32.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 65, // rondpoint:rondpoint_c6ef_Optionneur_sinon_u32_dec ++ 65, // rondpoint:rondpoint_33e7_Optionneur_sinon_u32_dec + FfiConverterTypeOptionneur.lower(this), + FfiConverterU32.lower(value), + ) +@@ -805,7 +805,7 @@ + const functionCall = () => { + FfiConverterI32.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 66, // rondpoint:rondpoint_c6ef_Optionneur_sinon_i32_dec ++ 66, // rondpoint:rondpoint_33e7_Optionneur_sinon_i32_dec + FfiConverterTypeOptionneur.lower(this), + FfiConverterI32.lower(value), + ) +@@ -821,7 +821,7 @@ + const functionCall = () => { + FfiConverterU64.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 67, // rondpoint:rondpoint_c6ef_Optionneur_sinon_u64_dec ++ 67, // rondpoint:rondpoint_33e7_Optionneur_sinon_u64_dec + FfiConverterTypeOptionneur.lower(this), + FfiConverterU64.lower(value), + ) +@@ -837,7 +837,7 @@ + const functionCall = () => { + FfiConverterI64.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 68, // rondpoint:rondpoint_c6ef_Optionneur_sinon_i64_dec ++ 68, // rondpoint:rondpoint_33e7_Optionneur_sinon_i64_dec + FfiConverterTypeOptionneur.lower(this), + FfiConverterI64.lower(value), + ) +@@ -853,7 +853,7 @@ + const functionCall = () => { + FfiConverterU8.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 69, // rondpoint:rondpoint_c6ef_Optionneur_sinon_u8_hex ++ 69, // rondpoint:rondpoint_33e7_Optionneur_sinon_u8_hex + FfiConverterTypeOptionneur.lower(this), + FfiConverterU8.lower(value), + ) +@@ -869,7 +869,7 @@ + const functionCall = () => { + FfiConverterI8.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 70, // rondpoint:rondpoint_c6ef_Optionneur_sinon_i8_hex ++ 70, // rondpoint:rondpoint_33e7_Optionneur_sinon_i8_hex + FfiConverterTypeOptionneur.lower(this), + FfiConverterI8.lower(value), + ) +@@ -885,7 +885,7 @@ + const functionCall = () => { + FfiConverterU16.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 71, // rondpoint:rondpoint_c6ef_Optionneur_sinon_u16_hex ++ 71, // rondpoint:rondpoint_33e7_Optionneur_sinon_u16_hex + FfiConverterTypeOptionneur.lower(this), + FfiConverterU16.lower(value), + ) +@@ -901,7 +901,7 @@ + const functionCall = () => { + FfiConverterI16.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 72, // rondpoint:rondpoint_c6ef_Optionneur_sinon_i16_hex ++ 72, // rondpoint:rondpoint_33e7_Optionneur_sinon_i16_hex + FfiConverterTypeOptionneur.lower(this), + FfiConverterI16.lower(value), + ) +@@ -917,7 +917,7 @@ + const functionCall = () => { + FfiConverterU32.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 73, // rondpoint:rondpoint_c6ef_Optionneur_sinon_u32_hex ++ 73, // rondpoint:rondpoint_33e7_Optionneur_sinon_u32_hex + FfiConverterTypeOptionneur.lower(this), + FfiConverterU32.lower(value), + ) +@@ -933,7 +933,7 @@ + const functionCall = () => { + FfiConverterI32.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 74, // rondpoint:rondpoint_c6ef_Optionneur_sinon_i32_hex ++ 74, // rondpoint:rondpoint_33e7_Optionneur_sinon_i32_hex + FfiConverterTypeOptionneur.lower(this), + FfiConverterI32.lower(value), + ) +@@ -949,7 +949,7 @@ + const functionCall = () => { + FfiConverterU64.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 75, // rondpoint:rondpoint_c6ef_Optionneur_sinon_u64_hex ++ 75, // rondpoint:rondpoint_33e7_Optionneur_sinon_u64_hex + FfiConverterTypeOptionneur.lower(this), + FfiConverterU64.lower(value), + ) +@@ -965,7 +965,7 @@ + const functionCall = () => { + FfiConverterI64.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 76, // rondpoint:rondpoint_c6ef_Optionneur_sinon_i64_hex ++ 76, // rondpoint:rondpoint_33e7_Optionneur_sinon_i64_hex + FfiConverterTypeOptionneur.lower(this), + FfiConverterI64.lower(value), + ) +@@ -981,7 +981,7 @@ + const functionCall = () => { + FfiConverterU32.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 77, // rondpoint:rondpoint_c6ef_Optionneur_sinon_u32_oct ++ 77, // rondpoint:rondpoint_33e7_Optionneur_sinon_u32_oct + FfiConverterTypeOptionneur.lower(this), + FfiConverterU32.lower(value), + ) +@@ -997,7 +997,7 @@ + const functionCall = () => { + FfiConverterF32.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 78, // rondpoint:rondpoint_c6ef_Optionneur_sinon_f32 ++ 78, // rondpoint:rondpoint_33e7_Optionneur_sinon_f32 + FfiConverterTypeOptionneur.lower(this), + FfiConverterF32.lower(value), + ) +@@ -1013,7 +1013,7 @@ + const functionCall = () => { + FfiConverterF64.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 79, // rondpoint:rondpoint_c6ef_Optionneur_sinon_f64 ++ 79, // rondpoint:rondpoint_33e7_Optionneur_sinon_f64 + FfiConverterTypeOptionneur.lower(this), + FfiConverterF64.lower(value), + ) +@@ -1029,7 +1029,7 @@ + const functionCall = () => { + FfiConverterTypeEnumeration.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 80, // rondpoint:rondpoint_c6ef_Optionneur_sinon_enum ++ 80, // rondpoint:rondpoint_33e7_Optionneur_sinon_enum + FfiConverterTypeOptionneur.lower(this), + FfiConverterTypeEnumeration.lower(value), + ) +@@ -1095,7 +1095,7 @@ + const liftError = null; + const functionCall = () => { + return UniFFIScaffolding.callAsync( +- 26, // rondpoint:rondpoint_c6ef_Retourneur_new ++ 26, // rondpoint:rondpoint_33e7_Retourneur_new + ) + } + try { +@@ -1109,7 +1109,7 @@ + const functionCall = () => { + FfiConverterI8.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 27, // rondpoint:rondpoint_c6ef_Retourneur_identique_i8 ++ 27, // rondpoint:rondpoint_33e7_Retourneur_identique_i8 + FfiConverterTypeRetourneur.lower(this), + FfiConverterI8.lower(value), + ) +@@ -1125,7 +1125,7 @@ + const functionCall = () => { + FfiConverterU8.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 28, // rondpoint:rondpoint_c6ef_Retourneur_identique_u8 ++ 28, // rondpoint:rondpoint_33e7_Retourneur_identique_u8 + FfiConverterTypeRetourneur.lower(this), + FfiConverterU8.lower(value), + ) +@@ -1141,7 +1141,7 @@ + const functionCall = () => { + FfiConverterI16.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 29, // rondpoint:rondpoint_c6ef_Retourneur_identique_i16 ++ 29, // rondpoint:rondpoint_33e7_Retourneur_identique_i16 + FfiConverterTypeRetourneur.lower(this), + FfiConverterI16.lower(value), + ) +@@ -1157,7 +1157,7 @@ + const functionCall = () => { + FfiConverterU16.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 30, // rondpoint:rondpoint_c6ef_Retourneur_identique_u16 ++ 30, // rondpoint:rondpoint_33e7_Retourneur_identique_u16 + FfiConverterTypeRetourneur.lower(this), + FfiConverterU16.lower(value), + ) +@@ -1173,7 +1173,7 @@ + const functionCall = () => { + FfiConverterI32.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 31, // rondpoint:rondpoint_c6ef_Retourneur_identique_i32 ++ 31, // rondpoint:rondpoint_33e7_Retourneur_identique_i32 + FfiConverterTypeRetourneur.lower(this), + FfiConverterI32.lower(value), + ) +@@ -1189,7 +1189,7 @@ + const functionCall = () => { + FfiConverterU32.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 32, // rondpoint:rondpoint_c6ef_Retourneur_identique_u32 ++ 32, // rondpoint:rondpoint_33e7_Retourneur_identique_u32 + FfiConverterTypeRetourneur.lower(this), + FfiConverterU32.lower(value), + ) +@@ -1205,7 +1205,7 @@ + const functionCall = () => { + FfiConverterI64.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 33, // rondpoint:rondpoint_c6ef_Retourneur_identique_i64 ++ 33, // rondpoint:rondpoint_33e7_Retourneur_identique_i64 + FfiConverterTypeRetourneur.lower(this), + FfiConverterI64.lower(value), + ) +@@ -1221,7 +1221,7 @@ + const functionCall = () => { + FfiConverterU64.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 34, // rondpoint:rondpoint_c6ef_Retourneur_identique_u64 ++ 34, // rondpoint:rondpoint_33e7_Retourneur_identique_u64 + FfiConverterTypeRetourneur.lower(this), + FfiConverterU64.lower(value), + ) +@@ -1237,7 +1237,7 @@ + const functionCall = () => { + FfiConverterF32.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 35, // rondpoint:rondpoint_c6ef_Retourneur_identique_float ++ 35, // rondpoint:rondpoint_33e7_Retourneur_identique_float + FfiConverterTypeRetourneur.lower(this), + FfiConverterF32.lower(value), + ) +@@ -1253,7 +1253,7 @@ + const functionCall = () => { + FfiConverterF64.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 36, // rondpoint:rondpoint_c6ef_Retourneur_identique_double ++ 36, // rondpoint:rondpoint_33e7_Retourneur_identique_double + FfiConverterTypeRetourneur.lower(this), + FfiConverterF64.lower(value), + ) +@@ -1269,7 +1269,7 @@ + const functionCall = () => { + FfiConverterBool.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 37, // rondpoint:rondpoint_c6ef_Retourneur_identique_boolean ++ 37, // rondpoint:rondpoint_33e7_Retourneur_identique_boolean + FfiConverterTypeRetourneur.lower(this), + FfiConverterBool.lower(value), + ) +@@ -1285,7 +1285,7 @@ + const functionCall = () => { + FfiConverterString.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 38, // rondpoint:rondpoint_c6ef_Retourneur_identique_string ++ 38, // rondpoint:rondpoint_33e7_Retourneur_identique_string + FfiConverterTypeRetourneur.lower(this), + FfiConverterString.lower(value), + ) +@@ -1301,7 +1301,7 @@ + const functionCall = () => { + FfiConverterTypeDictionnaireNombresSignes.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 39, // rondpoint:rondpoint_c6ef_Retourneur_identique_nombres_signes ++ 39, // rondpoint:rondpoint_33e7_Retourneur_identique_nombres_signes + FfiConverterTypeRetourneur.lower(this), + FfiConverterTypeDictionnaireNombresSignes.lower(value), + ) +@@ -1317,7 +1317,7 @@ + const functionCall = () => { + FfiConverterTypeDictionnaireNombres.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 40, // rondpoint:rondpoint_c6ef_Retourneur_identique_nombres ++ 40, // rondpoint:rondpoint_33e7_Retourneur_identique_nombres + FfiConverterTypeRetourneur.lower(this), + FfiConverterTypeDictionnaireNombres.lower(value), + ) +@@ -1333,7 +1333,7 @@ + const functionCall = () => { + FfiConverterTypeOptionneurDictionnaire.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 41, // rondpoint:rondpoint_c6ef_Retourneur_identique_optionneur_dictionnaire ++ 41, // rondpoint:rondpoint_33e7_Retourneur_identique_optionneur_dictionnaire + FfiConverterTypeRetourneur.lower(this), + FfiConverterTypeOptionneurDictionnaire.lower(value), + ) +@@ -1399,7 +1399,7 @@ + const liftError = null; + const functionCall = () => { + return UniFFIScaffolding.callAsync( +- 42, // rondpoint:rondpoint_c6ef_Stringifier_new ++ 42, // rondpoint:rondpoint_33e7_Stringifier_new + ) + } + try { +@@ -1413,7 +1413,7 @@ + const functionCall = () => { + FfiConverterString.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 43, // rondpoint:rondpoint_c6ef_Stringifier_well_known_string ++ 43, // rondpoint:rondpoint_33e7_Stringifier_well_known_string + FfiConverterTypeStringifier.lower(this), + FfiConverterString.lower(value), + ) +@@ -1429,7 +1429,7 @@ + const functionCall = () => { + FfiConverterI8.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 44, // rondpoint:rondpoint_c6ef_Stringifier_to_string_i8 ++ 44, // rondpoint:rondpoint_33e7_Stringifier_to_string_i8 + FfiConverterTypeStringifier.lower(this), + FfiConverterI8.lower(value), + ) +@@ -1445,7 +1445,7 @@ + const functionCall = () => { + FfiConverterU8.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 45, // rondpoint:rondpoint_c6ef_Stringifier_to_string_u8 ++ 45, // rondpoint:rondpoint_33e7_Stringifier_to_string_u8 + FfiConverterTypeStringifier.lower(this), + FfiConverterU8.lower(value), + ) +@@ -1461,7 +1461,7 @@ + const functionCall = () => { + FfiConverterI16.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 46, // rondpoint:rondpoint_c6ef_Stringifier_to_string_i16 ++ 46, // rondpoint:rondpoint_33e7_Stringifier_to_string_i16 + FfiConverterTypeStringifier.lower(this), + FfiConverterI16.lower(value), + ) +@@ -1477,7 +1477,7 @@ + const functionCall = () => { + FfiConverterU16.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 47, // rondpoint:rondpoint_c6ef_Stringifier_to_string_u16 ++ 47, // rondpoint:rondpoint_33e7_Stringifier_to_string_u16 + FfiConverterTypeStringifier.lower(this), + FfiConverterU16.lower(value), + ) +@@ -1493,7 +1493,7 @@ + const functionCall = () => { + FfiConverterI32.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 48, // rondpoint:rondpoint_c6ef_Stringifier_to_string_i32 ++ 48, // rondpoint:rondpoint_33e7_Stringifier_to_string_i32 + FfiConverterTypeStringifier.lower(this), + FfiConverterI32.lower(value), + ) +@@ -1509,7 +1509,7 @@ + const functionCall = () => { + FfiConverterU32.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 49, // rondpoint:rondpoint_c6ef_Stringifier_to_string_u32 ++ 49, // rondpoint:rondpoint_33e7_Stringifier_to_string_u32 + FfiConverterTypeStringifier.lower(this), + FfiConverterU32.lower(value), + ) +@@ -1525,7 +1525,7 @@ + const functionCall = () => { + FfiConverterI64.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 50, // rondpoint:rondpoint_c6ef_Stringifier_to_string_i64 ++ 50, // rondpoint:rondpoint_33e7_Stringifier_to_string_i64 + FfiConverterTypeStringifier.lower(this), + FfiConverterI64.lower(value), + ) +@@ -1541,7 +1541,7 @@ + const functionCall = () => { + FfiConverterU64.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 51, // rondpoint:rondpoint_c6ef_Stringifier_to_string_u64 ++ 51, // rondpoint:rondpoint_33e7_Stringifier_to_string_u64 + FfiConverterTypeStringifier.lower(this), + FfiConverterU64.lower(value), + ) +@@ -1557,7 +1557,7 @@ + const functionCall = () => { + FfiConverterF32.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 52, // rondpoint:rondpoint_c6ef_Stringifier_to_string_float ++ 52, // rondpoint:rondpoint_33e7_Stringifier_to_string_float + FfiConverterTypeStringifier.lower(this), + FfiConverterF32.lower(value), + ) +@@ -1573,7 +1573,7 @@ + const functionCall = () => { + FfiConverterF64.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 53, // rondpoint:rondpoint_c6ef_Stringifier_to_string_double ++ 53, // rondpoint:rondpoint_33e7_Stringifier_to_string_double + FfiConverterTypeStringifier.lower(this), + FfiConverterF64.lower(value), + ) +@@ -1589,7 +1589,7 @@ + const functionCall = () => { + FfiConverterBool.checkType("value", value); + return UniFFIScaffolding.callAsync( +- 54, // rondpoint:rondpoint_c6ef_Stringifier_to_string_boolean ++ 54, // rondpoint:rondpoint_33e7_Stringifier_to_string_boolean + FfiConverterTypeStringifier.lower(this), + FfiConverterBool.lower(value), + ) +@@ -2375,7 +2375,7 @@ + const functionCall = () => { + FfiConverterTypeDictionnaire.checkType("d", d); + return UniFFIScaffolding.callAsync( +- 81, // rondpoint:rondpoint_c6ef_copie_dictionnaire ++ 81, // rondpoint:rondpoint_33e7_copie_dictionnaire + FfiConverterTypeDictionnaire.lower(d), + ) + } +@@ -2394,7 +2394,7 @@ + const functionCall = () => { + FfiConverterTypeEnumeration.checkType("e", e); + return UniFFIScaffolding.callAsync( +- 82, // rondpoint:rondpoint_c6ef_copie_enumeration ++ 82, // rondpoint:rondpoint_33e7_copie_enumeration + FfiConverterTypeEnumeration.lower(e), + ) + } +@@ -2413,7 +2413,7 @@ + const functionCall = () => { + FfiConverterSequenceTypeEnumeration.checkType("e", e); + return UniFFIScaffolding.callAsync( +- 83, // rondpoint:rondpoint_c6ef_copie_enumerations ++ 83, // rondpoint:rondpoint_33e7_copie_enumerations + FfiConverterSequenceTypeEnumeration.lower(e), + ) + } +@@ -2432,7 +2432,7 @@ + const functionCall = () => { + FfiConverterMapStringTypeEnumerationAvecDonnees.checkType("c", c); + return UniFFIScaffolding.callAsync( +- 84, // rondpoint:rondpoint_c6ef_copie_carte ++ 84, // rondpoint:rondpoint_33e7_copie_carte + FfiConverterMapStringTypeEnumerationAvecDonnees.lower(c), + ) + } +@@ -2451,7 +2451,7 @@ + const functionCall = () => { + FfiConverterBool.checkType("b", b); + return UniFFIScaffolding.callAsync( +- 85, // rondpoint:rondpoint_c6ef_switcheroo ++ 85, // rondpoint:rondpoint_33e7_switcheroo + FfiConverterBool.lower(b), + ) + } +diff -u -r --new-file firefox-108.0.orig/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustSprites.jsm firefox-108.0/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustSprites.jsm +--- firefox-108.0.orig/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustSprites.jsm 2022-12-08 10:27:29.000000000 -0600 ++++ firefox-108.0/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustSprites.jsm 2022-12-15 13:20:01.335880947 -0600 +@@ -309,7 +309,7 @@ + const functionCall = () => { + FfiConverterOptionalTypePoint.checkType("initialPosition", initialPosition); + return UniFFIScaffolding.callAsync( +- 86, // sprites:sprites_accb_Sprite_new ++ 86, // sprites:sprites_a679_Sprite_new + FfiConverterOptionalTypePoint.lower(initialPosition), + ) + } +@@ -331,7 +331,7 @@ + FfiConverterTypePoint.checkType("reference", reference); + FfiConverterTypeVector.checkType("direction", direction); + return UniFFIScaffolding.callAsync( +- 87, // sprites:sprites_accb_Sprite_new_relative_to ++ 87, // sprites:sprites_a679_Sprite_new_relative_to + FfiConverterTypePoint.lower(reference), + FfiConverterTypeVector.lower(direction), + ) +@@ -346,7 +346,7 @@ + const liftError = null; + const functionCall = () => { + return UniFFIScaffolding.callAsync( +- 88, // sprites:sprites_accb_Sprite_get_position ++ 88, // sprites:sprites_a679_Sprite_get_position + FfiConverterTypeSprite.lower(this), + ) + } +@@ -361,7 +361,7 @@ + const functionCall = () => { + FfiConverterTypePoint.checkType("position", position); + return UniFFIScaffolding.callAsync( +- 89, // sprites:sprites_accb_Sprite_move_to ++ 89, // sprites:sprites_a679_Sprite_move_to + FfiConverterTypeSprite.lower(this), + FfiConverterTypePoint.lower(position), + ) +@@ -377,7 +377,7 @@ + const functionCall = () => { + FfiConverterTypeVector.checkType("direction", direction); + return UniFFIScaffolding.callAsync( +- 90, // sprites:sprites_accb_Sprite_move_by ++ 90, // sprites:sprites_a679_Sprite_move_by + FfiConverterTypeSprite.lower(this), + FfiConverterTypeVector.lower(direction), + ) +@@ -567,7 +567,7 @@ + FfiConverterTypePoint.checkType("position", position); + FfiConverterTypeVector.checkType("direction", direction); + return UniFFIScaffolding.callAsync( +- 91, // sprites:sprites_accb_translate ++ 91, // sprites:sprites_a679_translate + FfiConverterTypePoint.lower(position), + FfiConverterTypeVector.lower(direction), + ) +diff -u -r --new-file firefox-108.0.orig/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustTodolist.jsm firefox-108.0/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustTodolist.jsm +--- firefox-108.0.orig/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustTodolist.jsm 2022-12-08 10:27:29.000000000 -0600 ++++ firefox-108.0/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustTodolist.jsm 2022-12-15 13:20:01.336880947 -0600 +@@ -287,7 +287,7 @@ + const liftError = null; + const functionCall = () => { + return UniFFIScaffolding.callAsync( +- 92, // todolist:todolist_aa33_TodoList_new ++ 92, // todolist:todolist_cd5b_TodoList_new + ) + } + try { +@@ -301,7 +301,7 @@ + const functionCall = () => { + FfiConverterString.checkType("todo", todo); + return UniFFIScaffolding.callAsync( +- 93, // todolist:todolist_aa33_TodoList_add_item ++ 93, // todolist:todolist_cd5b_TodoList_add_item + FfiConverterTypeTodoList.lower(this), + FfiConverterString.lower(todo), + ) +@@ -317,7 +317,7 @@ + const functionCall = () => { + FfiConverterTypeTodoEntry.checkType("entry", entry); + return UniFFIScaffolding.callAsync( +- 94, // todolist:todolist_aa33_TodoList_add_entry ++ 94, // todolist:todolist_cd5b_TodoList_add_entry + FfiConverterTypeTodoList.lower(this), + FfiConverterTypeTodoEntry.lower(entry), + ) +@@ -332,7 +332,7 @@ + const liftError = null; + const functionCall = () => { + return UniFFIScaffolding.callAsync( +- 95, // todolist:todolist_aa33_TodoList_get_entries ++ 95, // todolist:todolist_cd5b_TodoList_get_entries + FfiConverterTypeTodoList.lower(this), + ) + } +@@ -346,7 +346,7 @@ + const liftError = null; + const functionCall = () => { + return UniFFIScaffolding.callAsync( +- 96, // todolist:todolist_aa33_TodoList_get_items ++ 96, // todolist:todolist_cd5b_TodoList_get_items + FfiConverterTypeTodoList.lower(this), + ) + } +@@ -361,7 +361,7 @@ + const functionCall = () => { + FfiConverterSequenceTypeTodoEntry.checkType("entries", entries); + return UniFFIScaffolding.callAsync( +- 97, // todolist:todolist_aa33_TodoList_add_entries ++ 97, // todolist:todolist_cd5b_TodoList_add_entries + FfiConverterTypeTodoList.lower(this), + FfiConverterSequenceTypeTodoEntry.lower(entries), + ) +@@ -377,7 +377,7 @@ + const functionCall = () => { + FfiConverterSequencestring.checkType("items", items); + return UniFFIScaffolding.callAsync( +- 98, // todolist:todolist_aa33_TodoList_add_items ++ 98, // todolist:todolist_cd5b_TodoList_add_items + FfiConverterTypeTodoList.lower(this), + FfiConverterSequencestring.lower(items), + ) +@@ -392,7 +392,7 @@ + const liftError = (data) => FfiConverterTypeTodoError.lift(data); + const functionCall = () => { + return UniFFIScaffolding.callAsync( +- 99, // todolist:todolist_aa33_TodoList_get_last_entry ++ 99, // todolist:todolist_cd5b_TodoList_get_last_entry + FfiConverterTypeTodoList.lower(this), + ) + } +@@ -406,7 +406,7 @@ + const liftError = (data) => FfiConverterTypeTodoError.lift(data); + const functionCall = () => { + return UniFFIScaffolding.callAsync( +- 100, // todolist:todolist_aa33_TodoList_get_last ++ 100, // todolist:todolist_cd5b_TodoList_get_last + FfiConverterTypeTodoList.lower(this), + ) + } +@@ -420,7 +420,7 @@ + const liftError = (data) => FfiConverterTypeTodoError.lift(data); + const functionCall = () => { + return UniFFIScaffolding.callAsync( +- 101, // todolist:todolist_aa33_TodoList_get_first ++ 101, // todolist:todolist_cd5b_TodoList_get_first + FfiConverterTypeTodoList.lower(this), + ) + } +@@ -435,7 +435,7 @@ + const functionCall = () => { + FfiConverterString.checkType("todo", todo); + return UniFFIScaffolding.callAsync( +- 102, // todolist:todolist_aa33_TodoList_clear_item ++ 102, // todolist:todolist_cd5b_TodoList_clear_item + FfiConverterTypeTodoList.lower(this), + FfiConverterString.lower(todo), + ) +@@ -450,7 +450,7 @@ + const liftError = null; + const functionCall = () => { + return UniFFIScaffolding.callAsync( +- 103, // todolist:todolist_aa33_TodoList_make_default ++ 103, // todolist:todolist_cd5b_TodoList_make_default + FfiConverterTypeTodoList.lower(this), + ) + } +@@ -711,7 +711,7 @@ + const liftError = null; + const functionCall = () => { + return UniFFIScaffolding.callAsync( +- 104, // todolist:todolist_aa33_get_default_list ++ 104, // todolist:todolist_cd5b_get_default_list + ) + } + try { +@@ -729,7 +729,7 @@ + const functionCall = () => { + FfiConverterTypeTodoList.checkType("list", list); + return UniFFIScaffolding.callAsync( +- 105, // todolist:todolist_aa33_set_default_list ++ 105, // todolist:todolist_cd5b_set_default_list + FfiConverterTypeTodoList.lower(list), + ) + } +@@ -748,7 +748,7 @@ + const functionCall = () => { + FfiConverterString.checkType("todo", todo); + return UniFFIScaffolding.callAsync( +- 106, // todolist:todolist_aa33_create_entry_with ++ 106, // todolist:todolist_cd5b_create_entry_with + FfiConverterString.lower(todo), + ) + } +diff -u -r --new-file firefox-108.0.orig/toolkit/components/uniffi-js/UniFFIFixtureScaffolding.cpp firefox-108.0/toolkit/components/uniffi-js/UniFFIFixtureScaffolding.cpp +--- firefox-108.0.orig/toolkit/components/uniffi-js/UniFFIFixtureScaffolding.cpp 2022-12-08 10:27:29.000000000 -0600 ++++ firefox-108.0/toolkit/components/uniffi-js/UniFFIFixtureScaffolding.cpp 2022-12-15 13:20:01.332880947 -0600 +@@ -19,481 +19,481 @@ + + // Define scaffolding functions from UniFFI + extern "C" { +- double geometry_1cce_gradient(RustBuffer, RustCallStatus*); +- RustBuffer geometry_1cce_intersection(RustBuffer, RustBuffer, RustCallStatus*); +- uint64_t arithmetic_906c_add(uint64_t, uint64_t, RustCallStatus*); +- uint64_t arithmetic_906c_sub(uint64_t, uint64_t, RustCallStatus*); +- uint64_t arithmetic_906c_div(uint64_t, uint64_t, RustCallStatus*); +- int8_t arithmetic_906c_equal(uint64_t, uint64_t, RustCallStatus*); +- void ffi_rondpoint_c6ef_Retourneur_object_free(void *, RustCallStatus*); +- void * rondpoint_c6ef_Retourneur_new(RustCallStatus*); +- int8_t rondpoint_c6ef_Retourneur_identique_i8(void *, int8_t, RustCallStatus*); +- uint8_t rondpoint_c6ef_Retourneur_identique_u8(void *, uint8_t, RustCallStatus*); +- int16_t rondpoint_c6ef_Retourneur_identique_i16(void *, int16_t, RustCallStatus*); +- uint16_t rondpoint_c6ef_Retourneur_identique_u16(void *, uint16_t, RustCallStatus*); +- int32_t rondpoint_c6ef_Retourneur_identique_i32(void *, int32_t, RustCallStatus*); +- uint32_t rondpoint_c6ef_Retourneur_identique_u32(void *, uint32_t, RustCallStatus*); +- int64_t rondpoint_c6ef_Retourneur_identique_i64(void *, int64_t, RustCallStatus*); +- uint64_t rondpoint_c6ef_Retourneur_identique_u64(void *, uint64_t, RustCallStatus*); +- float rondpoint_c6ef_Retourneur_identique_float(void *, float, RustCallStatus*); +- double rondpoint_c6ef_Retourneur_identique_double(void *, double, RustCallStatus*); +- int8_t rondpoint_c6ef_Retourneur_identique_boolean(void *, int8_t, RustCallStatus*); +- RustBuffer rondpoint_c6ef_Retourneur_identique_string(void *, RustBuffer, RustCallStatus*); +- RustBuffer rondpoint_c6ef_Retourneur_identique_nombres_signes(void *, RustBuffer, RustCallStatus*); +- RustBuffer rondpoint_c6ef_Retourneur_identique_nombres(void *, RustBuffer, RustCallStatus*); +- RustBuffer rondpoint_c6ef_Retourneur_identique_optionneur_dictionnaire(void *, RustBuffer, RustCallStatus*); +- void ffi_rondpoint_c6ef_Stringifier_object_free(void *, RustCallStatus*); +- void * rondpoint_c6ef_Stringifier_new(RustCallStatus*); +- RustBuffer rondpoint_c6ef_Stringifier_well_known_string(void *, RustBuffer, RustCallStatus*); +- RustBuffer rondpoint_c6ef_Stringifier_to_string_i8(void *, int8_t, RustCallStatus*); +- RustBuffer rondpoint_c6ef_Stringifier_to_string_u8(void *, uint8_t, RustCallStatus*); +- RustBuffer rondpoint_c6ef_Stringifier_to_string_i16(void *, int16_t, RustCallStatus*); +- RustBuffer rondpoint_c6ef_Stringifier_to_string_u16(void *, uint16_t, RustCallStatus*); +- RustBuffer rondpoint_c6ef_Stringifier_to_string_i32(void *, int32_t, RustCallStatus*); +- RustBuffer rondpoint_c6ef_Stringifier_to_string_u32(void *, uint32_t, RustCallStatus*); +- RustBuffer rondpoint_c6ef_Stringifier_to_string_i64(void *, int64_t, RustCallStatus*); +- RustBuffer rondpoint_c6ef_Stringifier_to_string_u64(void *, uint64_t, RustCallStatus*); +- RustBuffer rondpoint_c6ef_Stringifier_to_string_float(void *, float, RustCallStatus*); +- RustBuffer rondpoint_c6ef_Stringifier_to_string_double(void *, double, RustCallStatus*); +- RustBuffer rondpoint_c6ef_Stringifier_to_string_boolean(void *, int8_t, RustCallStatus*); +- void ffi_rondpoint_c6ef_Optionneur_object_free(void *, RustCallStatus*); +- void * rondpoint_c6ef_Optionneur_new(RustCallStatus*); +- int8_t rondpoint_c6ef_Optionneur_sinon_boolean(void *, int8_t, RustCallStatus*); +- RustBuffer rondpoint_c6ef_Optionneur_sinon_string(void *, RustBuffer, RustCallStatus*); +- RustBuffer rondpoint_c6ef_Optionneur_sinon_sequence(void *, RustBuffer, RustCallStatus*); +- RustBuffer rondpoint_c6ef_Optionneur_sinon_null(void *, RustBuffer, RustCallStatus*); +- RustBuffer rondpoint_c6ef_Optionneur_sinon_zero(void *, RustBuffer, RustCallStatus*); +- uint8_t rondpoint_c6ef_Optionneur_sinon_u8_dec(void *, uint8_t, RustCallStatus*); +- int8_t rondpoint_c6ef_Optionneur_sinon_i8_dec(void *, int8_t, RustCallStatus*); +- uint16_t rondpoint_c6ef_Optionneur_sinon_u16_dec(void *, uint16_t, RustCallStatus*); +- int16_t rondpoint_c6ef_Optionneur_sinon_i16_dec(void *, int16_t, RustCallStatus*); +- uint32_t rondpoint_c6ef_Optionneur_sinon_u32_dec(void *, uint32_t, RustCallStatus*); +- int32_t rondpoint_c6ef_Optionneur_sinon_i32_dec(void *, int32_t, RustCallStatus*); +- uint64_t rondpoint_c6ef_Optionneur_sinon_u64_dec(void *, uint64_t, RustCallStatus*); +- int64_t rondpoint_c6ef_Optionneur_sinon_i64_dec(void *, int64_t, RustCallStatus*); +- uint8_t rondpoint_c6ef_Optionneur_sinon_u8_hex(void *, uint8_t, RustCallStatus*); +- int8_t rondpoint_c6ef_Optionneur_sinon_i8_hex(void *, int8_t, RustCallStatus*); +- uint16_t rondpoint_c6ef_Optionneur_sinon_u16_hex(void *, uint16_t, RustCallStatus*); +- int16_t rondpoint_c6ef_Optionneur_sinon_i16_hex(void *, int16_t, RustCallStatus*); +- uint32_t rondpoint_c6ef_Optionneur_sinon_u32_hex(void *, uint32_t, RustCallStatus*); +- int32_t rondpoint_c6ef_Optionneur_sinon_i32_hex(void *, int32_t, RustCallStatus*); +- uint64_t rondpoint_c6ef_Optionneur_sinon_u64_hex(void *, uint64_t, RustCallStatus*); +- int64_t rondpoint_c6ef_Optionneur_sinon_i64_hex(void *, int64_t, RustCallStatus*); +- uint32_t rondpoint_c6ef_Optionneur_sinon_u32_oct(void *, uint32_t, RustCallStatus*); +- float rondpoint_c6ef_Optionneur_sinon_f32(void *, float, RustCallStatus*); +- double rondpoint_c6ef_Optionneur_sinon_f64(void *, double, RustCallStatus*); +- RustBuffer rondpoint_c6ef_Optionneur_sinon_enum(void *, RustBuffer, RustCallStatus*); +- RustBuffer rondpoint_c6ef_copie_dictionnaire(RustBuffer, RustCallStatus*); +- RustBuffer rondpoint_c6ef_copie_enumeration(RustBuffer, RustCallStatus*); +- RustBuffer rondpoint_c6ef_copie_enumerations(RustBuffer, RustCallStatus*); +- RustBuffer rondpoint_c6ef_copie_carte(RustBuffer, RustCallStatus*); +- int8_t rondpoint_c6ef_switcheroo(int8_t, RustCallStatus*); +- void ffi_sprites_accb_Sprite_object_free(void *, RustCallStatus*); +- void * sprites_accb_Sprite_new(RustBuffer, RustCallStatus*); +- void * sprites_accb_Sprite_new_relative_to(RustBuffer, RustBuffer, RustCallStatus*); +- RustBuffer sprites_accb_Sprite_get_position(void *, RustCallStatus*); +- void sprites_accb_Sprite_move_to(void *, RustBuffer, RustCallStatus*); +- void sprites_accb_Sprite_move_by(void *, RustBuffer, RustCallStatus*); +- RustBuffer sprites_accb_translate(RustBuffer, RustBuffer, RustCallStatus*); +- void ffi_todolist_aa33_TodoList_object_free(void *, RustCallStatus*); +- void * todolist_aa33_TodoList_new(RustCallStatus*); +- void todolist_aa33_TodoList_add_item(void *, RustBuffer, RustCallStatus*); +- void todolist_aa33_TodoList_add_entry(void *, RustBuffer, RustCallStatus*); +- RustBuffer todolist_aa33_TodoList_get_entries(void *, RustCallStatus*); +- RustBuffer todolist_aa33_TodoList_get_items(void *, RustCallStatus*); +- void todolist_aa33_TodoList_add_entries(void *, RustBuffer, RustCallStatus*); +- void todolist_aa33_TodoList_add_items(void *, RustBuffer, RustCallStatus*); +- RustBuffer todolist_aa33_TodoList_get_last_entry(void *, RustCallStatus*); +- RustBuffer todolist_aa33_TodoList_get_last(void *, RustCallStatus*); +- RustBuffer todolist_aa33_TodoList_get_first(void *, RustCallStatus*); +- void todolist_aa33_TodoList_clear_item(void *, RustBuffer, RustCallStatus*); +- void todolist_aa33_TodoList_make_default(void *, RustCallStatus*); +- RustBuffer todolist_aa33_get_default_list(RustCallStatus*); +- void todolist_aa33_set_default_list(void *, RustCallStatus*); +- RustBuffer todolist_aa33_create_entry_with(RustBuffer, RustCallStatus*); +- RustBuffer custom_types_8ecd_get_custom_types_demo(RustBuffer, RustCallStatus*); +- double external_types_54cc_gradient(RustBuffer, RustCallStatus*); ++ double geometry_deb7_gradient(RustBuffer, RustCallStatus*); ++ RustBuffer geometry_deb7_intersection(RustBuffer, RustBuffer, RustCallStatus*); ++ uint64_t arithmetic_be49_add(uint64_t, uint64_t, RustCallStatus*); ++ uint64_t arithmetic_be49_sub(uint64_t, uint64_t, RustCallStatus*); ++ uint64_t arithmetic_be49_div(uint64_t, uint64_t, RustCallStatus*); ++ int8_t arithmetic_be49_equal(uint64_t, uint64_t, RustCallStatus*); ++ void ffi_rondpoint_33e7_Retourneur_object_free(void *, RustCallStatus*); ++ void * rondpoint_33e7_Retourneur_new(RustCallStatus*); ++ int8_t rondpoint_33e7_Retourneur_identique_i8(void *, int8_t, RustCallStatus*); ++ uint8_t rondpoint_33e7_Retourneur_identique_u8(void *, uint8_t, RustCallStatus*); ++ int16_t rondpoint_33e7_Retourneur_identique_i16(void *, int16_t, RustCallStatus*); ++ uint16_t rondpoint_33e7_Retourneur_identique_u16(void *, uint16_t, RustCallStatus*); ++ int32_t rondpoint_33e7_Retourneur_identique_i32(void *, int32_t, RustCallStatus*); ++ uint32_t rondpoint_33e7_Retourneur_identique_u32(void *, uint32_t, RustCallStatus*); ++ int64_t rondpoint_33e7_Retourneur_identique_i64(void *, int64_t, RustCallStatus*); ++ uint64_t rondpoint_33e7_Retourneur_identique_u64(void *, uint64_t, RustCallStatus*); ++ float rondpoint_33e7_Retourneur_identique_float(void *, float, RustCallStatus*); ++ double rondpoint_33e7_Retourneur_identique_double(void *, double, RustCallStatus*); ++ int8_t rondpoint_33e7_Retourneur_identique_boolean(void *, int8_t, RustCallStatus*); ++ RustBuffer rondpoint_33e7_Retourneur_identique_string(void *, RustBuffer, RustCallStatus*); ++ RustBuffer rondpoint_33e7_Retourneur_identique_nombres_signes(void *, RustBuffer, RustCallStatus*); ++ RustBuffer rondpoint_33e7_Retourneur_identique_nombres(void *, RustBuffer, RustCallStatus*); ++ RustBuffer rondpoint_33e7_Retourneur_identique_optionneur_dictionnaire(void *, RustBuffer, RustCallStatus*); ++ void ffi_rondpoint_33e7_Stringifier_object_free(void *, RustCallStatus*); ++ void * rondpoint_33e7_Stringifier_new(RustCallStatus*); ++ RustBuffer rondpoint_33e7_Stringifier_well_known_string(void *, RustBuffer, RustCallStatus*); ++ RustBuffer rondpoint_33e7_Stringifier_to_string_i8(void *, int8_t, RustCallStatus*); ++ RustBuffer rondpoint_33e7_Stringifier_to_string_u8(void *, uint8_t, RustCallStatus*); ++ RustBuffer rondpoint_33e7_Stringifier_to_string_i16(void *, int16_t, RustCallStatus*); ++ RustBuffer rondpoint_33e7_Stringifier_to_string_u16(void *, uint16_t, RustCallStatus*); ++ RustBuffer rondpoint_33e7_Stringifier_to_string_i32(void *, int32_t, RustCallStatus*); ++ RustBuffer rondpoint_33e7_Stringifier_to_string_u32(void *, uint32_t, RustCallStatus*); ++ RustBuffer rondpoint_33e7_Stringifier_to_string_i64(void *, int64_t, RustCallStatus*); ++ RustBuffer rondpoint_33e7_Stringifier_to_string_u64(void *, uint64_t, RustCallStatus*); ++ RustBuffer rondpoint_33e7_Stringifier_to_string_float(void *, float, RustCallStatus*); ++ RustBuffer rondpoint_33e7_Stringifier_to_string_double(void *, double, RustCallStatus*); ++ RustBuffer rondpoint_33e7_Stringifier_to_string_boolean(void *, int8_t, RustCallStatus*); ++ void ffi_rondpoint_33e7_Optionneur_object_free(void *, RustCallStatus*); ++ void * rondpoint_33e7_Optionneur_new(RustCallStatus*); ++ int8_t rondpoint_33e7_Optionneur_sinon_boolean(void *, int8_t, RustCallStatus*); ++ RustBuffer rondpoint_33e7_Optionneur_sinon_string(void *, RustBuffer, RustCallStatus*); ++ RustBuffer rondpoint_33e7_Optionneur_sinon_sequence(void *, RustBuffer, RustCallStatus*); ++ RustBuffer rondpoint_33e7_Optionneur_sinon_null(void *, RustBuffer, RustCallStatus*); ++ RustBuffer rondpoint_33e7_Optionneur_sinon_zero(void *, RustBuffer, RustCallStatus*); ++ uint8_t rondpoint_33e7_Optionneur_sinon_u8_dec(void *, uint8_t, RustCallStatus*); ++ int8_t rondpoint_33e7_Optionneur_sinon_i8_dec(void *, int8_t, RustCallStatus*); ++ uint16_t rondpoint_33e7_Optionneur_sinon_u16_dec(void *, uint16_t, RustCallStatus*); ++ int16_t rondpoint_33e7_Optionneur_sinon_i16_dec(void *, int16_t, RustCallStatus*); ++ uint32_t rondpoint_33e7_Optionneur_sinon_u32_dec(void *, uint32_t, RustCallStatus*); ++ int32_t rondpoint_33e7_Optionneur_sinon_i32_dec(void *, int32_t, RustCallStatus*); ++ uint64_t rondpoint_33e7_Optionneur_sinon_u64_dec(void *, uint64_t, RustCallStatus*); ++ int64_t rondpoint_33e7_Optionneur_sinon_i64_dec(void *, int64_t, RustCallStatus*); ++ uint8_t rondpoint_33e7_Optionneur_sinon_u8_hex(void *, uint8_t, RustCallStatus*); ++ int8_t rondpoint_33e7_Optionneur_sinon_i8_hex(void *, int8_t, RustCallStatus*); ++ uint16_t rondpoint_33e7_Optionneur_sinon_u16_hex(void *, uint16_t, RustCallStatus*); ++ int16_t rondpoint_33e7_Optionneur_sinon_i16_hex(void *, int16_t, RustCallStatus*); ++ uint32_t rondpoint_33e7_Optionneur_sinon_u32_hex(void *, uint32_t, RustCallStatus*); ++ int32_t rondpoint_33e7_Optionneur_sinon_i32_hex(void *, int32_t, RustCallStatus*); ++ uint64_t rondpoint_33e7_Optionneur_sinon_u64_hex(void *, uint64_t, RustCallStatus*); ++ int64_t rondpoint_33e7_Optionneur_sinon_i64_hex(void *, int64_t, RustCallStatus*); ++ uint32_t rondpoint_33e7_Optionneur_sinon_u32_oct(void *, uint32_t, RustCallStatus*); ++ float rondpoint_33e7_Optionneur_sinon_f32(void *, float, RustCallStatus*); ++ double rondpoint_33e7_Optionneur_sinon_f64(void *, double, RustCallStatus*); ++ RustBuffer rondpoint_33e7_Optionneur_sinon_enum(void *, RustBuffer, RustCallStatus*); ++ RustBuffer rondpoint_33e7_copie_dictionnaire(RustBuffer, RustCallStatus*); ++ RustBuffer rondpoint_33e7_copie_enumeration(RustBuffer, RustCallStatus*); ++ RustBuffer rondpoint_33e7_copie_enumerations(RustBuffer, RustCallStatus*); ++ RustBuffer rondpoint_33e7_copie_carte(RustBuffer, RustCallStatus*); ++ int8_t rondpoint_33e7_switcheroo(int8_t, RustCallStatus*); ++ void ffi_sprites_a679_Sprite_object_free(void *, RustCallStatus*); ++ void * sprites_a679_Sprite_new(RustBuffer, RustCallStatus*); ++ void * sprites_a679_Sprite_new_relative_to(RustBuffer, RustBuffer, RustCallStatus*); ++ RustBuffer sprites_a679_Sprite_get_position(void *, RustCallStatus*); ++ void sprites_a679_Sprite_move_to(void *, RustBuffer, RustCallStatus*); ++ void sprites_a679_Sprite_move_by(void *, RustBuffer, RustCallStatus*); ++ RustBuffer sprites_a679_translate(RustBuffer, RustBuffer, RustCallStatus*); ++ void ffi_todolist_cd5b_TodoList_object_free(void *, RustCallStatus*); ++ void * todolist_cd5b_TodoList_new(RustCallStatus*); ++ void todolist_cd5b_TodoList_add_item(void *, RustBuffer, RustCallStatus*); ++ void todolist_cd5b_TodoList_add_entry(void *, RustBuffer, RustCallStatus*); ++ RustBuffer todolist_cd5b_TodoList_get_entries(void *, RustCallStatus*); ++ RustBuffer todolist_cd5b_TodoList_get_items(void *, RustCallStatus*); ++ void todolist_cd5b_TodoList_add_entries(void *, RustBuffer, RustCallStatus*); ++ void todolist_cd5b_TodoList_add_items(void *, RustBuffer, RustCallStatus*); ++ RustBuffer todolist_cd5b_TodoList_get_last_entry(void *, RustCallStatus*); ++ RustBuffer todolist_cd5b_TodoList_get_last(void *, RustCallStatus*); ++ RustBuffer todolist_cd5b_TodoList_get_first(void *, RustCallStatus*); ++ void todolist_cd5b_TodoList_clear_item(void *, RustBuffer, RustCallStatus*); ++ void todolist_cd5b_TodoList_make_default(void *, RustCallStatus*); ++ RustBuffer todolist_cd5b_get_default_list(RustCallStatus*); ++ void todolist_cd5b_set_default_list(void *, RustCallStatus*); ++ RustBuffer todolist_cd5b_create_entry_with(RustBuffer, RustCallStatus*); ++ RustBuffer custom_types_41fc_get_custom_types_demo(RustBuffer, RustCallStatus*); ++ double external_types_4cd4_gradient(RustBuffer, RustCallStatus*); + } + + // Define pointer types + const static mozilla::uniffi::UniFFIPointerType kRondpointRetourneurPointerType { + "rondpoint::Retourneur"_ns, +- ffi_rondpoint_c6ef_Retourneur_object_free ++ ffi_rondpoint_33e7_Retourneur_object_free + }; + const static mozilla::uniffi::UniFFIPointerType kRondpointStringifierPointerType { + "rondpoint::Stringifier"_ns, +- ffi_rondpoint_c6ef_Stringifier_object_free ++ ffi_rondpoint_33e7_Stringifier_object_free + }; + const static mozilla::uniffi::UniFFIPointerType kRondpointOptionneurPointerType { + "rondpoint::Optionneur"_ns, +- ffi_rondpoint_c6ef_Optionneur_object_free ++ ffi_rondpoint_33e7_Optionneur_object_free + }; + const static mozilla::uniffi::UniFFIPointerType kSpritesSpritePointerType { + "sprites::Sprite"_ns, +- ffi_sprites_accb_Sprite_object_free ++ ffi_sprites_a679_Sprite_object_free + }; + const static mozilla::uniffi::UniFFIPointerType kTodolistTodoListPointerType { + "todolist::TodoList"_ns, +- ffi_todolist_aa33_TodoList_object_free ++ ffi_todolist_cd5b_TodoList_object_free + }; + + Maybe<already_AddRefed<Promise>> UniFFIFixturesCallAsync(const GlobalObject& aGlobal, uint64_t aId, const Sequence<ScaffoldingType>& aArgs, ErrorResult& aError) { + switch (aId) { +- case 20: { // geometry:geometry_1cce_gradient ++ case 20: { // geometry:geometry_deb7_gradient + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<double>, ScaffoldingConverter<RustBuffer>>; +- return Some(CallHandler::CallAsync(geometry_1cce_gradient, aGlobal, aArgs, "geometry_1cce_gradient: "_ns, aError)); ++ return Some(CallHandler::CallAsync(geometry_deb7_gradient, aGlobal, aArgs, "geometry_deb7_gradient: "_ns, aError)); + } +- case 21: { // geometry:geometry_1cce_intersection ++ case 21: { // geometry:geometry_deb7_intersection + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>>; +- return Some(CallHandler::CallAsync(geometry_1cce_intersection, aGlobal, aArgs, "geometry_1cce_intersection: "_ns, aError)); ++ return Some(CallHandler::CallAsync(geometry_deb7_intersection, aGlobal, aArgs, "geometry_deb7_intersection: "_ns, aError)); + } +- case 22: { // arithmetic:arithmetic_906c_add ++ case 22: { // arithmetic:arithmetic_be49_add + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint64_t>, ScaffoldingConverter<uint64_t>, ScaffoldingConverter<uint64_t>>; +- return Some(CallHandler::CallAsync(arithmetic_906c_add, aGlobal, aArgs, "arithmetic_906c_add: "_ns, aError)); ++ return Some(CallHandler::CallAsync(arithmetic_be49_add, aGlobal, aArgs, "arithmetic_be49_add: "_ns, aError)); + } +- case 23: { // arithmetic:arithmetic_906c_sub ++ case 23: { // arithmetic:arithmetic_be49_sub + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint64_t>, ScaffoldingConverter<uint64_t>, ScaffoldingConverter<uint64_t>>; +- return Some(CallHandler::CallAsync(arithmetic_906c_sub, aGlobal, aArgs, "arithmetic_906c_sub: "_ns, aError)); ++ return Some(CallHandler::CallAsync(arithmetic_be49_sub, aGlobal, aArgs, "arithmetic_be49_sub: "_ns, aError)); + } +- case 24: { // arithmetic:arithmetic_906c_div ++ case 24: { // arithmetic:arithmetic_be49_div + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint64_t>, ScaffoldingConverter<uint64_t>, ScaffoldingConverter<uint64_t>>; +- return Some(CallHandler::CallAsync(arithmetic_906c_div, aGlobal, aArgs, "arithmetic_906c_div: "_ns, aError)); ++ return Some(CallHandler::CallAsync(arithmetic_be49_div, aGlobal, aArgs, "arithmetic_be49_div: "_ns, aError)); + } +- case 25: { // arithmetic:arithmetic_906c_equal ++ case 25: { // arithmetic:arithmetic_be49_equal + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int8_t>, ScaffoldingConverter<uint64_t>, ScaffoldingConverter<uint64_t>>; +- return Some(CallHandler::CallAsync(arithmetic_906c_equal, aGlobal, aArgs, "arithmetic_906c_equal: "_ns, aError)); ++ return Some(CallHandler::CallAsync(arithmetic_be49_equal, aGlobal, aArgs, "arithmetic_be49_equal: "_ns, aError)); + } +- case 26: { // rondpoint:rondpoint_c6ef_Retourneur_new ++ case 26: { // rondpoint:rondpoint_33e7_Retourneur_new + using CallHandler = ScaffoldingCallHandler<ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Retourneur_new, aGlobal, aArgs, "rondpoint_c6ef_Retourneur_new: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Retourneur_new, aGlobal, aArgs, "rondpoint_33e7_Retourneur_new: "_ns, aError)); + } +- case 27: { // rondpoint:rondpoint_c6ef_Retourneur_identique_i8 ++ case 27: { // rondpoint:rondpoint_33e7_Retourneur_identique_i8 + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int8_t>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<int8_t>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Retourneur_identique_i8, aGlobal, aArgs, "rondpoint_c6ef_Retourneur_identique_i8: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Retourneur_identique_i8, aGlobal, aArgs, "rondpoint_33e7_Retourneur_identique_i8: "_ns, aError)); + } +- case 28: { // rondpoint:rondpoint_c6ef_Retourneur_identique_u8 ++ case 28: { // rondpoint:rondpoint_33e7_Retourneur_identique_u8 + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint8_t>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<uint8_t>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Retourneur_identique_u8, aGlobal, aArgs, "rondpoint_c6ef_Retourneur_identique_u8: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Retourneur_identique_u8, aGlobal, aArgs, "rondpoint_33e7_Retourneur_identique_u8: "_ns, aError)); + } +- case 29: { // rondpoint:rondpoint_c6ef_Retourneur_identique_i16 ++ case 29: { // rondpoint:rondpoint_33e7_Retourneur_identique_i16 + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int16_t>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<int16_t>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Retourneur_identique_i16, aGlobal, aArgs, "rondpoint_c6ef_Retourneur_identique_i16: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Retourneur_identique_i16, aGlobal, aArgs, "rondpoint_33e7_Retourneur_identique_i16: "_ns, aError)); + } +- case 30: { // rondpoint:rondpoint_c6ef_Retourneur_identique_u16 ++ case 30: { // rondpoint:rondpoint_33e7_Retourneur_identique_u16 + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint16_t>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<uint16_t>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Retourneur_identique_u16, aGlobal, aArgs, "rondpoint_c6ef_Retourneur_identique_u16: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Retourneur_identique_u16, aGlobal, aArgs, "rondpoint_33e7_Retourneur_identique_u16: "_ns, aError)); + } +- case 31: { // rondpoint:rondpoint_c6ef_Retourneur_identique_i32 ++ case 31: { // rondpoint:rondpoint_33e7_Retourneur_identique_i32 + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int32_t>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<int32_t>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Retourneur_identique_i32, aGlobal, aArgs, "rondpoint_c6ef_Retourneur_identique_i32: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Retourneur_identique_i32, aGlobal, aArgs, "rondpoint_33e7_Retourneur_identique_i32: "_ns, aError)); + } +- case 32: { // rondpoint:rondpoint_c6ef_Retourneur_identique_u32 ++ case 32: { // rondpoint:rondpoint_33e7_Retourneur_identique_u32 + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint32_t>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<uint32_t>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Retourneur_identique_u32, aGlobal, aArgs, "rondpoint_c6ef_Retourneur_identique_u32: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Retourneur_identique_u32, aGlobal, aArgs, "rondpoint_33e7_Retourneur_identique_u32: "_ns, aError)); + } +- case 33: { // rondpoint:rondpoint_c6ef_Retourneur_identique_i64 ++ case 33: { // rondpoint:rondpoint_33e7_Retourneur_identique_i64 + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int64_t>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<int64_t>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Retourneur_identique_i64, aGlobal, aArgs, "rondpoint_c6ef_Retourneur_identique_i64: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Retourneur_identique_i64, aGlobal, aArgs, "rondpoint_33e7_Retourneur_identique_i64: "_ns, aError)); + } +- case 34: { // rondpoint:rondpoint_c6ef_Retourneur_identique_u64 ++ case 34: { // rondpoint:rondpoint_33e7_Retourneur_identique_u64 + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint64_t>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<uint64_t>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Retourneur_identique_u64, aGlobal, aArgs, "rondpoint_c6ef_Retourneur_identique_u64: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Retourneur_identique_u64, aGlobal, aArgs, "rondpoint_33e7_Retourneur_identique_u64: "_ns, aError)); + } +- case 35: { // rondpoint:rondpoint_c6ef_Retourneur_identique_float ++ case 35: { // rondpoint:rondpoint_33e7_Retourneur_identique_float + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<float>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<float>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Retourneur_identique_float, aGlobal, aArgs, "rondpoint_c6ef_Retourneur_identique_float: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Retourneur_identique_float, aGlobal, aArgs, "rondpoint_33e7_Retourneur_identique_float: "_ns, aError)); + } +- case 36: { // rondpoint:rondpoint_c6ef_Retourneur_identique_double ++ case 36: { // rondpoint:rondpoint_33e7_Retourneur_identique_double + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<double>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<double>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Retourneur_identique_double, aGlobal, aArgs, "rondpoint_c6ef_Retourneur_identique_double: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Retourneur_identique_double, aGlobal, aArgs, "rondpoint_33e7_Retourneur_identique_double: "_ns, aError)); + } +- case 37: { // rondpoint:rondpoint_c6ef_Retourneur_identique_boolean ++ case 37: { // rondpoint:rondpoint_33e7_Retourneur_identique_boolean + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int8_t>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<int8_t>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Retourneur_identique_boolean, aGlobal, aArgs, "rondpoint_c6ef_Retourneur_identique_boolean: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Retourneur_identique_boolean, aGlobal, aArgs, "rondpoint_33e7_Retourneur_identique_boolean: "_ns, aError)); + } +- case 38: { // rondpoint:rondpoint_c6ef_Retourneur_identique_string ++ case 38: { // rondpoint:rondpoint_33e7_Retourneur_identique_string + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<RustBuffer>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Retourneur_identique_string, aGlobal, aArgs, "rondpoint_c6ef_Retourneur_identique_string: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Retourneur_identique_string, aGlobal, aArgs, "rondpoint_33e7_Retourneur_identique_string: "_ns, aError)); + } +- case 39: { // rondpoint:rondpoint_c6ef_Retourneur_identique_nombres_signes ++ case 39: { // rondpoint:rondpoint_33e7_Retourneur_identique_nombres_signes + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<RustBuffer>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Retourneur_identique_nombres_signes, aGlobal, aArgs, "rondpoint_c6ef_Retourneur_identique_nombres_signes: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Retourneur_identique_nombres_signes, aGlobal, aArgs, "rondpoint_33e7_Retourneur_identique_nombres_signes: "_ns, aError)); + } +- case 40: { // rondpoint:rondpoint_c6ef_Retourneur_identique_nombres ++ case 40: { // rondpoint:rondpoint_33e7_Retourneur_identique_nombres + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<RustBuffer>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Retourneur_identique_nombres, aGlobal, aArgs, "rondpoint_c6ef_Retourneur_identique_nombres: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Retourneur_identique_nombres, aGlobal, aArgs, "rondpoint_33e7_Retourneur_identique_nombres: "_ns, aError)); + } +- case 41: { // rondpoint:rondpoint_c6ef_Retourneur_identique_optionneur_dictionnaire ++ case 41: { // rondpoint:rondpoint_33e7_Retourneur_identique_optionneur_dictionnaire + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<RustBuffer>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Retourneur_identique_optionneur_dictionnaire, aGlobal, aArgs, "rondpoint_c6ef_Retourneur_identique_optionneur_dictionnaire: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Retourneur_identique_optionneur_dictionnaire, aGlobal, aArgs, "rondpoint_33e7_Retourneur_identique_optionneur_dictionnaire: "_ns, aError)); + } +- case 42: { // rondpoint:rondpoint_c6ef_Stringifier_new ++ case 42: { // rondpoint:rondpoint_33e7_Stringifier_new + using CallHandler = ScaffoldingCallHandler<ScaffoldingObjectConverter<&kRondpointStringifierPointerType>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Stringifier_new, aGlobal, aArgs, "rondpoint_c6ef_Stringifier_new: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Stringifier_new, aGlobal, aArgs, "rondpoint_33e7_Stringifier_new: "_ns, aError)); + } +- case 43: { // rondpoint:rondpoint_c6ef_Stringifier_well_known_string ++ case 43: { // rondpoint:rondpoint_33e7_Stringifier_well_known_string + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointStringifierPointerType>, ScaffoldingConverter<RustBuffer>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Stringifier_well_known_string, aGlobal, aArgs, "rondpoint_c6ef_Stringifier_well_known_string: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Stringifier_well_known_string, aGlobal, aArgs, "rondpoint_33e7_Stringifier_well_known_string: "_ns, aError)); + } +- case 44: { // rondpoint:rondpoint_c6ef_Stringifier_to_string_i8 ++ case 44: { // rondpoint:rondpoint_33e7_Stringifier_to_string_i8 + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointStringifierPointerType>, ScaffoldingConverter<int8_t>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Stringifier_to_string_i8, aGlobal, aArgs, "rondpoint_c6ef_Stringifier_to_string_i8: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Stringifier_to_string_i8, aGlobal, aArgs, "rondpoint_33e7_Stringifier_to_string_i8: "_ns, aError)); + } +- case 45: { // rondpoint:rondpoint_c6ef_Stringifier_to_string_u8 ++ case 45: { // rondpoint:rondpoint_33e7_Stringifier_to_string_u8 + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointStringifierPointerType>, ScaffoldingConverter<uint8_t>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Stringifier_to_string_u8, aGlobal, aArgs, "rondpoint_c6ef_Stringifier_to_string_u8: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Stringifier_to_string_u8, aGlobal, aArgs, "rondpoint_33e7_Stringifier_to_string_u8: "_ns, aError)); + } +- case 46: { // rondpoint:rondpoint_c6ef_Stringifier_to_string_i16 ++ case 46: { // rondpoint:rondpoint_33e7_Stringifier_to_string_i16 + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointStringifierPointerType>, ScaffoldingConverter<int16_t>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Stringifier_to_string_i16, aGlobal, aArgs, "rondpoint_c6ef_Stringifier_to_string_i16: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Stringifier_to_string_i16, aGlobal, aArgs, "rondpoint_33e7_Stringifier_to_string_i16: "_ns, aError)); + } +- case 47: { // rondpoint:rondpoint_c6ef_Stringifier_to_string_u16 ++ case 47: { // rondpoint:rondpoint_33e7_Stringifier_to_string_u16 + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointStringifierPointerType>, ScaffoldingConverter<uint16_t>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Stringifier_to_string_u16, aGlobal, aArgs, "rondpoint_c6ef_Stringifier_to_string_u16: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Stringifier_to_string_u16, aGlobal, aArgs, "rondpoint_33e7_Stringifier_to_string_u16: "_ns, aError)); + } +- case 48: { // rondpoint:rondpoint_c6ef_Stringifier_to_string_i32 ++ case 48: { // rondpoint:rondpoint_33e7_Stringifier_to_string_i32 + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointStringifierPointerType>, ScaffoldingConverter<int32_t>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Stringifier_to_string_i32, aGlobal, aArgs, "rondpoint_c6ef_Stringifier_to_string_i32: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Stringifier_to_string_i32, aGlobal, aArgs, "rondpoint_33e7_Stringifier_to_string_i32: "_ns, aError)); + } +- case 49: { // rondpoint:rondpoint_c6ef_Stringifier_to_string_u32 ++ case 49: { // rondpoint:rondpoint_33e7_Stringifier_to_string_u32 + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointStringifierPointerType>, ScaffoldingConverter<uint32_t>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Stringifier_to_string_u32, aGlobal, aArgs, "rondpoint_c6ef_Stringifier_to_string_u32: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Stringifier_to_string_u32, aGlobal, aArgs, "rondpoint_33e7_Stringifier_to_string_u32: "_ns, aError)); + } +- case 50: { // rondpoint:rondpoint_c6ef_Stringifier_to_string_i64 ++ case 50: { // rondpoint:rondpoint_33e7_Stringifier_to_string_i64 + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointStringifierPointerType>, ScaffoldingConverter<int64_t>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Stringifier_to_string_i64, aGlobal, aArgs, "rondpoint_c6ef_Stringifier_to_string_i64: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Stringifier_to_string_i64, aGlobal, aArgs, "rondpoint_33e7_Stringifier_to_string_i64: "_ns, aError)); + } +- case 51: { // rondpoint:rondpoint_c6ef_Stringifier_to_string_u64 ++ case 51: { // rondpoint:rondpoint_33e7_Stringifier_to_string_u64 + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointStringifierPointerType>, ScaffoldingConverter<uint64_t>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Stringifier_to_string_u64, aGlobal, aArgs, "rondpoint_c6ef_Stringifier_to_string_u64: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Stringifier_to_string_u64, aGlobal, aArgs, "rondpoint_33e7_Stringifier_to_string_u64: "_ns, aError)); + } +- case 52: { // rondpoint:rondpoint_c6ef_Stringifier_to_string_float ++ case 52: { // rondpoint:rondpoint_33e7_Stringifier_to_string_float + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointStringifierPointerType>, ScaffoldingConverter<float>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Stringifier_to_string_float, aGlobal, aArgs, "rondpoint_c6ef_Stringifier_to_string_float: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Stringifier_to_string_float, aGlobal, aArgs, "rondpoint_33e7_Stringifier_to_string_float: "_ns, aError)); + } +- case 53: { // rondpoint:rondpoint_c6ef_Stringifier_to_string_double ++ case 53: { // rondpoint:rondpoint_33e7_Stringifier_to_string_double + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointStringifierPointerType>, ScaffoldingConverter<double>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Stringifier_to_string_double, aGlobal, aArgs, "rondpoint_c6ef_Stringifier_to_string_double: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Stringifier_to_string_double, aGlobal, aArgs, "rondpoint_33e7_Stringifier_to_string_double: "_ns, aError)); + } +- case 54: { // rondpoint:rondpoint_c6ef_Stringifier_to_string_boolean ++ case 54: { // rondpoint:rondpoint_33e7_Stringifier_to_string_boolean + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointStringifierPointerType>, ScaffoldingConverter<int8_t>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Stringifier_to_string_boolean, aGlobal, aArgs, "rondpoint_c6ef_Stringifier_to_string_boolean: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Stringifier_to_string_boolean, aGlobal, aArgs, "rondpoint_33e7_Stringifier_to_string_boolean: "_ns, aError)); + } +- case 55: { // rondpoint:rondpoint_c6ef_Optionneur_new ++ case 55: { // rondpoint:rondpoint_33e7_Optionneur_new + using CallHandler = ScaffoldingCallHandler<ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_new, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_new: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_new, aGlobal, aArgs, "rondpoint_33e7_Optionneur_new: "_ns, aError)); + } +- case 56: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_boolean ++ case 56: { // rondpoint:rondpoint_33e7_Optionneur_sinon_boolean + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int8_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<int8_t>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_boolean, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_boolean: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_boolean, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_boolean: "_ns, aError)); + } +- case 57: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_string ++ case 57: { // rondpoint:rondpoint_33e7_Optionneur_sinon_string + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<RustBuffer>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_string, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_string: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_string, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_string: "_ns, aError)); + } +- case 58: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_sequence ++ case 58: { // rondpoint:rondpoint_33e7_Optionneur_sinon_sequence + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<RustBuffer>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_sequence, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_sequence: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_sequence, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_sequence: "_ns, aError)); + } +- case 59: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_null ++ case 59: { // rondpoint:rondpoint_33e7_Optionneur_sinon_null + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<RustBuffer>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_null, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_null: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_null, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_null: "_ns, aError)); + } +- case 60: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_zero ++ case 60: { // rondpoint:rondpoint_33e7_Optionneur_sinon_zero + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<RustBuffer>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_zero, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_zero: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_zero, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_zero: "_ns, aError)); + } +- case 61: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_u8_dec ++ case 61: { // rondpoint:rondpoint_33e7_Optionneur_sinon_u8_dec + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint8_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<uint8_t>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_u8_dec, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_u8_dec: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_u8_dec, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_u8_dec: "_ns, aError)); + } +- case 62: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_i8_dec ++ case 62: { // rondpoint:rondpoint_33e7_Optionneur_sinon_i8_dec + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int8_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<int8_t>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_i8_dec, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_i8_dec: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_i8_dec, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_i8_dec: "_ns, aError)); + } +- case 63: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_u16_dec ++ case 63: { // rondpoint:rondpoint_33e7_Optionneur_sinon_u16_dec + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint16_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<uint16_t>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_u16_dec, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_u16_dec: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_u16_dec, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_u16_dec: "_ns, aError)); + } +- case 64: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_i16_dec ++ case 64: { // rondpoint:rondpoint_33e7_Optionneur_sinon_i16_dec + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int16_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<int16_t>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_i16_dec, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_i16_dec: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_i16_dec, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_i16_dec: "_ns, aError)); + } +- case 65: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_u32_dec ++ case 65: { // rondpoint:rondpoint_33e7_Optionneur_sinon_u32_dec + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint32_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<uint32_t>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_u32_dec, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_u32_dec: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_u32_dec, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_u32_dec: "_ns, aError)); + } +- case 66: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_i32_dec ++ case 66: { // rondpoint:rondpoint_33e7_Optionneur_sinon_i32_dec + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int32_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<int32_t>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_i32_dec, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_i32_dec: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_i32_dec, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_i32_dec: "_ns, aError)); + } +- case 67: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_u64_dec ++ case 67: { // rondpoint:rondpoint_33e7_Optionneur_sinon_u64_dec + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint64_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<uint64_t>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_u64_dec, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_u64_dec: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_u64_dec, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_u64_dec: "_ns, aError)); + } +- case 68: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_i64_dec ++ case 68: { // rondpoint:rondpoint_33e7_Optionneur_sinon_i64_dec + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int64_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<int64_t>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_i64_dec, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_i64_dec: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_i64_dec, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_i64_dec: "_ns, aError)); + } +- case 69: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_u8_hex ++ case 69: { // rondpoint:rondpoint_33e7_Optionneur_sinon_u8_hex + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint8_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<uint8_t>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_u8_hex, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_u8_hex: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_u8_hex, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_u8_hex: "_ns, aError)); + } +- case 70: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_i8_hex ++ case 70: { // rondpoint:rondpoint_33e7_Optionneur_sinon_i8_hex + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int8_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<int8_t>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_i8_hex, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_i8_hex: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_i8_hex, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_i8_hex: "_ns, aError)); + } +- case 71: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_u16_hex ++ case 71: { // rondpoint:rondpoint_33e7_Optionneur_sinon_u16_hex + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint16_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<uint16_t>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_u16_hex, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_u16_hex: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_u16_hex, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_u16_hex: "_ns, aError)); + } +- case 72: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_i16_hex ++ case 72: { // rondpoint:rondpoint_33e7_Optionneur_sinon_i16_hex + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int16_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<int16_t>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_i16_hex, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_i16_hex: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_i16_hex, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_i16_hex: "_ns, aError)); + } +- case 73: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_u32_hex ++ case 73: { // rondpoint:rondpoint_33e7_Optionneur_sinon_u32_hex + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint32_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<uint32_t>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_u32_hex, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_u32_hex: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_u32_hex, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_u32_hex: "_ns, aError)); + } +- case 74: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_i32_hex ++ case 74: { // rondpoint:rondpoint_33e7_Optionneur_sinon_i32_hex + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int32_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<int32_t>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_i32_hex, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_i32_hex: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_i32_hex, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_i32_hex: "_ns, aError)); + } +- case 75: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_u64_hex ++ case 75: { // rondpoint:rondpoint_33e7_Optionneur_sinon_u64_hex + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint64_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<uint64_t>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_u64_hex, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_u64_hex: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_u64_hex, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_u64_hex: "_ns, aError)); + } +- case 76: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_i64_hex ++ case 76: { // rondpoint:rondpoint_33e7_Optionneur_sinon_i64_hex + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int64_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<int64_t>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_i64_hex, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_i64_hex: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_i64_hex, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_i64_hex: "_ns, aError)); + } +- case 77: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_u32_oct ++ case 77: { // rondpoint:rondpoint_33e7_Optionneur_sinon_u32_oct + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint32_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<uint32_t>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_u32_oct, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_u32_oct: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_u32_oct, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_u32_oct: "_ns, aError)); + } +- case 78: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_f32 ++ case 78: { // rondpoint:rondpoint_33e7_Optionneur_sinon_f32 + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<float>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<float>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_f32, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_f32: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_f32, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_f32: "_ns, aError)); + } +- case 79: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_f64 ++ case 79: { // rondpoint:rondpoint_33e7_Optionneur_sinon_f64 + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<double>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<double>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_f64, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_f64: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_f64, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_f64: "_ns, aError)); + } +- case 80: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_enum ++ case 80: { // rondpoint:rondpoint_33e7_Optionneur_sinon_enum + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<RustBuffer>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_enum, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_enum: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_enum, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_enum: "_ns, aError)); + } +- case 81: { // rondpoint:rondpoint_c6ef_copie_dictionnaire ++ case 81: { // rondpoint:rondpoint_33e7_copie_dictionnaire + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_copie_dictionnaire, aGlobal, aArgs, "rondpoint_c6ef_copie_dictionnaire: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_copie_dictionnaire, aGlobal, aArgs, "rondpoint_33e7_copie_dictionnaire: "_ns, aError)); + } +- case 82: { // rondpoint:rondpoint_c6ef_copie_enumeration ++ case 82: { // rondpoint:rondpoint_33e7_copie_enumeration + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_copie_enumeration, aGlobal, aArgs, "rondpoint_c6ef_copie_enumeration: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_copie_enumeration, aGlobal, aArgs, "rondpoint_33e7_copie_enumeration: "_ns, aError)); + } +- case 83: { // rondpoint:rondpoint_c6ef_copie_enumerations ++ case 83: { // rondpoint:rondpoint_33e7_copie_enumerations + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_copie_enumerations, aGlobal, aArgs, "rondpoint_c6ef_copie_enumerations: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_copie_enumerations, aGlobal, aArgs, "rondpoint_33e7_copie_enumerations: "_ns, aError)); + } +- case 84: { // rondpoint:rondpoint_c6ef_copie_carte ++ case 84: { // rondpoint:rondpoint_33e7_copie_carte + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_copie_carte, aGlobal, aArgs, "rondpoint_c6ef_copie_carte: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_copie_carte, aGlobal, aArgs, "rondpoint_33e7_copie_carte: "_ns, aError)); + } +- case 85: { // rondpoint:rondpoint_c6ef_switcheroo ++ case 85: { // rondpoint:rondpoint_33e7_switcheroo + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int8_t>, ScaffoldingConverter<int8_t>>; +- return Some(CallHandler::CallAsync(rondpoint_c6ef_switcheroo, aGlobal, aArgs, "rondpoint_c6ef_switcheroo: "_ns, aError)); ++ return Some(CallHandler::CallAsync(rondpoint_33e7_switcheroo, aGlobal, aArgs, "rondpoint_33e7_switcheroo: "_ns, aError)); + } +- case 86: { // sprites:sprites_accb_Sprite_new ++ case 86: { // sprites:sprites_a679_Sprite_new + using CallHandler = ScaffoldingCallHandler<ScaffoldingObjectConverter<&kSpritesSpritePointerType>, ScaffoldingConverter<RustBuffer>>; +- return Some(CallHandler::CallAsync(sprites_accb_Sprite_new, aGlobal, aArgs, "sprites_accb_Sprite_new: "_ns, aError)); ++ return Some(CallHandler::CallAsync(sprites_a679_Sprite_new, aGlobal, aArgs, "sprites_a679_Sprite_new: "_ns, aError)); + } +- case 87: { // sprites:sprites_accb_Sprite_new_relative_to ++ case 87: { // sprites:sprites_a679_Sprite_new_relative_to + using CallHandler = ScaffoldingCallHandler<ScaffoldingObjectConverter<&kSpritesSpritePointerType>, ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>>; +- return Some(CallHandler::CallAsync(sprites_accb_Sprite_new_relative_to, aGlobal, aArgs, "sprites_accb_Sprite_new_relative_to: "_ns, aError)); ++ return Some(CallHandler::CallAsync(sprites_a679_Sprite_new_relative_to, aGlobal, aArgs, "sprites_a679_Sprite_new_relative_to: "_ns, aError)); + } +- case 88: { // sprites:sprites_accb_Sprite_get_position ++ case 88: { // sprites:sprites_a679_Sprite_get_position + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kSpritesSpritePointerType>>; +- return Some(CallHandler::CallAsync(sprites_accb_Sprite_get_position, aGlobal, aArgs, "sprites_accb_Sprite_get_position: "_ns, aError)); ++ return Some(CallHandler::CallAsync(sprites_a679_Sprite_get_position, aGlobal, aArgs, "sprites_a679_Sprite_get_position: "_ns, aError)); + } +- case 89: { // sprites:sprites_accb_Sprite_move_to ++ case 89: { // sprites:sprites_a679_Sprite_move_to + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kSpritesSpritePointerType>, ScaffoldingConverter<RustBuffer>>; +- return Some(CallHandler::CallAsync(sprites_accb_Sprite_move_to, aGlobal, aArgs, "sprites_accb_Sprite_move_to: "_ns, aError)); ++ return Some(CallHandler::CallAsync(sprites_a679_Sprite_move_to, aGlobal, aArgs, "sprites_a679_Sprite_move_to: "_ns, aError)); + } +- case 90: { // sprites:sprites_accb_Sprite_move_by ++ case 90: { // sprites:sprites_a679_Sprite_move_by + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kSpritesSpritePointerType>, ScaffoldingConverter<RustBuffer>>; +- return Some(CallHandler::CallAsync(sprites_accb_Sprite_move_by, aGlobal, aArgs, "sprites_accb_Sprite_move_by: "_ns, aError)); ++ return Some(CallHandler::CallAsync(sprites_a679_Sprite_move_by, aGlobal, aArgs, "sprites_a679_Sprite_move_by: "_ns, aError)); + } +- case 91: { // sprites:sprites_accb_translate ++ case 91: { // sprites:sprites_a679_translate + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>>; +- return Some(CallHandler::CallAsync(sprites_accb_translate, aGlobal, aArgs, "sprites_accb_translate: "_ns, aError)); ++ return Some(CallHandler::CallAsync(sprites_a679_translate, aGlobal, aArgs, "sprites_a679_translate: "_ns, aError)); + } +- case 92: { // todolist:todolist_aa33_TodoList_new ++ case 92: { // todolist:todolist_cd5b_TodoList_new + using CallHandler = ScaffoldingCallHandler<ScaffoldingObjectConverter<&kTodolistTodoListPointerType>>; +- return Some(CallHandler::CallAsync(todolist_aa33_TodoList_new, aGlobal, aArgs, "todolist_aa33_TodoList_new: "_ns, aError)); ++ return Some(CallHandler::CallAsync(todolist_cd5b_TodoList_new, aGlobal, aArgs, "todolist_cd5b_TodoList_new: "_ns, aError)); + } +- case 93: { // todolist:todolist_aa33_TodoList_add_item ++ case 93: { // todolist:todolist_cd5b_TodoList_add_item + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTodolistTodoListPointerType>, ScaffoldingConverter<RustBuffer>>; +- return Some(CallHandler::CallAsync(todolist_aa33_TodoList_add_item, aGlobal, aArgs, "todolist_aa33_TodoList_add_item: "_ns, aError)); ++ return Some(CallHandler::CallAsync(todolist_cd5b_TodoList_add_item, aGlobal, aArgs, "todolist_cd5b_TodoList_add_item: "_ns, aError)); + } +- case 94: { // todolist:todolist_aa33_TodoList_add_entry ++ case 94: { // todolist:todolist_cd5b_TodoList_add_entry + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTodolistTodoListPointerType>, ScaffoldingConverter<RustBuffer>>; +- return Some(CallHandler::CallAsync(todolist_aa33_TodoList_add_entry, aGlobal, aArgs, "todolist_aa33_TodoList_add_entry: "_ns, aError)); ++ return Some(CallHandler::CallAsync(todolist_cd5b_TodoList_add_entry, aGlobal, aArgs, "todolist_cd5b_TodoList_add_entry: "_ns, aError)); + } +- case 95: { // todolist:todolist_aa33_TodoList_get_entries ++ case 95: { // todolist:todolist_cd5b_TodoList_get_entries + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTodolistTodoListPointerType>>; +- return Some(CallHandler::CallAsync(todolist_aa33_TodoList_get_entries, aGlobal, aArgs, "todolist_aa33_TodoList_get_entries: "_ns, aError)); ++ return Some(CallHandler::CallAsync(todolist_cd5b_TodoList_get_entries, aGlobal, aArgs, "todolist_cd5b_TodoList_get_entries: "_ns, aError)); + } +- case 96: { // todolist:todolist_aa33_TodoList_get_items ++ case 96: { // todolist:todolist_cd5b_TodoList_get_items + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTodolistTodoListPointerType>>; +- return Some(CallHandler::CallAsync(todolist_aa33_TodoList_get_items, aGlobal, aArgs, "todolist_aa33_TodoList_get_items: "_ns, aError)); ++ return Some(CallHandler::CallAsync(todolist_cd5b_TodoList_get_items, aGlobal, aArgs, "todolist_cd5b_TodoList_get_items: "_ns, aError)); + } +- case 97: { // todolist:todolist_aa33_TodoList_add_entries ++ case 97: { // todolist:todolist_cd5b_TodoList_add_entries + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTodolistTodoListPointerType>, ScaffoldingConverter<RustBuffer>>; +- return Some(CallHandler::CallAsync(todolist_aa33_TodoList_add_entries, aGlobal, aArgs, "todolist_aa33_TodoList_add_entries: "_ns, aError)); ++ return Some(CallHandler::CallAsync(todolist_cd5b_TodoList_add_entries, aGlobal, aArgs, "todolist_cd5b_TodoList_add_entries: "_ns, aError)); + } +- case 98: { // todolist:todolist_aa33_TodoList_add_items ++ case 98: { // todolist:todolist_cd5b_TodoList_add_items + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTodolistTodoListPointerType>, ScaffoldingConverter<RustBuffer>>; +- return Some(CallHandler::CallAsync(todolist_aa33_TodoList_add_items, aGlobal, aArgs, "todolist_aa33_TodoList_add_items: "_ns, aError)); ++ return Some(CallHandler::CallAsync(todolist_cd5b_TodoList_add_items, aGlobal, aArgs, "todolist_cd5b_TodoList_add_items: "_ns, aError)); + } +- case 99: { // todolist:todolist_aa33_TodoList_get_last_entry ++ case 99: { // todolist:todolist_cd5b_TodoList_get_last_entry + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTodolistTodoListPointerType>>; +- return Some(CallHandler::CallAsync(todolist_aa33_TodoList_get_last_entry, aGlobal, aArgs, "todolist_aa33_TodoList_get_last_entry: "_ns, aError)); ++ return Some(CallHandler::CallAsync(todolist_cd5b_TodoList_get_last_entry, aGlobal, aArgs, "todolist_cd5b_TodoList_get_last_entry: "_ns, aError)); + } +- case 100: { // todolist:todolist_aa33_TodoList_get_last ++ case 100: { // todolist:todolist_cd5b_TodoList_get_last + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTodolistTodoListPointerType>>; +- return Some(CallHandler::CallAsync(todolist_aa33_TodoList_get_last, aGlobal, aArgs, "todolist_aa33_TodoList_get_last: "_ns, aError)); ++ return Some(CallHandler::CallAsync(todolist_cd5b_TodoList_get_last, aGlobal, aArgs, "todolist_cd5b_TodoList_get_last: "_ns, aError)); + } +- case 101: { // todolist:todolist_aa33_TodoList_get_first ++ case 101: { // todolist:todolist_cd5b_TodoList_get_first + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTodolistTodoListPointerType>>; +- return Some(CallHandler::CallAsync(todolist_aa33_TodoList_get_first, aGlobal, aArgs, "todolist_aa33_TodoList_get_first: "_ns, aError)); ++ return Some(CallHandler::CallAsync(todolist_cd5b_TodoList_get_first, aGlobal, aArgs, "todolist_cd5b_TodoList_get_first: "_ns, aError)); + } +- case 102: { // todolist:todolist_aa33_TodoList_clear_item ++ case 102: { // todolist:todolist_cd5b_TodoList_clear_item + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTodolistTodoListPointerType>, ScaffoldingConverter<RustBuffer>>; +- return Some(CallHandler::CallAsync(todolist_aa33_TodoList_clear_item, aGlobal, aArgs, "todolist_aa33_TodoList_clear_item: "_ns, aError)); ++ return Some(CallHandler::CallAsync(todolist_cd5b_TodoList_clear_item, aGlobal, aArgs, "todolist_cd5b_TodoList_clear_item: "_ns, aError)); + } +- case 103: { // todolist:todolist_aa33_TodoList_make_default ++ case 103: { // todolist:todolist_cd5b_TodoList_make_default + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTodolistTodoListPointerType>>; +- return Some(CallHandler::CallAsync(todolist_aa33_TodoList_make_default, aGlobal, aArgs, "todolist_aa33_TodoList_make_default: "_ns, aError)); ++ return Some(CallHandler::CallAsync(todolist_cd5b_TodoList_make_default, aGlobal, aArgs, "todolist_cd5b_TodoList_make_default: "_ns, aError)); + } +- case 104: { // todolist:todolist_aa33_get_default_list ++ case 104: { // todolist:todolist_cd5b_get_default_list + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>>; +- return Some(CallHandler::CallAsync(todolist_aa33_get_default_list, aGlobal, aArgs, "todolist_aa33_get_default_list: "_ns, aError)); ++ return Some(CallHandler::CallAsync(todolist_cd5b_get_default_list, aGlobal, aArgs, "todolist_cd5b_get_default_list: "_ns, aError)); + } +- case 105: { // todolist:todolist_aa33_set_default_list ++ case 105: { // todolist:todolist_cd5b_set_default_list + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTodolistTodoListPointerType>>; +- return Some(CallHandler::CallAsync(todolist_aa33_set_default_list, aGlobal, aArgs, "todolist_aa33_set_default_list: "_ns, aError)); ++ return Some(CallHandler::CallAsync(todolist_cd5b_set_default_list, aGlobal, aArgs, "todolist_cd5b_set_default_list: "_ns, aError)); + } +- case 106: { // todolist:todolist_aa33_create_entry_with ++ case 106: { // todolist:todolist_cd5b_create_entry_with + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>>; +- return Some(CallHandler::CallAsync(todolist_aa33_create_entry_with, aGlobal, aArgs, "todolist_aa33_create_entry_with: "_ns, aError)); ++ return Some(CallHandler::CallAsync(todolist_cd5b_create_entry_with, aGlobal, aArgs, "todolist_cd5b_create_entry_with: "_ns, aError)); + } +- case 107: { // custom_types:custom_types_8ecd_get_custom_types_demo ++ case 107: { // custom_types:custom_types_41fc_get_custom_types_demo + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>>; +- return Some(CallHandler::CallAsync(custom_types_8ecd_get_custom_types_demo, aGlobal, aArgs, "custom_types_8ecd_get_custom_types_demo: "_ns, aError)); ++ return Some(CallHandler::CallAsync(custom_types_41fc_get_custom_types_demo, aGlobal, aArgs, "custom_types_41fc_get_custom_types_demo: "_ns, aError)); + } +- case 108: { // external_types:external_types_54cc_gradient ++ case 108: { // external_types:external_types_4cd4_gradient + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<double>, ScaffoldingConverter<RustBuffer>>; +- return Some(CallHandler::CallAsync(external_types_54cc_gradient, aGlobal, aArgs, "external_types_54cc_gradient: "_ns, aError)); ++ return Some(CallHandler::CallAsync(external_types_4cd4_gradient, aGlobal, aArgs, "external_types_4cd4_gradient: "_ns, aError)); + } + } + return Nothing(); +@@ -501,449 +501,449 @@ + + bool UniFFIFixturesCallSync(const GlobalObject& aGlobal, uint64_t aId, const Sequence<ScaffoldingType>& aArgs, RootedDictionary<UniFFIScaffoldingCallResult>& aReturnValue, ErrorResult& aError) { + switch (aId) { +- case 20: { // geometry:geometry_1cce_gradient ++ case 20: { // geometry:geometry_deb7_gradient + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<double>, ScaffoldingConverter<RustBuffer>>; +- CallHandler::CallSync(geometry_1cce_gradient, aGlobal, aArgs, aReturnValue, "geometry_1cce_gradient: "_ns, aError); ++ CallHandler::CallSync(geometry_deb7_gradient, aGlobal, aArgs, aReturnValue, "geometry_deb7_gradient: "_ns, aError); + return true; + } +- case 21: { // geometry:geometry_1cce_intersection ++ case 21: { // geometry:geometry_deb7_intersection + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>>; +- CallHandler::CallSync(geometry_1cce_intersection, aGlobal, aArgs, aReturnValue, "geometry_1cce_intersection: "_ns, aError); ++ CallHandler::CallSync(geometry_deb7_intersection, aGlobal, aArgs, aReturnValue, "geometry_deb7_intersection: "_ns, aError); + return true; + } +- case 22: { // arithmetic:arithmetic_906c_add ++ case 22: { // arithmetic:arithmetic_be49_add + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint64_t>, ScaffoldingConverter<uint64_t>, ScaffoldingConverter<uint64_t>>; +- CallHandler::CallSync(arithmetic_906c_add, aGlobal, aArgs, aReturnValue, "arithmetic_906c_add: "_ns, aError); ++ CallHandler::CallSync(arithmetic_be49_add, aGlobal, aArgs, aReturnValue, "arithmetic_be49_add: "_ns, aError); + return true; + } +- case 23: { // arithmetic:arithmetic_906c_sub ++ case 23: { // arithmetic:arithmetic_be49_sub + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint64_t>, ScaffoldingConverter<uint64_t>, ScaffoldingConverter<uint64_t>>; +- CallHandler::CallSync(arithmetic_906c_sub, aGlobal, aArgs, aReturnValue, "arithmetic_906c_sub: "_ns, aError); ++ CallHandler::CallSync(arithmetic_be49_sub, aGlobal, aArgs, aReturnValue, "arithmetic_be49_sub: "_ns, aError); + return true; + } +- case 24: { // arithmetic:arithmetic_906c_div ++ case 24: { // arithmetic:arithmetic_be49_div + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint64_t>, ScaffoldingConverter<uint64_t>, ScaffoldingConverter<uint64_t>>; +- CallHandler::CallSync(arithmetic_906c_div, aGlobal, aArgs, aReturnValue, "arithmetic_906c_div: "_ns, aError); ++ CallHandler::CallSync(arithmetic_be49_div, aGlobal, aArgs, aReturnValue, "arithmetic_be49_div: "_ns, aError); + return true; + } +- case 25: { // arithmetic:arithmetic_906c_equal ++ case 25: { // arithmetic:arithmetic_be49_equal + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int8_t>, ScaffoldingConverter<uint64_t>, ScaffoldingConverter<uint64_t>>; +- CallHandler::CallSync(arithmetic_906c_equal, aGlobal, aArgs, aReturnValue, "arithmetic_906c_equal: "_ns, aError); ++ CallHandler::CallSync(arithmetic_be49_equal, aGlobal, aArgs, aReturnValue, "arithmetic_be49_equal: "_ns, aError); + return true; + } +- case 26: { // rondpoint:rondpoint_c6ef_Retourneur_new ++ case 26: { // rondpoint:rondpoint_33e7_Retourneur_new + using CallHandler = ScaffoldingCallHandler<ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>>; +- CallHandler::CallSync(rondpoint_c6ef_Retourneur_new, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Retourneur_new: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Retourneur_new, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Retourneur_new: "_ns, aError); + return true; + } +- case 27: { // rondpoint:rondpoint_c6ef_Retourneur_identique_i8 ++ case 27: { // rondpoint:rondpoint_33e7_Retourneur_identique_i8 + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int8_t>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<int8_t>>; +- CallHandler::CallSync(rondpoint_c6ef_Retourneur_identique_i8, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Retourneur_identique_i8: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Retourneur_identique_i8, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Retourneur_identique_i8: "_ns, aError); + return true; + } +- case 28: { // rondpoint:rondpoint_c6ef_Retourneur_identique_u8 ++ case 28: { // rondpoint:rondpoint_33e7_Retourneur_identique_u8 + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint8_t>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<uint8_t>>; +- CallHandler::CallSync(rondpoint_c6ef_Retourneur_identique_u8, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Retourneur_identique_u8: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Retourneur_identique_u8, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Retourneur_identique_u8: "_ns, aError); + return true; + } +- case 29: { // rondpoint:rondpoint_c6ef_Retourneur_identique_i16 ++ case 29: { // rondpoint:rondpoint_33e7_Retourneur_identique_i16 + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int16_t>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<int16_t>>; +- CallHandler::CallSync(rondpoint_c6ef_Retourneur_identique_i16, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Retourneur_identique_i16: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Retourneur_identique_i16, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Retourneur_identique_i16: "_ns, aError); + return true; + } +- case 30: { // rondpoint:rondpoint_c6ef_Retourneur_identique_u16 ++ case 30: { // rondpoint:rondpoint_33e7_Retourneur_identique_u16 + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint16_t>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<uint16_t>>; +- CallHandler::CallSync(rondpoint_c6ef_Retourneur_identique_u16, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Retourneur_identique_u16: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Retourneur_identique_u16, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Retourneur_identique_u16: "_ns, aError); + return true; + } +- case 31: { // rondpoint:rondpoint_c6ef_Retourneur_identique_i32 ++ case 31: { // rondpoint:rondpoint_33e7_Retourneur_identique_i32 + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int32_t>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<int32_t>>; +- CallHandler::CallSync(rondpoint_c6ef_Retourneur_identique_i32, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Retourneur_identique_i32: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Retourneur_identique_i32, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Retourneur_identique_i32: "_ns, aError); + return true; + } +- case 32: { // rondpoint:rondpoint_c6ef_Retourneur_identique_u32 ++ case 32: { // rondpoint:rondpoint_33e7_Retourneur_identique_u32 + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint32_t>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<uint32_t>>; +- CallHandler::CallSync(rondpoint_c6ef_Retourneur_identique_u32, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Retourneur_identique_u32: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Retourneur_identique_u32, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Retourneur_identique_u32: "_ns, aError); + return true; + } +- case 33: { // rondpoint:rondpoint_c6ef_Retourneur_identique_i64 ++ case 33: { // rondpoint:rondpoint_33e7_Retourneur_identique_i64 + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int64_t>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<int64_t>>; +- CallHandler::CallSync(rondpoint_c6ef_Retourneur_identique_i64, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Retourneur_identique_i64: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Retourneur_identique_i64, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Retourneur_identique_i64: "_ns, aError); + return true; + } +- case 34: { // rondpoint:rondpoint_c6ef_Retourneur_identique_u64 ++ case 34: { // rondpoint:rondpoint_33e7_Retourneur_identique_u64 + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint64_t>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<uint64_t>>; +- CallHandler::CallSync(rondpoint_c6ef_Retourneur_identique_u64, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Retourneur_identique_u64: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Retourneur_identique_u64, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Retourneur_identique_u64: "_ns, aError); + return true; + } +- case 35: { // rondpoint:rondpoint_c6ef_Retourneur_identique_float ++ case 35: { // rondpoint:rondpoint_33e7_Retourneur_identique_float + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<float>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<float>>; +- CallHandler::CallSync(rondpoint_c6ef_Retourneur_identique_float, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Retourneur_identique_float: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Retourneur_identique_float, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Retourneur_identique_float: "_ns, aError); + return true; + } +- case 36: { // rondpoint:rondpoint_c6ef_Retourneur_identique_double ++ case 36: { // rondpoint:rondpoint_33e7_Retourneur_identique_double + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<double>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<double>>; +- CallHandler::CallSync(rondpoint_c6ef_Retourneur_identique_double, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Retourneur_identique_double: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Retourneur_identique_double, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Retourneur_identique_double: "_ns, aError); + return true; + } +- case 37: { // rondpoint:rondpoint_c6ef_Retourneur_identique_boolean ++ case 37: { // rondpoint:rondpoint_33e7_Retourneur_identique_boolean + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int8_t>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<int8_t>>; +- CallHandler::CallSync(rondpoint_c6ef_Retourneur_identique_boolean, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Retourneur_identique_boolean: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Retourneur_identique_boolean, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Retourneur_identique_boolean: "_ns, aError); + return true; + } +- case 38: { // rondpoint:rondpoint_c6ef_Retourneur_identique_string ++ case 38: { // rondpoint:rondpoint_33e7_Retourneur_identique_string + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<RustBuffer>>; +- CallHandler::CallSync(rondpoint_c6ef_Retourneur_identique_string, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Retourneur_identique_string: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Retourneur_identique_string, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Retourneur_identique_string: "_ns, aError); + return true; + } +- case 39: { // rondpoint:rondpoint_c6ef_Retourneur_identique_nombres_signes ++ case 39: { // rondpoint:rondpoint_33e7_Retourneur_identique_nombres_signes + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<RustBuffer>>; +- CallHandler::CallSync(rondpoint_c6ef_Retourneur_identique_nombres_signes, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Retourneur_identique_nombres_signes: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Retourneur_identique_nombres_signes, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Retourneur_identique_nombres_signes: "_ns, aError); + return true; + } +- case 40: { // rondpoint:rondpoint_c6ef_Retourneur_identique_nombres ++ case 40: { // rondpoint:rondpoint_33e7_Retourneur_identique_nombres + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<RustBuffer>>; +- CallHandler::CallSync(rondpoint_c6ef_Retourneur_identique_nombres, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Retourneur_identique_nombres: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Retourneur_identique_nombres, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Retourneur_identique_nombres: "_ns, aError); + return true; + } +- case 41: { // rondpoint:rondpoint_c6ef_Retourneur_identique_optionneur_dictionnaire ++ case 41: { // rondpoint:rondpoint_33e7_Retourneur_identique_optionneur_dictionnaire + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<RustBuffer>>; +- CallHandler::CallSync(rondpoint_c6ef_Retourneur_identique_optionneur_dictionnaire, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Retourneur_identique_optionneur_dictionnaire: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Retourneur_identique_optionneur_dictionnaire, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Retourneur_identique_optionneur_dictionnaire: "_ns, aError); + return true; + } +- case 42: { // rondpoint:rondpoint_c6ef_Stringifier_new ++ case 42: { // rondpoint:rondpoint_33e7_Stringifier_new + using CallHandler = ScaffoldingCallHandler<ScaffoldingObjectConverter<&kRondpointStringifierPointerType>>; +- CallHandler::CallSync(rondpoint_c6ef_Stringifier_new, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Stringifier_new: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Stringifier_new, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Stringifier_new: "_ns, aError); + return true; + } +- case 43: { // rondpoint:rondpoint_c6ef_Stringifier_well_known_string ++ case 43: { // rondpoint:rondpoint_33e7_Stringifier_well_known_string + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointStringifierPointerType>, ScaffoldingConverter<RustBuffer>>; +- CallHandler::CallSync(rondpoint_c6ef_Stringifier_well_known_string, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Stringifier_well_known_string: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Stringifier_well_known_string, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Stringifier_well_known_string: "_ns, aError); + return true; + } +- case 44: { // rondpoint:rondpoint_c6ef_Stringifier_to_string_i8 ++ case 44: { // rondpoint:rondpoint_33e7_Stringifier_to_string_i8 + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointStringifierPointerType>, ScaffoldingConverter<int8_t>>; +- CallHandler::CallSync(rondpoint_c6ef_Stringifier_to_string_i8, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Stringifier_to_string_i8: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Stringifier_to_string_i8, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Stringifier_to_string_i8: "_ns, aError); + return true; + } +- case 45: { // rondpoint:rondpoint_c6ef_Stringifier_to_string_u8 ++ case 45: { // rondpoint:rondpoint_33e7_Stringifier_to_string_u8 + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointStringifierPointerType>, ScaffoldingConverter<uint8_t>>; +- CallHandler::CallSync(rondpoint_c6ef_Stringifier_to_string_u8, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Stringifier_to_string_u8: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Stringifier_to_string_u8, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Stringifier_to_string_u8: "_ns, aError); + return true; + } +- case 46: { // rondpoint:rondpoint_c6ef_Stringifier_to_string_i16 ++ case 46: { // rondpoint:rondpoint_33e7_Stringifier_to_string_i16 + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointStringifierPointerType>, ScaffoldingConverter<int16_t>>; +- CallHandler::CallSync(rondpoint_c6ef_Stringifier_to_string_i16, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Stringifier_to_string_i16: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Stringifier_to_string_i16, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Stringifier_to_string_i16: "_ns, aError); + return true; + } +- case 47: { // rondpoint:rondpoint_c6ef_Stringifier_to_string_u16 ++ case 47: { // rondpoint:rondpoint_33e7_Stringifier_to_string_u16 + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointStringifierPointerType>, ScaffoldingConverter<uint16_t>>; +- CallHandler::CallSync(rondpoint_c6ef_Stringifier_to_string_u16, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Stringifier_to_string_u16: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Stringifier_to_string_u16, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Stringifier_to_string_u16: "_ns, aError); + return true; + } +- case 48: { // rondpoint:rondpoint_c6ef_Stringifier_to_string_i32 ++ case 48: { // rondpoint:rondpoint_33e7_Stringifier_to_string_i32 + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointStringifierPointerType>, ScaffoldingConverter<int32_t>>; +- CallHandler::CallSync(rondpoint_c6ef_Stringifier_to_string_i32, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Stringifier_to_string_i32: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Stringifier_to_string_i32, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Stringifier_to_string_i32: "_ns, aError); + return true; + } +- case 49: { // rondpoint:rondpoint_c6ef_Stringifier_to_string_u32 ++ case 49: { // rondpoint:rondpoint_33e7_Stringifier_to_string_u32 + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointStringifierPointerType>, ScaffoldingConverter<uint32_t>>; +- CallHandler::CallSync(rondpoint_c6ef_Stringifier_to_string_u32, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Stringifier_to_string_u32: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Stringifier_to_string_u32, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Stringifier_to_string_u32: "_ns, aError); + return true; + } +- case 50: { // rondpoint:rondpoint_c6ef_Stringifier_to_string_i64 ++ case 50: { // rondpoint:rondpoint_33e7_Stringifier_to_string_i64 + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointStringifierPointerType>, ScaffoldingConverter<int64_t>>; +- CallHandler::CallSync(rondpoint_c6ef_Stringifier_to_string_i64, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Stringifier_to_string_i64: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Stringifier_to_string_i64, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Stringifier_to_string_i64: "_ns, aError); + return true; + } +- case 51: { // rondpoint:rondpoint_c6ef_Stringifier_to_string_u64 ++ case 51: { // rondpoint:rondpoint_33e7_Stringifier_to_string_u64 + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointStringifierPointerType>, ScaffoldingConverter<uint64_t>>; +- CallHandler::CallSync(rondpoint_c6ef_Stringifier_to_string_u64, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Stringifier_to_string_u64: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Stringifier_to_string_u64, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Stringifier_to_string_u64: "_ns, aError); + return true; + } +- case 52: { // rondpoint:rondpoint_c6ef_Stringifier_to_string_float ++ case 52: { // rondpoint:rondpoint_33e7_Stringifier_to_string_float + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointStringifierPointerType>, ScaffoldingConverter<float>>; +- CallHandler::CallSync(rondpoint_c6ef_Stringifier_to_string_float, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Stringifier_to_string_float: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Stringifier_to_string_float, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Stringifier_to_string_float: "_ns, aError); + return true; + } +- case 53: { // rondpoint:rondpoint_c6ef_Stringifier_to_string_double ++ case 53: { // rondpoint:rondpoint_33e7_Stringifier_to_string_double + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointStringifierPointerType>, ScaffoldingConverter<double>>; +- CallHandler::CallSync(rondpoint_c6ef_Stringifier_to_string_double, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Stringifier_to_string_double: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Stringifier_to_string_double, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Stringifier_to_string_double: "_ns, aError); + return true; + } +- case 54: { // rondpoint:rondpoint_c6ef_Stringifier_to_string_boolean ++ case 54: { // rondpoint:rondpoint_33e7_Stringifier_to_string_boolean + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointStringifierPointerType>, ScaffoldingConverter<int8_t>>; +- CallHandler::CallSync(rondpoint_c6ef_Stringifier_to_string_boolean, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Stringifier_to_string_boolean: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Stringifier_to_string_boolean, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Stringifier_to_string_boolean: "_ns, aError); + return true; + } +- case 55: { // rondpoint:rondpoint_c6ef_Optionneur_new ++ case 55: { // rondpoint:rondpoint_33e7_Optionneur_new + using CallHandler = ScaffoldingCallHandler<ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>>; +- CallHandler::CallSync(rondpoint_c6ef_Optionneur_new, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_new: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Optionneur_new, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_new: "_ns, aError); + return true; + } +- case 56: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_boolean ++ case 56: { // rondpoint:rondpoint_33e7_Optionneur_sinon_boolean + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int8_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<int8_t>>; +- CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_boolean, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_boolean: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_boolean, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_boolean: "_ns, aError); + return true; + } +- case 57: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_string ++ case 57: { // rondpoint:rondpoint_33e7_Optionneur_sinon_string + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<RustBuffer>>; +- CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_string, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_string: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_string, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_string: "_ns, aError); + return true; + } +- case 58: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_sequence ++ case 58: { // rondpoint:rondpoint_33e7_Optionneur_sinon_sequence + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<RustBuffer>>; +- CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_sequence, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_sequence: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_sequence, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_sequence: "_ns, aError); + return true; + } +- case 59: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_null ++ case 59: { // rondpoint:rondpoint_33e7_Optionneur_sinon_null + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<RustBuffer>>; +- CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_null, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_null: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_null, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_null: "_ns, aError); + return true; + } +- case 60: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_zero ++ case 60: { // rondpoint:rondpoint_33e7_Optionneur_sinon_zero + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<RustBuffer>>; +- CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_zero, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_zero: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_zero, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_zero: "_ns, aError); + return true; + } +- case 61: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_u8_dec ++ case 61: { // rondpoint:rondpoint_33e7_Optionneur_sinon_u8_dec + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint8_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<uint8_t>>; +- CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_u8_dec, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_u8_dec: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_u8_dec, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_u8_dec: "_ns, aError); + return true; + } +- case 62: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_i8_dec ++ case 62: { // rondpoint:rondpoint_33e7_Optionneur_sinon_i8_dec + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int8_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<int8_t>>; +- CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_i8_dec, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_i8_dec: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_i8_dec, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_i8_dec: "_ns, aError); + return true; + } +- case 63: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_u16_dec ++ case 63: { // rondpoint:rondpoint_33e7_Optionneur_sinon_u16_dec + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint16_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<uint16_t>>; +- CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_u16_dec, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_u16_dec: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_u16_dec, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_u16_dec: "_ns, aError); + return true; + } +- case 64: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_i16_dec ++ case 64: { // rondpoint:rondpoint_33e7_Optionneur_sinon_i16_dec + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int16_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<int16_t>>; +- CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_i16_dec, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_i16_dec: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_i16_dec, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_i16_dec: "_ns, aError); + return true; + } +- case 65: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_u32_dec ++ case 65: { // rondpoint:rondpoint_33e7_Optionneur_sinon_u32_dec + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint32_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<uint32_t>>; +- CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_u32_dec, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_u32_dec: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_u32_dec, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_u32_dec: "_ns, aError); + return true; + } +- case 66: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_i32_dec ++ case 66: { // rondpoint:rondpoint_33e7_Optionneur_sinon_i32_dec + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int32_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<int32_t>>; +- CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_i32_dec, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_i32_dec: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_i32_dec, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_i32_dec: "_ns, aError); + return true; + } +- case 67: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_u64_dec ++ case 67: { // rondpoint:rondpoint_33e7_Optionneur_sinon_u64_dec + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint64_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<uint64_t>>; +- CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_u64_dec, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_u64_dec: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_u64_dec, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_u64_dec: "_ns, aError); + return true; + } +- case 68: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_i64_dec ++ case 68: { // rondpoint:rondpoint_33e7_Optionneur_sinon_i64_dec + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int64_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<int64_t>>; +- CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_i64_dec, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_i64_dec: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_i64_dec, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_i64_dec: "_ns, aError); + return true; + } +- case 69: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_u8_hex ++ case 69: { // rondpoint:rondpoint_33e7_Optionneur_sinon_u8_hex + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint8_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<uint8_t>>; +- CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_u8_hex, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_u8_hex: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_u8_hex, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_u8_hex: "_ns, aError); + return true; + } +- case 70: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_i8_hex ++ case 70: { // rondpoint:rondpoint_33e7_Optionneur_sinon_i8_hex + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int8_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<int8_t>>; +- CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_i8_hex, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_i8_hex: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_i8_hex, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_i8_hex: "_ns, aError); + return true; + } +- case 71: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_u16_hex ++ case 71: { // rondpoint:rondpoint_33e7_Optionneur_sinon_u16_hex + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint16_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<uint16_t>>; +- CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_u16_hex, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_u16_hex: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_u16_hex, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_u16_hex: "_ns, aError); + return true; + } +- case 72: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_i16_hex ++ case 72: { // rondpoint:rondpoint_33e7_Optionneur_sinon_i16_hex + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int16_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<int16_t>>; +- CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_i16_hex, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_i16_hex: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_i16_hex, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_i16_hex: "_ns, aError); + return true; + } +- case 73: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_u32_hex ++ case 73: { // rondpoint:rondpoint_33e7_Optionneur_sinon_u32_hex + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint32_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<uint32_t>>; +- CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_u32_hex, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_u32_hex: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_u32_hex, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_u32_hex: "_ns, aError); + return true; + } +- case 74: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_i32_hex ++ case 74: { // rondpoint:rondpoint_33e7_Optionneur_sinon_i32_hex + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int32_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<int32_t>>; +- CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_i32_hex, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_i32_hex: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_i32_hex, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_i32_hex: "_ns, aError); + return true; + } +- case 75: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_u64_hex ++ case 75: { // rondpoint:rondpoint_33e7_Optionneur_sinon_u64_hex + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint64_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<uint64_t>>; +- CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_u64_hex, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_u64_hex: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_u64_hex, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_u64_hex: "_ns, aError); + return true; + } +- case 76: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_i64_hex ++ case 76: { // rondpoint:rondpoint_33e7_Optionneur_sinon_i64_hex + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int64_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<int64_t>>; +- CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_i64_hex, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_i64_hex: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_i64_hex, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_i64_hex: "_ns, aError); + return true; + } +- case 77: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_u32_oct ++ case 77: { // rondpoint:rondpoint_33e7_Optionneur_sinon_u32_oct + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint32_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<uint32_t>>; +- CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_u32_oct, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_u32_oct: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_u32_oct, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_u32_oct: "_ns, aError); + return true; + } +- case 78: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_f32 ++ case 78: { // rondpoint:rondpoint_33e7_Optionneur_sinon_f32 + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<float>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<float>>; +- CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_f32, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_f32: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_f32, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_f32: "_ns, aError); + return true; + } +- case 79: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_f64 ++ case 79: { // rondpoint:rondpoint_33e7_Optionneur_sinon_f64 + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<double>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<double>>; +- CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_f64, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_f64: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_f64, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_f64: "_ns, aError); + return true; + } +- case 80: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_enum ++ case 80: { // rondpoint:rondpoint_33e7_Optionneur_sinon_enum + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<RustBuffer>>; +- CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_enum, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_enum: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_enum, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_enum: "_ns, aError); + return true; + } +- case 81: { // rondpoint:rondpoint_c6ef_copie_dictionnaire ++ case 81: { // rondpoint:rondpoint_33e7_copie_dictionnaire + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>>; +- CallHandler::CallSync(rondpoint_c6ef_copie_dictionnaire, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_copie_dictionnaire: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_copie_dictionnaire, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_copie_dictionnaire: "_ns, aError); + return true; + } +- case 82: { // rondpoint:rondpoint_c6ef_copie_enumeration ++ case 82: { // rondpoint:rondpoint_33e7_copie_enumeration + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>>; +- CallHandler::CallSync(rondpoint_c6ef_copie_enumeration, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_copie_enumeration: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_copie_enumeration, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_copie_enumeration: "_ns, aError); + return true; + } +- case 83: { // rondpoint:rondpoint_c6ef_copie_enumerations ++ case 83: { // rondpoint:rondpoint_33e7_copie_enumerations + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>>; +- CallHandler::CallSync(rondpoint_c6ef_copie_enumerations, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_copie_enumerations: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_copie_enumerations, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_copie_enumerations: "_ns, aError); + return true; + } +- case 84: { // rondpoint:rondpoint_c6ef_copie_carte ++ case 84: { // rondpoint:rondpoint_33e7_copie_carte + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>>; +- CallHandler::CallSync(rondpoint_c6ef_copie_carte, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_copie_carte: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_copie_carte, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_copie_carte: "_ns, aError); + return true; + } +- case 85: { // rondpoint:rondpoint_c6ef_switcheroo ++ case 85: { // rondpoint:rondpoint_33e7_switcheroo + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int8_t>, ScaffoldingConverter<int8_t>>; +- CallHandler::CallSync(rondpoint_c6ef_switcheroo, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_switcheroo: "_ns, aError); ++ CallHandler::CallSync(rondpoint_33e7_switcheroo, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_switcheroo: "_ns, aError); + return true; + } +- case 86: { // sprites:sprites_accb_Sprite_new ++ case 86: { // sprites:sprites_a679_Sprite_new + using CallHandler = ScaffoldingCallHandler<ScaffoldingObjectConverter<&kSpritesSpritePointerType>, ScaffoldingConverter<RustBuffer>>; +- CallHandler::CallSync(sprites_accb_Sprite_new, aGlobal, aArgs, aReturnValue, "sprites_accb_Sprite_new: "_ns, aError); ++ CallHandler::CallSync(sprites_a679_Sprite_new, aGlobal, aArgs, aReturnValue, "sprites_a679_Sprite_new: "_ns, aError); + return true; + } +- case 87: { // sprites:sprites_accb_Sprite_new_relative_to ++ case 87: { // sprites:sprites_a679_Sprite_new_relative_to + using CallHandler = ScaffoldingCallHandler<ScaffoldingObjectConverter<&kSpritesSpritePointerType>, ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>>; +- CallHandler::CallSync(sprites_accb_Sprite_new_relative_to, aGlobal, aArgs, aReturnValue, "sprites_accb_Sprite_new_relative_to: "_ns, aError); ++ CallHandler::CallSync(sprites_a679_Sprite_new_relative_to, aGlobal, aArgs, aReturnValue, "sprites_a679_Sprite_new_relative_to: "_ns, aError); + return true; + } +- case 88: { // sprites:sprites_accb_Sprite_get_position ++ case 88: { // sprites:sprites_a679_Sprite_get_position + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kSpritesSpritePointerType>>; +- CallHandler::CallSync(sprites_accb_Sprite_get_position, aGlobal, aArgs, aReturnValue, "sprites_accb_Sprite_get_position: "_ns, aError); ++ CallHandler::CallSync(sprites_a679_Sprite_get_position, aGlobal, aArgs, aReturnValue, "sprites_a679_Sprite_get_position: "_ns, aError); + return true; + } +- case 89: { // sprites:sprites_accb_Sprite_move_to ++ case 89: { // sprites:sprites_a679_Sprite_move_to + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kSpritesSpritePointerType>, ScaffoldingConverter<RustBuffer>>; +- CallHandler::CallSync(sprites_accb_Sprite_move_to, aGlobal, aArgs, aReturnValue, "sprites_accb_Sprite_move_to: "_ns, aError); ++ CallHandler::CallSync(sprites_a679_Sprite_move_to, aGlobal, aArgs, aReturnValue, "sprites_a679_Sprite_move_to: "_ns, aError); + return true; + } +- case 90: { // sprites:sprites_accb_Sprite_move_by ++ case 90: { // sprites:sprites_a679_Sprite_move_by + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kSpritesSpritePointerType>, ScaffoldingConverter<RustBuffer>>; +- CallHandler::CallSync(sprites_accb_Sprite_move_by, aGlobal, aArgs, aReturnValue, "sprites_accb_Sprite_move_by: "_ns, aError); ++ CallHandler::CallSync(sprites_a679_Sprite_move_by, aGlobal, aArgs, aReturnValue, "sprites_a679_Sprite_move_by: "_ns, aError); + return true; + } +- case 91: { // sprites:sprites_accb_translate ++ case 91: { // sprites:sprites_a679_translate + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>>; +- CallHandler::CallSync(sprites_accb_translate, aGlobal, aArgs, aReturnValue, "sprites_accb_translate: "_ns, aError); ++ CallHandler::CallSync(sprites_a679_translate, aGlobal, aArgs, aReturnValue, "sprites_a679_translate: "_ns, aError); + return true; + } +- case 92: { // todolist:todolist_aa33_TodoList_new ++ case 92: { // todolist:todolist_cd5b_TodoList_new + using CallHandler = ScaffoldingCallHandler<ScaffoldingObjectConverter<&kTodolistTodoListPointerType>>; +- CallHandler::CallSync(todolist_aa33_TodoList_new, aGlobal, aArgs, aReturnValue, "todolist_aa33_TodoList_new: "_ns, aError); ++ CallHandler::CallSync(todolist_cd5b_TodoList_new, aGlobal, aArgs, aReturnValue, "todolist_cd5b_TodoList_new: "_ns, aError); + return true; + } +- case 93: { // todolist:todolist_aa33_TodoList_add_item ++ case 93: { // todolist:todolist_cd5b_TodoList_add_item + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTodolistTodoListPointerType>, ScaffoldingConverter<RustBuffer>>; +- CallHandler::CallSync(todolist_aa33_TodoList_add_item, aGlobal, aArgs, aReturnValue, "todolist_aa33_TodoList_add_item: "_ns, aError); ++ CallHandler::CallSync(todolist_cd5b_TodoList_add_item, aGlobal, aArgs, aReturnValue, "todolist_cd5b_TodoList_add_item: "_ns, aError); + return true; + } +- case 94: { // todolist:todolist_aa33_TodoList_add_entry ++ case 94: { // todolist:todolist_cd5b_TodoList_add_entry + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTodolistTodoListPointerType>, ScaffoldingConverter<RustBuffer>>; +- CallHandler::CallSync(todolist_aa33_TodoList_add_entry, aGlobal, aArgs, aReturnValue, "todolist_aa33_TodoList_add_entry: "_ns, aError); ++ CallHandler::CallSync(todolist_cd5b_TodoList_add_entry, aGlobal, aArgs, aReturnValue, "todolist_cd5b_TodoList_add_entry: "_ns, aError); + return true; + } +- case 95: { // todolist:todolist_aa33_TodoList_get_entries ++ case 95: { // todolist:todolist_cd5b_TodoList_get_entries + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTodolistTodoListPointerType>>; +- CallHandler::CallSync(todolist_aa33_TodoList_get_entries, aGlobal, aArgs, aReturnValue, "todolist_aa33_TodoList_get_entries: "_ns, aError); ++ CallHandler::CallSync(todolist_cd5b_TodoList_get_entries, aGlobal, aArgs, aReturnValue, "todolist_cd5b_TodoList_get_entries: "_ns, aError); + return true; + } +- case 96: { // todolist:todolist_aa33_TodoList_get_items ++ case 96: { // todolist:todolist_cd5b_TodoList_get_items + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTodolistTodoListPointerType>>; +- CallHandler::CallSync(todolist_aa33_TodoList_get_items, aGlobal, aArgs, aReturnValue, "todolist_aa33_TodoList_get_items: "_ns, aError); ++ CallHandler::CallSync(todolist_cd5b_TodoList_get_items, aGlobal, aArgs, aReturnValue, "todolist_cd5b_TodoList_get_items: "_ns, aError); + return true; + } +- case 97: { // todolist:todolist_aa33_TodoList_add_entries ++ case 97: { // todolist:todolist_cd5b_TodoList_add_entries + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTodolistTodoListPointerType>, ScaffoldingConverter<RustBuffer>>; +- CallHandler::CallSync(todolist_aa33_TodoList_add_entries, aGlobal, aArgs, aReturnValue, "todolist_aa33_TodoList_add_entries: "_ns, aError); ++ CallHandler::CallSync(todolist_cd5b_TodoList_add_entries, aGlobal, aArgs, aReturnValue, "todolist_cd5b_TodoList_add_entries: "_ns, aError); + return true; + } +- case 98: { // todolist:todolist_aa33_TodoList_add_items ++ case 98: { // todolist:todolist_cd5b_TodoList_add_items + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTodolistTodoListPointerType>, ScaffoldingConverter<RustBuffer>>; +- CallHandler::CallSync(todolist_aa33_TodoList_add_items, aGlobal, aArgs, aReturnValue, "todolist_aa33_TodoList_add_items: "_ns, aError); ++ CallHandler::CallSync(todolist_cd5b_TodoList_add_items, aGlobal, aArgs, aReturnValue, "todolist_cd5b_TodoList_add_items: "_ns, aError); + return true; + } +- case 99: { // todolist:todolist_aa33_TodoList_get_last_entry ++ case 99: { // todolist:todolist_cd5b_TodoList_get_last_entry + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTodolistTodoListPointerType>>; +- CallHandler::CallSync(todolist_aa33_TodoList_get_last_entry, aGlobal, aArgs, aReturnValue, "todolist_aa33_TodoList_get_last_entry: "_ns, aError); ++ CallHandler::CallSync(todolist_cd5b_TodoList_get_last_entry, aGlobal, aArgs, aReturnValue, "todolist_cd5b_TodoList_get_last_entry: "_ns, aError); + return true; + } +- case 100: { // todolist:todolist_aa33_TodoList_get_last ++ case 100: { // todolist:todolist_cd5b_TodoList_get_last + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTodolistTodoListPointerType>>; +- CallHandler::CallSync(todolist_aa33_TodoList_get_last, aGlobal, aArgs, aReturnValue, "todolist_aa33_TodoList_get_last: "_ns, aError); ++ CallHandler::CallSync(todolist_cd5b_TodoList_get_last, aGlobal, aArgs, aReturnValue, "todolist_cd5b_TodoList_get_last: "_ns, aError); + return true; + } +- case 101: { // todolist:todolist_aa33_TodoList_get_first ++ case 101: { // todolist:todolist_cd5b_TodoList_get_first + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTodolistTodoListPointerType>>; +- CallHandler::CallSync(todolist_aa33_TodoList_get_first, aGlobal, aArgs, aReturnValue, "todolist_aa33_TodoList_get_first: "_ns, aError); ++ CallHandler::CallSync(todolist_cd5b_TodoList_get_first, aGlobal, aArgs, aReturnValue, "todolist_cd5b_TodoList_get_first: "_ns, aError); + return true; + } +- case 102: { // todolist:todolist_aa33_TodoList_clear_item ++ case 102: { // todolist:todolist_cd5b_TodoList_clear_item + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTodolistTodoListPointerType>, ScaffoldingConverter<RustBuffer>>; +- CallHandler::CallSync(todolist_aa33_TodoList_clear_item, aGlobal, aArgs, aReturnValue, "todolist_aa33_TodoList_clear_item: "_ns, aError); ++ CallHandler::CallSync(todolist_cd5b_TodoList_clear_item, aGlobal, aArgs, aReturnValue, "todolist_cd5b_TodoList_clear_item: "_ns, aError); + return true; + } +- case 103: { // todolist:todolist_aa33_TodoList_make_default ++ case 103: { // todolist:todolist_cd5b_TodoList_make_default + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTodolistTodoListPointerType>>; +- CallHandler::CallSync(todolist_aa33_TodoList_make_default, aGlobal, aArgs, aReturnValue, "todolist_aa33_TodoList_make_default: "_ns, aError); ++ CallHandler::CallSync(todolist_cd5b_TodoList_make_default, aGlobal, aArgs, aReturnValue, "todolist_cd5b_TodoList_make_default: "_ns, aError); + return true; + } +- case 104: { // todolist:todolist_aa33_get_default_list ++ case 104: { // todolist:todolist_cd5b_get_default_list + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>>; +- CallHandler::CallSync(todolist_aa33_get_default_list, aGlobal, aArgs, aReturnValue, "todolist_aa33_get_default_list: "_ns, aError); ++ CallHandler::CallSync(todolist_cd5b_get_default_list, aGlobal, aArgs, aReturnValue, "todolist_cd5b_get_default_list: "_ns, aError); + return true; + } +- case 105: { // todolist:todolist_aa33_set_default_list ++ case 105: { // todolist:todolist_cd5b_set_default_list + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTodolistTodoListPointerType>>; +- CallHandler::CallSync(todolist_aa33_set_default_list, aGlobal, aArgs, aReturnValue, "todolist_aa33_set_default_list: "_ns, aError); ++ CallHandler::CallSync(todolist_cd5b_set_default_list, aGlobal, aArgs, aReturnValue, "todolist_cd5b_set_default_list: "_ns, aError); + return true; + } +- case 106: { // todolist:todolist_aa33_create_entry_with ++ case 106: { // todolist:todolist_cd5b_create_entry_with + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>>; +- CallHandler::CallSync(todolist_aa33_create_entry_with, aGlobal, aArgs, aReturnValue, "todolist_aa33_create_entry_with: "_ns, aError); ++ CallHandler::CallSync(todolist_cd5b_create_entry_with, aGlobal, aArgs, aReturnValue, "todolist_cd5b_create_entry_with: "_ns, aError); + return true; + } +- case 107: { // custom_types:custom_types_8ecd_get_custom_types_demo ++ case 107: { // custom_types:custom_types_41fc_get_custom_types_demo + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>>; +- CallHandler::CallSync(custom_types_8ecd_get_custom_types_demo, aGlobal, aArgs, aReturnValue, "custom_types_8ecd_get_custom_types_demo: "_ns, aError); ++ CallHandler::CallSync(custom_types_41fc_get_custom_types_demo, aGlobal, aArgs, aReturnValue, "custom_types_41fc_get_custom_types_demo: "_ns, aError); + return true; + } +- case 108: { // external_types:external_types_54cc_gradient ++ case 108: { // external_types:external_types_4cd4_gradient + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<double>, ScaffoldingConverter<RustBuffer>>; +- CallHandler::CallSync(external_types_54cc_gradient, aGlobal, aArgs, aReturnValue, "external_types_54cc_gradient: "_ns, aError); ++ CallHandler::CallSync(external_types_4cd4_gradient, aGlobal, aArgs, aReturnValue, "external_types_4cd4_gradient: "_ns, aError); + return true; + } + } +diff -u -r --new-file firefox-108.0.orig/toolkit/components/uniffi-js/UniFFIGeneratedScaffolding.cpp firefox-108.0/toolkit/components/uniffi-js/UniFFIGeneratedScaffolding.cpp +--- firefox-108.0.orig/toolkit/components/uniffi-js/UniFFIGeneratedScaffolding.cpp 2022-12-08 10:27:29.000000000 -0600 ++++ firefox-108.0/toolkit/components/uniffi-js/UniFFIGeneratedScaffolding.cpp 2022-12-15 13:20:01.332880947 -0600 +@@ -19,121 +19,121 @@ + + // Define scaffolding functions from UniFFI + extern "C" { +- void ffi_tabs_4d51_TabsStore_object_free(void *, RustCallStatus*); +- void * tabs_4d51_TabsStore_new(RustBuffer, RustCallStatus*); +- RustBuffer tabs_4d51_TabsStore_get_all(void *, RustCallStatus*); +- void tabs_4d51_TabsStore_set_local_tabs(void *, RustBuffer, RustCallStatus*); +- void tabs_4d51_TabsStore_register_with_sync_manager(void *, RustCallStatus*); +- void tabs_4d51_TabsStore_reset(void *, RustCallStatus*); +- RustBuffer tabs_4d51_TabsStore_sync(void *, RustBuffer, RustBuffer, RustBuffer, RustBuffer, RustBuffer, RustCallStatus*); +- void * tabs_4d51_TabsStore_bridged_engine(void *, RustCallStatus*); +- void ffi_tabs_4d51_TabsBridgedEngine_object_free(void *, RustCallStatus*); +- int64_t tabs_4d51_TabsBridgedEngine_last_sync(void *, RustCallStatus*); +- void tabs_4d51_TabsBridgedEngine_set_last_sync(void *, int64_t, RustCallStatus*); +- RustBuffer tabs_4d51_TabsBridgedEngine_sync_id(void *, RustCallStatus*); +- RustBuffer tabs_4d51_TabsBridgedEngine_reset_sync_id(void *, RustCallStatus*); +- RustBuffer tabs_4d51_TabsBridgedEngine_ensure_current_sync_id(void *, RustBuffer, RustCallStatus*); +- void tabs_4d51_TabsBridgedEngine_prepare_for_sync(void *, RustBuffer, RustCallStatus*); +- void tabs_4d51_TabsBridgedEngine_sync_started(void *, RustCallStatus*); +- void tabs_4d51_TabsBridgedEngine_store_incoming(void *, RustBuffer, RustCallStatus*); +- RustBuffer tabs_4d51_TabsBridgedEngine_apply(void *, RustCallStatus*); +- void tabs_4d51_TabsBridgedEngine_set_uploaded(void *, int64_t, RustBuffer, RustCallStatus*); +- void tabs_4d51_TabsBridgedEngine_sync_finished(void *, RustCallStatus*); +- void tabs_4d51_TabsBridgedEngine_reset(void *, RustCallStatus*); +- void tabs_4d51_TabsBridgedEngine_wipe(void *, RustCallStatus*); ++ void ffi_tabs_1c79_TabsStore_object_free(void *, RustCallStatus*); ++ void * tabs_1c79_TabsStore_new(RustBuffer, RustCallStatus*); ++ RustBuffer tabs_1c79_TabsStore_get_all(void *, RustCallStatus*); ++ void tabs_1c79_TabsStore_set_local_tabs(void *, RustBuffer, RustCallStatus*); ++ void tabs_1c79_TabsStore_register_with_sync_manager(void *, RustCallStatus*); ++ void tabs_1c79_TabsStore_reset(void *, RustCallStatus*); ++ RustBuffer tabs_1c79_TabsStore_sync(void *, RustBuffer, RustBuffer, RustBuffer, RustBuffer, RustBuffer, RustCallStatus*); ++ void * tabs_1c79_TabsStore_bridged_engine(void *, RustCallStatus*); ++ void ffi_tabs_1c79_TabsBridgedEngine_object_free(void *, RustCallStatus*); ++ int64_t tabs_1c79_TabsBridgedEngine_last_sync(void *, RustCallStatus*); ++ void tabs_1c79_TabsBridgedEngine_set_last_sync(void *, int64_t, RustCallStatus*); ++ RustBuffer tabs_1c79_TabsBridgedEngine_sync_id(void *, RustCallStatus*); ++ RustBuffer tabs_1c79_TabsBridgedEngine_reset_sync_id(void *, RustCallStatus*); ++ RustBuffer tabs_1c79_TabsBridgedEngine_ensure_current_sync_id(void *, RustBuffer, RustCallStatus*); ++ void tabs_1c79_TabsBridgedEngine_prepare_for_sync(void *, RustBuffer, RustCallStatus*); ++ void tabs_1c79_TabsBridgedEngine_sync_started(void *, RustCallStatus*); ++ void tabs_1c79_TabsBridgedEngine_store_incoming(void *, RustBuffer, RustCallStatus*); ++ RustBuffer tabs_1c79_TabsBridgedEngine_apply(void *, RustCallStatus*); ++ void tabs_1c79_TabsBridgedEngine_set_uploaded(void *, int64_t, RustBuffer, RustCallStatus*); ++ void tabs_1c79_TabsBridgedEngine_sync_finished(void *, RustCallStatus*); ++ void tabs_1c79_TabsBridgedEngine_reset(void *, RustCallStatus*); ++ void tabs_1c79_TabsBridgedEngine_wipe(void *, RustCallStatus*); + } + + // Define pointer types + const static mozilla::uniffi::UniFFIPointerType kTabsTabsStorePointerType { + "tabs::TabsStore"_ns, +- ffi_tabs_4d51_TabsStore_object_free ++ ffi_tabs_1c79_TabsStore_object_free + }; + const static mozilla::uniffi::UniFFIPointerType kTabsTabsBridgedEnginePointerType { + "tabs::TabsBridgedEngine"_ns, +- ffi_tabs_4d51_TabsBridgedEngine_object_free ++ ffi_tabs_1c79_TabsBridgedEngine_object_free + }; + + Maybe<already_AddRefed<Promise>> UniFFICallAsync(const GlobalObject& aGlobal, uint64_t aId, const Sequence<ScaffoldingType>& aArgs, ErrorResult& aError) { + switch (aId) { +- case 0: { // tabs:tabs_4d51_TabsStore_new ++ case 0: { // tabs:tabs_1c79_TabsStore_new + using CallHandler = ScaffoldingCallHandler<ScaffoldingObjectConverter<&kTabsTabsStorePointerType>, ScaffoldingConverter<RustBuffer>>; +- return Some(CallHandler::CallAsync(tabs_4d51_TabsStore_new, aGlobal, aArgs, "tabs_4d51_TabsStore_new: "_ns, aError)); ++ return Some(CallHandler::CallAsync(tabs_1c79_TabsStore_new, aGlobal, aArgs, "tabs_1c79_TabsStore_new: "_ns, aError)); + } +- case 1: { // tabs:tabs_4d51_TabsStore_get_all ++ case 1: { // tabs:tabs_1c79_TabsStore_get_all + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTabsTabsStorePointerType>>; +- return Some(CallHandler::CallAsync(tabs_4d51_TabsStore_get_all, aGlobal, aArgs, "tabs_4d51_TabsStore_get_all: "_ns, aError)); ++ return Some(CallHandler::CallAsync(tabs_1c79_TabsStore_get_all, aGlobal, aArgs, "tabs_1c79_TabsStore_get_all: "_ns, aError)); + } +- case 2: { // tabs:tabs_4d51_TabsStore_set_local_tabs ++ case 2: { // tabs:tabs_1c79_TabsStore_set_local_tabs + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsStorePointerType>, ScaffoldingConverter<RustBuffer>>; +- return Some(CallHandler::CallAsync(tabs_4d51_TabsStore_set_local_tabs, aGlobal, aArgs, "tabs_4d51_TabsStore_set_local_tabs: "_ns, aError)); ++ return Some(CallHandler::CallAsync(tabs_1c79_TabsStore_set_local_tabs, aGlobal, aArgs, "tabs_1c79_TabsStore_set_local_tabs: "_ns, aError)); + } +- case 3: { // tabs:tabs_4d51_TabsStore_register_with_sync_manager ++ case 3: { // tabs:tabs_1c79_TabsStore_register_with_sync_manager + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsStorePointerType>>; +- return Some(CallHandler::CallAsync(tabs_4d51_TabsStore_register_with_sync_manager, aGlobal, aArgs, "tabs_4d51_TabsStore_register_with_sync_manager: "_ns, aError)); ++ return Some(CallHandler::CallAsync(tabs_1c79_TabsStore_register_with_sync_manager, aGlobal, aArgs, "tabs_1c79_TabsStore_register_with_sync_manager: "_ns, aError)); + } +- case 4: { // tabs:tabs_4d51_TabsStore_reset ++ case 4: { // tabs:tabs_1c79_TabsStore_reset + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsStorePointerType>>; +- return Some(CallHandler::CallAsync(tabs_4d51_TabsStore_reset, aGlobal, aArgs, "tabs_4d51_TabsStore_reset: "_ns, aError)); ++ return Some(CallHandler::CallAsync(tabs_1c79_TabsStore_reset, aGlobal, aArgs, "tabs_1c79_TabsStore_reset: "_ns, aError)); + } +- case 5: { // tabs:tabs_4d51_TabsStore_sync ++ case 5: { // tabs:tabs_1c79_TabsStore_sync + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTabsTabsStorePointerType>, ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>>; +- return Some(CallHandler::CallAsync(tabs_4d51_TabsStore_sync, aGlobal, aArgs, "tabs_4d51_TabsStore_sync: "_ns, aError)); ++ return Some(CallHandler::CallAsync(tabs_1c79_TabsStore_sync, aGlobal, aArgs, "tabs_1c79_TabsStore_sync: "_ns, aError)); + } +- case 6: { // tabs:tabs_4d51_TabsStore_bridged_engine ++ case 6: { // tabs:tabs_1c79_TabsStore_bridged_engine + using CallHandler = ScaffoldingCallHandler<ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>, ScaffoldingObjectConverter<&kTabsTabsStorePointerType>>; +- return Some(CallHandler::CallAsync(tabs_4d51_TabsStore_bridged_engine, aGlobal, aArgs, "tabs_4d51_TabsStore_bridged_engine: "_ns, aError)); ++ return Some(CallHandler::CallAsync(tabs_1c79_TabsStore_bridged_engine, aGlobal, aArgs, "tabs_1c79_TabsStore_bridged_engine: "_ns, aError)); + } +- case 7: { // tabs:tabs_4d51_TabsBridgedEngine_last_sync ++ case 7: { // tabs:tabs_1c79_TabsBridgedEngine_last_sync + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int64_t>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>>; +- return Some(CallHandler::CallAsync(tabs_4d51_TabsBridgedEngine_last_sync, aGlobal, aArgs, "tabs_4d51_TabsBridgedEngine_last_sync: "_ns, aError)); ++ return Some(CallHandler::CallAsync(tabs_1c79_TabsBridgedEngine_last_sync, aGlobal, aArgs, "tabs_1c79_TabsBridgedEngine_last_sync: "_ns, aError)); + } +- case 8: { // tabs:tabs_4d51_TabsBridgedEngine_set_last_sync ++ case 8: { // tabs:tabs_1c79_TabsBridgedEngine_set_last_sync + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>, ScaffoldingConverter<int64_t>>; +- return Some(CallHandler::CallAsync(tabs_4d51_TabsBridgedEngine_set_last_sync, aGlobal, aArgs, "tabs_4d51_TabsBridgedEngine_set_last_sync: "_ns, aError)); ++ return Some(CallHandler::CallAsync(tabs_1c79_TabsBridgedEngine_set_last_sync, aGlobal, aArgs, "tabs_1c79_TabsBridgedEngine_set_last_sync: "_ns, aError)); + } +- case 9: { // tabs:tabs_4d51_TabsBridgedEngine_sync_id ++ case 9: { // tabs:tabs_1c79_TabsBridgedEngine_sync_id + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>>; +- return Some(CallHandler::CallAsync(tabs_4d51_TabsBridgedEngine_sync_id, aGlobal, aArgs, "tabs_4d51_TabsBridgedEngine_sync_id: "_ns, aError)); ++ return Some(CallHandler::CallAsync(tabs_1c79_TabsBridgedEngine_sync_id, aGlobal, aArgs, "tabs_1c79_TabsBridgedEngine_sync_id: "_ns, aError)); + } +- case 10: { // tabs:tabs_4d51_TabsBridgedEngine_reset_sync_id ++ case 10: { // tabs:tabs_1c79_TabsBridgedEngine_reset_sync_id + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>>; +- return Some(CallHandler::CallAsync(tabs_4d51_TabsBridgedEngine_reset_sync_id, aGlobal, aArgs, "tabs_4d51_TabsBridgedEngine_reset_sync_id: "_ns, aError)); ++ return Some(CallHandler::CallAsync(tabs_1c79_TabsBridgedEngine_reset_sync_id, aGlobal, aArgs, "tabs_1c79_TabsBridgedEngine_reset_sync_id: "_ns, aError)); + } +- case 11: { // tabs:tabs_4d51_TabsBridgedEngine_ensure_current_sync_id ++ case 11: { // tabs:tabs_1c79_TabsBridgedEngine_ensure_current_sync_id + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>, ScaffoldingConverter<RustBuffer>>; +- return Some(CallHandler::CallAsync(tabs_4d51_TabsBridgedEngine_ensure_current_sync_id, aGlobal, aArgs, "tabs_4d51_TabsBridgedEngine_ensure_current_sync_id: "_ns, aError)); ++ return Some(CallHandler::CallAsync(tabs_1c79_TabsBridgedEngine_ensure_current_sync_id, aGlobal, aArgs, "tabs_1c79_TabsBridgedEngine_ensure_current_sync_id: "_ns, aError)); + } +- case 12: { // tabs:tabs_4d51_TabsBridgedEngine_prepare_for_sync ++ case 12: { // tabs:tabs_1c79_TabsBridgedEngine_prepare_for_sync + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>, ScaffoldingConverter<RustBuffer>>; +- return Some(CallHandler::CallAsync(tabs_4d51_TabsBridgedEngine_prepare_for_sync, aGlobal, aArgs, "tabs_4d51_TabsBridgedEngine_prepare_for_sync: "_ns, aError)); ++ return Some(CallHandler::CallAsync(tabs_1c79_TabsBridgedEngine_prepare_for_sync, aGlobal, aArgs, "tabs_1c79_TabsBridgedEngine_prepare_for_sync: "_ns, aError)); + } +- case 13: { // tabs:tabs_4d51_TabsBridgedEngine_sync_started ++ case 13: { // tabs:tabs_1c79_TabsBridgedEngine_sync_started + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>>; +- return Some(CallHandler::CallAsync(tabs_4d51_TabsBridgedEngine_sync_started, aGlobal, aArgs, "tabs_4d51_TabsBridgedEngine_sync_started: "_ns, aError)); ++ return Some(CallHandler::CallAsync(tabs_1c79_TabsBridgedEngine_sync_started, aGlobal, aArgs, "tabs_1c79_TabsBridgedEngine_sync_started: "_ns, aError)); + } +- case 14: { // tabs:tabs_4d51_TabsBridgedEngine_store_incoming ++ case 14: { // tabs:tabs_1c79_TabsBridgedEngine_store_incoming + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>, ScaffoldingConverter<RustBuffer>>; +- return Some(CallHandler::CallAsync(tabs_4d51_TabsBridgedEngine_store_incoming, aGlobal, aArgs, "tabs_4d51_TabsBridgedEngine_store_incoming: "_ns, aError)); ++ return Some(CallHandler::CallAsync(tabs_1c79_TabsBridgedEngine_store_incoming, aGlobal, aArgs, "tabs_1c79_TabsBridgedEngine_store_incoming: "_ns, aError)); + } +- case 15: { // tabs:tabs_4d51_TabsBridgedEngine_apply ++ case 15: { // tabs:tabs_1c79_TabsBridgedEngine_apply + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>>; +- return Some(CallHandler::CallAsync(tabs_4d51_TabsBridgedEngine_apply, aGlobal, aArgs, "tabs_4d51_TabsBridgedEngine_apply: "_ns, aError)); ++ return Some(CallHandler::CallAsync(tabs_1c79_TabsBridgedEngine_apply, aGlobal, aArgs, "tabs_1c79_TabsBridgedEngine_apply: "_ns, aError)); + } +- case 16: { // tabs:tabs_4d51_TabsBridgedEngine_set_uploaded ++ case 16: { // tabs:tabs_1c79_TabsBridgedEngine_set_uploaded + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>, ScaffoldingConverter<int64_t>, ScaffoldingConverter<RustBuffer>>; +- return Some(CallHandler::CallAsync(tabs_4d51_TabsBridgedEngine_set_uploaded, aGlobal, aArgs, "tabs_4d51_TabsBridgedEngine_set_uploaded: "_ns, aError)); ++ return Some(CallHandler::CallAsync(tabs_1c79_TabsBridgedEngine_set_uploaded, aGlobal, aArgs, "tabs_1c79_TabsBridgedEngine_set_uploaded: "_ns, aError)); + } +- case 17: { // tabs:tabs_4d51_TabsBridgedEngine_sync_finished ++ case 17: { // tabs:tabs_1c79_TabsBridgedEngine_sync_finished + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>>; +- return Some(CallHandler::CallAsync(tabs_4d51_TabsBridgedEngine_sync_finished, aGlobal, aArgs, "tabs_4d51_TabsBridgedEngine_sync_finished: "_ns, aError)); ++ return Some(CallHandler::CallAsync(tabs_1c79_TabsBridgedEngine_sync_finished, aGlobal, aArgs, "tabs_1c79_TabsBridgedEngine_sync_finished: "_ns, aError)); + } +- case 18: { // tabs:tabs_4d51_TabsBridgedEngine_reset ++ case 18: { // tabs:tabs_1c79_TabsBridgedEngine_reset + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>>; +- return Some(CallHandler::CallAsync(tabs_4d51_TabsBridgedEngine_reset, aGlobal, aArgs, "tabs_4d51_TabsBridgedEngine_reset: "_ns, aError)); ++ return Some(CallHandler::CallAsync(tabs_1c79_TabsBridgedEngine_reset, aGlobal, aArgs, "tabs_1c79_TabsBridgedEngine_reset: "_ns, aError)); + } +- case 19: { // tabs:tabs_4d51_TabsBridgedEngine_wipe ++ case 19: { // tabs:tabs_1c79_TabsBridgedEngine_wipe + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>>; +- return Some(CallHandler::CallAsync(tabs_4d51_TabsBridgedEngine_wipe, aGlobal, aArgs, "tabs_4d51_TabsBridgedEngine_wipe: "_ns, aError)); ++ return Some(CallHandler::CallAsync(tabs_1c79_TabsBridgedEngine_wipe, aGlobal, aArgs, "tabs_1c79_TabsBridgedEngine_wipe: "_ns, aError)); + } + } + return Nothing(); +@@ -141,104 +141,104 @@ + + bool UniFFICallSync(const GlobalObject& aGlobal, uint64_t aId, const Sequence<ScaffoldingType>& aArgs, RootedDictionary<UniFFIScaffoldingCallResult>& aReturnValue, ErrorResult& aError) { + switch (aId) { +- case 0: { // tabs:tabs_4d51_TabsStore_new ++ case 0: { // tabs:tabs_1c79_TabsStore_new + using CallHandler = ScaffoldingCallHandler<ScaffoldingObjectConverter<&kTabsTabsStorePointerType>, ScaffoldingConverter<RustBuffer>>; +- CallHandler::CallSync(tabs_4d51_TabsStore_new, aGlobal, aArgs, aReturnValue, "tabs_4d51_TabsStore_new: "_ns, aError); ++ CallHandler::CallSync(tabs_1c79_TabsStore_new, aGlobal, aArgs, aReturnValue, "tabs_1c79_TabsStore_new: "_ns, aError); + return true; + } +- case 1: { // tabs:tabs_4d51_TabsStore_get_all ++ case 1: { // tabs:tabs_1c79_TabsStore_get_all + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTabsTabsStorePointerType>>; +- CallHandler::CallSync(tabs_4d51_TabsStore_get_all, aGlobal, aArgs, aReturnValue, "tabs_4d51_TabsStore_get_all: "_ns, aError); ++ CallHandler::CallSync(tabs_1c79_TabsStore_get_all, aGlobal, aArgs, aReturnValue, "tabs_1c79_TabsStore_get_all: "_ns, aError); + return true; + } +- case 2: { // tabs:tabs_4d51_TabsStore_set_local_tabs ++ case 2: { // tabs:tabs_1c79_TabsStore_set_local_tabs + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsStorePointerType>, ScaffoldingConverter<RustBuffer>>; +- CallHandler::CallSync(tabs_4d51_TabsStore_set_local_tabs, aGlobal, aArgs, aReturnValue, "tabs_4d51_TabsStore_set_local_tabs: "_ns, aError); ++ CallHandler::CallSync(tabs_1c79_TabsStore_set_local_tabs, aGlobal, aArgs, aReturnValue, "tabs_1c79_TabsStore_set_local_tabs: "_ns, aError); + return true; + } +- case 3: { // tabs:tabs_4d51_TabsStore_register_with_sync_manager ++ case 3: { // tabs:tabs_1c79_TabsStore_register_with_sync_manager + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsStorePointerType>>; +- CallHandler::CallSync(tabs_4d51_TabsStore_register_with_sync_manager, aGlobal, aArgs, aReturnValue, "tabs_4d51_TabsStore_register_with_sync_manager: "_ns, aError); ++ CallHandler::CallSync(tabs_1c79_TabsStore_register_with_sync_manager, aGlobal, aArgs, aReturnValue, "tabs_1c79_TabsStore_register_with_sync_manager: "_ns, aError); + return true; + } +- case 4: { // tabs:tabs_4d51_TabsStore_reset ++ case 4: { // tabs:tabs_1c79_TabsStore_reset + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsStorePointerType>>; +- CallHandler::CallSync(tabs_4d51_TabsStore_reset, aGlobal, aArgs, aReturnValue, "tabs_4d51_TabsStore_reset: "_ns, aError); ++ CallHandler::CallSync(tabs_1c79_TabsStore_reset, aGlobal, aArgs, aReturnValue, "tabs_1c79_TabsStore_reset: "_ns, aError); + return true; + } +- case 5: { // tabs:tabs_4d51_TabsStore_sync ++ case 5: { // tabs:tabs_1c79_TabsStore_sync + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTabsTabsStorePointerType>, ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>>; +- CallHandler::CallSync(tabs_4d51_TabsStore_sync, aGlobal, aArgs, aReturnValue, "tabs_4d51_TabsStore_sync: "_ns, aError); ++ CallHandler::CallSync(tabs_1c79_TabsStore_sync, aGlobal, aArgs, aReturnValue, "tabs_1c79_TabsStore_sync: "_ns, aError); + return true; + } +- case 6: { // tabs:tabs_4d51_TabsStore_bridged_engine ++ case 6: { // tabs:tabs_1c79_TabsStore_bridged_engine + using CallHandler = ScaffoldingCallHandler<ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>, ScaffoldingObjectConverter<&kTabsTabsStorePointerType>>; +- CallHandler::CallSync(tabs_4d51_TabsStore_bridged_engine, aGlobal, aArgs, aReturnValue, "tabs_4d51_TabsStore_bridged_engine: "_ns, aError); ++ CallHandler::CallSync(tabs_1c79_TabsStore_bridged_engine, aGlobal, aArgs, aReturnValue, "tabs_1c79_TabsStore_bridged_engine: "_ns, aError); + return true; + } +- case 7: { // tabs:tabs_4d51_TabsBridgedEngine_last_sync ++ case 7: { // tabs:tabs_1c79_TabsBridgedEngine_last_sync + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int64_t>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>>; +- CallHandler::CallSync(tabs_4d51_TabsBridgedEngine_last_sync, aGlobal, aArgs, aReturnValue, "tabs_4d51_TabsBridgedEngine_last_sync: "_ns, aError); ++ CallHandler::CallSync(tabs_1c79_TabsBridgedEngine_last_sync, aGlobal, aArgs, aReturnValue, "tabs_1c79_TabsBridgedEngine_last_sync: "_ns, aError); + return true; + } +- case 8: { // tabs:tabs_4d51_TabsBridgedEngine_set_last_sync ++ case 8: { // tabs:tabs_1c79_TabsBridgedEngine_set_last_sync + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>, ScaffoldingConverter<int64_t>>; +- CallHandler::CallSync(tabs_4d51_TabsBridgedEngine_set_last_sync, aGlobal, aArgs, aReturnValue, "tabs_4d51_TabsBridgedEngine_set_last_sync: "_ns, aError); ++ CallHandler::CallSync(tabs_1c79_TabsBridgedEngine_set_last_sync, aGlobal, aArgs, aReturnValue, "tabs_1c79_TabsBridgedEngine_set_last_sync: "_ns, aError); + return true; + } +- case 9: { // tabs:tabs_4d51_TabsBridgedEngine_sync_id ++ case 9: { // tabs:tabs_1c79_TabsBridgedEngine_sync_id + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>>; +- CallHandler::CallSync(tabs_4d51_TabsBridgedEngine_sync_id, aGlobal, aArgs, aReturnValue, "tabs_4d51_TabsBridgedEngine_sync_id: "_ns, aError); ++ CallHandler::CallSync(tabs_1c79_TabsBridgedEngine_sync_id, aGlobal, aArgs, aReturnValue, "tabs_1c79_TabsBridgedEngine_sync_id: "_ns, aError); + return true; + } +- case 10: { // tabs:tabs_4d51_TabsBridgedEngine_reset_sync_id ++ case 10: { // tabs:tabs_1c79_TabsBridgedEngine_reset_sync_id + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>>; +- CallHandler::CallSync(tabs_4d51_TabsBridgedEngine_reset_sync_id, aGlobal, aArgs, aReturnValue, "tabs_4d51_TabsBridgedEngine_reset_sync_id: "_ns, aError); ++ CallHandler::CallSync(tabs_1c79_TabsBridgedEngine_reset_sync_id, aGlobal, aArgs, aReturnValue, "tabs_1c79_TabsBridgedEngine_reset_sync_id: "_ns, aError); + return true; + } +- case 11: { // tabs:tabs_4d51_TabsBridgedEngine_ensure_current_sync_id ++ case 11: { // tabs:tabs_1c79_TabsBridgedEngine_ensure_current_sync_id + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>, ScaffoldingConverter<RustBuffer>>; +- CallHandler::CallSync(tabs_4d51_TabsBridgedEngine_ensure_current_sync_id, aGlobal, aArgs, aReturnValue, "tabs_4d51_TabsBridgedEngine_ensure_current_sync_id: "_ns, aError); ++ CallHandler::CallSync(tabs_1c79_TabsBridgedEngine_ensure_current_sync_id, aGlobal, aArgs, aReturnValue, "tabs_1c79_TabsBridgedEngine_ensure_current_sync_id: "_ns, aError); + return true; + } +- case 12: { // tabs:tabs_4d51_TabsBridgedEngine_prepare_for_sync ++ case 12: { // tabs:tabs_1c79_TabsBridgedEngine_prepare_for_sync + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>, ScaffoldingConverter<RustBuffer>>; +- CallHandler::CallSync(tabs_4d51_TabsBridgedEngine_prepare_for_sync, aGlobal, aArgs, aReturnValue, "tabs_4d51_TabsBridgedEngine_prepare_for_sync: "_ns, aError); ++ CallHandler::CallSync(tabs_1c79_TabsBridgedEngine_prepare_for_sync, aGlobal, aArgs, aReturnValue, "tabs_1c79_TabsBridgedEngine_prepare_for_sync: "_ns, aError); + return true; + } +- case 13: { // tabs:tabs_4d51_TabsBridgedEngine_sync_started ++ case 13: { // tabs:tabs_1c79_TabsBridgedEngine_sync_started + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>>; +- CallHandler::CallSync(tabs_4d51_TabsBridgedEngine_sync_started, aGlobal, aArgs, aReturnValue, "tabs_4d51_TabsBridgedEngine_sync_started: "_ns, aError); ++ CallHandler::CallSync(tabs_1c79_TabsBridgedEngine_sync_started, aGlobal, aArgs, aReturnValue, "tabs_1c79_TabsBridgedEngine_sync_started: "_ns, aError); + return true; + } +- case 14: { // tabs:tabs_4d51_TabsBridgedEngine_store_incoming ++ case 14: { // tabs:tabs_1c79_TabsBridgedEngine_store_incoming + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>, ScaffoldingConverter<RustBuffer>>; +- CallHandler::CallSync(tabs_4d51_TabsBridgedEngine_store_incoming, aGlobal, aArgs, aReturnValue, "tabs_4d51_TabsBridgedEngine_store_incoming: "_ns, aError); ++ CallHandler::CallSync(tabs_1c79_TabsBridgedEngine_store_incoming, aGlobal, aArgs, aReturnValue, "tabs_1c79_TabsBridgedEngine_store_incoming: "_ns, aError); + return true; + } +- case 15: { // tabs:tabs_4d51_TabsBridgedEngine_apply ++ case 15: { // tabs:tabs_1c79_TabsBridgedEngine_apply + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>>; +- CallHandler::CallSync(tabs_4d51_TabsBridgedEngine_apply, aGlobal, aArgs, aReturnValue, "tabs_4d51_TabsBridgedEngine_apply: "_ns, aError); ++ CallHandler::CallSync(tabs_1c79_TabsBridgedEngine_apply, aGlobal, aArgs, aReturnValue, "tabs_1c79_TabsBridgedEngine_apply: "_ns, aError); + return true; + } +- case 16: { // tabs:tabs_4d51_TabsBridgedEngine_set_uploaded ++ case 16: { // tabs:tabs_1c79_TabsBridgedEngine_set_uploaded + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>, ScaffoldingConverter<int64_t>, ScaffoldingConverter<RustBuffer>>; +- CallHandler::CallSync(tabs_4d51_TabsBridgedEngine_set_uploaded, aGlobal, aArgs, aReturnValue, "tabs_4d51_TabsBridgedEngine_set_uploaded: "_ns, aError); ++ CallHandler::CallSync(tabs_1c79_TabsBridgedEngine_set_uploaded, aGlobal, aArgs, aReturnValue, "tabs_1c79_TabsBridgedEngine_set_uploaded: "_ns, aError); + return true; + } +- case 17: { // tabs:tabs_4d51_TabsBridgedEngine_sync_finished ++ case 17: { // tabs:tabs_1c79_TabsBridgedEngine_sync_finished + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>>; +- CallHandler::CallSync(tabs_4d51_TabsBridgedEngine_sync_finished, aGlobal, aArgs, aReturnValue, "tabs_4d51_TabsBridgedEngine_sync_finished: "_ns, aError); ++ CallHandler::CallSync(tabs_1c79_TabsBridgedEngine_sync_finished, aGlobal, aArgs, aReturnValue, "tabs_1c79_TabsBridgedEngine_sync_finished: "_ns, aError); + return true; + } +- case 18: { // tabs:tabs_4d51_TabsBridgedEngine_reset ++ case 18: { // tabs:tabs_1c79_TabsBridgedEngine_reset + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>>; +- CallHandler::CallSync(tabs_4d51_TabsBridgedEngine_reset, aGlobal, aArgs, aReturnValue, "tabs_4d51_TabsBridgedEngine_reset: "_ns, aError); ++ CallHandler::CallSync(tabs_1c79_TabsBridgedEngine_reset, aGlobal, aArgs, aReturnValue, "tabs_1c79_TabsBridgedEngine_reset: "_ns, aError); + return true; + } +- case 19: { // tabs:tabs_4d51_TabsBridgedEngine_wipe ++ case 19: { // tabs:tabs_1c79_TabsBridgedEngine_wipe + using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>>; +- CallHandler::CallSync(tabs_4d51_TabsBridgedEngine_wipe, aGlobal, aArgs, aReturnValue, "tabs_4d51_TabsBridgedEngine_wipe: "_ns, aError); ++ CallHandler::CallSync(tabs_1c79_TabsBridgedEngine_wipe, aGlobal, aArgs, aReturnValue, "tabs_1c79_TabsBridgedEngine_wipe: "_ns, aError); + return true; + } + } diff --git a/source/xap/mozilla-thunderbird/mozilla-thunderbird.SlackBuild b/source/xap/mozilla-thunderbird/mozilla-thunderbird.SlackBuild index c5730f5d6..b4efb59f0 100755 --- a/source/xap/mozilla-thunderbird/mozilla-thunderbird.SlackBuild +++ b/source/xap/mozilla-thunderbird/mozilla-thunderbird.SlackBuild @@ -317,20 +317,6 @@ mkdir -p $PKG/usr/share/pixmaps # Symlinked below. #cat $CWD/thunderbird.png > $PKG/usr/share/pixmaps/thunderbird.png -# These files/directories are usually created if Thunderbird is run as root, -# which on many systems might (and possibly should) be never. Therefore, if we -# don't see them we'll put stubs in place to prevent startup errors. -( cd $PKG/usr/lib${LIBDIRSUFFIX}/thunderbird-$RELEASEVER - if [ -d extensions/talkback\@mozilla.org ]; then - if [ ! -r extensions/talkback\@mozilla.org/chrome.manifest ]; then - echo > extensions/talkback\@mozilla.org/chrome.manifest - fi - fi - if [ ! -d updates ]; then - mkdir -p updates/0 - fi -) - # Need some default icons in the right place: for i in 16 22 24 32 48 256; do install -m 0644 -D comm/mail/branding/thunderbird/default${i}.png \ |