Lines Matching full:same

70 ///     reference the same byte range at the same time
89 ///   aliasing trivially: since `src` and `dst` have the same lifetime, `src` is
91 ///   references may reference the same referent.
96 ///     pointing to the same byte range at the same time.
137 //   - Since the underlying cast is size-preserving, `dst` addresses the same
142 //   addresses the same referent as `src`. By `Src: TransmuteFrom<Dst, DV, SV>`,
151 //     same invariants, and permit interior mutation on the same byte ranges
183 /// referencing the same referent at the same time, cannot be used by safe code
207 /// Denotes that two types have the same invariants.
212 /// same referent at the same time - no such safe code can cause undefined
216 // SAFETY: Trivially sound to have multiple `&T` pointing to the same referent.
245 // SAFETY: `ManuallyDrop<T>` has the same size and bit validity as `T` [1], and
247 // code to obtain a `&T` and a `&ManuallyDrop<T>` to the same referent at the
248 // same time.
252 //   `ManuallyDrop<T>` is guaranteed to have the same layout and bit
302 /// referents of `src` and `dst` are the same size, then the set of bit patterns
306 /// If the referents are not the same size, then `Dst: TransmuteFrom<Src, SV,
358 // `Ptr` is the same regardless of referent type.
381 // - `ManuallyDrop<T>` has the same size as `T` [1]
382 // - `ManuallyDrop<T>` has the same validity as `T` [1]
386 //   `ManuallyDrop<T>` is guaranteed to have the same layout and bit validity as
392 // - `Unalign<T>` promises to have the same size as `T`.
393 // - `Unalign<T>` promises to have the same validity as `T`.
396 // SAFETY: `Unalign<T>` promises to have the same size and validity as `T`.
398 // u.try_deref().unwrap()`. Because `Unalign<T>` has the same size as `T`, the
399 // returned `&T` must point to the same referent as `u`, and thus it must be
400 // sound for these two references to exist at the same time since it's already
406 // - `Wrapping<T>` has the same size as `T` [1].
408 //   guaranteed per that `Wrapping<T>` has the same layout as `T` [1]. The only
410 //   have the same bit validity as `T`. In particular, in order to change the
419 //   `Wrapping<T>` is guaranteed to have the same layout and ABI as `T`.
430 // SAFETY: By the preceding safety proof, `Wrapping<T>` and `T` have the same
434 // to the same referent at the same time. Thus, this must be sound.
439 // - `UnsafeCell<T>` has the same size as `T` [1].
440 // - Per [1], `UnsafeCell<T>` has the same bit validity as `T`. Technically the
446 //   `UnsafeCell<T>` has the same in-memory representation as its inner type
453 // - `Cell<T>` has the same size as `T` [1].
454 // - Per [1], `Cell<T>` has the same bit validity as `T`. Technically the term
456 //   "same memory layout and caveats as `UnsafeCell<T>`." The `UnsafeCell` docs
462 //   `Cell<T>` has the same memory layout and caveats as `UnsafeCell<T>`. In
463 //   particular, this means that `Cell<T>` has the same in-memory representation
468 //   `UnsafeCell<T>` has the same in-memory representation as its inner type