• abin 0.1.6/src/implementation/reference_counted/data.rs
    27
    		 
        /// be able to mutate the reference counter.
    28
    		 
        #[allow(clippy::mut_from_ref)]
    29
    		 
        #[inline]
  • actori-service 1.0.5/src/cell.rs
    38
    		 
        #[allow(clippy::mut_from_ref)]
    39
    		 
        pub(crate) unsafe fn get_mut_unsafe(&self) -> &mut T {
  • actori-utils 1.0.6/src/cell.rs
    44
    		 
        #[allow(clippy::mut_from_ref)]
    45
    		 
        pub(crate) unsafe fn get_mut_unsafe(&self) -> &mut T {
  • aftermath 1.1.3/src/differentiation.rs
    262
    		 
    #[allow(clippy::mut_from_ref, clippy::missing_errors_doc)]
    263
    		 
    /// A trait that mark a function as differentiable
  • aftermath 1.1.3/src/expr.rs
    48
    		 
        /// Clone an AST with another backing [arena](bumpalo::Bump)
    49
    		 
        #[allow(clippy::mut_from_ref)]
    50
    		 
        pub fn clone_in<'new_arena>(
  • alloc-from-pool 1.0.4/src/inner_pool.rs
    25
    		 
        #[allow(mutable_transmutes)]
    26
    		 
        #[allow(clippy::mut_from_ref)]
    27
    		 
        fn as_mut(&self) -> &'static mut Self {
  • amethyst_tiles 0.15.3/src/map.rs
    392
    		 
                }
    393
    		 
                #[allow(clippy::mut_from_ref)]
    394
    		 
                pub fn get_mut(&self) -> &mut TileMap<TestTile, E> {
  • aqueue 1.2.10/src/actor.rs
    17
    		 
        #[inline]
    18
    		 
        #[allow(clippy::mut_from_ref)]
    19
    		 
        pub fn get_mut(&self) -> &mut T {
  • arcon 0.2.1/src/index/hash_table/mod.rs
    133
    		 
        #[inline(always)]
    134
    		 
        #[allow(clippy::mut_from_ref)]
    135
    		 
        fn raw_table_mut(&self) -> &mut RawTable<K, V> {
  • arcon_state 0.2.1/src/backend/rocks/mod.rs
    37
    		 
        #[inline(always)]
    38
    		 
        #[allow(clippy::mut_from_ref)]
    39
    		 
        fn db_mut(&self) -> &mut DB {
  • astral-string 0.0.5/src/static_ref_vector.rs
    87
    		 
    	// Returning `mut` is allowed because of `UnsafeCell`
    88
    		 
    	#[allow(clippy::mut_from_ref)]
    89
    		 
    	unsafe fn page(&self, index: usize) -> &mut Option<Page<T>> {
    95
    		 
    	// Returning `mut` is allowed because of `UnsafeCell`
    96
    		 
    	#[allow(clippy::mut_from_ref)]
    97
    		 
    	unsafe fn page_or_create(&self, index: usize) -> (&mut Page<T>, usize, usize) {
  • asyncsync 0.2.0/src/utils/notify.rs
    23
    		 
        /// The [`Waiter`] must be accessed from multiple threads at the same time.
    24
    		 
        #[allow(clippy::mut_from_ref)]
    25
    		 
        pub unsafe fn get(&self) -> &mut WaiterInner {
  • augmented_baseview 0.1.0/src/macos/window.rs
    335
    		 
        /// callback, meaning that this shouldn't be a problem in practice.
    336
    		 
        #[allow(clippy::mut_from_ref)]
    337
    		 
        pub(super) unsafe fn from_field(obj: &Object) -> &mut Self {
  • bable 0.1.0/src/table/builder.rs
    165
    		 
        #[inline(always)]
    166
    		 
        #[allow(clippy::mut_from_ref)]
    167
    		 
        fn inner_mut(&self) -> &mut BBlockInner {
  • bootloader-x86_64-bios-common 0.11.0/src/racy_cell.rs
    13
    		 
        /// Ensure that the access is unique (no active references, mutable or not).
    14
    		 
        #[allow(clippy::mut_from_ref)]
    15
    		 
        pub unsafe fn get_mut(&self) -> &mut T {
  • broker-tokio 0.2.16/src/time/driver/entry.rs
    137
    		 
        /// Only called by `Registration`
    138
    		 
        #[allow(clippy::mut_from_ref)] // https://github.com/rust-lang/rust-clippy/issues/4281
    139
    		 
        pub(crate) unsafe fn time_mut(&self) -> &mut Time {
  • bumpalo 3.12.0/src/lib.rs
    803
    		 
        #[inline(always)]
    804
    		 
        #[allow(clippy::mut_from_ref)]
    805
    		 
        pub fn alloc<T>(&self, val: T) -> &mut T {
    823
    		 
        #[inline(always)]
    824
    		 
        #[allow(clippy::mut_from_ref)]
    825
    		 
        pub fn try_alloc<T>(&self, val: T) -> Result<&mut T, AllocErr> {
    848
    		 
        #[inline(always)]
    849
    		 
        #[allow(clippy::mut_from_ref)]
    850
    		 
        pub fn alloc_with<F, T>(&self, f: F) -> &mut T
    901
    		 
        #[inline(always)]
    902
    		 
        #[allow(clippy::mut_from_ref)]
    903
    		 
        pub fn try_alloc_with<F, T>(&self, f: F) -> Result<&mut T, AllocErr>
    973
    		 
        #[inline(always)]
    974
    		 
        #[allow(clippy::mut_from_ref)]
    975
    		 
        pub fn alloc_try_with<F, T, E>(&self, f: F) -> Result<&mut T, E>
  • cell-family 0.1.0/src/lib.rs
    193
    		 
        /// lifetime of the returned reference.
    194
    		 
        #[allow(clippy::mut_from_ref)]
    195
    		 
        pub unsafe fn get_unchecked_mut(&self) -> &mut T {
  • cess-sp-porep 0.1.2/src/stacked/vanilla/memory_handling.rs
    160
    		 
        #[inline]
    161
    		 
        #[allow(clippy::mut_from_ref)]
    162
    		 
        unsafe fn get_mut_bufs(&self) -> &mut [Mmap] {
  • cess-sp-porep 0.1.2/src/stacked/vanilla/utils.rs
    110
    		 
        #[allow(clippy::mut_from_ref)]
    111
    		 
        unsafe fn slice_mut(&self) -> &mut [u8] {
    119
    		 
        #[allow(clippy::mut_from_ref)]
    120
    		 
        pub unsafe fn slot_mut(&self, slot: usize) -> &mut [u8] {
  • cli_lib 1.25.2/tools/coverage/range_tree.rs
    21
    		 
      #[allow(clippy::mut_from_ref)]
    22
    		 
      pub fn alloc(&'a self, value: RangeTree<'a>) -> &'a mut RangeTree<'a> {
  • concread 0.4.1/src/internals/hashtrie/cursor.rs
    178
    		 
        #[inline(always)]
    179
    		 
        #[allow(clippy::mut_from_ref)]
    180
    		 
        pub(crate) fn as_bucket_mut<K: Hash + Eq + Clone + Debug, V: Clone>(
    209
    		 
        #[inline(always)]
    210
    		 
        #[allow(clippy::mut_from_ref)]
    211
    		 
        pub(crate) fn as_branch_mut<K: Hash + Eq + Clone + Debug, V: Clone>(
    224
    		 
        #[inline(always)]
    225
    		 
        #[allow(clippy::mut_from_ref)]
    226
    		 
        unsafe fn as_branch_mut_nock<K: Hash + Eq + Clone + Debug, V: Clone>(
  • contain 0.4.0/src/lib.rs
    20
    		 
        /// This returns a mutable reference with the same lifetime as the [`Container`].
    21
    		 
        #[allow(clippy::mut_from_ref)]
    22
    		 
        fn put_mut(&self, item: T) -> &mut T;
  • content-tree 0.2.0/src/unsafe_cursor.rs
    15
    		 
        #[allow(clippy::mut_from_ref)] // Dirty.
    16
    		 
        pub(crate) unsafe fn get_node_mut(&self) -> &mut NodeLeaf<E, I, IE, LE> {
  • cordyceps 0.3.1/src/loom.rs
    125
    		 
                // pointer, so we have to do that here.
    126
    		 
                #[allow(clippy::mut_from_ref)]
    127
    		 
                #[inline(always)]
  • corundum 0.4.1/src/cell/refcell.rs
    211
    		 
        #[inline(always)]
    212
    		 
        #[allow(clippy::mut_from_ref)]
    213
    		 
        fn self_mut(&self) -> &mut Self {
    220
    		 
        #[inline]
    221
    		 
        #[allow(clippy::mut_from_ref)]
    222
    		 
        /// Takes a log and returns a mutable reference to the underlying data.
  • corundum 0.4.1/src/prc.rs
    1164
    		 
    trait PrcBoxPtr<T: PSafe + ?Sized, A: MemPool> {
    1165
    		 
        #[allow(clippy::mut_from_ref)]
    1166
    		 
        fn count(&self) -> &mut Counter<A>;
  • corundum 0.4.1/src/ptr/ptr.rs
    107
    		 
        #[inline]
    108
    		 
        #[allow(clippy::mut_from_ref)]
    109
    		 
        /// Returns the mutable reference of the value
  • corundum 0.4.1/src/sync/mutex.rs
    167
    		 
        #[inline]
    168
    		 
        #[allow(clippy::mut_from_ref)]
    169
    		 
        #[track_caller]
    182
    		 
        #[inline]
    183
    		 
        #[allow(clippy::mut_from_ref)]
    184
    		 
        fn self_mut(&self) -> &mut Self {
  • crndm 0.1.0/src/cell/refcell.rs
    191
    		 
        #[inline(always)]
    192
    		 
        #[allow(clippy::mut_from_ref)]
    193
    		 
        fn self_mut(&self) -> &mut Self {
    200
    		 
        #[inline]
    201
    		 
        #[allow(clippy::mut_from_ref)]
    202
    		 
        /// Takes a log and returns a mutable reference to the underlying data.
    258
    		 
        #[inline]
    259
    		 
        #[allow(clippy::mut_from_ref)]
    260
    		 
        #[inline]
  • crndm 0.1.0/src/prc.rs
    855
    		 
    trait PrcBoxPtr<T: PSafe + ?Sized, A: MemPool> {
    856
    		 
        #[allow(clippy::mut_from_ref)]
    857
    		 
        fn count(&self) -> &mut Counter;
  • crndm 0.1.0/src/ptr/ptr.rs
    103
    		 
        #[inline]
    104
    		 
        #[allow(clippy::mut_from_ref)]
    105
    		 
        /// Returns the mutable reference of the value
  • crndm 0.1.0/src/sync/mutex.rs
    168
    		 
        #[inline]
    169
    		 
        #[allow(clippy::mut_from_ref)]
    170
    		 
        /// Takes a log and returns a `&mut T` for interior mutability
    181
    		 
        #[inline]
    182
    		 
        #[allow(clippy::mut_from_ref)]
    183
    		 
        fn self_mut(&self) -> &mut Self {
  • dakv_skiplist 0.1.3/src/arena.rs
    78
    		 
    #[allow(clippy::mut_from_ref)]
    79
    		 
    pub trait Arena {
  • dakv_skiplist 0.1.3/src/skipnode.rs
    12
    		 
    impl Node {
    13
    		 
        #[allow(clippy::mut_from_ref)]
    14
    		 
        pub fn new<A: Arena>(data: Bytes, height: usize, arena: &A) -> &mut Self {
    28
    		 
        #[allow(clippy::mut_from_ref)]
    29
    		 
        pub fn head<A: Arena>(arena: &A) -> &mut Self {
  • delorean 0.2.1/src/lib.rs
    68
    		 
        #[inline]
    69
    		 
        #[allow(clippy::mut_from_ref)]
    70
    		 
        pub(crate) unsafe fn app(&self) -> &mut A {
  • deno 1.30.0/tools/coverage/range_tree.rs
    22
    		 
      #[allow(clippy::mut_from_ref)]
    23
    		 
      pub fn alloc(&'a self, value: RangeTree<'a>) -> &'a mut RangeTree<'a> {
  • deno_3p_lib 1.25.2/tools/coverage/range_tree.rs
    21
    		 
      #[allow(clippy::mut_from_ref)]
    22
    		 
      pub fn alloc(&'a self, value: RangeTree<'a>) -> &'a mut RangeTree<'a> {
  • denox 0.2.1/tools/coverage/range_tree.rs
    22
    		 
      #[allow(clippy::mut_from_ref)]
    23
    		 
      pub fn alloc(&'a self, value: RangeTree<'a>) -> &'a mut RangeTree<'a> {
  • diatom 0.4.0/src/vm/gc.rs
    210
    		 
        #[allow(clippy::mut_from_ref)]
    211
    		 
        pub fn string_pool(&self) -> &mut StringPool {
  • dioxus-core 0.3.1/src/bump_frame.rs
    34
    		 
        #[allow(clippy::mut_from_ref)]
    35
    		 
        pub(crate) unsafe fn bump_mut(&self) -> &mut Bump {
  • dioxus-core 0.3.1/src/scopes.rs
    643
    		 
        /// ```
    644
    		 
        #[allow(clippy::mut_from_ref)]
    645
    		 
        pub fn use_hook<State: 'static>(&self, initializer: impl FnOnce() -> State) -> &mut State {
  • disrustor 0.3.0/src/prelude.rs
    72
    		 
    #[allow(clippy::mut_from_ref)]
    73
    		 
    #[allow(clippy::missing_safety_doc)]
  • drone-core 0.14.3/src/sync/spsc/mod.rs
    33
    		 
        #[allow(clippy::mut_from_ref)]
    34
    		 
        unsafe fn rx_waker_mut(&self) -> &mut MaybeUninit<Waker>;
    36
    		 
        #[allow(clippy::mut_from_ref)]
    37
    		 
        unsafe fn tx_waker_mut(&self) -> &mut MaybeUninit<Waker>;
    168
    		 
        #[allow(clippy::mut_from_ref)]
    169
    		 
        unsafe fn err_mut(&self) -> &mut Option<Self::Error>;
  • drop-bin 0.2.2/src/concurrent_vec.rs
    17
    		 
        // This is safe because this container cannot be immutably iterated over
    18
    		 
        #[allow(clippy::mut_from_ref)]
    19
    		 
        pub(crate) fn push(&self, mut value: T) -> &mut T {
  • dynamic-arena 0.1.6/src/lib.rs
    156
    		 
        #[inline]
    157
    		 
        #[allow(clippy::mut_from_ref)]
    158
    		 
        pub fn alloc_copy<T: Copy + Send>(&self, value: T) -> &mut T {
    170
    		 
        #[inline]
    171
    		 
        #[allow(clippy::mut_from_ref)]
    172
    		 
        pub unsafe fn alloc_unchecked<T>(&self, value: T) -> &mut T {
    239
    		 
        #[inline]
    240
    		 
        #[allow(clippy::mut_from_ref)]
    241
    		 
        pub fn alloc<T: Send + 'a>(&self, value: T) -> &mut T {
    267
    		 
        #[inline]
    268
    		 
        #[allow(clippy::mut_from_ref)]
    269
    		 
        pub fn alloc<T: 'a>(&self, value: T) -> &mut T {
  • embassy-executor 0.1.1/src/raw/util.rs
    15
    		 
        #[allow(clippy::mut_from_ref)]
    16
    		 
        pub unsafe fn as_mut(&self) -> &mut T {
  • embedded-threads 0.1.0/src/lib.rs
    45
    		 
        /// get the global THREADS list, mutable
    46
    		 
        #[allow(clippy::mut_from_ref)]
    47
    		 
        pub(crate) unsafe fn get_mut(cs: &CriticalSection) -> &mut Threads {
  • eternal 0.3.2/src/util/cell.rs
    44
    		 
        #[allow(clippy::mut_from_ref)]
    45
    		 
        pub(crate) unsafe fn get_mut_unsafe(&self) -> &mut T {
  • exprtk_rs 0.1.0/src/exprtk.rs
    318
    		 
        #[allow(clippy::mut_from_ref)]
    319
    		 
        #[inline]
  • ffimage 0.9.0/src/packed/convert/rayon.rs
    24
    		 
        #[allow(clippy::mut_from_ref)]
    25
    		 
        pub unsafe fn get(&self) -> &mut T {
  • fixed-bump 0.3.3/src/bump.rs
    111
    		 
        /// [`handle_alloc_error`]: alloc::alloc::handle_alloc_error
    112
    		 
        #[allow(clippy::mut_from_ref)]
    113
    		 
        #[must_use]
    130
    		 
        /// If allocation fails, <code>[Err]\(value)</code> is returned.
    131
    		 
        #[allow(clippy::mut_from_ref)]
    132
    		 
        pub fn try_alloc_value<T>(&self, value: T) -> Result<&mut T, T> {
  • fixed-bump 0.3.3/src/dynamic.rs
    92
    		 
        /// [`handle_alloc_error`]: alloc::alloc::handle_alloc_error
    93
    		 
        #[allow(clippy::mut_from_ref)]
    94
    		 
        #[must_use]
    111
    		 
        /// If allocation fails, <code>[Err]\(value)</code> is returned.
    112
    		 
        #[allow(clippy::mut_from_ref)]
    113
    		 
        pub fn try_alloc_value<T>(&self, value: T) -> Result<&mut T, T> {
  • fixed-bump 0.3.3/src/generic.rs
    57
    		 
        #[allow(clippy::mut_from_ref)]
    58
    		 
        #[must_use]
    69
    		 
        #[allow(clippy::mut_from_ref)]
    70
    		 
        pub fn try_alloc_value<T>(&self, value: T) -> Result<&mut T, T> {
  • fixed-typed-arena 0.3.2/src/arena.rs
    81
    		 
        /// [`handle_alloc_error`]: alloc::alloc::handle_alloc_error
    82
    		 
        #[allow(clippy::mut_from_ref)]
    83
    		 
        pub fn alloc(&self, value: T) -> &mut T
    100
    		 
        /// Like [`Self::alloc`], but returns [`None`] if memory allocation fails.
    101
    		 
        #[allow(clippy::mut_from_ref)]
    102
    		 
        pub fn try_alloc(&self, value: T) -> Option<&mut T>
  • flize 4.2.3/src/mutex.rs
    44
    		 
        #[allow(clippy::mut_from_ref)]
    45
    		 
        fn get_unique(&self) -> &mut T {
  • frawk 0.4.7/src/runtime/str_impl.rs
    400
    		 
        // "logically" immutable and reference counted.
    401
    		 
        #[allow(clippy::mut_from_ref)]
    402
    		 
        unsafe fn rep_mut(&self) -> &mut StrRep<'a> {
  • frugalos_config 1.2.0/src/builder.rs
    219
    		 
        #[allow(clippy::mut_from_ref)]
    220
    		 
        fn get_device<'b, 'c>(&'b self, device_no: DeviceNo) -> &'c Device {
  • fumio-pool 0.1.0/src/pool/task.rs
    220
    		 
    	#[allow(clippy::mut_from_ref)] // unsafe anyway
    221
    		 
    	unsafe fn local_future(&self) -> &mut Option<LocalFutureObj<'static, ()>> {
  • fumio-utils 0.1.0/src/mpsc.rs
    37
    		 
    	// at most one pop operation must be in progress at a time.
    38
    		 
    	#[allow(clippy::mut_from_ref)]
    39
    		 
    	pub unsafe fn start_pop(&self) -> impl Iterator<Item = *const Link> + '_ {
  • gdk 0.16.2/src/window.rs
    168
    		 
        #[allow(clippy::mut_from_ref)]
    169
    		 
        #[doc(alias = "gdk_window_get_user_data")]
  • gdk-pixbuf 0.16.7/src/pixbuf.rs
    244
    		 
        /// or write to the data.
    245
    		 
        #[allow(clippy::mut_from_ref)]
    246
    		 
        #[allow(clippy::missing_safety_doc)]
  • gdnative-core 0.11.3/src/core_types/dictionary.rs
    161
    		 
        #[inline]
    162
    		 
        #[allow(clippy::mut_from_ref)]
    163
    		 
        pub unsafe fn get_mut_ref<K>(&self, key: K) -> &mut Variant
  • gdnative-core 0.11.3/src/core_types/variant_array.rs
    80
    		 
        #[inline]
    81
    		 
        #[allow(clippy::mut_from_ref)]
    82
    		 
        pub unsafe fn get_mut_ref(&self, idx: i32) -> &mut Variant {
  • gemachain-bucket-map 1.8.2/src/bucket_storage.rs
    218
    		 
        #[allow(clippy::mut_from_ref)]
    219
    		 
        pub fn get_mut<T: Sized>(&self, ix: u64) -> &mut T {
    232
    		 
        #[allow(clippy::mut_from_ref)]
    233
    		 
        pub fn get_mut_cell_slice<T: Sized>(&self, ix: u64, len: u64) -> &mut [T] {
  • geo-booleanop 0.3.2/src/splay/tree.rs
    249
    		 
        // Messy code ahead
    250
    		 
        #[allow(clippy::mut_from_ref)]
    251
    		 
        fn root_mut(&self) -> &mut Option<Box<Node<K, V>>> {
  • grr 0.8.0/src/buffer.rs
    114
    		 
        /// Returns a typed slice of the mapped memory range.
    115
    		 
        #[allow(clippy::mut_from_ref)]
    116
    		 
        pub unsafe fn map_buffer<T>(
  • hv-atom 0.1.0/src/lib.rs
    333
    		 
    #[inline]
    334
    		 
    #[allow(unknown_lints, clippy::mut_from_ref)]
    335
    		 
    unsafe fn copy_mut_lifetime<'a, S: ?Sized, T: ?Sized + 'a>(_ptr: &'a S, ptr: &mut T) -> &'a mut T {
  • indexed-ring-buffer 0.1.3/src/lib.rs
    70
    		 
        }
    71
    		 
        #[allow(clippy::mut_from_ref)]
    72
    		 
        #[inline(always)]
  • ipmpsc 0.5.1/src/posix.rs
    86
    		 
        #[allow(clippy::mut_from_ref)]
    87
    		 
        pub fn map_mut(&self) -> &mut MmapMut {
  • ipmpsc 0.5.1/src/windows.rs
    148
    		 
        #[allow(clippy::mut_from_ref)]
    149
    		 
        pub fn map_mut(&self) -> &mut MmapMut {
  • json-gettext 4.0.5/src/mutate.rs
    25
    		 
        #[inline]
    26
    		 
        #[allow(clippy::mut_from_ref)]
    27
    		 
        pub fn get_mut(&self) -> &mut T {
  • jsonata 0.0.0/src/value/mod.rs
    60
    		 
    #[allow(clippy::mut_from_ref)]
    61
    		 
    impl<'a> Value<'a> {
  • kanidm 1.1.0-alpha/src/lib/be/mod.rs
    98
    		 
        #[allow(clippy::mut_from_ref)]
    99
    		 
        fn get_idlayer(&self) -> &mut Self::IdlLayerType;
    672
    		 
        #[allow(clippy::mut_from_ref)]
    673
    		 
        fn get_idlayer(&self) -> &mut IdlArcSqliteReadTransaction<'a> {
    696
    		 
        #[allow(clippy::mut_from_ref)]
    697
    		 
        fn get_idlayer(&self) -> &mut IdlArcSqliteWriteTransaction<'a> {
  • kayrx 0.18.0/src/timer/driver/entry.rs
    127
    		 
        /// Only called by `Registration`
    128
    		 
        #[allow(clippy::mut_from_ref)] // https://github.com/rust-lang/rust-clippy/issues/4281
    129
    		 
        pub(crate) unsafe fn time_mut(&self) -> &mut Time {
  • kayrx-timer 0.1.1/src/driver/cell.rs
    93
    		 
        #[allow(clippy::mut_from_ref)]
    94
    		 
        pub(crate) unsafe fn get_mut_unsafe(&self) -> &mut T {
  • kayrx-timer 0.1.1/src/driver/entry.rs
    137
    		 
        /// Only called by `Registration`
    138
    		 
        #[allow(clippy::mut_from_ref)] // https://github.com/rust-lang/rust-clippy/issues/4281
    139
    		 
        pub(crate) unsafe fn time_mut(&self) -> &mut Time {
  • knife-util 0.1.7/src/any/ref.rs
    57
    		 
        /// 取出可变数据引用
    58
    		 
        #[allow(clippy::mut_from_ref)]
    59
    		 
        pub fn to_mut<V>(&self) -> &mut V {
  • knife-util 0.1.7/src/any/value.rs
    99
    		 
        /// 取出可变数据引用，可采用继承类型的特征，不需要与原始类型完全一致
    100
    		 
        #[allow(clippy::mut_from_ref)]
    101
    		 
        pub fn to_mut<V>(&self) -> &mut V {
  • kvm-ioctls 0.13.0/src/ioctls/mod.rs
    77
    		 
        /// Returns a mutable reference to `kvm_run`.
    78
    		 
        #[allow(clippy::mut_from_ref)]
    79
    		 
        pub fn as_mut_ref(&self) -> &mut kvm_run {
  • lapce-wasi-experimental-http 0.10.0/src/lib.rs
    9
    		 
    #[allow(dead_code)]
    10
    		 
    #[allow(clippy::mut_from_ref)]
    11
    		 
    #[allow(clippy::too_many_arguments)]
  • legion 0.4.0/src/internals/systems/schedule.rs
    117
    		 
        #[allow(clippy::mut_from_ref)]
    118
    		 
        unsafe fn get_mut(&self) -> &mut dyn ParallelRunnable {
  • legion-systems 0.2.4/src/schedule.rs
    104
    		 
        #[allow(clippy::mut_from_ref)]
    105
    		 
        unsafe fn get_mut(&self) -> &mut dyn Schedulable {
  • leo-asg 1.5.3/src/context.rs
    45
    		 
        #[allow(clippy::mut_from_ref)]
    46
    		 
        pub fn alloc_expression(&'a self, expr: Expression<'a>) -> &'a Expression<'a> {
    53
    		 
        #[allow(clippy::mut_from_ref)]
    54
    		 
        pub fn alloc_statement(&'a self, statement: Statement<'a>) -> &'a Statement<'a> {
    61
    		 
        #[allow(clippy::mut_from_ref)]
    62
    		 
        pub fn alloc_variable(&'a self, variable: Variable<'a>) -> &'a Variable<'a> {
    69
    		 
        #[allow(clippy::mut_from_ref)]
    70
    		 
        pub fn alloc_scope(&'a self, scope: Scope<'a>) -> &'a Scope<'a> {
    77
    		 
        #[allow(clippy::mut_from_ref)]
    78
    		 
        pub fn alloc_circuit(&'a self, circuit: Circuit<'a>) -> &'a Circuit<'a> {
  • leo-asg 1.5.3/src/scope.rs
    55
    		 
    #[allow(clippy::mut_from_ref)]
    56
    		 
    impl<'a> Scope<'a> {
  • libafl_qemu 0.9.0/src/asan.rs
    312
    		 
        #[inline]
    313
    		 
        #[allow(clippy::mut_from_ref)]
    314
    		 
        fn get_shadow_page(emu: &Emulator, page: GuestAddr) -> &mut [i8] {
  • libnotcurses-sys 3.7.1/src/plane/methods.rs
    1242
    		 
        // SAFETY: it's a new NcPlane, not a new one
    1243
    		 
        #[allow(clippy::mut_from_ref)]
    1244
    		 
        pub fn dup(&self) -> &mut NcPlane {
  • libreda-splay 0.1.0/src/tree.rs
    251
    		 
        // Messy code ahead
    252
    		 
        #[allow(clippy::mut_from_ref)]
    253
    		 
        fn root_mut(&self) -> &mut Option<Box<Node<K, V>>> {
  • lightws 0.6.7/src/bleed/mod.rs
    27
    		 
    #[allow(unused)]
    28
    		 
    #[allow(clippy::mut_from_ref)]
    29
    		 
    pub(crate) const unsafe fn const_cast<T: ?Sized>(x: &T) -> &mut T {
  • lockfree-object-pool 0.1.3/src/page.rs
    93
    		 
        #[inline]
    94
    		 
        #[allow(clippy::mut_from_ref)] // the function is marked as unsafe for a reason
    95
    		 
        pub unsafe fn get_mut(&self, id: &PageId) -> &mut T {
  • loom 0.5.6/src/cell/unsafe_cell.rs
    406
    		 
        // pointer, so we have to do that here.
    407
    		 
        #[allow(clippy::mut_from_ref)]
    408
    		 
        pub unsafe fn deref(&self) -> &mut T {
  • mapcell 0.0.0/src/lib.rs
    37
    		 
        /// - the value is atomic, so thread-safely update.
    38
    		 
        #[allow(clippy::mut_from_ref)]
    39
    		 
        #[inline(always)]
  • millennium-webview 1.0.0-beta.3/src/webview/wkwebview/file_drop.rs
    59
    		 
    #[allow(clippy::mut_from_ref)]
    60
    		 
    unsafe fn get_handler(this: &Object) -> &mut (Box<dyn Fn(&Window, FileDropEvent) -> bool>, Rc<Window>) {
  • mini-io-queue 0.1.0/src/storage/mod.rs
    101
    		 
        /// [`capacity`]: Storage::capacity
    102
    		 
        #[allow(clippy::mut_from_ref)]
    103
    		 
        unsafe fn slice_mut_unchecked(&self, range: Range<usize>) -> &mut [T];
  • mmtk 0.16.0/src/policy/sft_map.rs
    160
    		 
            #[allow(clippy::cast_ref_to_mut)]
    161
    		 
            #[allow(clippy::mut_from_ref)]
    162
    		 
            unsafe fn mut_self(&self) -> &mut Self {
    366
    		 
            #[allow(clippy::cast_ref_to_mut)]
    367
    		 
            #[allow(clippy::mut_from_ref)]
    368
    		 
            unsafe fn mut_self(&self) -> &mut Self {
    460
    		 
            #[allow(clippy::cast_ref_to_mut)]
    461
    		 
            #[allow(clippy::mut_from_ref)]
    462
    		 
            unsafe fn mut_self(&self) -> &mut Self {
  • mmtk 0.16.0/src/util/heap/layout/fragmented_mapper.rs
    228
    		 
        #[allow(clippy::cast_ref_to_mut)]
    229
    		 
        #[allow(clippy::mut_from_ref)]
    230
    		 
        unsafe fn mut_self(&self) -> &mut Self {
  • mmtk 0.16.0/src/util/heap/layout/map32.rs
    259
    		 
        #[allow(clippy::cast_ref_to_mut)]
    260
    		 
        #[allow(clippy::mut_from_ref)]
    261
    		 
        unsafe fn mut_self(&self) -> &mut Self {
  • mmtk 0.16.0/src/util/heap/layout/map64.rs
    223
    		 
        #[allow(clippy::cast_ref_to_mut)]
    224
    		 
        #[allow(clippy::mut_from_ref)]
    225
    		 
        unsafe fn mut_self(&self) -> &mut Self {
  • mod_language 0.1.22/src/lib/session.rs
    239
    		 
    impl Session {
    240
    		 
      #[allow(clippy::mut_from_ref)]
    241
    		 
      unsafe fn inner (&self) -> &mut Option<Vec<Message>> {
    245
    		 
      #[allow(clippy::mut_from_ref)]
    246
    		 
      fn vec (&self) -> &mut Vec<Message> {
  • mod_language 0.1.22/src/lib/source.rs
    196
    		 
    impl SourceManager {
    197
    		 
      #[allow(clippy::mut_from_ref)]
    198
    		 
      unsafe fn inner (&self) -> &mut Option<SlotMap<SourceKey, Source>> {
    202
    		 
      #[allow(clippy::mut_from_ref)]
    203
    		 
      fn map (&self) -> &mut SlotMap<SourceKey, Source> {
  • monoio-compat 0.0.9/src/buf.rs
    132
    		 
        /// Return slice for copying data from user space to Buf.
    133
    		 
        #[allow(clippy::mut_from_ref)]
    134
    		 
        pub(crate) fn buf_to_write(&mut self) -> &mut [u8] {
  • napi 2.10.14/src/bindgen_runtime/module_register.rs
    36
    		 
    impl<T> PersistedPerInstanceVec<T> {
    37
    		 
      #[allow(clippy::mut_from_ref)]
    38
    		 
      fn borrow_mut<F>(&self, f: F)
    83
    		 
      #[allow(clippy::mut_from_ref)]
    84
    		 
      pub(crate) fn borrow_mut<F, R>(&self, f: F) -> R
  • nerdondon-hopscotch 2.7.0/src/concurrent_skiplist.rs
    455
    		 
        /// data race because we assert that a lock is around insert. Porting C++ to Rust kinda hurts :/
    456
    		 
        #[allow(clippy::mut_from_ref)]
    457
    		 
        fn head_mut(&self) -> &mut SkipNode<K, V> {
  • ntex-amqp 0.7.0/src/cell.rs
    47
    		 
        #[allow(clippy::mut_from_ref)]
    48
    		 
        pub(crate) fn get_mut(&self) -> &mut T {
  • ntex-util 0.2.0/src/channel/cell.rs
    37
    		 
        #[allow(clippy::mut_from_ref)]
    38
    		 
        pub(super) fn get_mut(&self) -> &mut T {
  • ntex-util 0.2.0/src/channel/pool.rs
    100
    		 
    #[allow(clippy::mut_from_ref)]
    101
    		 
    fn get_inner<T>(inner: &Cell<Slab<Inner<T>>>, token: usize) -> &mut Inner<T> {
  • numpy 0.18.0/src/array.rs
    800
    		 
        #[inline(always)]
    801
    		 
        #[allow(clippy::mut_from_ref)]
    802
    		 
        pub unsafe fn uget_mut<Idx>(&self, index: Idx) -> &mut T
  • numpy 0.18.0/src/datetime.rs
    223
    		 
        #[allow(clippy::mut_from_ref)]
    224
    		 
        unsafe fn get(&self) -> &mut FxHashMap<NPY_DATETIMEUNIT, Py<PyArrayDescr>> {
  • objc2 0.3.0-beta.4/src/rc/autorelease.rs
    107
    		 
        #[allow(clippy::needless_lifetimes)]
    108
    		 
        #[allow(clippy::mut_from_ref)]
    109
    		 
        pub unsafe fn ptr_as_mut<'p, T: ?Sized>(&'p self, ptr: *mut T) -> &'p mut T {
  • objc2 0.3.0-beta.4/src/rc/id.rs
    544
    		 
        #[allow(clippy::needless_lifetimes)]
    545
    		 
        #[allow(clippy::mut_from_ref)]
    546
    		 
        pub fn autorelease<'p>(self, pool: &'p AutoreleasePool) -> &'p mut T {
  • pebble-skip 0.0.1/src/lib.rs
    192
    		 
    	#[allow(clippy::mut_from_ref)]
    193
    		 
    	pub unsafe fn as_mut_unchecked(&self) -> &mut T {
  • pi_cg2d 0.2.0/src/boolean/splay/tree.rs
    251
    		 
        // Messy code ahead
    252
    		 
        #[allow(clippy::mut_from_ref)]
    253
    		 
        fn root_mut(&self) -> &mut Option<Box<Node<K, V>>> {
  • polars-utils 0.26.1/src/mem.rs
    2
    		 
    /// This may break aliasing rules, make sure you are the only owner.
    3
    		 
    #[allow(clippy::mut_from_ref)]
    4
    		 
    pub unsafe fn to_mutable_slice<T: Copy>(s: &[T]) -> &mut [T] {
  • pufferfish 0.1.1/src/assets.rs
    149
    		 
        #[allow(clippy::mut_from_ref)]
    150
    		 
        unsafe fn downcast_mut<T>(&self) -> &mut T {
  • pyo3 0.18.0/src/types/bytearray.rs
    201
    		 
        /// apply to this function as well.
    202
    		 
        #[allow(clippy::mut_from_ref)]
    203
    		 
        pub unsafe fn as_bytes_mut(&self) -> &mut [u8] {
  • python-oxidized-importer 0.9.0/src/importer.rs
    433
    		 
        /// leak outside of a single call site that needs to access it!
    434
    		 
        #[allow(clippy::mut_from_ref)]
    435
    		 
        pub fn get_resources_state_mut<'a>(&self) -> &mut PythonResourcesState<'a, u8> {
  • qcell 0.5.3/src/qcell.rs
    660
    		 
        #[inline]
    661
    		 
        #[allow(clippy::mut_from_ref)]
    662
    		 
        pub fn rw<'a, T: ?Sized>(self: Pin<&'a mut Self>, qc: &'a QCell<T>) -> &'a mut T {
  • r3_core 0.1.4/src/bind.rs
    209
    		 
        // through `UnsafeCell`
    210
    		 
        #[allow(clippy::mut_from_ref)]
    211
    		 
        unsafe fn assume_init_mut(&self) -> &mut T {
  • range-lock 0.2.3/src/rangelock.rs
    177
    		 
        #[inline]
    178
    		 
        #[allow(clippy::mut_from_ref)] // Slices won't overlap. See SAFETY.
    179
    		 
        unsafe fn get_mut_slice(&self, range: &Range<usize>) -> &mut [T] {
  • range-lock 0.2.3/src/reprangelock.rs
    246
    		 
        #[inline]
    247
    		 
        #[allow(clippy::mut_from_ref)] // Slices won't overlap. See SAFETY.
    248
    		 
        unsafe fn get_mut_slice(&self, cycle_offset_slices: usize, cycle: usize) -> &mut [T] {
  • raw_sync 0.1.5/src/locks/mod.rs
    52
    		 
        #[doc(hidden)]
    53
    		 
        #[allow(clippy::mut_from_ref)]
    54
    		 
        unsafe fn get_inner(&self) -> &mut *mut u8;
  • redb 0.12.1/src/tree_store/page_store/mmap.rs
    209
    		 
        #[allow(clippy::mut_from_ref)]
    210
    		 
        unsafe fn write(&self, offset: u64, len: usize) -> Result<PageHackMut> {
  • rend3 0.3.0/src/graph/temp.rs
    20
    		 
        #[allow(clippy::mut_from_ref)]
    21
    		 
        pub fn add<T: 'rpass>(&'rpass self, v: T) -> &'rpass mut T {
  • requiem-service 1.0.5/src/cell.rs
    38
    		 
        #[allow(clippy::mut_from_ref)]
    39
    		 
        pub(crate) unsafe fn get_mut_unsafe(&self) -> &mut T {
  • requiem-utils 1.0.6/src/cell.rs
    44
    		 
        #[allow(clippy::mut_from_ref)]
    45
    		 
        pub(crate) unsafe fn get_mut_unsafe(&self) -> &mut T {
  • rexsgdata 0.12.0/src/utils.rs
    23
    		 
    #[allow(clippy::mut_from_ref)]
    24
    		 
    pub(crate) unsafe fn iovec_as_slice_mut(iov: &iovec) -> &mut [u8] {
  • ringbuf 0.3.2/src/ring_buffer/base.rs
    27
    		 
        /// It is recommended to use [`Consumer::as_slices`](`crate::Consumer::as_slices`) and [`Producer::free_space_as_slices`](`crate::Producer::free_space_as_slices`) instead.
    28
    		 
        #[allow(clippy::mut_from_ref)]
    29
    		 
        unsafe fn data(&self) -> &mut [MaybeUninit<T>];
  • ringbuf 0.3.2/src/ring_buffer/storage.rs
    107
    		 
        /// [`Producer::free_space_as_slices`](`crate::LocalProducer::free_space_as_slices`) instead.
    108
    		 
        #[allow(clippy::mut_from_ref)]
    109
    		 
        #[inline]
  • ringbuf-basedrop 0.1.1/src/ring_buffer.rs
    33
    		 
        }
    34
    		 
        #[allow(clippy::mut_from_ref)]
    35
    		 
        pub unsafe fn get_mut(&self) -> &mut Vec<T> {
  • ringbuffer-spsc 0.1.9/src/lib.rs
    90
    		 
        #[allow(clippy::mut_from_ref)]
    91
    		 
        #[inline]
  • rivulet 0.1.0/src/circular_buffer.rs
    85
    		 
        // Only safe if you can guarantee no other references to the same range
    86
    		 
        #[allow(clippy::mut_from_ref)]
    87
    		 
        pub unsafe fn range_mut(&self, index: u64, len: usize) -> &mut [T] {
  • rivulet 0.1.0/src/splittable.rs
    94
    		 
        /// mutability (such as using `UnsafeCell`).
    95
    		 
        #[allow(clippy::mut_from_ref)]
    96
    		 
        unsafe fn view_mut(&self, index: u64, len: usize) -> &mut [Self::Item];
  • rtbvh 0.6.2/src/utils.rs
    152
    		 
        #[allow(clippy::mut_from_ref)]
    153
    		 
        pub fn as_mut(&self) -> &mut [T] {
    171
    		 
        #[allow(clippy::mut_from_ref)]
    172
    		 
        pub fn range(&self, start: usize, end: usize) -> &mut [T] {
  • rucene 0.1.1/src/core/codec/multi_fields.rs
    767
    		 
        #[allow(clippy::mut_from_ref)]
    768
    		 
        fn current(&self) -> &mut MappingPostingsSub<T> {
  • rucene 0.1.1/src/core/codec/multi_terms.rs
    582
    		 
        #[allow(clippy::mut_from_ref)]
    583
    		 
        fn slice(&self) -> &mut TermIteratorWithSlice<T> {
  • rucene 0.1.1/src/core/codec/postings/blocktree/term_iter_frame.rs
    136
    		 
        #[allow(clippy::mut_from_ref)]
    137
    		 
        fn terms_iter(&self) -> &mut SegmentTermIteratorInner {
  • rucene 0.1.1/src/core/codec/sorter.rs
    455
    		 
        #[allow(clippy::mut_from_ref)]
    456
    		 
        fn comparators(&self) -> &mut [CrossReaderComparatorEnum] {
  • rucene 0.1.1/src/core/codec/stored_fields/stored_fields_reader.rs
    1000
    		 
        #[allow(clippy::mut_from_ref)]
    1001
    		 
        fn reader(&self) -> &mut CompressingStoredFieldsReader {
  • rucene 0.1.1/src/core/codec/term_vectors/term_vector_consumer.rs
    627
    		 
        #[allow(clippy::mut_from_ref)]
    628
    		 
        fn term_vectors_writer(&self) -> &mut TermVectorsConsumer<D, C, MS, MP> {
  • rucene 0.1.1/src/core/index/merge/doc_id_merger.rs
    298
    		 
        #[allow(clippy::mut_from_ref)]
    299
    		 
        fn sub(&self) -> &mut T {
  • rucene 0.1.1/src/core/index/merge/merge_scheduler.rs
    200
    		 
        #[allow(clippy::mut_from_ref)]
    201
    		 
        unsafe fn scheduler_mut(&self, _guard: &MutexGuard<()>) -> &mut ConcurrentMergeSchedulerInner {
  • rucene 0.1.1/src/core/index/merge/merge_state.rs
    162
    		 
        #[allow(clippy::mut_from_ref)]
    163
    		 
        pub fn segment_info(&self) -> &mut SegmentInfo<D, C> {
  • rucene 0.1.1/src/core/index/writer/doc_consumer.rs
    130
    		 
        #[allow(clippy::mut_from_ref)]
    131
    		 
        fn doc_writer(&self) -> &mut DocumentsWriterPerThread<D, C, MS, MP> {
  • safecoin-bucket-map 1.14.3/src/bucket_storage.rs
    154
    		 
        /// return ref to header of item 'ix' in mmapped file
    155
    		 
        #[allow(clippy::mut_from_ref)]
    156
    		 
        fn header_mut_ptr(&self, ix: u64) -> &mut Header {
    239
    		 
        #[allow(clippy::mut_from_ref)]
    240
    		 
        pub fn get_mut<T: Sized>(&self, ix: u64) -> &mut T {
    251
    		 
        #[allow(clippy::mut_from_ref)]
    252
    		 
        pub fn get_mut_cell_slice<T: Sized>(&self, ix: u64, len: u64) -> &mut [T] {
  • safety_breaker 0.1.0/src/lib.rs
    16
    		 
    #[allow(clippy::needless_doctest_main)]
    17
    		 
    #[allow(clippy::mut_from_ref)]
    18
    		 
    #[allow(clippy::needless_lifetimes)]
  • scc 1.1.1/src/hash_table/bucket.rs
    343
    		 
        /// The [`EntryPtr`] must point to a valid entry, and the associated [`Bucket`] must be locked.
    344
    		 
        #[allow(clippy::mut_from_ref)]
    345
    		 
        #[inline]
  • scc 1.1.1/src/hash_table/bucket_array.rs
    95
    		 
        /// Returns a mutable reference to a [`Bucket`] at the given position.
    96
    		 
        #[allow(clippy::mut_from_ref)]
    97
    		 
        #[inline]
  • sciter-rs 0.5.58/src/capi/schandler.rs
    69
    		 
      #[allow(clippy::mut_from_ref)]
    70
    		 
    	pub fn get_data<T>(ptr: &LPVOID) -> &mut T {
  • sciter-rs 0.5.58/src/om.rs
    195
    		 
    	/// Cast the pointer to a managed asset reference.
    196
    		 
    	#[allow(clippy::mut_from_ref)]
    197
    		 
    	pub fn from_raw(thing: &*mut som_asset_t) -> &mut IAsset<T> {
  • sciter-rs 0.5.58/src/value.rs
    574
    		 
      #[allow(clippy::mut_from_ref)]
    575
    		 
    	fn ensure_tmp_mut(&self) -> &mut Value {
  • scrappy-service 0.0.1/src/cell.rs
    38
    		 
        #[allow(clippy::mut_from_ref)]
    39
    		 
        pub(crate) unsafe fn get_mut_unsafe(&self) -> &mut T {
  • scrappy-utils 0.0.1/src/cell.rs
    44
    		 
        #[allow(clippy::mut_from_ref)]
    45
    		 
        pub(crate) unsafe fn get_mut_unsafe(&self) -> &mut T {
  • scylla-rs 0.1.6/src/app/stage/mod.rs
    132
    		 
    impl Reusable {
    133
    		 
        #[allow(clippy::mut_from_ref)]
    134
    		 
        /// Return as mutable sender payload value.
  • scylladb 0.1.11/src/app/stage/mod.rs
    205
    		 
    impl Reusable {
    206
    		 
        #[allow(clippy::mut_from_ref)]
    207
    		 
        /// Return as mutable sender payload value.
  • sharedptr 0.3.4/src/unsafe_def.rs
    10
    		 
        /// panic!! ptr is none
    11
    		 
        #[allow(clippy::mut_from_ref)]
    12
    		 
        unsafe fn get_mut_unchecked(&self)->&mut T;
  • silicon 0.5.1/src/blur.rs
    16
    		 
    impl SharedMutPtr {
    17
    		 
        #[allow(clippy::mut_from_ref)]
    18
    		 
        unsafe fn get(&self) -> &mut [[u8; 4]] {
  • silkworm_err 0.1.0-dev.1/src/lib.rs
    58
    		 
    // same memory locations are ever created.
    59
    		 
    #[allow(clippy::mut_from_ref)]
    60
    		 
    impl ErrorCtx {
  • singleton-cell 0.3.1/src/lib.rs
    164
    		 
         */
    165
    		 
        #[allow(clippy::mut_from_ref)] // Clippy can't see through the Exists
    166
    		 
        #[inline(always)]
  • snarc 0.1.0/src/thread_local.rs
    33
    		 
        #[inline]
    34
    		 
        #[allow(clippy::mut_from_ref)]
    35
    		 
        unsafe fn into_mut_unchecked(ptr: &*mut SnarcBox<T>) -> &mut T {
  • solana-bucket-map 1.14.13/src/bucket_storage.rs
    154
    		 
        /// return ref to header of item 'ix' in mmapped file
    155
    		 
        #[allow(clippy::mut_from_ref)]
    156
    		 
        fn header_mut_ptr(&self, ix: u64) -> &mut Header {
    239
    		 
        #[allow(clippy::mut_from_ref)]
    240
    		 
        pub fn get_mut<T: Sized>(&self, ix: u64) -> &mut T {
    251
    		 
        #[allow(clippy::mut_from_ref)]
    252
    		 
        pub fn get_mut_cell_slice<T: Sized>(&self, ix: u64, len: u64) -> &mut [T] {
  • solana_libra_vm_cache_map 0.0.1-sol5/src/arena.rs
    35
    		 
        // This is safe because it's part of the API design.
    36
    		 
        #[allow(clippy::mut_from_ref)]
    37
    		 
        pub fn alloc(&self, value: T) -> &mut T {
  • static_cell 1.0.0/src/lib.rs
    41
    		 
        #[inline]
    42
    		 
        #[allow(clippy::mut_from_ref)]
    43
    		 
        pub fn init(&'static self, val: T) -> &'static mut T {
    55
    		 
        #[inline]
    56
    		 
        #[allow(clippy::mut_from_ref)]
    57
    		 
        pub fn init_with(&'static self, val: impl FnOnce() -> T) -> &'static mut T {
  • static-rc 0.6.1/src/lift.rs
    150
    		 
    #[allow(clippy::mut_from_ref)]
    151
    		 
    trait LeakBorrow {
  • stm32h7-ethernet 0.3.0/src/ethernet.rs
    362
    		 
        /// function.
    363
    		 
        #[allow(clippy::mut_from_ref)]
    364
    		 
        pub unsafe fn buf_as_slice_mut(&self) -> &mut [u8] {
  • stm32h7xx-hal 0.13.1/src/ethernet/eth.rs
    335
    		 
        /// function.
    336
    		 
        #[allow(clippy::mut_from_ref)]
    337
    		 
        pub unsafe fn buf_as_slice_mut(&self) -> &mut [u8] {
  • storage-proofs-porep 12.0.0/src/stacked/vanilla/memory_handling.rs
    160
    		 
        #[inline]
    161
    		 
        #[allow(clippy::mut_from_ref)]
    162
    		 
        unsafe fn get_mut_bufs(&self) -> &mut [Mmap] {
  • storage-proofs-porep 12.0.0/src/stacked/vanilla/utils.rs
    1
    		 
    #![allow(clippy::mut_from_ref)]
    112
    		 
        #[allow(clippy::mut_from_ref)]
    113
    		 
        unsafe fn slice_mut(&self) -> &mut [u8] {
    121
    		 
        #[allow(clippy::mut_from_ref)]
    122
    		 
        pub unsafe fn slot_mut(&self, slot: usize) -> &mut [u8] {
  • subshell 1.23.1/tools/coverage/range_tree.rs
    21
    		 
      #[allow(clippy::mut_from_ref)]
    22
    		 
      pub fn alloc(&'a self, value: RangeTree<'a>) -> &'a mut RangeTree<'a> {
  • sycamore-reactive 0.8.1/src/arena.rs
    24
    		 
        /// itself.
    25
    		 
        #[allow(clippy::mut_from_ref)] // We return a new reference each time so this is a false-positive.
    26
    		 
        pub fn alloc<T: 'a>(&'a self, value: T) -> &'a mut T {
  • takecell 0.1.1/src/lib.rs
    281
    		 
        /// [`heal`]: TakeCell::heal
    282
    		 
        #[allow(clippy::mut_from_ref)]
    283
    		 
        pub unsafe fn steal(&self) -> &mut T {
  • thingbuf 0.1.3/src/loom.rs
    264
    		 
                // pointer, so we have to do that here.
    265
    		 
                #[allow(clippy::mut_from_ref)]
    266
    		 
                #[inline(always)]
  • three_em_wasm 0.2.0/lib.rs
    476
    		 
    #[allow(clippy::mut_from_ref)]
    477
    		 
    unsafe fn get_backing_store_slice_mut(
  • tokio-timer 0.3.0-alpha.6/src/timer/entry.rs
    127
    		 
        /// Only called by `Registration`
    128
    		 
        #[allow(clippy::mut_from_ref)] // https://github.com/rust-lang/rust-clippy/issues/4281
    129
    		 
        pub(crate) unsafe fn time_mut(&self) -> &mut Time {
  • toolbox-rs 0.1.6/src/unsafe_slice.rs
    27
    		 
        ///  Two threads concurrently writing to the same location will cause UB!!
    28
    		 
        #[allow(clippy::mut_from_ref)]
    29
    		 
        pub unsafe fn get(&self, index: usize) -> &mut T {
  • tudelft-quadrupel 0.1.1/src/mutex.rs
    63
    		 
        /// * You only access this outside of interrupts, as interrupts don't break the mutex guarantees
    64
    		 
        #[allow(clippy::mut_from_ref)]
    65
    		 
        pub unsafe fn no_critical_section_lock(&self) -> &mut T {
  • UWUWUW 0.13.4/src/webview/wkwebview/file_drop.rs
    66
    		 
    #[allow(clippy::mut_from_ref)]
    67
    		 
    unsafe fn get_handler(
  • vela-utils 0.1.0/src/map_cell.rs
    30
    		 
        /// - the value is atomic, so thread-safely update.
    31
    		 
        #[allow(clippy::mut_from_ref)]
    32
    		 
        #[inline(always)]
  • vm-memory 0.10.0/src/mmap.rs
    68
    		 
        /// explicitly accounted for.
    69
    		 
        #[allow(clippy::mut_from_ref)]
    70
    		 
        unsafe fn as_mut_slice(&self) -> &mut [u8];
  • vm-memory 0.10.0/src/mmap_unix.rs
    412
    		 
        // overflow. However, it is possible to alias.
    413
    		 
        #[allow(clippy::mut_from_ref)]
    414
    		 
        unsafe fn as_mut_slice(&self) -> &mut [u8] {
  • vm-memory 0.10.0/src/mmap_windows.rs
    200
    		 
        #[allow(clippy::mut_from_ref)]
    201
    		 
        unsafe fn as_mut_slice(&self) -> &mut [u8] {
  • vm-memory 0.10.0/src/volatile_memory.rs
    544
    		 
        /// recorded using the associated bitmap object.
    545
    		 
        #[allow(clippy::mut_from_ref)]
    546
    		 
        unsafe fn as_mut_slice(&self) -> &mut [u8] {
  • vmcircbuffer 0.0.9/src/double_mapped_buffer/double_mapped_buffer.rs
    49
    		 
        /// Provides raw access to the slice.
    50
    		 
        #[allow(clippy::mut_from_ref)]
    51
    		 
        pub unsafe fn slice_mut(&self) -> &mut [T] {
    75
    		 
        /// [capacity](DoubleMappedBuffer::capacity) of the buffer.
    76
    		 
        #[allow(clippy::mut_from_ref)]
    77
    		 
        pub unsafe fn slice_with_offset_mut(&self, offset: usize) -> &mut [T] {
  • vrp-core 1.19.1/src/utils/mutability.rs
    12
    		 
    /// # Safety
    13
    		 
    #[allow(clippy::mut_from_ref)]
    14
    		 
    pub unsafe fn as_mut<T>(reference: &T) -> &mut T {
  • vrp-core 1.19.1/tests/helpers/utils/random.rs
    37
    		 
        #[allow(clippy::mut_from_ref)]
    38
    		 
        unsafe fn const_cast(&self) -> &mut Self {
  • vst_window 0.3.0/src/platform/macos/event_source.rs
    88
    		 
        /// blocks for the entire duration of each event callback, so this should be fine.
    89
    		 
        #[allow(clippy::mut_from_ref)]
    90
    		 
        fn from_field(obj: &Object) -> &mut EventDelegate {
  • waffles-solana-bucket-map 1.15.0/src/bucket_storage.rs
    154
    		 
        /// return ref to header of item 'ix' in mmapped file
    155
    		 
        #[allow(clippy::mut_from_ref)]
    156
    		 
        fn header_mut_ptr(&self, ix: u64) -> &mut Header {
    239
    		 
        #[allow(clippy::mut_from_ref)]
    240
    		 
        pub fn get_mut<T: Sized>(&self, ix: u64) -> &mut T {
    251
    		 
        #[allow(clippy::mut_from_ref)]
    252
    		 
        pub fn get_mut_cell_slice<T: Sized>(&self, ix: u64, len: u64) -> &mut [T] {
  • waitcache 0.1.3/src/lib.rs
    222
    		 
        #[allow(clippy::mut_from_ref)]
    223
    		 
        #[must_use]
  • waitcell 0.4.1/src/lib.rs
    222
    		 
        #[allow(clippy::mut_from_ref)]
    223
    		 
        #[must_use]
  • wasi-experimental-http 0.10.0/src/lib.rs
    9
    		 
    #[allow(dead_code)]
    10
    		 
    #[allow(clippy::mut_from_ref)]
    11
    		 
    #[allow(clippy::too_many_arguments)]
  • wasmer 3.2.0-alpha.1/src/js/externals/memory_view.rs
    84
    		 
        /// by resizing this Memory.
    85
    		 
        #[allow(clippy::mut_from_ref)]
    86
    		 
        #[doc(hidden)]
  • wasmer 3.2.0-alpha.1/src/sys/externals/memory_view.rs
    76
    		 
        /// by resizing this Memory.
    77
    		 
        #[allow(clippy::mut_from_ref)]
    78
    		 
        #[doc(hidden)]
  • wasmer-asml-fork 2.0.0/src/externals/memory.rs
    115
    		 
        /// by resizing this Memory.
    116
    		 
        #[allow(clippy::mut_from_ref)]
    117
    		 
        pub unsafe fn data_unchecked_mut(&self) -> &mut [u8] {
  • wasmer-near 2.4.0/src/sys/externals/memory.rs
    113
    		 
        /// by resizing this Memory.
    114
    		 
        #[allow(clippy::mut_from_ref)]
    115
    		 
        pub unsafe fn data_unchecked_mut(&self) -> &mut [u8] {
  • wasmer-vm 3.2.0-alpha.1/src/instance/mod.rs
    1402
    		 
    #[allow(clippy::mut_from_ref)]
    1403
    		 
    #[allow(dead_code)]
  • wasmer-vm-near 2.4.0/src/instance/mod.rs
    1216
    		 
    #[allow(clippy::mut_from_ref)]
    1217
    		 
    /// Return a byte-slice view of a memory's data.
  • wasmer-wasi-fl 0.17.1/src/syscalls/mod.rs
    42
    		 
    /// This function is not safe
    43
    		 
    #[allow(clippy::mut_from_ref)]
    44
    		 
    pub(crate) fn get_memory_and_wasi_state(
  • wrflib 0.0.3/src/cx_cocoa.rs
    1280
    		 
    #[allow(clippy::mut_from_ref)]
    1281
    		 
    fn get_cocoa_window(this: &Object) -> &mut CocoaWindow {
    1288
    		 
    #[allow(clippy::mut_from_ref)]
    1289
    		 
    fn get_cocoa_app(this: &Object) -> &mut CocoaApp {
  • wrflib_cef 0.0.3/src/ptr.rs
    72
    		 
        #[allow(clippy::mut_from_ref)]
    73
    		 
        pub fn as_ref(&self) -> &mut T {
  • wry 0.26.0/src/webview/wkwebview/file_drop.rs
    72
    		 
    #[allow(clippy::mut_from_ref)]
    73
    		 
    unsafe fn get_handler(
  • wz 1.0.3/src/builder.rs
    35
    		 
    pub trait Builder {
    36
    		 
        #[allow(clippy::mut_from_ref)]
    37
    		 
        fn build<'bump>(&self, bump: &'bump bumpalo::Bump) -> &'bump mut dyn Counter<Stats>;
  • xdevs 0.2.0/src/modeling/port.rs
    64
    		 
        #[inline]
    65
    		 
        #[allow(clippy::mut_from_ref)]
    66
    		 
        pub(crate) unsafe fn borrow_mut(&self) -> &mut Vec<T> {
  • xilinx-dma 0.0.7/src/dma_buffer.rs
    86
    		 
        #[allow(clippy::mut_from_ref)]
    87
    		 
        pub fn slice<T>(&self) -> &mut [T] {
  • yarte_wasm_app 0.2.1/src/lib.rs
    289
    		 
        #[inline]
    290
    		 
        #[allow(clippy::mut_from_ref)]
    291
    		 
        pub(crate) unsafe fn app(&self) -> &mut A {
  • zallocator 0.3.1/src/lib.rs
    698
    		 
        #[inline(always)]
    699
    		 
        #[allow(clippy::mut_from_ref)]
    700
    		 
        #[cfg(not(feature = "nightly"))]
    706
    		 
        #[inline(always)]
    707
    		 
        #[allow(clippy::mut_from_ref)]
    708
    		 
        #[cfg(feature = "nightly")]
  • zaplib 0.0.3/src/cx_cocoa.rs
    1274
    		 
    #[allow(clippy::mut_from_ref)]
    1275
    		 
    fn get_cocoa_window(this: &Object) -> &mut CocoaWindow {
    1282
    		 
    #[allow(clippy::mut_from_ref)]
    1283
    		 
    fn get_cocoa_app(this: &Object) -> &mut CocoaApp {
  • zaplib_cef 0.0.3/src/ptr.rs
    66
    		 
        #[allow(clippy::mut_from_ref)]
    67
    		 
        pub fn as_ref(&self) -> &mut T {
  • zenoh-buffers 0.7.0-rc/src/zslice.rs
    54
    		 
        #[allow(clippy::missing_safety_doc)]
    55
    		 
        #[allow(clippy::mut_from_ref)]
    56
    		 
        unsafe fn as_mut_slice(&self) -> &mut [u8] {
    245
    		 
        /// undefined behavior in Rust. To use with extreme caution.
    246
    		 
        #[allow(clippy::mut_from_ref)]
    247
    		 
        #[inline]
  • zenoh-link-serial 0.7.0-rc/src/unicast.rs
    87
    		 
        //       are respectively acquired in any read and write operation.
    88
    		 
        #[allow(clippy::mut_from_ref)]
    89
    		 
        fn get_port_mut(&self) -> &mut ZSerial {
  • zenoh-link-tls 0.7.0-rc/src/unicast.rs
    122
    		 
        //       are respectively acquired in any read and write operation.
    123
    		 
        #[allow(clippy::mut_from_ref)]
    124
    		 
        fn get_sock_mut(&self) -> &mut TlsStream<TcpStream> {
  • zeroconf 0.10.5/src/linux/txt_record.rs
    82
    		 
    impl AvahiTxtRecord {
    83
    		 
        #[allow(clippy::mut_from_ref)]
    84
    		 
        fn inner_mut(&self) -> &mut ManagedAvahiStringList {
  • abi_stable_derive 0.11.0/src/arenas.rs
    1
    		 
    #![allow(clippy::mut_from_ref)]
  • kioku 0.3.1/src/lib.rs
    75
    		 
    // sound.  Thus, disabling the lint.
    76
    		 
    #![allow(clippy::mut_from_ref)]
  • pleco_engine 0.1.6/src/lib.rs
    15
    		 
    #![allow(clippy::cast_ptr_alignment)]
    16
    		 
    #![allow(clippy::mut_from_ref)]
    17
    		 
    #![allow(clippy::cognitive_complexity)]
  • tanton_engine 1.0.0/src/lib.rs
    14
    		 
    #![allow(clippy::cast_ptr_alignment)]
    15
    		 
    #![allow(clippy::mut_from_ref)]
    16
    		 
    #![allow(clippy::cognitive_complexity)]
  • vertigo 0.1.1/src/computed/struct_mut/inner_value.rs
    1
    		 
    #![allow(clippy::mut_from_ref)]