• art-tree 0.2.0/src/lib.rs
    288
    		 
            let node = unsafe {
    289
    		 
                #[allow(clippy::cast_ref_to_mut)]
    290
    		 
                &mut *(interim as *const BoxedNode<TypedNode<K, V>> as *mut BoxedNode<TypedNode<K, V>>)
  • atri_bot 0.5.3/src/service/listener.rs
    131
    		 
                // and the node will not remove when listener close
    132
    		 
                #[allow(clippy::cast_ref_to_mut)]
    133
    		 
                let list = unsafe { &mut *(list as *const _ as *mut LimitedListeners) };
  • atri_qq 0.2.0/src/service/listeners.rs
    116
    		 
                // and the node will not remove when listener close
    117
    		 
                #[allow(clippy::cast_ref_to_mut)]
    118
    		 
                let list = unsafe { &mut *(list as *const _ as *mut LimitedListeners) };
  • egui-d3d11 0.8.0/src/app.rs
    216
    		 
        /// Present call. Should be called once per original present call, before or inside of hook.
    217
    		 
        #[allow(clippy::cast_ref_to_mut)]
    218
    		 
        pub fn present(&self, swap_chain: &IDXGISwapChain) {
  • gemachain-runtime 1.8.2/src/append_vec.rs
    594
    		 
        impl<'a> StoredAccountMeta<'a> {
    595
    		 
            #[allow(clippy::cast_ref_to_mut)]
    596
    		 
            fn set_data_len_unsafe(&self, new_data_len: u64) {
    610
    		 
            #[allow(clippy::cast_ref_to_mut)]
    611
    		 
            fn set_executable_as_byte(&self, new_executable_byte: u8) {
  • grpcio 0.12.0/src/buf.rs
    264
    		 
        /// A buffer, which length is 1, is allocated for the slice.
    265
    		 
        #[allow(clippy::cast_ref_to_mut)]
    266
    		 
        fn from(s: &'a GrpcSlice) -> GrpcByteBuffer {
  • knife-util 0.1.7/src/any/value.rs
    82
    		 
        /// 替换数据，需指定数据类型V
    83
    		 
        #[allow(clippy::cast_ref_to_mut)]
    84
    		 
        pub fn replace_with_write<V, F>(&self, v: V, f: F)
    132
    		 
        /// 取出数据，只能执行一次
    133
    		 
        #[allow(clippy::cast_ref_to_mut)]
    134
    		 
        pub fn take_with_read<V, F>(&self, f: F) -> V
  • knife-util 0.1.7/src/template/render.rs
    72
    		 
    #[allow(clippy::cast_ref_to_mut)]
    73
    		 
    fn render_template_recursion_inner(
  • knife-util 0.1.7/src/value_type/main.rs
    204
    		 
        #[allow(clippy::cast_ref_to_mut)]
    205
    		 
        pub fn as_object_mut(&self) -> Result<&mut BTreeMap<String, Value>> {
  • localize 0.2.0/src/cache.rs
    70
    		 
        #[allow(unused, clippy::cast_ref_to_mut)]
    71
    		 
        pub fn look_up_or_cache<'w>(&mut self, tag: &'w str, sources: &Sources) -> crate::Result<&Locale>
  • may_queue 0.1.16/src/mpsc_seg_queue.rs
    115
    		 
        fn load_index(&self) -> usize {
    116
    		 
            #[allow(clippy::cast_ref_to_mut)]
    117
    		 
            let index = unsafe { &mut *(&self.index as *const _ as *mut AtomicUsize) };
    121
    		 
        fn set_index(&self, index: usize) {
    122
    		 
            #[allow(clippy::cast_ref_to_mut)]
    123
    		 
            let idx = unsafe { &mut *(&self.index as *const _ as *mut AtomicUsize) };
    127
    		 
        fn set_block(&self, block: *mut Block<T>) {
    128
    		 
            #[allow(clippy::cast_ref_to_mut)]
    129
    		 
            let blk = unsafe { &mut *(&self.block as *const _ as *mut AtomicPtr<Block<T>>) };
  • memflex 0.4.1/src/macros/cell.rs
    18
    		 
        #[allow(clippy::cast_ref_to_mut)]
    19
    		 
        #[inline]
  • miden-assembly 0.3.0/src/assembler/mod.rs
    155
    		 
        /// Compiles all procedures in the specified module and adds them to the procedure cache.
    156
    		 
        #[allow(clippy::cast_ref_to_mut)]
    157
    		 
        fn compile_module(
  • mmtk 0.16.0/src/policy/sft_map.rs
    159
    		 
            // FIXME: We need a safe implementation.
    160
    		 
            #[allow(clippy::cast_ref_to_mut)]
    161
    		 
            #[allow(clippy::mut_from_ref)]
    365
    		 
            // FIXME: We need a safe implementation.
    366
    		 
            #[allow(clippy::cast_ref_to_mut)]
    367
    		 
            #[allow(clippy::mut_from_ref)]
    459
    		 
            // FIXME: We need a safe implementation.
    460
    		 
            #[allow(clippy::cast_ref_to_mut)]
    461
    		 
            #[allow(clippy::mut_from_ref)]
  • mmtk 0.16.0/src/scheduler/gc_work.rs
    43
    		 
            // We assume this is the only running work packet that accesses plan at the point of execution
    44
    		 
            #[allow(clippy::cast_ref_to_mut)]
    45
    		 
            let plan_mut: &mut C::PlanType = unsafe { &mut *(self.plan as *const _ as *mut _) };
    112
    		 
            // We assume this is the only running work packet that accesses plan at the point of execution
    113
    		 
            #[allow(clippy::cast_ref_to_mut)]
    114
    		 
            let plan_mut: &mut C::PlanType = unsafe { &mut *(self.plan as *const _ as *mut _) };
  • mmtk 0.16.0/src/util/heap/freelistpageresource.rs
    98
    		 
            // FIXME: We need a safe implementation
    99
    		 
            #[allow(clippy::cast_ref_to_mut)]
    100
    		 
            let self_mut: &mut Self = unsafe { &mut *(self as *const _ as *mut _) };
    242
    		 
            // FIXME: We need a safe implementation
    243
    		 
            #[allow(clippy::cast_ref_to_mut)]
    244
    		 
            let self_mut: &mut Self = unsafe { &mut *(self as *const _ as *mut _) };
    328
    		 
            // FIXME
    329
    		 
            #[allow(clippy::cast_ref_to_mut)]
    330
    		 
            let me = unsafe { &mut *(self as *const _ as *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)]
  • mmtk 0.16.0/src/util/heap/layout/map32.rs
    197
    		 
                if let Some(fl) = fl {
    198
    		 
                    #[allow(clippy::cast_ref_to_mut)]
    199
    		 
                    let fl_mut: &mut CommonFreeListPageResource =
  • monoio 0.0.9/src/io/util/split.rs
    64
    		 
    #[allow(clippy::cast_ref_to_mut)]
    65
    		 
    impl<'t, Inner> AsyncReadRent for ReadHalf<'t, Inner>
    90
    		 
    #[allow(clippy::cast_ref_to_mut)]
    91
    		 
    impl<'t, Inner> AsyncWriteRent for WriteHalf<'t, Inner>
  • monoio 0.0.9/src/net/tcp/split.rs
    14
    		 
    #[allow(clippy::cast_ref_to_mut)]
    15
    		 
    impl<'t> AsReadFd for TcpReadHalf<'t> {
    42
    		 
    #[allow(clippy::cast_ref_to_mut)]
    43
    		 
    impl<'t> AsWriteFd for TcpWriteHalf<'t> {
  • monoio 0.0.9/src/net/unix/split.rs
    15
    		 
    #[allow(clippy::cast_ref_to_mut)]
    16
    		 
    impl<'t> AsReadFd for UnixReadHalf<'t> {
    23
    		 
    #[allow(clippy::cast_ref_to_mut)]
    24
    		 
    impl<'t> AsWriteFd for UnixWriteHalf<'t> {
  • monoio-compat 0.0.9/src/safe_wrapper.rs
    81
    		 
                    // we must leak the stream
    82
    		 
                    #[allow(clippy::cast_ref_to_mut)]
    83
    		 
                    let stream = unsafe { &mut *(&this.stream as *const T as *mut T) };
    147
    		 
            // we must leak the stream
    148
    		 
            #[allow(clippy::cast_ref_to_mut)]
    149
    		 
            let stream = unsafe { &mut *(&this.stream as *const T as *mut T) };
    186
    		 
            if !this.flush_fut.armed() {
    187
    		 
                #[allow(clippy::cast_ref_to_mut)]
    188
    		 
                let stream = unsafe { &mut *(&this.stream as *const T as *mut T) };
    213
    		 
            if !this.shutdown_fut.armed() {
    214
    		 
                #[allow(clippy::cast_ref_to_mut)]
    215
    		 
                let stream = unsafe { &mut *(&this.stream as *const T as *mut T) };
  • monoio-compat 0.0.9/src/tcp_unsafe.rs
    85
    		 
                // we must leak the stream
    86
    		 
                #[allow(clippy::cast_ref_to_mut)]
    87
    		 
                let stream = unsafe { &mut *(&this.stream as *const TcpStream as *mut TcpStream) };
    117
    		 
                // we must leak the stream
    118
    		 
                #[allow(clippy::cast_ref_to_mut)]
    119
    		 
                let stream = unsafe { &mut *(&this.stream as *const TcpStream as *mut TcpStream) };
    140
    		 
            if !this.flush_fut.armed() {
    141
    		 
                #[allow(clippy::cast_ref_to_mut)]
    142
    		 
                let stream = unsafe { &mut *(&this.stream as *const TcpStream as *mut TcpStream) };
    154
    		 
            if !this.shutdown_fut.armed() {
    155
    		 
                #[allow(clippy::cast_ref_to_mut)]
    156
    		 
                let stream = unsafe { &mut *(&this.stream as *const TcpStream as *mut TcpStream) };
  • mun_runtime 0.4.0/src/lib.rs
    661
    		 
        {
    662
    		 
            #[allow(clippy::cast_ref_to_mut)]
    663
    		 
            let runtime = &mut *(runtime as *const Runtime as *mut Runtime);
  • nib 0.0.8/src/renderer.rs
    118
    		 
                        let ms: &mut MySection = unsafe {
    119
    		 
                            #[allow(clippy::cast_ref_to_mut)]
    120
    		 
                            &mut *(&**s as *const Section as *mut MySection)
  • nut 0.1.1/src/bucket/cursor.rs
    45
    		 
            unsafe {
    46
    		 
                #[allow(clippy::cast_ref_to_mut)]
    47
    		 
                &mut *((&*self.bucket) as *const Bucket as *mut Bucket)
  • nut 0.1.1/src/page/mod.rs
    189
    		 
            unsafe {
    190
    		 
                #[allow(clippy::cast_ref_to_mut)]
    191
    		 
                &mut *(self.branch_page_elements() as *const [BranchPageElement]
    206
    		 
            unsafe {
    207
    		 
                #[allow(clippy::cast_ref_to_mut)]
    208
    		 
                &mut *(self.branch_page_element(index) as *const BranchPageElement
    224
    		 
            unsafe {
    225
    		 
                #[allow(clippy::cast_ref_to_mut)]
    226
    		 
                &mut *(self.leaf_page_elements() as *const [LeafPageElement]
    241
    		 
            unsafe {
    242
    		 
                #[allow(clippy::cast_ref_to_mut)]
    243
    		 
                &mut *(self.leaf_page_element(index) as *const LeafPageElement as *mut LeafPageElement)
    257
    		 
            unsafe {
    258
    		 
                #[allow(clippy::cast_ref_to_mut)]
    259
    		 
                &mut *(self.meta() as *const Meta as *mut Meta)
  • rusty_spine 0.5.0/src/atlas.rs
    233
    		 
                    self.page = unsafe { (*self.page).next };
    234
    		 
                    #[allow(clippy::cast_ref_to_mut)]
    235
    		 
                    Some(CTmpMut::new(
    410
    		 
                    self.region = unsafe { (*self.region).next };
    411
    		 
                    #[allow(clippy::cast_ref_to_mut)]
    412
    		 
                    Some(CTmpMut::new(
  • safecoin-runtime 1.14.3/src/append_vec.rs
    584
    		 
        impl<'a> StoredAccountMeta<'a> {
    585
    		 
            #[allow(clippy::cast_ref_to_mut)]
    586
    		 
            fn set_data_len_unsafe(&self, new_data_len: u64) {
    600
    		 
            #[allow(clippy::cast_ref_to_mut)]
    601
    		 
            fn set_executable_as_byte(&self, new_executable_byte: u8) {
  • safety_breaker 0.1.0/src/lib.rs
    27
    		 
    #[allow(clippy::needless_lifetimes)]
    28
    		 
    #[allow(clippy::cast_ref_to_mut)]
    29
    		 
    impl<T: ?Sized> ForceMut for T {
  • serde_v8 0.79.0/magic/v8slice.rs
    53
    		 
      fn as_slice_mut(&mut self) -> &mut [u8] {
    54
    		 
        #[allow(clippy::cast_ref_to_mut)]
    55
    		 
        // SAFETY: v8::SharedRef<v8::BackingStore> is similar to Arc<[u8]>,
  • solana-runtime 1.14.13/src/append_vec.rs
    584
    		 
        impl<'a> StoredAccountMeta<'a> {
    585
    		 
            #[allow(clippy::cast_ref_to_mut)]
    586
    		 
            fn set_data_len_unsafe(&self, new_data_len: u64) {
    600
    		 
            #[allow(clippy::cast_ref_to_mut)]
    601
    		 
            fn set_executable_as_byte(&self, new_executable_byte: u8) {
  • starlark 0.8.0/src/values/trace.rs
    78
    		 
                // so things like Hash/Ord/Eq will work the same
    79
    		 
                #[allow(clippy::cast_ref_to_mut)]
    80
    		 
                let k_mut = unsafe { &mut *(k as *const K as *mut K) };
  • starlark 0.8.0/src/values/types/enumeration.rs
    138
    		 
            let t = typ.downcast_ref::<EnumType>().unwrap();
    139
    		 
            #[allow(clippy::cast_ref_to_mut)]
    140
    		 
            unsafe {
  • waffles-solana-runtime 1.15.0/src/append_vec.rs
    746
    		 
        impl<'a> StoredAccountMeta<'a> {
    747
    		 
            #[allow(clippy::cast_ref_to_mut)]
    748
    		 
            fn set_data_len_unsafe(&self, new_data_len: u64) {
    762
    		 
            #[allow(clippy::cast_ref_to_mut)]
    763
    		 
            fn set_executable_as_byte(&self, new_executable_byte: u8) {
  • patricia_tree 0.5.5/src/lib.rs
    25
    		 
    #![warn(missing_docs)]
    26
    		 
    #![allow(clippy::cast_ptr_alignment, clippy::cast_ref_to_mut)]