Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
30 commits
Select commit Hold shift + click to select a range
72e164e
chore(quest): claim quest/m1/ffi-export/copy-values.md
kixelated Nov 13, 2026
3182bb3
wip(ffi): Copy types cross by value
kixelated Nov 13, 2026
8ae8e8f
wip(ffi): moq's tests and benches hold Copy types by value
kixelated Nov 13, 2026
170ff76
wip(ffi): Python holds a Copy value's bytes in place, in the runtime'…
kixelated Nov 13, 2026
24d8f6d
Merge remote-tracking branch 'origin/main' into quest/m1/ffi-export/c…
kixelated Nov 13, 2026
7766768
feat(ffi): the API lock catches a Copy value's layout change
kixelated Nov 13, 2026
e11059e
docs(ffi): measure Copy values, and leave the quest what remains
kixelated Nov 13, 2026
753dc16
fix(ffi): a Copy object taken by value is copied, and review's other …
kixelated Nov 13, 2026
f15b0b6
docs(quest): zero an opaque value's padding, as a follow-up
kixelated Nov 13, 2026
f2e2b2b
fix(ffi): an opaque value's padding crosses zeroed
kixelated Nov 13, 2026
5936da3
fix(ffi): tag Python objects with their class, and keep generated nam…
kixelated Nov 13, 2026
01bca97
fix(ffi): read a baseline whose records have no padding
kixelated Nov 13, 2026
1c389cb
fix(ffi): merge base generator changes with opaque values
Nov 13, 2026
30af352
fix(ffi): preserve opaque conversions beside record flattening
Nov 13, 2026
f015ed0
Merge origin/main into quest/m1/ffi-export/copy-values
kixelated Nov 13, 2026
fcdcc56
fix(ffi): count a word opaque value as the two JVM slots its long takes
kixelated Nov 13, 2026
7ce117f
fix(ffi): qualify JvmInline, document opaque handles and Kotlin's wor…
kixelated Nov 13, 2026
11c4e55
fix(ffi): finish the merge: lock test records and fixture lines
kixelated Nov 13, 2026
b882efb
quest: record padding-layout follow-up answers
kixelated Nov 14, 2026
c046216
Merge remote-tracking branch 'origin/main' into quest/m1/ffi-export/c…
kixelated Nov 14, 2026
ea888ad
fix(ffi): know std by its crates in dense, assert Copy in the glue, r…
kixelated Nov 14, 2026
4e1fd3f
style(ffi): fmt
kixelated Nov 14, 2026
8c79bcc
fix(ffi): an impl Trait return hiding a value crosses as its bytes
kixelated Nov 14, 2026
086dc35
style(ffi): fmt
kixelated Nov 14, 2026
f314f58
fix(ffi): keep lending and write-back guards to objects
kixelated Nov 14, 2026
530c7f7
fix(ffi): an impl Trait hiding a value holds what it captures
kixelated Nov 14, 2026
8552436
Merge origin/main into quest/m1/ffi-export/copy-values
kixelated Nov 14, 2026
12cf91a
fix(ffi): read an array's element once for its padding
kixelated Nov 14, 2026
50b88c0
fix(ffi): keep Writer::value in its impl after merging main
kixelated Nov 14, 2026
bf31cef
Merge origin/main into quest/m1/ffi-export/copy-values
kixelated Nov 14, 2026
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
35 changes: 29 additions & 6 deletions bench/ffi/README.md
Original file line number Diff line number Diff line change
Expand Up @@ -27,7 +27,7 @@ the run's summary; nothing fails on a number.
| u64 getter | `demand.sequence()`: one borrowed handle and a field read, so all but 0.4 ns is the binding's | `group.sequence()` |
| record return | `track.largest()`: an `Option` of two `u64`s, copied across | `track.info()`, a record |
| object return | `track.info()`: a new handle, freed | none |
| write | `group.write_frame(at, frame)` with one `Timestamp` handle and 100 B, copied into Rust | `write_frame` |
| write | `group.write_frame(at, frame)` with one `Timestamp` and 100 B, copied into Rust | `write_frame` |
| stamped write | the same with a new `Timestamp` per frame, as a caller holding a `u64` must | none |
| ready read | a 100 B frame written, then read through a new future ready at its first poll | `await noop_async()`, plus a write |
| woken read | a read started before its frame is written, as the language starts work concurrently, so it suspends and the write's wake resumes it | `await yield_once()`, plus a write |
Expand Down Expand Up @@ -243,10 +243,12 @@ From the CPU tables of 2026-11-10, measured at rust2 `7383790d` at a load averag
29 and since replaced by the tables above, read against the code each call runs. In order of what it costs moq's
frame path:

1. **A handle per frame timestamp.** `Timestamp` is `Copy` in Rust, but its private fields
make it an object, so each stamped frame makes and frees a handle: 21 ns in C, 27 in
Swift, 140 in Python, 250 in Kotlin, 260 in Go, and 245 in Dart (stamped write minus
write). In Go, Dart, and Kotlin that doubles the write.
1. **A call per frame timestamp.** `Timestamp` is `Copy` with private fields, so it
crosses as its 16 bytes, and a stamped frame allocates and frees nothing in Rust. As
a handle, it cost 21 ns in C, 27 in Swift, 140 in Python, 250 in Kotlin, 260 in Go,
and 245 in Dart (stamped write minus write, in the tables above); as a value, see
[Copy values](#copy-values): what remains is each language's call and, in Kotlin and
Python, an object of its own.
2. **Ownership of a returned object.** An object return costs C 25 ns, but Go 263 and
Dart 242, ten times C: each new Go object registers `runtime.AddCleanup` and each Dart
one a `NativeFinalizer`, beside a handle allocation. Kotlin's 137 ns wall (210 CPU) is a phantom
Expand Down Expand Up @@ -285,12 +287,33 @@ count since the change below. Kotlin: 24 wall, Go 38, Dart 28, Python 49, each w
transition besides.

Swift has since made each object a noncopyable struct and dropped its hold count, but for
a class: a `Copy` object or one thrown as an error. Measured 2026-11-11 at that change, 5
a class: one thrown as an error. A `Copy` type is a value since [Copy values](#copy-values). Measured 2026-11-11 at that change, 5
rounds interleaved with C at a load average of 7 to 12, its getter costs 10 ns, as C's
does, and `track.is_closed()`, on `TrackProducer`, still a class since moq throws it, 26
against C's 18, as in the table. A change to the accounting moves this row and the handle call's by the
same amount; measure both, CPU first, at the load beside them.

### Copy values

A `Copy` type with private fields, such as `Timestamp`, crosses by value: a struct of its
bytes in C, C++, Swift, Go, and Dart, a class over a `LongArray` in Kotlin (a word value
class when it fits one), and a class of the runtime's `Value` holding its bytes in Python.
Measured 2026-11-13 at rust2 `7766768f`, moq `ffcb7cd9`, on an AMD Ryzen 9 9950X (32 threads),
Linux, at a load average of 13 to 15, the median of 3 rounds, in CPU time:

| | C | C++ | Swift | Go | Dart | Kotlin | Python |
|---|---|---|---|---|---|---|---|
| write | 163 | 165 | 173 | 260 | 251 | 280 | 224 |
| stamped write | 161 | 168 | 174 | 293 | 296 | 430 | 384 |
| stamped minus write | 0 | 3 | 1 | 33 | 45 | 150 (35 wall) | 160 |

C, C++, and Swift pay nothing for the timestamp; Go and Dart pay about their getter's call,
the `from_micros` itself. Kotlin's 35 ns wall is its call, and its CPU column adds the
collector's work on each `LongArray`. Python's is a call and a new object. The handle's cost
in the tables above came from another load, so Python's was also measured against main's
build on the same host, interleaved over 5 rounds at a load of 10 to 12: stamped minus write
fell from 205 ns to 166, and the stamped write from 441 to 391.

### Against the targets

Where the cases match, on wall time: Kotlin's getter costs 24 ns against BoltFFI's 5.8,
Expand Down
86 changes: 54 additions & 32 deletions ffi/README.md

Large diffs are not rendered by default.

30 changes: 29 additions & 1 deletion ffi/fixtures/api/examples/transcript.rs
Original file line number Diff line number Diff line change
Expand Up @@ -299,11 +299,13 @@ fn main() {
println!("secs {}", stamp.secs());
println!("later {}", Stamp::from_millis(3000).later(stamp));
println!("secs {}", stamp.secs());
let whole: Stamp = stamp.whole().into();
println!("whole {whole:?}");
let mut message = Message::new(Some(stamp), Bytes::from_static(b"body"));
println!("payload {}", String::from_utf8_lossy(&message.payload));
println!("stamp {:?}", message.stamp.unwrap());
println!("sent {}", message.sent());
// Setters assign in place: the bytes are copied in, and a `Copy` handle copied.
// Setters assign in place: the bytes are copied in, and a `Copy` value copied.
let reset = Stamp::from_millis(4000);
message.stamp = Some(reset);
message.payload = Bytes::from_static(b"edited");
Expand All @@ -313,6 +315,32 @@ fn main() {
message.stamp = None;
println!("stamp {}", message.stamp.is_some());

// A value past a word, copied across: a closure takes and returns one by value.
let moment = api::Moment::new(1500, 1000).unwrap();
println!("moment {} {}", moment.millis(), api::Moment::new(1, 0).is_none());
let shifted = api::shifted(moment, |m| m.after(500));
println!("shifted {} {}", shifted.millis(), shifted == moment.after(500));
println!("wrapped {} {}", moment.after(u64::MAX).millis(), moment == shifted);

// A padded value crosses with its padding zeroed, and one whose bytes vary is a handle.
let gap = api::Gap::new(7, 3);
println!("gap {} {}", gap.sum(), gap == api::Gap::new(7, 3));
let berth = api::Berth::new(Some(4));
println!("berth {:?} {:?}", berth.at(), api::Berth::new(None).at());

// A `Copy` type changed in place is a handle, which a call taking it by value copies.
let mut score = api::Score::of(2);
let step = api::Score::of(3);
score.add(step);
score.add(step);
println!("score {} {} {}", score.count(), step.doubled().count(), step.count());
let weighted = api::Weighted { score: step, weight: 4 };
println!(
"weighted {} {}",
weighted.total(),
weighted.score.count() + step.count()
);

println!("kept {}", api::emit(Print, vec![1, 2, 3, 4]));
let logger = Logger::new(Box::new(Print));
println!("write {}", logger.write("hi"));
Expand Down
162 changes: 157 additions & 5 deletions ffi/fixtures/api/src/lib.rs
Original file line number Diff line number Diff line change
Expand Up @@ -111,6 +111,20 @@ pub fn reading_echo(reading: Reading) -> Reading {
reading
}

/// Declares `crowded`, whose parameters take 243 of a JVM method's 255 slots, so flattening
/// its `Reading` would take 15 more: a binding that counts a `Stamp` as one slot, not the
/// two of the `long` it crosses as, flattens it past the limit.
macro_rules! crowded {
($($n:ident)*) => {
/// The sum of the reading's count, both stamps' millis, and every number.
pub fn crowded(reading: Reading, a: Stamp, b: Stamp, $($n: u64),*) -> u64 {
reading.count.wrapping_add(a.millis).wrapping_add(b.millis)$(.wrapping_add($n))*
}
};
}

crowded!(n0 n1 n2 n3 n4 n5 n6 n7 n8 n9 n10 n11 n12 n13 n14 n15 n16 n17 n18 n19 n20 n21 n22 n23 n24 n25 n26 n27 n28 n29 n30 n31 n32 n33 n34 n35 n36 n37 n38 n39 n40 n41 n42 n43 n44 n45 n46 n47 n48 n49 n50 n51 n52 n53 n54 n55 n56 n57 n58 n59 n60 n61 n62 n63 n64 n65 n66 n67 n68 n69 n70 n71 n72 n73 n74 n75 n76 n77 n78 n79 n80 n81 n82 n83 n84 n85 n86 n87 n88 n89 n90 n91 n92 n93 n94 n95 n96 n97 n98 n99 n100 n101 n102 n103 n104 n105 n106 n107 n108 n109 n110 n111 n112 n113 n114 n115 n116 n117 n118);

/// A plain enumeration.
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum Shape {
Expand Down Expand Up @@ -751,7 +765,7 @@ pub fn made<R>(n: u32, make: impl FnOnce(u32) -> R) -> R {
/// How many times a [`Ticket`]'s `Clone` ran.
static TICKET_CLONES: std::sync::atomic::AtomicU32 = std::sync::atomic::AtomicU32::new(0);

/// A `Copy` object whose `Clone` counts its calls, which a closure taking or returning one
/// A `Copy` value whose `Clone` counts its calls, which a closure taking or returning one
/// never runs, as Rust copies it instead.
#[derive(Copy, Debug, PartialEq)]
pub struct Ticket {
Expand Down Expand Up @@ -1015,8 +1029,7 @@ impl<F: Future> Future for Within<F> {
}
}

/// A time: an object, since its field is private, but `Copy`, so passing it by value
/// copies it rather than moving it out of its handle.
/// A time: `Copy` with a private field, so a value only Rust makes, copied across.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Stamp {
millis: u64,
Expand All @@ -1031,12 +1044,150 @@ impl Stamp {
self.millis / 1000
}

/// It rounded down to whole seconds, through an `impl Trait`, so it crosses as its bytes.
pub fn whole(self) -> impl Into<Stamp> + use<> {
Self {
millis: self.millis / 1000 * 1000,
}
}

pub fn later(self, other: Stamp) -> bool {
self.millis > other.millis
}
}

/// A stamp and a count: a record holding an object, whose method reads it.
/// A time on a clock of its own rate, as moq's `Timestamp`: `Copy` with private fields, past
/// a word on every target, and never all zero bytes, so only a value Rust made may cross.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Moment {
ticks: u64,
rate: std::num::NonZero<u64>,
}

impl Moment {
/// `ticks` of `rate` a second, or none at a rate of zero.
pub fn new(ticks: u64, rate: u64) -> Option<Self> {
std::num::NonZero::new(rate).map(|rate| Self { ticks, rate })
}

/// Whole milliseconds since zero.
pub fn millis(&self) -> u64 {
(u128::from(self.ticks) * 1000 / u128::from(self.rate.get())) as u64
}

/// The moment `ticks` later, at the same rate, wrapping as `u64` does.
pub fn after(self, ticks: u64) -> Self {
Self {
ticks: self.ticks.wrapping_add(ticks),
..self
}
}
}

/// The moment `shift` returns for `moment`, which C copies in and out.
pub fn shifted(moment: Moment, shift: impl Fn(Moment) -> Moment) -> Moment {
shift(moment)
}

/// A value with padding, after its `u8`: made from bytes all `0xff`, so its padding likely
/// holds them, which the export zeroes before any language sees it.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Gap {
wide: u64,
narrow: u8,
}

impl Gap {
pub fn new(wide: u64, narrow: u8) -> Self {
// SAFETY: every byte pattern is a `Gap`, whose fields are integers.
let mut gap: Gap = unsafe { std::mem::transmute([0xffu8; std::mem::size_of::<Gap>()]) };
gap.wide = wide;
gap.narrow = narrow;
gap
}

pub fn sum(&self) -> u64 {
self.wide.wrapping_add(u64::from(self.narrow))
}
}

/// A value named as Kotlin's `LongArray`, which holds a value's words, with a method named
/// as C++'s member holding its bytes: each generator keeps its own apart.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct LongArray {
words: [u64; 2],
}

impl LongArray {
pub fn new(low: u64, high: u64) -> Self {
LongArray { words: [low, high] }
}

pub fn c_(&self) -> u64 {
self.words[0].wrapping_add(self.words[1])
}
}

/// A `Copy` type whose `None` leaves its payload's bytes uninitialized, so no padding table
/// covers it: a handle, rather than a value.
#[derive(Clone, Copy, Debug)]
pub struct Berth {
at: Option<u32>,
}

impl Berth {
pub fn new(at: Option<u32>) -> Self {
Self { at }
}

pub fn at(&self) -> Option<u32> {
self.at
}
}

/// A running count, as moq's `stats::Traffic`: `Copy` with private fields, but changed in
/// place through `&mut self`, which a copy could not write back, so a handle. A call taking
/// one by value copies it out of its handle, leaving the caller's as it was.
#[derive(Clone, Copy, Debug)]
pub struct Score {
count: u64,
}

impl Score {
pub fn of(count: u64) -> Self {
Self { count }
}

pub fn count(&self) -> u64 {
self.count
}

/// Adds `other`'s count to this one, as Rust copies `other`.
pub fn add(&mut self, other: Score) {
self.count = self.count.wrapping_add(other.count);
}

/// Twice the count, as Rust copies `self`.
pub fn doubled(self) -> Score {
Self {
count: self.count.wrapping_mul(2),
}
}
}

/// A score and its weight: a record holding a `Copy` handle, copied in and out.
pub struct Weighted {
pub score: Score,
pub weight: u32,
}

impl Weighted {
pub fn total(&self) -> u64 {
self.score.count.wrapping_mul(u64::from(self.weight))
}
}

/// A stamp and a count: a record holding a value only Rust makes, whose method reads it.
pub struct Stamped {
pub at: Stamp,
pub count: u32,
Expand All @@ -1049,7 +1200,8 @@ impl Stamped {
}
}

/// A message: an object, since one field is private, whose `pub` fields read as getters.
/// A message: an object, since one field is private and it is not `Copy`, whose `pub`
/// fields read as getters.
#[derive(Clone, Debug)]
pub struct Message {
pub stamp: Option<Stamp>,
Expand Down
4 changes: 3 additions & 1 deletion ffi/fixtures/lock/expected.txt
Original file line number Diff line number Diff line change
Expand Up @@ -5,9 +5,11 @@ fixtures/lock/src/lib.rs:135:1: rust2-ffi: the API breaks the baseline at enum `
fixtures/lock/src/lib.rs:176:1: rust2-ffi: the API breaks the baseline at const `lock::DEPTH`: its type: it was `u32`, and is now `u64`
fixtures/lock/src/lib.rs:182:1: rust2-ffi: the API breaks the baseline at const `lock::PAGES`: its type: it was `u16`, and is now `i16`
fixtures/lock/src/lib.rs:191:1: rust2-ffi: the API breaks the baseline at tuple `((u32,), u64, u8)`: its C name `lock_tuple_tuple_u32_u64_u8` is now `lock_tuple_tuple_u32_u64_u8_`, and `lock_tuple_tuple_u32_u64_u8` names tuple `((u32, u64), u8)`
fixtures/lock/src/lib.rs:202:1: rust2-ffi: the API breaks the baseline at struct `lock::Tick`: its bytes: 4 aligned to 4, and now 8 aligned to 4
fixtures/lock/src/lib.rs:21:2: rust2-ffi: the API breaks the baseline at const `lock::limits_max::RATE`: its C name `LOCK_LIMITS_MAX_RATE` is now `LOCK_LIMITS_MAX_RATE_`, and `LOCK_LIMITS_MAX_RATE` names const `lock::limits::MAX_RATE`
fixtures/lock/src/lib.rs:308:1: rust2-ffi: the API breaks the baseline at enum `lock::Speed`: variant `Fast` is removed; variant `Quick` is added to an exhaustive enum
fixtures/lock/src/lib.rs:231:1: rust2-ffi: the API breaks the baseline at struct `lock::Beat`: how it is held: a word compared by its bits, and now bytes compared by Rust
fixtures/lock/src/lib.rs:30:1: rust2-ffi: the API breaks the baseline at fn `lock::removed`: it is removed
fixtures/lock/src/lib.rs:356:1: rust2-ffi: the API breaks the baseline at enum `lock::Speed`: variant `Fast` is removed; variant `Quick` is added to an exhaustive enum
fixtures/lock/src/lib.rs:36:1: rust2-ffi: the API breaks the baseline at fn `lock::portable`: it is no longer on wasm32-unknown-unknown
fixtures/lock/src/lib.rs:46:1: rust2-ffi: the API breaks the baseline at fn `lock::scale`: its parameter `x`'s type; its return type
fixtures/lock/src/lib.rs:66:2: rust2-ffi: the API breaks the baseline at fn `lock::Meter::add`: its parameter `n`'s type
Expand Down
48 changes: 48 additions & 0 deletions ffi/fixtures/lock/src/lib.rs
Original file line number Diff line number Diff line change
Expand Up @@ -197,6 +197,54 @@ pub fn flat(x: ((u32, u64), u8)) -> u32 {
x.0.0
}

/// A `Copy` value C holds as its bytes, which `next` lengthens.
#[derive(Clone, Copy)]
pub struct Tick {
at: u32,
#[cfg(feature = "next")]
late: u32,
}

impl Tick {
pub fn new(at: u32) -> Self {
Self {
at,
#[cfg(feature = "next")]
late: 0,
}
}

pub fn at(&self) -> u32 {
self.at
}

#[cfg(feature = "next")]
pub fn late(&self) -> u32 {
self.late
}
}

/// A `Copy` value in a word, whose `PartialEq` `next` writes by hand, so Kotlin can no
/// longer compare its bits.
#[derive(Clone, Copy)]
#[cfg_attr(not(feature = "next"), derive(PartialEq))]
pub struct Beat {
at: u32,
}

#[cfg(feature = "next")]
impl PartialEq for Beat {
fn eq(&self, other: &Self) -> bool {
self.at / 2 == other.at / 2
}
}

impl Beat {
pub fn new(at: u32) -> Self {
Self { at }
}
}

/// Kept class whose Pascal name collides only in the bindings.
pub mod graphics {
pub mod encoder {
Expand Down
12 changes: 8 additions & 4 deletions ffi/fixtures/reject/expected.txt
Original file line number Diff line number Diff line change
Expand Up @@ -24,10 +24,14 @@ fixtures/reject/src/lib.rs:1119:1: rust2-ffi: cannot export fn `hazard`: trait o
fixtures/reject/src/lib.rs:1109:1: note: C cannot implement `Hazard`: unsafe fn `risk`
fixtures/reject/src/lib.rs:111:1: rust2-ffi: cannot export fn `boxed`: reference inside a parameter `std::boxed::Box<&str>`; exclude it in the config to leave it out
fixtures/reject/src/lib.rs:1124:1: rust2-ffi: cannot export fn `wide_non_zero`: NonZero `u128`; exclude it in the config to leave it out
fixtures/reject/src/lib.rs:1129:1: rust2-ffi: cannot export fn `hidden_answer`: opaque type `impl std::marker::Copy`; exclude it in the config to leave it out
fixtures/reject/src/lib.rs:1134:1: rust2-ffi: cannot export fn `hidden_items`: opaque type `impl std::marker::Copy`; exclude it in the config to leave it out
fixtures/reject/src/lib.rs:1139:1: rust2-ffi: cannot export fn `hidden_option`: opaque type `impl std::clone::Clone`; exclude it in the config to leave it out
fixtures/reject/src/lib.rs:1144:1: rust2-ffi: cannot export fn `boxed_bytes`: boxed slice of bytes `std::boxed::Box<[u8]>`; exclude it in the config to leave it out
fixtures/reject/src/lib.rs:1146:1: rust2-ffi: cannot export fn `wrap`: returned object that borrows `View<'_>`; exclude it in the config to leave it out
fixtures/reject/src/lib.rs:1151:1: rust2-ffi: cannot export fn `hidden_wrap`: returned object that borrows `impl std::clone::Clone + '_`; exclude it in the config to leave it out
fixtures/reject/src/lib.rs:1167:1: rust2-ffi: cannot export fn `picked`: closure signature `&'static Mark`; exclude it in the config to leave it out
fixtures/reject/src/lib.rs:1172:1: rust2-ffi: cannot export fn `maybe_picked`: closure signature `std::option::Option<&'static Mark>`; exclude it in the config to leave it out
fixtures/reject/src/lib.rs:1177:1: rust2-ffi: cannot export fn `hidden_answer`: opaque type `impl std::marker::Copy`; exclude it in the config to leave it out
fixtures/reject/src/lib.rs:1182:1: rust2-ffi: cannot export fn `hidden_items`: opaque type `impl std::marker::Copy`; exclude it in the config to leave it out
fixtures/reject/src/lib.rs:1187:1: rust2-ffi: cannot export fn `hidden_option`: opaque type `impl std::clone::Clone`; exclude it in the config to leave it out
fixtures/reject/src/lib.rs:1192:1: rust2-ffi: cannot export fn `boxed_bytes`: boxed slice of bytes `std::boxed::Box<[u8]>`; exclude it in the config to leave it out
fixtures/reject/src/lib.rs:11:1: rust2-ffi: cannot export fn `map`: foreign type `std::collections::HashMap`; exclude it in the config to leave it out
fixtures/reject/src/lib.rs:122:1: rust2-ffi: cannot export fn `parse_later`: returned object that borrows `impl std::future::Future<Output = std::result::Result<u32, tls::held::Malformed<'_>>>`; exclude it in the config to leave it out
fixtures/reject/src/lib.rs:136:1: rust2-ffi: cannot export fn `poll_ready`: Poll with no Context or waiter parameter `std::task::Poll<u32>`; exclude it in the config to leave it out
Expand Down
Loading