1// This file is part of ICU4X. For terms of use, please see the file
2// called LICENSE at the top level of the ICU4X source tree
3// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
4
5// This way we can copy-paste Yokeable impls
6#![allow(unknown_lints)] // forgetting_copy_types
7#![allow(renamed_and_removed_lints)] // forgetting_copy_types
8#![allow(forgetting_copy_types)]
9#![allow(clippy::forget_copy)]
10#![allow(clippy::forget_non_drop)]
11
12use crate::flexzerovec::FlexZeroVec;
13use crate::map::ZeroMapBorrowed;
14use crate::map::ZeroMapKV;
15use crate::map2d::ZeroMap2dBorrowed;
16use crate::ule::*;
17use crate::{VarZeroVec, ZeroMap, ZeroMap2d, ZeroVec};
18use core::{mem, ptr};
19use yoke::*;
20
21// This impl is similar to the impl on Cow and is safe for the same reasons
22/// This impl requires enabling the optional `yoke` Cargo feature of the `zerovec` crate
23unsafe impl<'a, T: 'static + AsULE + ?Sized> Yokeable<'a> for ZeroVec<'static, T> {
24 type Output = ZeroVec<'a, T>;
25 #[inline]
26 fn transform(&'a self) -> &'a Self::Output {
27 self
28 }
29 #[inline]
30 fn transform_owned(self) -> Self::Output {
31 self
32 }
33 #[inline]
34 unsafe fn make(from: Self::Output) -> Self {
35 debug_assert!(mem::size_of::<Self::Output>() == mem::size_of::<Self>());
36 let from = mem::ManuallyDrop::new(from);
37 let ptr: *const Self = (&*from as *const Self::Output).cast();
38 ptr::read(ptr)
39 }
40 #[inline]
41 fn transform_mut<F>(&'a mut self, f: F)
42 where
43 F: 'static + for<'b> FnOnce(&'b mut Self::Output),
44 {
45 unsafe { f(mem::transmute::<&mut Self, &mut Self::Output>(self)) }
46 }
47}
48
49// This impl is similar to the impl on Cow and is safe for the same reasons
50/// This impl requires enabling the optional `yoke` Cargo feature of the `zerovec` crate
51unsafe impl<'a, T: 'static + VarULE + ?Sized> Yokeable<'a> for VarZeroVec<'static, T> {
52 type Output = VarZeroVec<'a, T>;
53 #[inline]
54 fn transform(&'a self) -> &'a Self::Output {
55 self
56 }
57 #[inline]
58 fn transform_owned(self) -> Self::Output {
59 self
60 }
61 #[inline]
62 unsafe fn make(from: Self::Output) -> Self {
63 debug_assert!(mem::size_of::<Self::Output>() == mem::size_of::<Self>());
64 let from = mem::ManuallyDrop::new(from);
65 let ptr: *const Self = (&*from as *const Self::Output).cast();
66 ptr::read(ptr)
67 }
68 #[inline]
69 fn transform_mut<F>(&'a mut self, f: F)
70 where
71 F: 'static + for<'b> FnOnce(&'b mut Self::Output),
72 {
73 unsafe { f(mem::transmute::<&mut Self, &mut Self::Output>(self)) }
74 }
75}
76
77// This impl is similar to the impl on Cow and is safe for the same reasons
78/// This impl requires enabling the optional `yoke` Cargo feature of the `zerovec` crate
79unsafe impl<'a> Yokeable<'a> for FlexZeroVec<'static> {
80 type Output = FlexZeroVec<'a>;
81 #[inline]
82 fn transform(&'a self) -> &'a Self::Output {
83 self
84 }
85 #[inline]
86 fn transform_owned(self) -> Self::Output {
87 self
88 }
89 #[inline]
90 unsafe fn make(from: Self::Output) -> Self {
91 debug_assert!(mem::size_of::<Self::Output>() == mem::size_of::<Self>());
92 let from = mem::ManuallyDrop::new(from);
93 let ptr: *const Self = (&*from as *const Self::Output).cast();
94 ptr::read(ptr)
95 }
96 #[inline]
97 fn transform_mut<F>(&'a mut self, f: F)
98 where
99 F: 'static + for<'b> FnOnce(&'b mut Self::Output),
100 {
101 unsafe { f(mem::transmute::<&mut Self, &mut Self::Output>(self)) }
102 }
103}
104
105/// This impl requires enabling the optional `yoke` Cargo feature of the `zerovec` crate
106#[allow(clippy::transmute_ptr_to_ptr)]
107unsafe impl<'a, K, V> Yokeable<'a> for ZeroMap<'static, K, V>
108where
109 K: 'static + for<'b> dynZeroMapKV<'b> + ?Sized,
110 V: 'static + for<'b> dynZeroMapKV<'b> + ?Sized,
111 <K as ZeroMapKV<'static>>::Container: for<'b> dynYokeable<'b>,
112 <V as ZeroMapKV<'static>>::Container: for<'b> dynYokeable<'b>,
113{
114 type Output = ZeroMap<'a, K, V>;
115 #[inline]
116 fn transform(&'a self) -> &'a Self::Output {
117 unsafe {
118 // Unfortunately, because K and V are generic, rustc is
119 // unaware that these are covariant types, and cannot perform this cast automatically.
120 // We transmute it instead, and enforce the lack of a lifetime with the `K, V: 'static` bound
121 mem::transmute::<&Self, &Self::Output>(self)
122 }
123 }
124 #[inline]
125 fn transform_owned(self) -> Self::Output {
126 debug_assert!(mem::size_of::<Self::Output>() == mem::size_of::<Self>());
127 unsafe {
128 // Similar problem as transform(), but we need to use ptr::read since
129 // the compiler isn't sure of the sizes
130 let this = mem::ManuallyDrop::new(self);
131 let ptr: *const Self::Output = (&*this as *const Self).cast();
132 ptr::read(ptr)
133 }
134 }
135 #[inline]
136 unsafe fn make(from: Self::Output) -> Self {
137 debug_assert!(mem::size_of::<Self::Output>() == mem::size_of::<Self>());
138 let from = mem::ManuallyDrop::new(from);
139 let ptr: *const Self = (&*from as *const Self::Output).cast();
140 ptr::read(ptr)
141 }
142 #[inline]
143 fn transform_mut<F>(&'a mut self, f: F)
144 where
145 F: 'static + for<'b> FnOnce(&'b mut Self::Output),
146 {
147 unsafe { f(mem::transmute::<&mut Self, &mut Self::Output>(self)) }
148 }
149}
150
151/// This impl requires enabling the optional `yoke` Cargo feature of the `zerovec` crate
152#[allow(clippy::transmute_ptr_to_ptr)]
153unsafe impl<'a, K, V> Yokeable<'a> for ZeroMapBorrowed<'static, K, V>
154where
155 K: 'static + for<'b> dynZeroMapKV<'b> + ?Sized,
156 V: 'static + for<'b> dynZeroMapKV<'b> + ?Sized,
157 &'static <K as ZeroMapKV<'static>>::Slice: for<'b> dynYokeable<'b>,
158 &'static <V as ZeroMapKV<'static>>::Slice: for<'b> dynYokeable<'b>,
159{
160 type Output = ZeroMapBorrowed<'a, K, V>;
161 #[inline]
162 fn transform(&'a self) -> &'a Self::Output {
163 unsafe {
164 // Unfortunately, because K and V are generic, rustc is
165 // unaware that these are covariant types, and cannot perform this cast automatically.
166 // We transmute it instead, and enforce the lack of a lifetime with the `K, V: 'static` bound
167 mem::transmute::<&Self, &Self::Output>(self)
168 }
169 }
170 #[inline]
171 fn transform_owned(self) -> Self::Output {
172 debug_assert!(mem::size_of::<Self::Output>() == mem::size_of::<Self>());
173 unsafe {
174 // Similar problem as transform(), but we need to use ptr::read since
175 // the compiler isn't sure of the sizes
176 let this = mem::ManuallyDrop::new(self);
177 let ptr: *const Self::Output = (&*this as *const Self).cast();
178 ptr::read(ptr)
179 }
180 }
181 #[inline]
182 unsafe fn make(from: Self::Output) -> Self {
183 debug_assert!(mem::size_of::<Self::Output>() == mem::size_of::<Self>());
184 let from = mem::ManuallyDrop::new(from);
185 let ptr: *const Self = (&*from as *const Self::Output).cast();
186 ptr::read(ptr)
187 }
188 #[inline]
189 fn transform_mut<F>(&'a mut self, f: F)
190 where
191 F: 'static + for<'b> FnOnce(&'b mut Self::Output),
192 {
193 unsafe { f(mem::transmute::<&mut Self, &mut Self::Output>(self)) }
194 }
195}
196
197/// This impl requires enabling the optional `yoke` Cargo feature of the `zerovec` crate
198#[allow(clippy::transmute_ptr_to_ptr)]
199unsafe impl<'a, K0, K1, V> Yokeable<'a> for ZeroMap2d<'static, K0, K1, V>
200where
201 K0: 'static + for<'b> dynZeroMapKV<'b> + ?Sized,
202 K1: 'static + for<'b> dynZeroMapKV<'b> + ?Sized,
203 V: 'static + for<'b> dynZeroMapKV<'b> + ?Sized,
204 <K0 as ZeroMapKV<'static>>::Container: for<'b> dynYokeable<'b>,
205 <K1 as ZeroMapKV<'static>>::Container: for<'b> dynYokeable<'b>,
206 <V as ZeroMapKV<'static>>::Container: for<'b> dynYokeable<'b>,
207{
208 type Output = ZeroMap2d<'a, K0, K1, V>;
209 #[inline]
210 fn transform(&'a self) -> &'a Self::Output {
211 unsafe {
212 // Unfortunately, because K and V are generic, rustc is
213 // unaware that these are covariant types, and cannot perform this cast automatically.
214 // We transmute it instead, and enforce the lack of a lifetime with the `K0, K1, V: 'static` bound
215 mem::transmute::<&Self, &Self::Output>(self)
216 }
217 }
218 #[inline]
219 fn transform_owned(self) -> Self::Output {
220 debug_assert!(mem::size_of::<Self::Output>() == mem::size_of::<Self>());
221 unsafe {
222 // Similar problem as transform(), but we need to use ptr::read since
223 // the compiler isn't sure of the sizes
224 let this = mem::ManuallyDrop::new(self);
225 let ptr: *const Self::Output = (&*this as *const Self).cast();
226 ptr::read(ptr)
227 }
228 }
229 #[inline]
230 unsafe fn make(from: Self::Output) -> Self {
231 debug_assert!(mem::size_of::<Self::Output>() == mem::size_of::<Self>());
232 let from = mem::ManuallyDrop::new(from);
233 let ptr: *const Self = (&*from as *const Self::Output).cast();
234 ptr::read(ptr)
235 }
236 #[inline]
237 fn transform_mut<F>(&'a mut self, f: F)
238 where
239 F: 'static + for<'b> FnOnce(&'b mut Self::Output),
240 {
241 unsafe { f(mem::transmute::<&mut Self, &mut Self::Output>(self)) }
242 }
243}
244
245/// This impl requires enabling the optional `yoke` Cargo feature of the `zerovec` crate
246#[allow(clippy::transmute_ptr_to_ptr)]
247unsafe impl<'a, K0, K1, V> Yokeable<'a> for ZeroMap2dBorrowed<'static, K0, K1, V>
248where
249 K0: 'static + for<'b> dynZeroMapKV<'b> + ?Sized,
250 K1: 'static + for<'b> dynZeroMapKV<'b> + ?Sized,
251 V: 'static + for<'b> dynZeroMapKV<'b> + ?Sized,
252 &'static <K0 as ZeroMapKV<'static>>::Slice: for<'b> dynYokeable<'b>,
253 &'static <K1 as ZeroMapKV<'static>>::Slice: for<'b> dynYokeable<'b>,
254 &'static <V as ZeroMapKV<'static>>::Slice: for<'b> dynYokeable<'b>,
255{
256 type Output = ZeroMap2dBorrowed<'a, K0, K1, V>;
257 #[inline]
258 fn transform(&'a self) -> &'a Self::Output {
259 unsafe {
260 // Unfortunately, because K and V are generic, rustc is
261 // unaware that these are covariant types, and cannot perform this cast automatically.
262 // We transmute it instead, and enforce the lack of a lifetime with the `K0, K1, V: 'static` bound
263 mem::transmute::<&Self, &Self::Output>(self)
264 }
265 }
266 #[inline]
267 fn transform_owned(self) -> Self::Output {
268 debug_assert!(mem::size_of::<Self::Output>() == mem::size_of::<Self>());
269 unsafe {
270 // Similar problem as transform(), but we need to use ptr::read since
271 // the compiler isn't sure of the sizes
272 let this = mem::ManuallyDrop::new(self);
273 let ptr: *const Self::Output = (&*this as *const Self).cast();
274 ptr::read(ptr)
275 }
276 }
277 #[inline]
278 unsafe fn make(from: Self::Output) -> Self {
279 debug_assert!(mem::size_of::<Self::Output>() == mem::size_of::<Self>());
280 let from = mem::ManuallyDrop::new(from);
281 let ptr: *const Self = (&*from as *const Self::Output).cast();
282 ptr::read(ptr)
283 }
284 #[inline]
285 fn transform_mut<F>(&'a mut self, f: F)
286 where
287 F: 'static + for<'b> FnOnce(&'b mut Self::Output),
288 {
289 unsafe { f(mem::transmute::<&mut Self, &mut Self::Output>(self)) }
290 }
291}
292
293#[cfg(test)]
294#[allow(non_camel_case_types, non_snake_case)]
295mod test {
296 use super::*;
297 use crate::{vecs::FlexZeroSlice, VarZeroSlice, ZeroSlice};
298 use databake::*;
299
300 // Note: The following derives cover Yoke as well as Serde and databake. These may partially
301 // duplicate tests elsewhere in this crate, but they are here for completeness.
302
303 #[derive(yoke::Yokeable, zerofrom::ZeroFrom)]
304 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
305 #[cfg_attr(feature = "databake", derive(databake::Bake), databake(path = zerovec::yoke_impls::test))]
306 struct DeriveTest_ZeroVec<'data> {
307 #[cfg_attr(feature = "serde", serde(borrow))]
308 _data: ZeroVec<'data, u16>,
309 }
310
311 #[test]
312 #[ignore] // https://github.com/rust-lang/rust/issues/98906
313 fn bake_ZeroVec() {
314 test_bake!(
315 DeriveTest_ZeroVec<'static>,
316 crate::yoke_impls::test::DeriveTest_ZeroVec {
317 _data: crate::ZeroVec::new(),
318 },
319 zerovec,
320 );
321 }
322
323 #[derive(yoke::Yokeable)]
324 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
325 #[cfg_attr(feature = "databake", derive(databake::Bake), databake(path = zerovec::yoke_impls::test))]
326 struct DeriveTest_ZeroSlice<'data> {
327 #[cfg_attr(feature = "serde", serde(borrow))]
328 _data: &'data ZeroSlice<u16>,
329 }
330
331 #[test]
332 fn bake_ZeroSlice() {
333 test_bake!(
334 DeriveTest_ZeroSlice<'static>,
335 crate::yoke_impls::test::DeriveTest_ZeroSlice {
336 _data: crate::ZeroSlice::new_empty(),
337 },
338 zerovec,
339 );
340 }
341
342 #[derive(yoke::Yokeable, zerofrom::ZeroFrom)]
343 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
344 #[cfg_attr(feature = "databake", derive(databake::Bake), databake(path = zerovec::yoke_impls::test))]
345 struct DeriveTest_FlexZeroVec<'data> {
346 #[cfg_attr(feature = "serde", serde(borrow))]
347 _data: FlexZeroVec<'data>,
348 }
349
350 #[test]
351 fn bake_FlexZeroVec() {
352 test_bake!(
353 DeriveTest_FlexZeroVec<'static>,
354 crate::yoke_impls::test::DeriveTest_FlexZeroVec {
355 _data: crate::vecs::FlexZeroVec::new(),
356 },
357 zerovec,
358 );
359 }
360
361 #[derive(yoke::Yokeable)]
362 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
363 #[cfg_attr(feature = "databake", derive(databake::Bake), databake(path = zerovec::yoke_impls::test))]
364 struct DeriveTest_FlexZeroSlice<'data> {
365 #[cfg_attr(feature = "serde", serde(borrow))]
366 _data: &'data FlexZeroSlice,
367 }
368
369 #[test]
370 fn bake_FlexZeroSlice() {
371 test_bake!(
372 DeriveTest_FlexZeroSlice<'static>,
373 crate::yoke_impls::test::DeriveTest_FlexZeroSlice {
374 _data: unsafe { crate::vecs::FlexZeroSlice::from_byte_slice_unchecked(b"\x01\0") },
375 },
376 zerovec,
377 );
378 }
379
380 #[derive(yoke::Yokeable, zerofrom::ZeroFrom)]
381 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
382 #[cfg_attr(feature = "databake", derive(databake::Bake), databake(path = zerovec::yoke_impls::test))]
383 struct DeriveTest_VarZeroVec<'data> {
384 #[cfg_attr(feature = "serde", serde(borrow))]
385 _data: VarZeroVec<'data, str>,
386 }
387
388 #[test]
389 fn bake_VarZeroVec() {
390 test_bake!(
391 DeriveTest_VarZeroVec<'static>,
392 crate::yoke_impls::test::DeriveTest_VarZeroVec {
393 _data: crate::VarZeroVec::new(),
394 },
395 zerovec,
396 );
397 }
398
399 #[derive(yoke::Yokeable)]
400 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
401 #[cfg_attr(feature = "databake", derive(databake::Bake), databake(path = zerovec::yoke_impls::test))]
402 struct DeriveTest_VarZeroSlice<'data> {
403 #[cfg_attr(feature = "serde", serde(borrow))]
404 _data: &'data VarZeroSlice<str>,
405 }
406
407 #[test]
408 fn bake_VarZeroSlice() {
409 test_bake!(
410 DeriveTest_VarZeroSlice<'static>,
411 crate::yoke_impls::test::DeriveTest_VarZeroSlice {
412 _data: crate::VarZeroSlice::new_empty()
413 },
414 zerovec,
415 );
416 }
417
418 #[derive(yoke::Yokeable, zerofrom::ZeroFrom)]
419 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
420 #[cfg_attr(feature = "databake", derive(databake::Bake), databake(path = zerovec::yoke_impls::test))]
421 #[yoke(prove_covariance_manually)]
422 struct DeriveTest_ZeroMap<'data> {
423 #[cfg_attr(feature = "serde", serde(borrow))]
424 _data: ZeroMap<'data, [u8], str>,
425 }
426
427 #[test]
428 fn bake_ZeroMap() {
429 test_bake!(
430 DeriveTest_ZeroMap<'static>,
431 crate::yoke_impls::test::DeriveTest_ZeroMap {
432 _data: unsafe {
433 #[allow(unused_unsafe)]
434 crate::ZeroMap::from_parts_unchecked(
435 crate::VarZeroVec::new(),
436 crate::VarZeroVec::new(),
437 )
438 },
439 },
440 zerovec,
441 );
442 }
443
444 #[derive(yoke::Yokeable)]
445 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
446 #[cfg_attr(feature = "databake", derive(databake::Bake), databake(path = zerovec::yoke_impls::test))]
447 #[yoke(prove_covariance_manually)]
448 struct DeriveTest_ZeroMapBorrowed<'data> {
449 #[cfg_attr(feature = "serde", serde(borrow))]
450 _data: ZeroMapBorrowed<'data, [u8], str>,
451 }
452
453 #[test]
454 fn bake_ZeroMapBorrowed() {
455 test_bake!(
456 DeriveTest_ZeroMapBorrowed<'static>,
457 crate::yoke_impls::test::DeriveTest_ZeroMapBorrowed {
458 _data: unsafe {
459 #[allow(unused_unsafe)]
460 crate::maps::ZeroMapBorrowed::from_parts_unchecked(
461 crate::VarZeroSlice::new_empty(),
462 crate::VarZeroSlice::new_empty(),
463 )
464 },
465 },
466 zerovec,
467 );
468 }
469
470 #[derive(yoke::Yokeable, zerofrom::ZeroFrom)]
471 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
472 #[cfg_attr(feature = "databake", derive(databake::Bake), databake(path = zerovec::yoke_impls::test))]
473 #[yoke(prove_covariance_manually)]
474 struct DeriveTest_ZeroMapWithULE<'data> {
475 #[cfg_attr(feature = "serde", serde(borrow))]
476 _data: ZeroMap<'data, ZeroSlice<u32>, str>,
477 }
478
479 #[test]
480 fn bake_ZeroMapWithULE() {
481 test_bake!(
482 DeriveTest_ZeroMapWithULE<'static>,
483 crate::yoke_impls::test::DeriveTest_ZeroMapWithULE {
484 _data: unsafe {
485 #[allow(unused_unsafe)]
486 crate::ZeroMap::from_parts_unchecked(
487 crate::VarZeroVec::new(),
488 crate::VarZeroVec::new(),
489 )
490 },
491 },
492 zerovec,
493 );
494 }
495
496 #[derive(yoke::Yokeable, zerofrom::ZeroFrom)]
497 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
498 #[cfg_attr(feature = "databake", derive(databake::Bake), databake(path = zerovec::yoke_impls::test))]
499 #[yoke(prove_covariance_manually)]
500 struct DeriveTest_ZeroMap2d<'data> {
501 #[cfg_attr(feature = "serde", serde(borrow))]
502 _data: ZeroMap2d<'data, u16, u16, str>,
503 }
504
505 #[test]
506 fn bake_ZeroMap2d() {
507 test_bake!(
508 DeriveTest_ZeroMap2d<'static>,
509 crate::yoke_impls::test::DeriveTest_ZeroMap2d {
510 _data: unsafe {
511 #[allow(unused_unsafe)]
512 crate::ZeroMap2d::from_parts_unchecked(
513 crate::ZeroVec::new(),
514 crate::ZeroVec::new(),
515 crate::ZeroVec::new(),
516 crate::VarZeroVec::new(),
517 )
518 },
519 },
520 zerovec,
521 );
522 }
523
524 #[derive(yoke::Yokeable)]
525 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
526 #[cfg_attr(feature = "databake", derive(databake::Bake), databake(path = zerovec::yoke_impls::test))]
527 #[yoke(prove_covariance_manually)]
528 struct DeriveTest_ZeroMap2dBorrowed<'data> {
529 #[cfg_attr(feature = "serde", serde(borrow))]
530 _data: ZeroMap2dBorrowed<'data, u16, u16, str>,
531 }
532
533 #[test]
534 fn bake_ZeroMap2dBorrowed() {
535 test_bake!(
536 DeriveTest_ZeroMap2dBorrowed<'static>,
537 crate::yoke_impls::test::DeriveTest_ZeroMap2dBorrowed {
538 _data: unsafe {
539 #[allow(unused_unsafe)]
540 crate::maps::ZeroMap2dBorrowed::from_parts_unchecked(
541 crate::ZeroSlice::new_empty(),
542 crate::ZeroSlice::new_empty(),
543 crate::ZeroSlice::new_empty(),
544 crate::VarZeroSlice::new_empty(),
545 )
546 },
547 },
548 zerovec,
549 );
550 }
551}
552