feat(uniffi): same-named types across crates in every generator

Cargo.toml

@@ -42,6 +42,7 @@ members = [
     "uniffi/dart/fixtures/library_config",
     "uniffi/dart/fixtures/map_type",
     "uniffi/dart/fixtures/metadata",
+    "uniffi/dart/fixtures/namespaces",
     "uniffi/dart/fixtures/proc-macro",
     "uniffi/dart/fixtures/proc-macro-no-implicit-prelude",
     "uniffi/dart/fixtures/simple-fns",
@@ -86,6 +87,8 @@ members = [
     "uniffi/fixtures/metadata",
     "uniffi/fixtures/multi-arch-extract",
     "uniffi/fixtures/mutable-records",
+    "uniffi/fixtures/namespaces/media",
+    "uniffi/fixtures/namespaces/net",
     "uniffi/fixtures/proc-macro",
     "uniffi/fixtures/proc-macro-no-implicit-prelude",
     "uniffi/fixtures/regressions/cdylib-crate-type-dependency/cdylib-dependency",

quest/m2/README.md

@@ -22,7 +22,6 @@ deletes the quests that follow it.
 - [Shared ownership](/quest/m2/ts-shared.md) - `Arc`/`Rc`/`Weak` keep exact counts, and locks and atomics become plain values
 - [Collections](/quest/m2/ts-collections.md) - maps, sets, and queues keep Rust's key semantics
 - [Translate moq-net's model to TypeScript](/quest/m2/ts-model.md) - the driver grows from moq-net's codec to its model, for moq to compare against WASM
-- [Namespaced external types](/quest/m2/uniffi-namespaces.md) - two crates linked into one library can each export a same-named type in every generator
 - [Zero-copy byte returns](/quest/m2/ffi-bytes-return.md) - returned payloads reach the host without a copy, if the payload numbers justify it
 - [Cheaper async](/quest/m2/ffi-async.md) - `RustFuture` exports cost fewer crossings, if the numbers show they matter
 - [Namespaced FFI contract](/quest/m2/uniffi-contract.md) - bindings and a cdylib from different UniFFI forks refuse to load together

quest/m2/uniffi-contract.md

@@ -26,7 +26,3 @@ anyway.
 
 Public API: the generated contract check, and the scaffolding's exported
 contract symbol.
-
-## Related
-
-- [Namespaced external types](/quest/m2/uniffi-namespaces.md) - may change the contract first

uniffi/MIGRATE.md

@@ -0,0 +1,10 @@
+# Migrating
+
+## Unreleased
+
+- `uniffi_bindgen`: a name no longer identifies a type across crates.
+  `ComponentInterface::is_name_used_as_error(name)` is now `is_used_as_error(&ty)`,
+  `ComponentInterface::get_type(name)` finds only the crate's own types, and
+  `VisitMut::visit_error_name` takes the module path of the crate that defines the error.
+- Generated C: every type and function name starts with the crate's namespace, so a crate
+  whose items did not already start with it gets renamed C symbols.

uniffi/README.md

@@ -73,6 +73,14 @@ uniffi-rs:
   consumer.
 - Test expectations that hold a path relative to the workspace root (`file!()` output and
   trybuild snapshots) gain the `uniffi/` prefix.
+- A crate can use another crate's type of the same name
+  ([mozilla/uniffi-rs#3026](https://github.com/mozilla/uniffi-rs/issues/3026)): the type
+  universe, the errors, and the recursion check key types by crate and name, and an external
+  type is walked through its own crate's interface. Kotlin spells external types with their
+  package, Swift qualifies an ambiguous one with its module (so same-named types need one
+  Swift module per crate), and Python keeps both definitions (mozilla/uniffi-rs#2985, from
+  upstream `main`). Container helpers for an external type carry its namespace. The
+  `namespaces` fixture covers it in every generator.
 - Scaffolding is written to a temporary file and renamed into place. Two trybuild cases
   expanding `generate_and_include_scaffolding!` on one UDL write it concurrently, and the
   in-place truncate let one include a partial file.
@@ -82,6 +90,8 @@ uniffi-bindgen-go, on top of upstream v0.7.1+v0.31.0:
 - The UniFFI 0.32 port ([NordSecurity/uniffi-bindgen-go#98](https://github.com/NordSecurity/uniffi-bindgen-go/pull/98)).
 - Generated async calls take a `context.Context` and cancel the Rust future.
 - An exported `Display` on an enum error renders as its `Error()`.
+- Container helpers for another crate's type carry its namespace, so they don't collide with
+  a same-named local type's.
 - `Types.go` renders its object, enum, error, record, callback interface, and custom type
   templates in their own functions, with byte-identical output. Inlined into one, the borrow
   checker took about 16 GB to check it, more than a CI runner has.
@@ -94,10 +104,17 @@ uniffi-dart, on top of upstream `main` at acterglobal/uniffi-dart@72d26c1:
   disposed objects refused as arguments.
 - Record errors keep their converter name, and futures cancel per operation (moq's
   `nix/uniffi-dart-record-error.patch` and `nix/uniffi-dart-cancellation.patch`).
+- Another crate's library is imported with a `uniffi_<namespace>` prefix that its types,
+  converters, and container helpers go through, the shared runtime comes from the same crate
+  every run, and the test harness drives library mode.
 
 uniffi-bindgen-cpp, on top of upstream `main` at NordSecurity/uniffi-bindgen-cpp@20bef75:
 
 - LiveKit's async support (livekit/uniffi-bindgen-cpp, by Alan George), ported to UniFFI 0.32.
 - `error_style = "expected"`, `strip_type_prefix`, exported `Display` and `Debug` on enums,
   newline-terminated files, released async results, and the C backend (`--lang c`).
 - The CMake test suite finds the fixtures in the root workspace's target directory.
+- Another crate's types are qualified from the global namespace, with aliased converters and
+  namespaced container helpers, definitions sort per crate, and `strip_type_prefix` renames
+  per crate. The C backend supports external types, and prefixes every C name with its
+  namespace.

uniffi/cpp/README.md

@@ -60,8 +60,10 @@ and RTTI may be off) and include only `<namespace>.h` from C.
 uniffi-bindgen-cpp --lang c --library your_rust_library.so --out-dir output_directory
 ```
 
-Names are the uniffi names in snake case: `MyObject.do_thing` is `my_object_do_thing`, and its
-handle is `my_object *`, released with `my_object_free`. The rest follows from a few rules:
+Names are the uniffi names in snake case, prefixed with the namespace unless they already start
+with it, since every crate's C API shares one scope: in namespace `app`, `MyObject.do_thing` is
+`app_my_object_do_thing`, and its handle is `app_my_object *`, released with
+`app_my_object_free`; `AppObject` is `app_object`. The rest follows from a few rules:
 
 * A call that can fail returns an error struct, or NULL on success, and writes its result to a
   trailing `out` pointer. An error is a tagged union with a `message`; free it with `<error>_free`.
@@ -79,9 +81,14 @@ handle is `my_object *`, released with `my_object_free`. The rest follows from a
   or will never run.
 * Callbacks run on the default dispatcher thread unless `<namespace>_set_dispatcher` installs a
   host's own, which receives `<namespace>_work *` items to run with `<namespace>_work_run`.
-
-The C backend refuses what it cannot render faithfully, such as callback interfaces, custom and
-external types, timestamps, durations, and exported traits other than `Display` on errors.
+* A type from another crate keeps that crate's C name and `_free`, and its header is included.
+  Generate the C API of every crate involved (one `--crate` each, or all at once) and compile
+  each one's `<namespace>.cpp` and `<namespace>_c.cpp`; a crate's implementation converts its
+  own types for the others.
+
+The C backend refuses what it cannot render faithfully, such as callback interfaces, custom
+types, timestamps, durations, and exported traits other than `Display` on errors, including in
+another crate whose types it uses.
 
 # Configuration options