1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
/* 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/. */
use super::*;
pub fn pass(int: &mut Interface) -> Result<()> {
match &int.imp {
ObjectImpl::Struct | ObjectImpl::Trait => {
// Interface that's only implemented in Rust:
// - Give the interface the main name and append the `Protocol` suffix to the protocol
// - Make the protocol inherit from `typing.Protocol`, since the #2264 doesn't affect
// these interfaces
int.protocol = Protocol {
name: format!("{}Protocol", int.name),
base_classes: vec!["typing.Protocol".to_string()],
methods: int.methods.clone(),
docstring: int.docstring.clone(),
};
}
ObjectImpl::CallbackTrait => {
// Trait interface that can be implemented in Rust or Python
// - Give the protocol the main name and append the `Impl` suffix to the interface
// - Don't make the protocol inherit from `typing.Protocol`. We're going to inherit
// from it so it's not a typical Python protocol
// (http://github.com/mozilla/uniffi-rs/issues/2264).
int.protocol = Protocol {
name: int.name.clone(),
base_classes: vec![],
methods: int.methods.clone(),
docstring: int.docstring.clone(),
};
int.name = format!("{}Impl", int.name);
}
};
int.base_classes.push(int.protocol.name.clone());
if int.self_type.is_used_as_error {
int.base_classes.push("Exception".to_string());
}
for t in int.trait_impls.iter() {
let (name, external_package_name) = match &t.trait_ty.ty {
Type::Interface {
name,
external_package_name,
imp,
..
} => {
// For trait interfaces implement in Rust-only, the protocol has `Protocol` appended.
// Trait interfaces with foreign implementations don't have that
match imp {
ObjectImpl::Trait => (format!("{name}Protocol"), external_package_name),
ObjectImpl::CallbackTrait => (name.to_string(), external_package_name),
ObjectImpl::Struct => {
bail!("Objects can only inherit from traits, not other objects")
}
}
}
Type::CallbackInterface {
name,
external_package_name,
..
} => (name.to_string(), external_package_name),
_ => bail!("trait_ty {:?} isn't a trait", t),
};
let fq = match external_package_name {
None => name.clone(),
Some(package) => format!("{package}.{name}"),
};
int.base_classes.push(fq);
}
int.has_primary_constructor = int.has_descendant(|c: &Callable| c.is_primary_constructor());
Ok(())
}