• arcon 0.2.1/src/index/hash_table/generic.rs
    25
    		 
    // We only care about the highest bit of each byte for the mask.
    26
    		 
    #[allow(clippy::cast_possible_truncation, clippy::unnecessary_cast)]
    27
    		 
    pub const BITMASK_MASK: BitMaskWord = 0x8080_8080_8080_8080_u64 as GroupWord;
  • autocxx-bindgen 0.62.1/clang.rs
    659
    		 
                if self.kind() == CXCursor_EnumConstantDecl {
    660
    		 
                    #[allow(clippy::unnecessary_cast)]
    661
    		 
                    Some(clang_getEnumConstantDeclValue(self.x) as i64)
    673
    		 
                if self.kind() == CXCursor_EnumConstantDecl {
    674
    		 
                    #[allow(clippy::unnecessary_cast)]
    675
    		 
                    Some(clang_getEnumConstantDeclUnsignedValue(self.x) as u64)
    2186
    		 
            }
    2187
    		 
            #[allow(clippy::unnecessary_cast)]
    2188
    		 
            Some(value as i64)
  • bindgen 0.63.0/clang.rs
    659
    		 
                if self.kind() == CXCursor_EnumConstantDecl {
    660
    		 
                    #[allow(clippy::unnecessary_cast)]
    661
    		 
                    Some(clang_getEnumConstantDeclValue(self.x) as i64)
    673
    		 
                if self.kind() == CXCursor_EnumConstantDecl {
    674
    		 
                    #[allow(clippy::unnecessary_cast)]
    675
    		 
                    Some(clang_getEnumConstantDeclUnsignedValue(self.x) as u64)
    2171
    		 
            }
    2172
    		 
            #[allow(clippy::unnecessary_cast)]
    2173
    		 
            Some(value as i64)
  • birli 0.8.0/src/corrections.rs
    859
    		 
        #[test]
    860
    		 
        #[allow(clippy::unnecessary_cast)]
    861
    		 
        fn test_cable_length_corrections_ord() {
    1001
    		 
        #[test]
    1002
    		 
        #[allow(clippy::unnecessary_cast)]
    1003
    		 
        fn test_geometric_corrections_ord() {
  • c-ares 7.6.0/src/a.rs
    95
    		 
        pub fn ttl(self) -> i32 {
    96
    		 
            #[allow(clippy::unnecessary_cast)]
    97
    		 
            let ttl = self.addrttl.ttl as i32;
  • c-ares 7.6.0/src/aaaa.rs
    97
    		 
        pub fn ttl(self) -> i32 {
    98
    		 
            #[allow(clippy::unnecessary_cast)]
    99
    		 
            let ttl = self.addr6ttl.ttl as i32;
  • c-ares 7.6.0/src/uri.rs
    122
    		 
        pub fn ttl(self) -> i32 {
    123
    		 
            #[allow(clippy::unnecessary_cast)]
    124
    		 
            let ttl = self.uri_reply.ttl as i32;
  • cec-rs 7.0.0/src/lib.rs
    105
    		 
        #[allow(clippy::unnecessary_cast)]
    106
    		 
        #[test]
    122
    		 
        #[allow(clippy::unnecessary_cast)]
    123
    		 
        #[test]
  • close_fds 0.3.2/src/closefds/close.rs
    107
    		 
        #[allow(clippy::unnecessary_cast)]
    108
    		 
        if libc::syscall(
  • dashmap-shard 0.1.1/src/raw/generic.rs
    25
    		 
        clippy::cast_possible_truncation,
    26
    		 
        clippy::unnecessary_cast,
    27
    		 
    )]
  • deno_ffi 0.73.0/turbocall.rs
    922
    		 
      #[allow(clippy::unnecessary_cast)]
    923
    		 
      fn save_frame_record(&mut self) {
    935
    		 
      #[allow(clippy::unnecessary_cast)]
    936
    		 
      fn recover_frame_record(&mut self) {
  • dmsort 1.0.2/tests/benchmark.rs
    23
    		 
                if rng.gen::<f32>() < disorder_factor {
    24
    		 
                    #[allow(clippy::unnecessary_cast)]
    25
    		 
                    rng.gen_range(0 as Integer, length as Integer)
  • doryen-extra 0.2.1/src/random/algorithms.rs
    38
    		 
    const RAND_DIV: f32 = 1.0 / 0xffff_ffff_u32 as f32; // u32::MAX
    39
    		 
    #[allow(clippy::unnecessary_cast)]
    40
    		 
    const RAND_DIV_DOUBLE: f64 = 1.0 / 0xffff_ffff_u32 as f64; // u32::MAX
  • drm 0.8.0/src/control/mod.rs
    887
    		 
                            ),
    888
    		 
                            #[allow(clippy::unnecessary_cast)]
    889
    		 
                            crtc: from_u32(vblank_event.crtc_id as u32).unwrap(),
  • exacl 0.10.0/src/flag.rs
    56
    		 
        const fn as_u32(self) -> u32 {
    57
    		 
            #[allow(clippy::unnecessary_cast)]
    58
    		 
            return self.bits as u32;
  • fclones 0.29.3/src/file.rs
    361
    		 
            let inode_id = metadata.inode_id();
    362
    		 
            #[allow(clippy::unnecessary_cast)] // cast needed when inode_id > 64 bits on some platforms
    363
    		 
            Ok(FileInfo {
  • fundsp 0.12.0/src/granular.rs
    53
    		 
    #[allow(clippy::unnecessary_cast)]
    54
    		 
    #[duplicate_item(
    181
    		 
    #[allow(clippy::unnecessary_cast)]
    182
    		 
    #[duplicate_item(
  • fundsp 0.12.0/src/sequencer.rs
    189
    		 
    #[allow(clippy::unnecessary_cast)]
    190
    		 
    #[duplicate_item(
    328
    		 
    #[allow(clippy::unnecessary_cast)]
    329
    		 
    #[duplicate_item(
  • fundsp 0.12.0/src/wave.rs
    97
    		 
    #[allow(clippy::unnecessary_cast)]
    98
    		 
    #[duplicate_item(
  • fuzzcheck 0.12.1/src/bitset.rs
    304
    		 
            }
    305
    		 
            #[allow(clippy::unnecessary_cast)]
    306
    		 
            let t = self.bitset & (0 as Block).wrapping_sub(self.bitset);
  • gdnative-core 0.11.3/src/core_types/error.rs
    3
    		 
    /// Error codes used in various Godot APIs.
    4
    		 
    #[allow(clippy::unnecessary_cast)] // False positives: casts necessary for cross-platform
    5
    		 
    #[derive(Copy, Clone, Debug, PartialEq, Eq)]
    68
    		 
        #[doc(hidden)]
    69
    		 
        #[allow(clippy::unnecessary_cast)] // False positives: casts necessary for cross-platform
    70
    		 
        pub unsafe fn result_from_sys(err: sys::godot_error) -> Result<(), Self> {
  • gdnative-core 0.11.3/src/core_types/variant.rs
    168
    		 
    impl VariantType {
    169
    		 
        #[allow(clippy::unnecessary_cast)] // False positives: casts necessary for cross-platform
    170
    		 
        #[doc(hidden)]
    186
    		 
    #[allow(clippy::unnecessary_cast)] // False positives: casts necessary for cross-platform
    187
    		 
    #[repr(u32)]
    202
    		 
    impl CallError {
    203
    		 
        #[allow(clippy::unnecessary_cast)] // False positives: casts necessary for cross-platform
    204
    		 
        #[inline]
    235
    		 
    /// Godot variant operator kind.
    236
    		 
    #[allow(clippy::unnecessary_cast)] // False positives: casts necessary for cross-platform
    237
    		 
    #[repr(u32)]
    276
    		 
    #[allow(clippy::unnecessary_cast)] // False positives: casts necessary for cross-platform
    277
    		 
    impl VariantOperator {
  • gdnative-core 0.11.3/src/core_types/vector3.rs
    18
    		 
    #[allow(clippy::unnecessary_cast)] // False positives: casts necessary for cross-platform
    19
    		 
    #[derive(Copy, Clone, Debug, PartialEq, Eq)]
  • gdnative-sys 0.11.3/src/lib.rs
    38
    		 
    #[allow(clippy::unnecessary_cast)] // False positives: casts necessary for cross-platform
    39
    		 
    unsafe fn find_version(
  • glib 0.16.7/src/char.rs
    58
    		 
        #[allow(clippy::unnecessary_cast)]
    59
    		 
        fn try_from(c: char) -> Result<Char, Self::Error> {
    70
    		 
    impl From<u8> for Char {
    71
    		 
        #[allow(clippy::unnecessary_cast)]
    72
    		 
        fn from(c: u8) -> Char {
    77
    		 
    impl From<Char> for u8 {
    78
    		 
        #[allow(clippy::unnecessary_cast)]
    79
    		 
        fn from(c: Char) -> u8 {
    131
    		 
        #[allow(clippy::unnecessary_cast)]
    132
    		 
        fn try_from(c: char) -> Result<UChar, Self::Error> {
    143
    		 
    impl From<u8> for UChar {
    144
    		 
        #[allow(clippy::unnecessary_cast)]
    145
    		 
        fn from(c: u8) -> UChar {
  • glib 0.16.7/src/translate.rs
    2674
    		 
                type Error = GlibNoneError;
    2675
    		 
                #[allow(clippy::unnecessary_cast)]
    2676
    		 
                unsafe fn try_from_glib(val: libc::c_uint) -> Result<Self, GlibNoneError> {
  • hashbrown 0.13.2/src/raw/generic.rs
    25
    		 
    // We only care about the highest bit of each byte for the mask.
    26
    		 
    #[allow(clippy::cast_possible_truncation, clippy::unnecessary_cast)]
    27
    		 
    pub const BITMASK_MASK: BitMaskWord = 0x8080_8080_8080_8080_u64 as GroupWord;
  • hashbrown_tstd 0.7.1/src/raw/generic.rs
    23
    		 
    // We only care about the highest bit of each byte for the mask.
    24
    		 
    #[allow(clippy::cast_possible_truncation, clippy::unnecessary_cast)]
    25
    		 
    pub const BITMASK_MASK: BitMaskWord = 0x8080_8080_8080_8080_u64 as GroupWord;
  • horde 0.1.1/src/raw/generic.rs
    24
    		 
    // We only care about the highest bit of each byte for the mask.
    25
    		 
    #[allow(clippy::cast_possible_truncation, clippy::unnecessary_cast)]
    26
    		 
    pub const BITMASK_MASK: BitMaskWord = 0x8080_8080_8080_8080_u64 as GroupWord;
  • ironworks 0.4.1/src/file/eqdp.rs
    113
    		 
    #[allow(dead_code, clippy::identity_op, clippy::unnecessary_cast)]
    114
    		 
    mod bitfield {
  • itron 0.1.9/src/task.rs
    1501
    		 
            impl IntoProcessorSet for Processor {
    1502
    		 
                #[allow(clippy::unnecessary_cast)] // <https://github.com/rust-lang/rust-clippy/issues/6923>
    1503
    		 
                #[doc(hidden)]
  • json-decode 0.6.0/src/lib.rs
    166
    		 
        #[test]
    167
    		 
        #[allow(clippy::unnecessary_cast)]
    168
    		 
        fn decoding_integers() {
  • lawn-9p 0.1.1/src/backend/libc.rs
    209
    		 
    #[cfg(any(target_os = "linux", target_os = "macos"))]
    210
    		 
    #[allow(clippy::unnecessary_cast)]
    211
    		 
    fn major_minor(dev: u64) -> (u32, u32) {
    517
    		 
        #[cfg(target_os = "linux")]
    518
    		 
        #[allow(clippy::unnecessary_cast)]
    519
    		 
        fn fstatat_dev_ino<F: AsRawFd>(&self, f: &F, path: &[u8], follow: bool) -> Result<(u64, u64)> {
    534
    		 
        #[cfg(not(target_os = "linux"))]
    535
    		 
        #[allow(clippy::unnecessary_cast)]
    536
    		 
        fn fstatat_dev_ino<F: AsRawFd>(&self, f: &F, path: &[u8], follow: bool) -> Result<(u64, u64)> {
    551
    		 
        #[cfg(target_os = "linux")]
    552
    		 
        #[allow(clippy::unnecessary_cast)]
    553
    		 
        fn ftruncate<F: AsRawFd>(f: &F, size: u64) -> Result<()> {
    558
    		 
        #[cfg(not(target_os = "linux"))]
    559
    		 
        #[allow(clippy::unnecessary_cast)]
    560
    		 
        fn ftruncate<F: AsRawFd>(f: &F, size: u64) -> Result<()> {
  • libafl_qemu 0.9.0/src/drcov.rs
    209
    		 
                    // GuestAddress is u32 for 32 bit guests
    210
    		 
                    #[allow(clippy::unnecessary_cast)]
    211
    		 
                    Some(id as u64)
  • libafl_qemu 0.9.0/src/edges.rs
    194
    		 
                // GuestAddress is u32 for 32 bit guests
    195
    		 
                #[allow(clippy::unnecessary_cast)]
    196
    		 
                Some(id as u64)
    231
    		 
        // GuestAddress is u32 for 32 bit guests
    232
    		 
        #[allow(clippy::unnecessary_cast)]
    233
    		 
        Some((hash_me(src as u64) ^ hash_me(dest as u64)) & (unsafe { EDGES_MAP_PTR_NUM } as u64 - 1))
    259
    		 
        // GuestAddress is u32 for 32 bit guests
    260
    		 
        #[allow(clippy::unnecessary_cast)]
    261
    		 
        Some(pc as u64)
    273
    		 
        // GuestAddress is u32 for 32 bit guests
    274
    		 
        #[allow(clippy::unnecessary_cast)]
    275
    		 
        Some(hash_me(pc as u64))
  • libnotcurses-sys 3.7.1/src/cell/methods.rs
    12
    		 
        #[inline]
    13
    		 
        #[allow(clippy::unnecessary_cast)]
    14
    		 
        pub fn from_char7b(ch: char) -> NcResult<Self> {
  • libnotcurses-sys 3.7.1/src/cell/reimplemented.rs
    258
    		 
    #[inline]
    259
    		 
    #[allow(clippy::unnecessary_cast)]
    260
    		 
    pub const fn nccell_fg_palindex(cell: &NcCell) -> NcPaletteIndex {
    267
    		 
    #[inline]
    268
    		 
    #[allow(clippy::unnecessary_cast)]
    269
    		 
    pub const fn nccell_bg_palindex(cell: &NcCell) -> NcPaletteIndex {
  • libnotcurses-sys 3.7.1/src/channel/reimplemented.rs
    671
    		 
    #[inline]
    672
    		 
    #[allow(clippy::unnecessary_cast)]
    673
    		 
    pub fn ncchannels_set_fg_palindex(channels: &mut NcChannels_u64, index: impl Into<NcPaletteIndex>) {
  • libnotcurses-sys 3.7.1/src/pixel/reimplemented.rs
    6
    		 
    #[inline]
    7
    		 
    #[allow(clippy::unnecessary_cast)]
    8
    		 
    pub const fn ncpixel(red: u8, green: u8, blue: u8) -> NcPixel_u32 {
  • littlefs2 0.3.2/src/path.rs
    209
    		 
                // NOTE(allow) cast is necessary on some architectures (e.g. x86)
    210
    		 
                #[allow(clippy::unnecessary_cast)]
    211
    		 
                "/" => {
  • marlu 0.8.0/src/selection.rs
    588
    		 
        #[test]
    589
    		 
        #[allow(clippy::unnecessary_cast)]
    590
    		 
        /// We expect coarse channel 0 ( fine channels 0,1 ) to be the same as in `get_mwa_ord_context`,
    778
    		 
        #[test]
    779
    		 
        #[allow(clippy::unnecessary_cast)]
    780
    		 
        fn test_read_mwalib_mwa_legacy() {
  • metaplex 0.0.1/src/processor/deprecated_populate_participation_printing_account.rs
    69
    		 
    #[allow(clippy::unnecessary_cast)]
    70
    		 
    #[allow(clippy::absurd_extreme_comparisons)]
  • metaplex 0.0.1/src/processor/redeem_participation_bid.rs
    233
    		 
    #[allow(clippy::unnecessary_cast)]
    234
    		 
    #[allow(clippy::absurd_extreme_comparisons)]
  • mpl-metaplex 0.1.0/src/processor/deprecated_populate_participation_printing_account.rs
    68
    		 
    #[allow(clippy::unnecessary_cast)]
    69
    		 
    #[allow(clippy::absurd_extreme_comparisons)]
  • mpl-metaplex 0.1.0/src/processor/redeem_participation_bid.rs
    228
    		 
    #[allow(clippy::unnecessary_cast)]
    229
    		 
    #[allow(clippy::absurd_extreme_comparisons)]
  • mprober-lib 0.1.10/src/volume/volume.rs
    95
    		 
                        #[allow(clippy::unnecessary_cast)]
    96
    		 
                        (
  • nix 0.26.2/src/dir.rs
    220
    		 
        // The cast is not unnecessary on all platforms.
    221
    		 
        #[allow(clippy::unnecessary_cast)]
    222
    		 
        pub fn ino(&self) -> u64 {
  • nix 0.26.2/src/sys/statfs.rs
    465
    		 
        #[cfg_attr(docsrs, doc(cfg(all())))]
    466
    		 
        #[allow(clippy::unnecessary_cast)] // Not unnecessary on all arches
    467
    		 
        pub fn flags(&self) -> MntFlags {
    794
    		 
        // The cast is not unnecessary on all platforms.
    795
    		 
        #[allow(clippy::unnecessary_cast)]
    796
    		 
        fn assert_fs_equals(fs: Statfs, vfs: Statvfs) {
    843
    		 
        // The cast is not unnecessary on all platforms.
    844
    		 
        #[allow(clippy::unnecessary_cast)]
    845
    		 
        fn assert_fs_equals_strict(fs: Statfs, vfs: Statvfs) {
  • nix 0.26.2/src/sys/sysinfo.rs
    33
    		 
        // The cast is not unnecessary on all platforms.
    34
    		 
        #[allow(clippy::unnecessary_cast)]
    35
    		 
        pub fn uptime(&self) -> Duration {
    69
    		 
        // The cast is not unnecessary on all platforms.
    70
    		 
        #[allow(clippy::unnecessary_cast)]
    71
    		 
        fn scale_mem(&self, units: mem_blocks_t) -> u64 {
  • nix 0.26.2/src/sys/time.rs
    307
    		 
        // The cast is not unnecessary on all platforms.
    308
    		 
        #[allow(clippy::unnecessary_cast)]
    309
    		 
        fn num_seconds(&self) -> i64 {
    325
    		 
        // The cast is not unnecessary on all platforms.
    326
    		 
        #[allow(clippy::unnecessary_cast)]
    327
    		 
        fn num_nanoseconds(&self) -> i64 {
    554
    		 
        // The cast is not unnecessary on all platforms.
    555
    		 
        #[allow(clippy::unnecessary_cast)]
    556
    		 
        fn num_seconds(&self) -> i64 {
    568
    		 
        // The cast is not unnecessary on all platforms.
    569
    		 
        #[allow(clippy::unnecessary_cast)]
    570
    		 
        fn num_microseconds(&self) -> i64 {
  • objc-sys 0.2.0-beta.3/src/constants.rs
    8
    		 
    /// The equivalent of `true` for Objective-C's [`BOOL`][`super::BOOL`] type.
    9
    		 
    #[allow(clippy::unnecessary_cast)]
    10
    		 
    pub const YES: BOOL = true as BOOL; // true -> 1
    12
    		 
    /// The equivalent of `false` for Objective-C's [`BOOL`][`super::BOOL`] type.
    13
    		 
    #[allow(clippy::unnecessary_cast)]
    14
    		 
    pub const NO: BOOL = false as BOOL; // false -> 0
  • openssl 0.10.45/src/asn1.rs
    514
    		 
    impl Asn1IntegerRef {
    515
    		 
        #[allow(missing_docs, clippy::unnecessary_cast)]
    516
    		 
        #[deprecated(since = "0.10.6", note = "use to_bn instead")]
  • openssl 0.10.45/src/bn.rs
    339
    		 
        #[corresponds(BN_num_bits)]
    340
    		 
        #[allow(clippy::unnecessary_cast)]
    341
    		 
        pub fn num_bits(&self) -> i32 {
  • openssl 0.10.45/src/rsa.rs
    236
    		 
        #[corresponds(RSA_check_key)]
    237
    		 
        #[allow(clippy::unnecessary_cast)]
    238
    		 
        pub fn check_key(&self) -> Result<bool, ErrorStack> {
  • openssl 0.10.45/src/ssl/mod.rs
    1869
    		 
        #[corresponds(SSL_CTX_sess_get_cache_size)]
    1870
    		 
        #[allow(clippy::unnecessary_cast)]
    1871
    		 
        pub fn session_cache_size(&self) -> i64 {
  • p384 0.12.0/src/arithmetic/scalar.rs
    9
    		 
        clippy::too_many_arguments,
    10
    		 
        clippy::unnecessary_cast
    11
    		 
    )]
  • p384_rs 0.1.10/src/arithmetic/scalar.rs
    9
    		 
        clippy::too_many_arguments,
    10
    		 
        clippy::unnecessary_cast
    11
    		 
    )]
  • pdfium-render 0.7.27/src/color.rs
    111
    		 
        #[inline]
    112
    		 
        #[allow(clippy::unnecessary_cast)]
    113
    		 
        fn color_components(&self) -> (FPDF_DWORD, FPDF_DWORD, FPDF_DWORD, FPDF_DWORD) {
  • phper 0.10.2/src/arrays.rs
    496
    		 
                } else if result == HASH_KEY_IS_LONG {
    497
    		 
                    #[allow(clippy::unnecessary_cast)]
    498
    		 
                    IterKey::Index(num_index as u64)
  • plist 1.4.0/src/stream/binary_writer.rs
    529
    		 
                        // we want to be explicit about the type here
    530
    		 
                        #[allow(clippy::unnecessary_cast)]
    531
    		 
                        buf[1..].copy_from_slice(&(v as u64).to_be_bytes());
  • psutil 3.2.2/src/types.rs
    33
    		 
    	#[allow(clippy::unnecessary_cast)]
    34
    		 
    	pub fn fahrenheit(&self) -> Degrees {
  • qiniu-upload-token 0.2.2/src/file_type.rs
    54
    		 
                FileType::DeepArchive => 3,
    55
    		 
                #[allow(clippy::unnecessary_cast)]
    56
    		 
                FileType::Other(ft) => ft as ty,
    69
    		 
        fn from(value: ty) -> Self {
    70
    		 
            #[allow(clippy::unnecessary_cast)]
    71
    		 
            match value as u8 {
  • rich-sdl2-rust 0.12.1/src/file/rw.rs
    222
    		 
    impl io::Write for RwOps<'_> {
    223
    		 
        #[allow(clippy::unnecessary_cast)]
    224
    		 
        fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
  • rich-sdl2-rust 0.12.1/src/mixer/chunk/channel/group.rs
    54
    		 
        /// Returns the first free mixing channel if exists.
    55
    		 
        #[allow(clippy::unnecessary_cast)]
    56
    		 
        pub fn first_free(&self) -> Option<Channel> {
  • rich-sdl2-rust 0.12.1/src/system.rs
    30
    		 
        #[must_use]
    31
    		 
        #[allow(clippy::unnecessary_cast)]
    32
    		 
        pub fn simd_alignment() -> usize {
  • rich-sdl2-rust 0.12.1/src/video/color/pixel/layout.rs
    59
    		 
    impl PackedPixelLayout {
    60
    		 
        #[allow(clippy::unnecessary_cast)]
    61
    		 
        pub(super) fn as_raw(self) -> u32 {
  • rich-sdl2-rust 0.12.1/src/video/color/pixel/order.rs
    14
    		 
    impl BitmapPixelOrder {
    15
    		 
        #[allow(clippy::unnecessary_cast)]
    16
    		 
        pub(super) fn as_raw(self) -> u32 {
    55
    		 
    impl PackedPixelOrder {
    56
    		 
        #[allow(clippy::unnecessary_cast)]
    57
    		 
        pub(super) fn as_raw(self) -> u32 {
    104
    		 
    impl ArrayPixelOrder {
    105
    		 
        #[allow(clippy::unnecessary_cast)]
    106
    		 
        pub(super) fn as_raw(self) -> u32 {
  • rich-sdl2-rust 0.12.1/src/video/color/pixel/ty.rs
    16
    		 
    impl BitmapPixelType {
    17
    		 
        #[allow(clippy::unnecessary_cast)]
    18
    		 
        pub(super) fn as_raw(self) -> u32 {
    54
    		 
    impl PackedPixelType {
    55
    		 
        #[allow(clippy::unnecessary_cast)]
    56
    		 
        pub(super) fn as_raw(self) -> u32 {
    89
    		 
    impl ArrayPixelType {
    90
    		 
        #[allow(clippy::unnecessary_cast)]
    91
    		 
        pub(super) fn as_raw(self) -> u32 {
  • rlimit 0.9.1/src/unix.rs
    6
    		 
    /// A value indicating no limit.
    7
    		 
    #[allow(clippy::unnecessary_cast)]
    8
    		 
    pub const INFINITY: u64 = C::RLIM_INFINITY as u64;
    47
    		 
        #[allow(clippy::unnecessary_cast)]
    48
    		 
        if ret == 0 {
    108
    		 
        if ret == 0 {
    109
    		 
            #[allow(clippy::unnecessary_cast)]
    110
    		 
            if let Some((soft, hard)) = old_limit {
  • rug 1.19.0/src/float/big.rs
    404
    		 
            let ret_prec_t = xmpfr::get_prec(self);
    405
    		 
            #[allow(clippy::unnecessary_cast)]
    406
    		 
            let ret = ret_prec_t as u32;
    407
    		 
            #[allow(clippy::unnecessary_cast)]
    408
    		 
            if ret_prec_t < 0 || ret_prec_t != ret as prec_t {
    1780
    		 
                let ret_exp_t = xmpfr::get_exp(self);
    1781
    		 
                #[allow(clippy::unnecessary_cast)]
    1782
    		 
                let ret = ret_exp_t as i32;
    1783
    		 
                #[allow(clippy::unnecessary_cast)]
    1784
    		 
                if ret_exp_t != ret as exp_t {
  • s2n-quic-platform 0.16.0/src/message/msg.rs
    312
    		 
            // some platforms encode lengths as `u32` so we cast everything to be safe
    313
    		 
            #[allow(clippy::unnecessary_cast)]
    314
    		 
            let msg_controllen = self.msg_controllen as usize;
  • sentry-core 0.29.2/src/performance.rs
    416
    		 
                            // NOTE: `pthread_t` is a `usize`, so clippy is wrong complaining about this cast
    417
    		 
                            #[allow(clippy::unnecessary_cast)]
    418
    		 
                            unsafe {
  • splr 0.17.0/src/assign/heap.rs
    200
    		 
        }
    201
    		 
        #[allow(clippy::unnecessary_cast)]
    202
    		 
        fn insert(&mut self, vi: VarId) -> usize {
  • splr 0.17.0/src/cdb/db.rs
    1082
    		 
        }
    1083
    		 
        #[allow(clippy::unnecessary_cast)]
    1084
    		 
        fn minimize_with_bi_clauses(&mut self, asg: &impl AssignIF, vec: &mut Vec<Lit>) {
  • stratisd 3.5.0/src/engine/strat_engine/thinpool/filesystem.rs
    361
    		 
                    {
    362
    		 
                        #[allow(clippy::unnecessary_cast)]
    363
    		 
                        if mount.major as u64 == major && mount.minor as u64 == minor {
    457
    		 
        // Upcast all arch-dependent variable width values to u64
    458
    		 
        #[allow(clippy::unnecessary_cast)]
    459
    		 
        let (block_size, blocks, blocks_free) = (
  • stronghold-runtime 1.0.2/old_fork/src/lib.rs
    81
    		 
    fn strerror(errno: libc::c_int) -> &'static str {
    82
    		 
        #[allow(clippy::unnecessary_cast)]
    83
    		 
        static mut BUF: [libc::c_char; 1024] = [0 as libc::c_char; 1024];
  • stronghold-runtime 1.0.2/old_fork/src/zone_posix.rs
    10
    		 
        unsafe {
    11
    		 
            #[allow(clippy::unnecessary_cast)]
    12
    		 
            let mut fds: [libc::c_int; 2] = [-1 as libc::c_int; 2];
  • subxt 0.26.0/src/events/events_type.rs
    866
    		 
            #[repr(u8)]
    867
    		 
            #[allow(trivial_numeric_casts, clippy::unnecessary_cast)] // required because the Encode derive produces a warning otherwise
    868
    		 
            pub enum MyType {
  • syntree 0.13.2/src/span.rs
    130
    		 
        /// ```
    131
    		 
        #[allow(clippy::unnecessary_cast)]
    132
    		 
        #[must_use]
  • thin-vec 0.2.10/src/lib.rs
    275
    		 
    impl Header {
    276
    		 
        #[allow(clippy::unnecessary_cast)]
    277
    		 
        fn len(&self) -> usize {
    309
    		 
    impl Header {
    310
    		 
        #[allow(clippy::unnecessary_cast)]
    311
    		 
        fn cap(&self) -> usize {
  • utcnow 0.2.2/src/impl_rustix.rs
    13
    		 
    #[allow(clippy::cast_sign_loss)]
    14
    		 
    #[allow(clippy::unnecessary_cast)]
    15
    		 
    #[allow(clippy::unnecessary_wraps)]
  • uu_ls 0.0.17/src/ls.rs
    2704
    		 
        // S_IXOTH -> other users have execute permission
    2705
    		 
        #[allow(clippy::unnecessary_cast)]
    2706
    		 
        return md.mode() & ((S_IXUSR | S_IXGRP | S_IXOTH) as u32) != 0;
  • uu_pinky 0.0.17/src/pinky.rs
    281
    		 
            match pts_path.metadata() {
    282
    		 
                #[allow(clippy::unnecessary_cast)]
    283
    		 
                Ok(meta) => {
  • uu_rm 0.0.17/src/rm.rs
    522
    		 
        // Why is S_IWUSR showing up as a u16 on macos?
    523
    		 
        #[allow(clippy::unnecessary_cast)]
    524
    		 
        let user_writable = (mode & (libc::S_IWUSR as u32)) != 0;
  • vorbis_bitpack 0.1.1/src/test.rs
    11
    		 
    /// The value of [`VORBIS_FLOAT_WORD`], as a native double-precision float.
    12
    		 
    #[allow(clippy::unnecessary_cast)] // There are no binary f64 literals
    13
    		 
    const VORBIS_FLOAT_VALUE: f64 = -0b100000000000000000001 as f64;
  • winreg 0.10.1/src/lib.rs
    1003
    		 
            let mut name_len = 2048;
    1004
    		 
            #[allow(clippy::unnecessary_cast)]
    1005
    		 
            let mut name = [0 as WCHAR; 2048];
    1028
    		 
            let mut name_len = 2048;
    1029
    		 
            #[allow(clippy::unnecessary_cast)]
    1030
    		 
            let mut name = [0 as WCHAR; 2048];
  • wpilib 0.4.0/src/serial.rs
    101
    		 
        #[allow(clippy::unnecessary_cast)]
    102
    		 
        pub fn enable_termination(&mut self, terminator: u8) -> HalResult<()> {
    121
    		 
        #[allow(clippy::unnecessary_cast)]
    122
    		 
        pub fn read(&mut self, buf: &mut [u8]) -> HalResult<i32> {
    130
    		 
        #[allow(clippy::unnecessary_cast)]
    131
    		 
        pub fn read_len(&mut self, buf: &mut [u8], len: usize) -> HalResult<i32> {
  • write-fonts 0.0.5/generated/generated_base.rs
    30
    		 
    impl FontWrite for Base {
    31
    		 
        #[allow(clippy::unnecessary_cast)]
    32
    		 
        fn write_into(&self, writer: &mut TableWriter) {
    155
    		 
    impl FontWrite for BaseTagList {
    156
    		 
        #[allow(clippy::unnecessary_cast)]
    157
    		 
        fn write_into(&self, writer: &mut TableWriter) {
    209
    		 
    impl FontWrite for BaseScriptList {
    210
    		 
        #[allow(clippy::unnecessary_cast)]
    211
    		 
        fn write_into(&self, writer: &mut TableWriter) {
    323
    		 
    impl FontWrite for BaseScript {
    324
    		 
        #[allow(clippy::unnecessary_cast)]
    325
    		 
        fn write_into(&self, writer: &mut TableWriter) {
    442
    		 
    impl FontWrite for BaseValues {
    443
    		 
        #[allow(clippy::unnecessary_cast)]
    444
    		 
        fn write_into(&self, writer: &mut TableWriter) {
  • write-fonts 0.0.5/generated/generated_cpal.rs
    69
    		 
    impl FontWrite for Cpal {
    70
    		 
        #[allow(clippy::unnecessary_cast)]
    71
    		 
        fn write_into(&self, writer: &mut TableWriter) {
  • write-fonts 0.0.5/generated/generated_font.rs
    39
    		 
    impl FontWrite for TableDirectory {
    40
    		 
        #[allow(clippy::unnecessary_cast)]
    41
    		 
        fn write_into(&self, writer: &mut TableWriter) {
  • write-fonts 0.0.5/generated/generated_gdef.rs
    51
    		 
    impl FontWrite for Gdef {
    52
    		 
        #[allow(clippy::unnecessary_cast)]
    53
    		 
        fn write_into(&self, writer: &mut TableWriter) {
    146
    		 
    impl FontWrite for AttachList {
    147
    		 
        #[allow(clippy::unnecessary_cast)]
    148
    		 
        fn write_into(&self, writer: &mut TableWriter) {
    204
    		 
    impl FontWrite for AttachPoint {
    205
    		 
        #[allow(clippy::unnecessary_cast)]
    206
    		 
        fn write_into(&self, writer: &mut TableWriter) {
  • ywpl-plex 0.0.3/src/processor/deprecated_populate_participation_printing_account.rs
    67
    		 
    #[allow(clippy::unnecessary_cast)]
    68
    		 
    #[allow(clippy::absurd_extreme_comparisons)]
  • ywpl-plex 0.0.3/src/processor/redeem_participation_bid.rs
    228
    		 
    #[allow(clippy::unnecessary_cast)]
    229
    		 
    #[allow(clippy::absurd_extreme_comparisons)]
  • zenoh-config 0.7.0-rc/src/defaults.rs
    126
    		 
    impl Default for LinkTxConf {
    127
    		 
        #[allow(clippy::unnecessary_cast)]
    128
    		 
        fn default() -> Self {
  • cobyla 0.3.2/src/cobyla.rs
    16
    		 
        clippy::single_match,
    17
    		 
        clippy::unnecessary_cast
    18
    		 
    )]
  • comparable_test 0.5.4/test/enums.rs
    1
    		 
    #![allow(clippy::useless_conversion)]
    2
    		 
    #![allow(clippy::unnecessary_cast)]
  • comparable_test 0.5.4/test/map.rs
    1
    		 
    #![allow(clippy::useless_conversion)]
    2
    		 
    #![allow(clippy::unnecessary_cast)]
  • comparable_test 0.5.4/test/scalar.rs
    1
    		 
    #![allow(clippy::useless_conversion)]
    2
    		 
    #![allow(clippy::unnecessary_cast)]
  • comparable_test 0.5.4/test/set.rs
    1
    		 
    #![allow(clippy::useless_conversion)]
    2
    		 
    #![allow(clippy::unnecessary_cast)]
  • comparable_test 0.5.4/test/structs.rs
    1
    		 
    #![allow(clippy::useless_conversion)]
    2
    		 
    #![allow(clippy::unnecessary_cast)]
  • coremidi 0.7.0/src/notifications.rs
    1
    		 
    #![allow(clippy::unnecessary_cast)]
  • egls 0.1.7/src/egl.rs
    6
    		 
    #![allow(clippy::missing_safety_doc)]
    7
    		 
    #![allow(clippy::unnecessary_cast)]
    8
    		 
    #![allow(clippy::unreadable_literal)]
  • gdnative-core 0.11.3/src/export/property.rs
    4
    		 
    // invocation.
    5
    		 
    #![allow(clippy::unnecessary_cast)]
  • glib 0.16.7/tests/structured_log.rs
    1
    		 
    #![allow(clippy::unnecessary_to_owned)]
    2
    		 
    #![allow(clippy::unnecessary_cast)]
  • glutin_egl_sys 0.3.1/src/lib.rs
    12
    		 
    #![allow(clippy::manual_non_exhaustive)]
    13
    		 
    #![allow(clippy::unnecessary_cast)]
  • glutin_gles2_sys 0.3.0/src/lib.rs
    4
    		 
    #![allow(clippy::manual_non_exhaustive)]
    5
    		 
    #![allow(clippy::unnecessary_cast)]
  • glutin_glx_sys 0.3.0/src/lib.rs
    11
    		 
    #![allow(clippy::redundant_static_lifetimes)]
    12
    		 
    #![allow(clippy::unnecessary_cast)]
  • glutin_wgl_sys 0.3.0/src/lib.rs
    4
    		 
    #![allow(clippy::manual_non_exhaustive)]
    5
    		 
    #![allow(clippy::unnecessary_cast)]
  • hdt 0.0.12/src/lib.rs
    50
    		 
    #![warn(clippy::pedantic)]
    51
    		 
    #![allow(clippy::unnecessary_cast)]
    52
    		 
    #![allow(clippy::must_use_candidate)]
  • libmacchina 6.3.5/src/android/mod.rs
    1
    		 
    #![allow(clippy::unnecessary_cast)]
    2
    		 
    mod sysinfo_ffi;
  • libmacchina 6.3.5/src/freebsd/mod.rs
    1
    		 
    #![allow(clippy::unnecessary_cast)]
    2
    		 
    use crate::extra;
  • libmacchina 6.3.5/src/linux/mod.rs
    1
    		 
    #![allow(clippy::unnecessary_cast)]
    2
    		 
    mod sysinfo_ffi;
  • libmacchina 6.3.5/src/macos/mod.rs
    1
    		 
    #![allow(clippy::unnecessary_cast)]
    2
    		 
    use crate::extra;
  • libmacchina 6.3.5/src/netbsd/mod.rs
    1
    		 
    #![allow(clippy::unnecessary_cast)]
    2
    		 
    use crate::dirs;
  • libmacchina 6.3.5/src/openwrt/mod.rs
    1
    		 
    #![allow(clippy::unnecessary_cast)]
    2
    		 
    mod sysinfo_ffi;
  • libmacchina 6.3.5/src/shared/mod.rs
    2
    		 
    #![allow(unused_imports)]
    3
    		 
    #![allow(clippy::unnecessary_cast)]
  • livesplit-auto-splitting 0.1.0/src/process.rs
    1
    		 
    #![allow(clippy::unnecessary_cast)]
  • livesplit-auto-splitting 0.1.0/src/runtime.rs
    1
    		 
    #![allow(clippy::unnecessary_cast)]
  • orml-auction 0.4.0/src/default_weight.rs
    4
    		 
    #![allow(unused_imports)]
    5
    		 
    #![allow(clippy::unnecessary_cast)]
  • orml-authority 0.4.0/src/default_weight.rs
    8
    		 
    #![allow(unused_imports)]
    9
    		 
    #![allow(clippy::unnecessary_cast)]
  • orml-currencies 0.4.0/src/default_weight.rs
    4
    		 
    #![allow(unused_imports)]
    5
    		 
    #![allow(clippy::unnecessary_cast)]
  • orml-gradually-update 0.4.0/src/default_weight.rs
    4
    		 
    #![allow(unused_imports)]
    5
    		 
    #![allow(clippy::unnecessary_cast)]
  • orml-oracle 0.4.0/src/default_weight.rs
    4
    		 
    #![allow(unused_imports)]
    5
    		 
    #![allow(clippy::unnecessary_cast)]
  • orml-rewards 0.4.0/src/default_weight.rs
    4
    		 
    #![allow(unused_imports)]
    5
    		 
    #![allow(clippy::unnecessary_cast)]
  • orml-tokens 0.4.0/src/default_weight.rs
    4
    		 
    #![allow(unused_imports)]
    5
    		 
    #![allow(clippy::unnecessary_cast)]
  • orml-vesting 0.4.0/src/default_weight.rs
    4
    		 
    #![allow(unused_imports)]
    5
    		 
    #![allow(clippy::unnecessary_cast)]
  • p384 0.12.0/src/arithmetic/field.rs
    17
    		 
        clippy::unused_unit,
    18
    		 
        clippy::unnecessary_cast,
    19
    		 
        clippy::too_many_arguments,
  • p384_rs 0.1.10/src/arithmetic/field.rs
    17
    		 
        clippy::unused_unit,
    18
    		 
        clippy::unnecessary_cast,
    19
    		 
        clippy::too_many_arguments,
  • paho-mqtt 0.12.0/src/lib.rs
    28
    		 
    #![allow(non_snake_case)]
    29
    		 
    #![allow(clippy::unnecessary_cast)]
  • polling 2.5.2/src/lib.rs
    52
    		 
    #![warn(missing_docs, missing_debug_implementations, rust_2018_idioms)]
    53
    		 
    #![allow(clippy::useless_conversion, clippy::unnecessary_cast)]
    54
    		 
    #![cfg_attr(docsrs, feature(doc_cfg))]
  • radio-sx1231 0.3.0/src/register.rs
    10
    		 
    // This warning is generated by some modular bitfield macro.
    11
    		 
    #![allow(clippy::unnecessary_cast)]
  • rgb-core 0.9.0/src/contract/data.rs
    12
    		 
    #![allow(clippy::unnecessary_cast)]
  • rgb-core 0.9.0/src/schema/script.rs
    12
    		 
    #![allow(clippy::unnecessary_cast)]
  • rlimit 0.9.1/src/bindings.rs
    1
    		 
    #![allow(clippy::cast_possible_truncation)]
    2
    		 
    #![allow(clippy::unnecessary_cast)]
  • rppal 0.14.1/src/gpio/ioctl.rs
    1
    		 
    #![allow(clippy::unnecessary_cast)]
    2
    		 
    #![allow(dead_code)]
  • rppal 0.14.1/src/pwm/sysfs.rs
    1
    		 
    #![allow(clippy::unnecessary_cast)]
  • rustix 0.36.7/src/lib.rs
    122
    		 
    // It is common in linux and libc APIs for types to vary between platforms.
    123
    		 
    #![allow(clippy::unnecessary_cast)]
    124
    		 
    // It is common in linux and libc APIs for types to vary between platforms.
  • s2n-quic-platform 0.16.0/src/message/cmsg.rs
    4
    		 
    #![allow(clippy::unnecessary_cast)] // some platforms encode lengths as `u32` so we cast everything to be safe
  • serp-market 0.5.3/src/default_weight.rs
    4
    		 
    #![allow(unused_imports)]
    5
    		 
    #![allow(clippy::unnecessary_cast)]
  • serp-tes 0.5.3/src/default_weight.rs
    4
    		 
    #![allow(unused_imports)]
    5
    		 
    #![allow(clippy::unnecessary_cast)]
  • stp258-currencies 0.5.3/src/default_weight.rs
    4
    		 
    #![allow(unused_imports)]
    5
    		 
    #![allow(clippy::unnecessary_cast)]
  • stp258-serp 0.5.3/src/default_weight.rs
    4
    		 
    #![allow(unused_imports)]
    5
    		 
    #![allow(clippy::unnecessary_cast)]
  • stp258-standard 0.5.3/src/default_weight.rs
    4
    		 
    #![allow(unused_imports)]
    5
    		 
    #![allow(clippy::unnecessary_cast)]
  • stp258-tokens 0.5.1/src/default_weight.rs
    4
    		 
    #![allow(unused_imports)]
    5
    		 
    #![allow(clippy::unnecessary_cast)]
  • tract-core 0.19.2/src/ops/logic.rs
    1
    		 
    #![allow(clippy::bool_comparison)]
    2
    		 
    #![allow(clippy::unnecessary_cast)]
  • tract-core 0.19.2/src/ops/math/mod.rs
    1
    		 
    #![allow(clippy::clone_on_copy)]
    2
    		 
    #![allow(clippy::unnecessary_cast)]
  • tract-core 0.19.2/src/ops/quant.rs
    1
    		 
    #![allow(clippy::unnecessary_cast)]
  • udf 0.5.1/src/types/config.rs
    3
    		 
    #![allow(clippy::useless_conversion, clippy::unnecessary_cast)]
  • unsafe-libyaml 0.2.5/src/lib.rs
    36
    		 
        clippy::too_many_lines,
    37
    		 
        clippy::unnecessary_cast,
    38
    		 
        clippy::unreadable_literal,
  • wide 0.7.5/tests/all_tests/main.rs
    1
    		 
    #![allow(clippy::approx_constant)]
    2
    		 
    #![allow(clippy::unnecessary_cast)]
    3
    		 
    #![allow(clippy::assertions_on_constants)]
  • zenoh-protocol 0.7.0-rc/src/proto/msg_writer.rs
    583
    		 
            // Note: desactivate Clippy check here because cast to ZInt can't be changed since ZInt size might change
    584
    		 
            #![allow(clippy::unnecessary_cast)]
    585
    		 
            match target {