mozilla
/
uniffi-rs
зеркало из https://github.com/mozilla/uniffi-rs.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность
uniffi-rs/Cargo.toml

65 строки
1.7 KiB
TOML
Исходник Обычный вид История

Turn example scripts into simple test fixtures. Prior to this commit, the only "tests" we had for the generated code were a small set of example scripts in the various target languages, and we could "test" them by manually executing the script and seeing whether it printed plausible output. With this commit, those scripts can now be proper testcases. It has involved a fair bit of restructuring, but broadly: * The crate and its examples are now part of a single workspace, so `cargo test` in the top-level directory will test them all. * There is a new `uniffi_macros` crate with a single macro called `build_foreign_language_testcases!`. Given a list of script files, it will generate a testcase shim for each one, executing the file via an appropriate interpret and failing the test if it does not exit successfully. * The various example crates have had their example scripts converted into testcases in this manner.
2020-07-10 14:34:12 +03:00
[workspace]
members = [
Refactor uniffi structure
2020-08-05 21:26:16 +03:00
"uniffi_bindgen",
"uniffi_build",
Prep work for new UniFFI workflow - Removed the `builtin-bindgen` feature. That code is now always enabled - Moved code from `uniffi` into `uniffi_core` and have `uniffi` re-export it. My goal is for `uniffi` to act as a frontend of sorts. UniFFIed crates will depend on `uniffi` only and that will pull in everything from the other uniffi crates.
2022-10-18 19:26:47 +03:00
"uniffi_core",
Turn example scripts into simple test fixtures. Prior to this commit, the only "tests" we had for the generated code were a small set of example scripts in the various target languages, and we could "test" them by manually executing the script and seeing whether it printed plausible output. With this commit, those scripts can now be proper testcases. It has involved a fair bit of restructuring, but broadly: * The crate and its examples are now part of a single workspace, so `cargo test` in the top-level directory will test them all. * There is a new `uniffi_macros` crate with a single macro called `build_foreign_language_testcases!`. Given a list of script files, it will generate a testcase shim for each one, executing the file via an appropriate interpret and failing the test if it does not exit successfully. * The various example crates have had their example scripts converted into testcases in this manner.
2020-07-10 14:34:12 +03:00
"uniffi_macros",
Add #[uniffi::export] attribute with support for non-impl functions
2022-05-30 16:48:47 +03:00
"uniffi_meta",
Adding support for external fixture/example tests Added code to allow external bindings crates to find the UDL files and cdylibs for examples/fixtures. Made a new crate for this, since I didn't want to pull in `serde` as a dependency for `uniffi`. Eventually, this can replace `uniffi/testing.rs` and we can remove some other dependencies from `uniffi` like `cargo_metadata`. Standardized the crate names for fixtures/examples. I think we're going to need to publish these to crates.io eventually. Make all fixtures/examples specify `crate-type = ["lib", "cdylib"]`. The `lib` part is needed for moz-central to be able to import these crates and build them into `libxul`. Added `Cargo.toml` config section that lists external clates for `ext-types` We copy the dylibs for external crates as well as our own. I think this should fix #1183.
2022-03-15 18:53:05 +03:00
"uniffi_testing",
Split UDL parts of uniffi_bindgen into a new uniffi_udl crate. (#1629)
2023-07-04 00:55:20 +03:00
"uniffi_udl",
Refactor uniffi structure
2020-08-05 21:26:16 +03:00
"uniffi",
Use locally-vendored weedle2
2022-04-22 14:19:39 +03:00
"weedle2",
Add #[uniffi::export] attribute with support for non-impl functions
2022-05-30 16:48:47 +03:00
Allow Rust traits to be exposed as an interface. (#1457)
2023-05-01 02:32:54 +03:00
"examples/app/uniffi-bindgen-cli",
Turn example scripts into simple test fixtures. Prior to this commit, the only "tests" we had for the generated code were a small set of example scripts in the various target languages, and we could "test" them by manually executing the script and seeing whether it printed plausible output. With this commit, those scripts can now be proper testcases. It has involved a fair bit of restructuring, but broadly: * The crate and its examples are now part of a single workspace, so `cargo test` in the top-level directory will test them all. * There is a new `uniffi_macros` crate with a single macro called `build_foreign_language_testcases!`. Given a list of script files, it will generate a testcase shim for each one, executing the file via an appropriate interpret and failing the test if it does not exit successfully. * The various example crates have had their example scripts converted into testcases in this manner.
2020-07-10 14:34:12 +03:00
"examples/arithmetic",
Add callback interfaces for Kotlin (#344) r=rfk * Add callback interfaces for Kotlin We'd like to have a Rust trait: ```rust trait FetchClient { fn fetch(url: String) -> String } // later impl Nimbus { fn set_fetch_client(client: Box<dyn FetchClient>) {} } ``` Declared in the IDL: ```idl interface Nimbus { set_fetch_client(FetchClient client); update_experiments(); } callback interface FetchClient { string fetch(string url); }; ``` And used in Kotlin: ```kotlin class ConceptFetchClient: FetchClient { override fun fetch(url: String): String { ... } } nimbus.setFetchClient(ConceptFetchClient()) nimbus.updateExperiments() // uses ConceptFetchClient ``` This commit sends JNA Callbacks to send a callback interface to Rust (a.k.a. `ForeignCallback`). This implementation of the `ForeignCallback` is individual to the callback interface— on the kotlin side; in this case this is called: `CallbackInterfaceFetchClientFFI`. As the `ConceptFetchClient` is sent from kotlin, it is placed in a kotlin `ConcurrentHandleMap`. A Rust `impl` of corresponding `FetchClient` trait is generated which proxies all calls through the `ForeignCallback` to kotlin, i.e. `CallbackInterfaceFetchClientProxy` in Rust calls to `CallbackInterfaceFetchClientFFI` in kotlin. The callback object i.e. the `ConceptFetchClient` is then found, and then methods are called from `CallbackInterfaceFetchClientFFI` to the client code `ConceptFetchClient`. * Address first pass review comments * Address reviewer comments * Review 3 comments * Final review comments
2021-01-22 15:31:05 +03:00
"examples/callbacks",
Allow Rust traits to be exposed as an interface. (#1457)
2023-05-01 02:32:54 +03:00
"examples/custom-types",
New example and docs for Futures (#1634) Co-authored-by: Ivan Enderlin <ivan@mnt.io> Co-authored-by: Jan-Erik Rediger <janerik@fnordig.de>
2023-07-19 18:30:19 +03:00
"examples/futures",
Turn example scripts into simple test fixtures. Prior to this commit, the only "tests" we had for the generated code were a small set of example scripts in the various target languages, and we could "test" them by manually executing the script and seeing whether it printed plausible output. With this commit, those scripts can now be proper testcases. It has involved a fair bit of restructuring, but broadly: * The crate and its examples are now part of a single workspace, so `cargo test` in the top-level directory will test them all. * There is a new `uniffi_macros` crate with a single macro called `build_foreign_language_testcases!`. Given a list of script files, it will generate a testcase shim for each one, executing the file via an appropriate interpret and failing the test if it does not exit successfully. * The various example crates have had their example scripts converted into testcases in this manner.
2020-07-10 14:34:12 +03:00
"examples/geometry",
Add Lowerable/Liftable impls for enums
2020-07-31 00:34:36 +03:00
"examples/rondpoint",
Turn example scripts into simple test fixtures. Prior to this commit, the only "tests" we had for the generated code were a small set of example scripts in the various target languages, and we could "test" them by manually executing the script and seeing whether it printed plausible output. With this commit, those scripts can now be proper testcases. It has involved a fair bit of restructuring, but broadly: * The crate and its examples are now part of a single workspace, so `cargo test` in the top-level directory will test them all. * There is a new `uniffi_macros` crate with a single macro called `build_foreign_language_testcases!`. Given a list of script files, it will generate a testcase shim for each one, executing the file via an appropriate interpret and failing the test if it does not exit successfully. * The various example crates have had their example scripts converted into testcases in this manner.
2020-07-10 14:34:12 +03:00
"examples/sprites",
Don't use i32 helpers in generated Enum code. Previously, the generated Kotlin code for enums would try to use helpers from the `Int` companion class, but we would only emit the code for those helpers if the interface was also using the integer type. Now, the generated Kotlin code for enums directly uses lower-level methods for reading and writing integers, so that it doesn't depend on other generated code. Fixes #356.
2020-12-08 09:50:00 +03:00
"examples/todolist",
Allow Rust traits to be exposed as an interface. (#1457)
2023-05-01 02:32:54 +03:00
"examples/traits",
New example and new fixture for imported and wrapping types.
2021-08-12 11:47:55 +03:00
Adding benchmark tests - Added the `benchmarks` fixture. This runs a set of benchmark tests and uses `criterion` to analyze the results. Added some benchmarks for calling functions and callback interfaces. - Added `run_script()` function, which is a more generic version of `run_test()`. - uniffi_testing: Don't add `--test` when running `cargo build` to find the dylibs. It's not needed for the fixture/example tests and it breaks the benchmark tests.
2023-03-01 23:18:05 +03:00
"fixtures/benchmarks",
New 'coverall' fixture to test coverage and edge-cases. (#431) This is similar to our examples, but it's intended to be contrived and to ensure we get good test coverage of all possible options - particularly for future changes. It's in the "fixtures" directory so it doesn't even need to make a cursory effort to be a "good example"; it intentionally panics, asserts params are certain values, has no-op methods etc. If you're trying to get your head around uniffi then the "examples" directory will be a much better bet.
2021-05-07 09:27:14 +03:00
"fixtures/coverall",
Move callbacks testing code into its own fixture crate for testing
2021-08-03 19:13:02 +03:00
"fixtures/callbacks",
New example and new fixture for imported and wrapping types.
2021-08-12 11:47:55 +03:00
"fixtures/ext-types/guid",
Re-allow more complex custom types in UDL (#1690) * Add http-headermap custom type fixture `http::HeaderMap` is a multi-map so for simplicity we expose as a `sequence` of headers. This was broken by https://github.com/mozilla/uniffi-rs/pull/1661 which caused: ``` error: unexpected token --> /tmp/target/debug/build/uniffi-fixture-ext-types-http-headermap-2750e41fdae052ad/out/http_headermap.uniffi.rs:132:40 | 132 | ::uniffi::custom_type!(r#HeaderMap, std::vec::Vec<r#HttpHeader>); | ^ ``` * Use builtin's `FfiConverter::FfiType` when implementing custom type `FfiConverter` This avoids needing to match on stringified Rust types. This is the first part of the fix for the `http-headmap` fixture. * Allow custom type's builtin to be a `Path` not just an `Ident` This allows the `http-headermap` test to pass again.
2023-08-09 16:57:42 +03:00
"fixtures/ext-types/http-headermap",
New example and new fixture for imported and wrapping types.
2021-08-12 11:47:55 +03:00
"fixtures/ext-types/uniffi-one",
"fixtures/ext-types/lib",
Added suport for using external types in proc-macros Moved the FfiConverter implementation for callback interfaces and traits from a declarative macro in `uniffi_core` to a proc-macro in `uniffi_macros`. This offers better `UniFfiTag` handling. Now `FfiConverter` is implemented for all tags for callback interfaces/traits that are wrapped with the proc-macro attributes. This matches the behavior for other types and will help fix #1531. Changed the object FfiConverter to be inside a proc-macro, rather than using the `Interface` trait. This more flexibility and avoids conflicting impls. For example, this allows for both the objects and trait interface `FfiConverters`s to be implemented on `Arc<T>`. I also think it's nicer with less indirection. One drawback is that libraries can't implement `FfiConverter` on Arc<T> because of the orphan rules. To get around this, I added the `FfiConverterArc` trait. Other changes: - Adding `module_path` to the user type metadata - Added an proc-macro -> proc-macro external type test by copying the ext-types fixture into another one that uses proc macros.
2023-06-15 17:54:30 +03:00
"fixtures/ext-types/proc-macro-lib",
New example and new fixture for imported and wrapping types.
2021-08-12 11:47:55 +03:00
Adding the `foreignexecutor` module This is the first step in an overall async plan layed out in PR #1494. This allows Rust calls to be scheduled using the foreign executor (AKA task queue, event loop, etc.). It's not yet documented in the manual, I plan to do that when I implement async callbacks. I hope to use this to simplify the `RustFuture` code. Issue 1507 makes me think that we don't want the foreign bindings to handle ownership of the future, it's very tricky to manage this across an FFI. Instead, let's have Rust manage the future and have the foreign bindings only handle the scheduling. Added support for `usize' ints. This lets foreign bindings choose between using an int or pointer to represent an opaque type. Kotlin: moved the async imports to Types.rs, so that we can use `add_import()` to handle them. The ForeignExecutor.kt template wants to import some of the same items. Swift: Added support for initialization functions
2023-04-07 22:33:36 +03:00
"fixtures/foreign-executor",
Allow Rust, Python and Kotlin keywords to be used as identifier names. (#1237)
2022-06-16 09:31:58 +03:00
"fixtures/keywords/kotlin",
"fixtures/keywords/rust",
Add fixtures test for using Swift reserved words as fn, var, enum, or enum variant names.
2022-09-30 01:29:08 +03:00
"fixtures/keywords/swift",
New system for interface metadata - Added the `uniffi_core::metadata` module, which provides a system for building metadata buffers using const code. - Added the `FfiConverter::TYPE_ID_META` const, which holds metadata to identify the type. - Made the proc-macros generate use the new system to generate metadata consts, then export them using static variables. - Removed the current code to generate/store metadata based on the syn parsing. - Removed the type assertions and the requirement for a `uniffi_types` module. We don't need them now that we`re getting the type ids from the type itself. - Made the `FnMetadata.throws` field a Type rather than a String. - Calculate module paths with the `module_path!()` macro. This means we get accurate module paths without nightly. Changed mod_path to be a String, rather than a Vec since this is what `module_path!()` outputs. - Added code to strip the `r#` part out of raw idents before serializing it into the metadata. - Replaced the `collect_params()` function with the `ScaffoldingBits` struct. There was too much complexity for a single function -- for example unzip() only works with pairs, not 3-tuples. In general, the new metadata system is more reliable doing everything in the proc-macros. Proc-macros can only see the type identifiers, but they don't anything about the underlying type, since users can rename types with type aliases. It's also simpler since you don't have to walk the AST so much. One TODO is getting checksum working again. One limitation of the const code is that we can't use it to generate function identifiers.
2023-02-02 19:19:14 +03:00
"fixtures/metadata",
proc-macro: Add a test for record type usage
2022-10-04 19:11:51 +03:00
"fixtures/proc-macro",
Added the uniffi_reexport_scaffolding macro This can be used to work around [rust-lang#50007](rust-lang/rust#50007), which is getting to be more and more of an issue on the desktop JS project. Updated `uniffi::interface` and some of the fixtures so that we can test this.
2022-03-28 23:20:04 +03:00
"fixtures/reexport-scaffolding-macro",
Don't use i32 helpers in generated Enum code. Previously, the generated Kotlin code for enums would try to use helpers from the `Int` companion class, but we would only emit the code for those helpers if the interface was also using the integer type. Now, the generated Kotlin code for enums directly uses lower-level methods for reading and writing integers, so that it doesn't depend on other generated code. Fixes #356.
2020-12-08 09:50:00 +03:00
"fixtures/regressions/enum-without-i32-helpers",
Use fully-qualified type names in generated scaffolding code. This fixes #1015, which was a regression in the v0.13.0 release. Where possible we should be robust against changes in the details of the Rust code that implements a UniFFI component, but the generated Rust scaffolding accidentally started assuming that the `HashMap` type would be in scope for any interface using a map. This turned out not to be true in practice. To improve things, this commit makes the generated scaffolding use fully-qualified type names for `HashMap`, `Vec` and `Option`. There is probably more we could do on this front (e.g. the `String` type) but these were low-hanging fruit that fixed a concrete regression, so that's where I started.
2021-08-10 04:35:03 +03:00
"fixtures/regressions/fully-qualified-types",
Add @ExperimentalUnsignedTypes to unsigned types in kotlin (#977) * Add a test fixture for Kotlin "experimental unsigned types" warnings. * add annotations to kotlin when detecting unsigned types Co-authored-by: Ryan Kelly <ryan@rfk.id.au>
2021-07-13 23:09:17 +03:00
"fixtures/regressions/kotlin-experimental-unsigned-types",
add regression test for dependency-cdylib exclusion
2021-02-18 13:51:01 +03:00
"fixtures/regressions/cdylib-crate-type-dependency/ffi-crate",
"fixtures/regressions/cdylib-crate-type-dependency/cdylib-dependency",
Don't log callback interface method calls (#1439)
2023-01-04 00:22:53 +03:00
"fixtures/regressions/logging-callback-interface",
New regression test: We missed a newline This is already fixed in `main`, but was an issue in 0.19.1
2022-06-21 11:10:07 +03:00
"fixtures/regressions/missing-newline",
Apply `omit_argument_labels` option when calling into a callback (#1316)
2022-08-26 19:45:17 +03:00
"fixtures/regressions/swift-callbacks-omit-labels",
Add tests for dictionary nesting in Swift
2022-10-06 18:14:05 +03:00
"fixtures/regressions/swift-dictionary-nesting",
Fully qualify uses of `Result` in scaffolding/macro code PR #1469 introduced an incompatibility with a local `type Result<T> = std::result::Result<T, MyError>` type alias. As can be seen with the included test without the fix applied: ``` error[E0107]: this type alias takes 1 generic argument but 2 generic arguments were supplied --> /mounted_workdir/target/debug/build/unary-result-alias-f408c03f1955dadd/out/unary-result-alias.uniffi.rs:79:1 | 79 | / #[::uniffi::ffi_converter_error( 80 | | tag = crate::UniFfiTag, 81 | | flat_error, 82 | | 83 | | )] | | ^ | | | | |__expected 1 generic argument | help: remove this generic argument | note: type alias defined here, with 1 generic parameter: `T` --> fixtures/regressions/unary-result-alias/src/lib.rs:7:10 | 7 | pub type Result<T> = std::result::Result<T, MyError>; | ^^^^^^ - = note: this error originates in the macro `::uniffi::ffi_converter_default_return` which comes from the expansion of the attribute macro `::uniffi::ffi_converter_error` (in Nightly builds, run with -Z macro-backtrace for more info) ``` Fixing the macros in `uniffi_core` to use `::std::result::Result` fixes that. This exposes a further case in the generated code: ``` error[E0107]: this type alias takes 1 generic argument but 2 generic arguments were supplied --> /mounted_workdir/target/debug/build/unary-result-alias-f408c03f1955dadd/out/unary-result-alias.uniffi.rs:108:40 | 108 | uniffi::rust_call(call_status, || <Result<(), r#MyError> as ::uniffi::FfiConverter<crate::UniFfiTag>>::lower_return( | ^^^^^^ --------- help: remove this generic argument | | | expected 1 generic argument | note: type alias defined here, with 1 generic parameter: `T` --> fixtures/regressions/unary-result-alias/src/lib.rs:7:10 | 7 | pub type Result<T> = std::result::Result<T, MyError>; | ^^^^^^ - ``` So the same change is required to the output produced by bindgen.
2023-04-05 18:40:57 +03:00
"fixtures/regressions/unary-result-alias",
Implement the ability to have rust trait methods be 'magic' methods in bindings. (#1551)
2023-05-25 20:01:12 +03:00
"fixtures/trait-methods",
Improve error reporting when an object impl isn't Sync+Send. We require the implementation of all object structs to be Sync+Send, and the generated Rust scaffolding will fail to compile if this requirement is not met. Unfortunately, the failure is currently triggered via some trait bounds on `FfiConverter` for `Arc<T>`, so the error message it produces is quite inscrutable and doesn't help the user debug the underlying issue. This commit adds an explicit static assertion about the Sync+Send requirement, which helps the Rust compiler to emit the proper diagnostic about why the underlying struct is not `Sync` or `Send`. It also has the added benefit of guarding against any future refactor of the code that might accidentally factor away the Sync+Send requirement. Fixes #1048. (Well, not really *fixes* I guess because the code in experience of debugging such cases much better).
2021-09-03 07:29:46 +03:00
"fixtures/uitests",
Move time tests to fixtures directory - Move time tests to fixtures directory - Remove redundant uniffi.toml from time fixture
2021-05-18 21:29:13 +03:00
"fixtures/uniffi-fixture-time",
New checksum handling Updated the checksum handling to work with the new proc-macro metadata system. Now that the metadata is calcualted using const functions rather than inside the macro code, we don't have a way to include the checksum in the exported symbol name. Instead, calculate the metadata and store it as its own symbol. Then the bindings code checks the checksums on startup as well as the contract ABI version. One nice aspect of this is that we can output a nicer error message than just "linker error". - Added scripts to test this. - Added flag to allow FFIFunctions to not always have the `&mut RustCallStatus` arg. - Changed the contract version to be a u32 rather than a &str. This simplifies the bindings code. - Added the `uniffi_meta::ffi_names` module. This contains the canonical code to generate ffi symbol names. - Use the module path that we calculate in the proc-macro when generating the metadata rather than calling `module_path!()`. `module_path!()` returns the full module path, but it's more important that our metadata agrees with the module path we used whene generating the scaffolding. - Reworked the `metadata::reader` code - Make `uniffi_meta` depend on `uniffi_core`. I was trying to avoid this, but uniffi_core is where the metadata buffer code lives and I don't want to duplicate it. Maybe we could make this a separate crate, but it doesn't seem worth it yet since `uniffi_core` is fairly small.
2023-03-27 00:32:41 +03:00
"fixtures/version-mismatch",
Add proc-macro test fixture with simple function calls
2022-05-30 16:49:36 +03:00
"fixtures/simple-fns",
Test mixing of proc-macro and udl
2022-06-01 19:33:59 +03:00
"fixtures/simple-iface",
[Swift] Allow to omit argument labels in functions This introduces a new configuration option `omit_argument_labels`. When set to `true` UniFFI will prefix arguments in function headers with `_`. This allows the caller to omit function names. Before: // Definition func add(amount: Int32) // To call it: add(amount: 2) Now with `omit_argument_labels = true`: // Definition func add(_ amount: Int32) // To call it: add(2)
2021-12-01 19:42:13 +03:00
"fixtures/swift-omit-labels",
test: Let's introduce the `future` fixture.
2022-11-03 19:46:42 +03:00
"fixtures/futures",
Ensure bridging header function prototypes are valid Compiling my swift project I am seeing: ``` Generated/mycrateFFI.h:75:45: error: this function declaration is not a prototype [-Werror,-Wstrict-prototypes] ``` for the `ffi_mycrate_uniffi_contract_version` and `uniffi_mycrate_checksum_func_myfun` declarations. This is because they take no arguments which is emitted as `()`, for C `(void)` is required, C++ is happy with either. The included fixture attempts to validate that the generated header is valid according to a compiler at a highly pendantic level, interestingly this doesn't actually cover `-Wstrict-prototypes` so that is enabled separately. Add a specific case to `swift::arg_list_ffi_decl` to handle this by adding the `void` when there are no arguments. The resulting diff is: ```diff --- swift_bridging_header_compileFFI.h.old 2023-04-06 14:30:29.994435300 +0000 +++ swift_bridging_header_compileFFI.h.new 2023-04-06 14:31:14.047300820 +0000 @@ -54,6 +54,7 @@ void uniffi_swift_bridging_header_compile_fn_func_no_arguments( RustCallStatus *_Nonnull out_status + ); RustBuffer ffi_swift_bridging_header_compile_rustbuffer_alloc( @@ -73,9 +74,11 @@ ); uint32_t ffi_swift_bridging_header_compile_uniffi_contract_version( + void ); uint16_t uniffi_swift_bridging_header_compile_checksum_func_no_arguments( + void ); ```
2023-04-06 12:48:52 +03:00
"fixtures/swift-bridging-header-compile",
Check for integer overflows in Python bindings Not spelling out the numbers as numbers is fine, CPython optimizes it out: ```py >>> import dis >>> dis.dis("not -2**63 <= value < 2**63") 0 0 RESUME 0 1 2 LOAD_CONST 0 (-9223372036854775808) 4 LOAD_NAME 0 (value) 6 SWAP 2 8 COPY 2 10 COMPARE_OP 1 (<=) 16 JUMP_IF_FALSE_OR_POP 5 (to 28) 18 LOAD_CONST 1 (9223372036854775808) 20 COMPARE_OP 0 (<) 26 JUMP_FORWARD 2 (to 32) >> 28 SWAP 2 30 POP_TOP >> 32 UNARY_NOT 34 RETURN_VALUE ``` The exception thrown imitates the one of the `struct` module: ```py >>> import struct >>> struct.pack("<I", 2**32) Traceback (most recent call last): File "<stdin>", line 1, in <module> struct.error: 'I' format requires 0 <= number <= 4294967295 ``` Also add some tests exercising these code paths. Fixes #1540.
2023-05-17 11:20:01 +03:00
"fixtures/type-limits",
bump the buffer size of metadata
2023-07-05 08:40:21 +03:00
"fixtures/large-enum",
Turn example scripts into simple test fixtures. Prior to this commit, the only "tests" we had for the generated code were a small set of example scripts in the various target languages, and we could "test" them by manually executing the script and seeing whether it printed plausible output. With this commit, those scripts can now be proper testcases. It has involved a fair bit of restructuring, but broadly: * The crate and its examples are now part of a single workspace, so `cargo test` in the top-level directory will test them all. * There is a new `uniffi_macros` crate with a single macro called `build_foreign_language_testcases!`. Given a list of script files, it will generate a testcase shim for each one, executing the file via an appropriate interpret and failing the test if it does not exit successfully. * The various example crates have had their example scripts converted into testcases in this manner.
2020-07-10 14:34:12 +03:00
]
Use Cargo's new feature resolver Default for Edition 2021, but not in virtual workspaces.
2022-05-27 13:34:16 +03:00
resolver = "2"