• actyx_sdk 0.3.0/src/types/fixnum.rs
    372
    		 
    #[cfg(test)]
    373
    		 
    #[allow(clippy::unusual_byte_groupings)]
    374
    		 
    mod tests {
  • agb 0.13.0/src/sound/dmg.rs
    43
    		 
            #[allow(clippy::unusual_byte_groupings)] // I've split these like this for a reason
    44
    		 
            MASTER_SOUND_VOLUME_ENABLE.set(0b1111_1111_0_111_0_111);
  • avr-oxide 0.4.0/src/hal/atmega4809/serial.rs
    187
    		 
        #[cfg(target_arch="avr")]
    188
    		 
        #[allow(clippy::unusual_byte_groupings)]
    189
    		 
        fn route(&self) {
  • avr-oxide 0.4.0/src/hal/generic/serial.rs
    574
    		 
           */
    575
    		 
          #[allow(clippy::unusual_byte_groupings)]
    576
    		 
          pub fn avr_0series_ctrlc(&self) -> u8 {
    1032
    		 
           */
    1033
    		 
          #[allow(clippy::unusual_byte_groupings)]
    1034
    		 
          pub fn avr_simple_ctrlc(&self) -> u8 {
  • bevy-aabb-instancing 0.7.0/src/vertex_pulling/index_buffer.rs
    31
    		 
            #[rustfmt::skip]
    32
    		 
            #[allow(clippy::unusual_byte_groupings)]
    33
    		 
            const CUBE_INDICES: [u32; NUM_CUBE_INDICES_USIZE] = [
  • bevy_reflect 0.9.1/src/lib.rs
    71
    		 
        /// The generated UUID will be a `UUIDv4` (meaning that the bytes should be random, not e.g. derived from the system time).
    72
    		 
        #[allow(clippy::unusual_byte_groupings)] // unusual byte grouping is meant to signal the relevant bits
    73
    		 
        pub const fn generate_composite_uuid(a: Uuid, b: Uuid) -> Uuid {
  • binstall-zip 0.6.4/src/types.rs
    509
    		 
        #[test]
    510
    		 
        #[allow(clippy::unusual_byte_groupings)]
    511
    		 
        fn datetime_default() {
    518
    		 
        #[test]
    519
    		 
        #[allow(clippy::unusual_byte_groupings)]
    520
    		 
        fn datetime_max() {
  • ca-formats 0.3.4/src/macrocell.rs
    321
    		 
    #[allow(clippy::unusual_byte_groupings)]
    322
    		 
    #[cfg(test)]
  • chewing 0.5.1-alpha.2/src/zhuyin/syllable.rs
    36
    		 
        }
    37
    		 
        #[allow(clippy::unusual_byte_groupings)]
    38
    		 
        pub const fn medial(&self) -> Option<Bopomofo> {
    48
    		 
        }
    49
    		 
        #[allow(clippy::unusual_byte_groupings)]
    50
    		 
        pub const fn rime(&self) -> Option<Bopomofo> {
    60
    		 
        }
    61
    		 
        #[allow(clippy::unusual_byte_groupings)]
    62
    		 
        pub const fn tone(&self) -> Option<Bopomofo> {
    201
    		 
        #[allow(clippy::unusual_byte_groupings)]
    202
    		 
        fn try_from(value: u16) -> Result<Self, Self::Error> {
  • coffer 1.0.1/src/mod_utf8.rs
    148
    		 
            #[allow(clippy::unusual_byte_groupings)]
    149
    		 
            match c {
  • dbs-virtio-devices 0.1.1/src/fs/device.rs
    1626
    		 
        #[test]
    1627
    		 
        #[allow(clippy::unusual_byte_groupings)]
    1628
    		 
        fn test_kb_to_bytes() {
  • dcc-rs 0.3.0/src/packets/baseline.rs
    295
    		 
            // 01 1 1 1101
    296
    		 
            #[allow(clippy::unusual_byte_groupings)]
    297
    		 
            let expected_arr = [
    323
    		 
            #[allow(clippy::unusual_byte_groupings)]
    324
    		 
            let expected_arr = [
    351
    		 
            #[allow(clippy::unusual_byte_groupings)]
    352
    		 
            let expected_arr = [
    379
    		 
            #[allow(clippy::unusual_byte_groupings)]
    380
    		 
            let expected_arr = [
  • dcc-rs 0.3.0/src/packets/service_mode.rs
    76
    		 
            // and value
    77
    		 
            #[allow(clippy::unusual_byte_groupings)]
    78
    		 
            let data = match self.typ {
    89
    		 
                    // padding - 0=verify - data - offset
    90
    		 
                    #[allow(clippy::unusual_byte_groupings)]
    91
    		 
                    let mut data = 0b111_0_0000;
    423
    		 
            #[allow(clippy::unusual_byte_groupings)]
    424
    		 
            let expected_arr = &[
    460
    		 
            #[allow(clippy::unusual_byte_groupings)]
    461
    		 
            let expected_arr = &[
    491
    		 
            #[allow(clippy::unusual_byte_groupings)]
    492
    		 
            let expected_arr = &[
  • dns-server 0.1.0/tests/test.rs
    74
    		 
    #[test]
    75
    		 
    #[allow(clippy::unusual_byte_groupings)]
    76
    		 
    #[allow(clippy::too_many_lines)]
  • edhoc 0.1.0/src/lib.rs
    28
    		 
    // Unusual byte groupings are used for consistency with RFC.
    29
    		 
    #[allow(clippy::unusual_byte_groupings)]
    30
    		 
    pub mod cbor;
  • flash-lso 0.5.0/src/amf3/read.rs
    26
    		 
    #[allow(clippy::unusual_byte_groupings)]
    27
    		 
    fn read_int_signed(i: &[u8]) -> AMFResult<'_, i32> {
    56
    		 
    #[allow(clippy::unusual_byte_groupings)]
    57
    		 
    fn read_int(i: &[u8]) -> AMFResult<'_, u32> {
  • flash-lso 0.5.0/src/amf3/write.rs
    63
    		 
    impl AMF3Encoder {
    64
    		 
        #[allow(clippy::unusual_byte_groupings)]
    65
    		 
        pub(crate) fn write_int<'a, 'b: 'a, W: Write + 'a>(&self, i: i32) -> impl SerializeFn<W> + 'a {
  • flight_tracking_erau_se300 0.5.0/src/tile/pipeline.rs
    286
    		 
                    },
    287
    		 
                    #[allow(clippy::unusual_byte_groupings)]
    288
    		 
                    0b101_00011,
    295
    		 
                    },
    296
    		 
                    #[allow(clippy::unusual_byte_groupings)]
    297
    		 
                    0b111__00000000_00000000_00000001__01001,
  • fpdec-core 0.5.4/src/lib.rs
    116
    		 
    // 0 < val <= u8::MAX
    117
    		 
    #[allow(clippy::unusual_byte_groupings)]
    118
    		 
    #[doc(hidden)]
    140
    		 
    // 0 < val < 100_000
    141
    		 
    #[allow(clippy::unusual_byte_groupings)]
    142
    		 
    #[doc(hidden)]
  • frosty 0.0.3/src/task/state.rs
    26
    		 
    /// The join handle is still around
    27
    		 
    #[allow(clippy::unusual_byte_groupings)] // https://github.com/rust-lang/rust-clippy/issues/6556
    28
    		 
    const JOIN_INTEREST: usize = 0b1_000;
    30
    		 
    /// A join handle waker has been set
    31
    		 
    #[allow(clippy::unusual_byte_groupings)] // https://github.com/rust-lang/rust-clippy/issues/6556
    32
    		 
    const JOIN_WAKER: usize = 0b10_000;
  • gdbstub_arch 0.2.4/src/aarch64/reg/id.rs
    58
    		 
                67 => Self::FPCR,
    59
    		 
                #[allow(clippy::unusual_byte_groupings)]
    60
    		 
                // We configure GDB to use regnums that correspond to the architectural u16 opcode
    71
    		 
    #[allow(clippy::unusual_byte_groupings)]
    72
    		 
    impl AArch64RegId {
  • h3o 0.3.0/src/base_cell.rs
    199
    		 
    /// rotation is encoded on 3-bit, where `111` means no rotation for this face.
    200
    		 
    #[allow(clippy::unusual_byte_groupings)] // Grouping by 3 is more explicit here.
    201
    		 
    const BASE_CELL_ROTATIONS: [u64; BaseCell::count() as usize] = [
  • h3o 0.3.0/src/index/cell.rs
    115
    		 
    /// than one icosahedron face is not permitted.
    116
    		 
    #[allow(clippy::unusual_byte_groupings)] // Grouping by 7 is more explicit here.
    117
    		 
    const FAILED_DIRECTIONS: u64 =
    1818
    		 
    #[rustfmt::skip] // Keep constants aligned for readability.
    1819
    		 
    #[allow(clippy::unusual_byte_groupings)] // Grouping by 3-bit is better here.
    1820
    		 
    const fn has_unused_direction(dirs: u64) -> bool {
  • hyper-openssl 0.9.2/build.rs
    3
    		 
    #[allow(clippy::unusual_byte_groupings)]
    4
    		 
    fn main() {
  • img-qoi 0.1.0/src/decode.rs
    377
    		 
        #[allow(clippy::identity_op)]
    378
    		 
        #[allow(clippy::unusual_byte_groupings)]
    379
    		 
        fn test_decode() {
  • img-qoi 0.1.0/src/encode.rs
    262
    		 
        #[allow(clippy::identity_op)]
    263
    		 
        #[allow(clippy::unusual_byte_groupings)]
    264
    		 
        fn test_encode() {
  • imxrt-rt 0.1.0/src/host.rs
    746
    		 
            /// Testing table of banks and expected configuration mask.
    747
    		 
            #[allow(clippy::unusual_byte_groupings)] // Spacing delimits ITCM / DTCM / OCRAM banks.
    748
    		 
            const TABLE: &[(FlexRamBanks, u32)] = &[
  • minreq 2.6.0/build.rs
    7
    		 
            #[allow(clippy::unusual_byte_groupings)]
    8
    		 
            if version >= 0x1_01_00_00_0 {
    16
    		 
            #[allow(clippy::unusual_byte_groupings)]
    17
    		 
            if version >= 0x2_06_01_00_0 {
  • monoio 0.0.9/src/task/state.rs
    25
    		 
    /// The join handle is still around
    26
    		 
    #[allow(clippy::unusual_byte_groupings)] // https://github.com/rust-lang/rust-clippy/issues/6556
    27
    		 
    const JOIN_INTEREST: usize = 0b1_000;
    29
    		 
    /// A join handle waker has been set
    30
    		 
    #[allow(clippy::unusual_byte_groupings)] // https://github.com/rust-lang/rust-clippy/issues/6556
    31
    		 
    const JOIN_WAKER: usize = 0b10_000;
  • mp4parse 0.12.0/src/tests.rs
    429
    		 
    #[test]
    430
    		 
    #[allow(clippy::unusual_byte_groupings)] // Allow odd grouping for test readability.
    431
    		 
    fn read_vpcc_version_1() {
  • netlink-packet-route 0.15.0/src/rtnl/tc/nlas/test.rs
    93
    		 
    #[test]
    94
    		 
    #[allow(clippy::unusual_byte_groupings)]
    95
    		 
    fn tc_filter_u32_read() {
    247
    		 
    #[test]
    248
    		 
    #[allow(clippy::unusual_byte_groupings)]
    249
    		 
    fn tc_filter_u32_emit() {
  • openssl 0.10.45/src/ssl/connector.rs
    26
    		 
    #[allow(clippy::inconsistent_digit_grouping, clippy::unusual_byte_groupings)]
    27
    		 
    fn ctx(method: SslMethod) -> Result<SslContextBuilder, ErrorStack> {
  • paging-calculator 0.1.2/src/main.rs
    340
    		 
            // of page table on x86.
    341
    		 
            #[allow(clippy::unusual_byte_groupings)]
    342
    		 
            let addr = 0b1111111111_1010101010_001111000011;
    371
    		 
            // of page table on x86_64.
    372
    		 
            #[allow(clippy::unusual_byte_groupings)]
    373
    		 
            let addr = 0b000100000_000011111_111111111_010101010_001111000011;
  • shakmaty 0.23.0/src/square.rs
    542
    		 
        #[inline]
    543
    		 
        #[allow(clippy::unusual_byte_groupings)]
    544
    		 
        pub fn flip_horizontal(self) -> Square {
    557
    		 
        #[inline]
    558
    		 
        #[allow(clippy::unusual_byte_groupings)]
    559
    		 
        pub fn flip_vertical(self) -> Square {
    617
    		 
        #[inline]
    618
    		 
        #[allow(clippy::unusual_byte_groupings)]
    619
    		 
        pub fn rotate_180(self) -> Square {
  • sn_cli 0.68.7/src/operations/helpers.rs
    152
    		 
        // Allow unusual bit grouping to clearly separate 3 bits parts
    153
    		 
        #[allow(clippy::unusual_byte_groupings)]
    154
    		 
        perms.set_mode(perms.mode() | 0b0_001_001_001);
  • spectrusty-core 0.4.0/src/video/pixel.rs
    140
    		 
    #[allow(clippy::unusual_byte_groupings)]
    141
    		 
    #[inline]
  • swf 0.2.0/src/avm2/read.rs
    875
    		 
    #[cfg(test)]
    876
    		 
    #[allow(clippy::unusual_byte_groupings)]
    877
    		 
    pub mod tests {
  • swf 0.2.0/src/avm2/write.rs
    112
    		 
        #[allow(clippy::unusual_byte_groupings)]
    113
    		 
        fn write_u32(&mut self, mut n: u32) -> Result<()> {
    480
    		 
        #[allow(clippy::unusual_byte_groupings)]
    481
    		 
        fn write_trait(&mut self, t: &Trait) -> Result<()> {
  • swf 0.2.0/src/read.rs
    2597
    		 
    #[cfg(test)]
    2598
    		 
    #[allow(clippy::unusual_byte_groupings)]
    2599
    		 
    pub mod tests {
  • swf 0.2.0/src/write.rs
    485
    		 
                #[allow(clippy::unusual_byte_groupings)]
    486
    		 
                Tag::CsmTextSettings(ref settings) => {
    2458
    		 
    #[cfg(test)]
    2459
    		 
    #[allow(clippy::unusual_byte_groupings)]
    2460
    		 
    mod tests {
  • tokio 1.25.0/src/runtime/task/state.rs
    31
    		 
    /// The join handle is still around.
    32
    		 
    #[allow(clippy::unusual_byte_groupings)] // https://github.com/rust-lang/rust-clippy/issues/6556
    33
    		 
    const JOIN_INTEREST: usize = 0b1_000;
    35
    		 
    /// A join handle waker has been set.
    36
    		 
    #[allow(clippy::unusual_byte_groupings)] // https://github.com/rust-lang/rust-clippy/issues/6556
    37
    		 
    const JOIN_WAKER: usize = 0b10_000;
    39
    		 
    /// The task has been forcibly cancelled.
    40
    		 
    #[allow(clippy::unusual_byte_groupings)] // https://github.com/rust-lang/rust-clippy/issues/6556
    41
    		 
    const CANCELLED: usize = 0b100_000;
  • tokio_wasi 1.23.0/src/runtime/task/state.rs
    31
    		 
    /// The join handle is still around.
    32
    		 
    #[allow(clippy::unusual_byte_groupings)] // https://github.com/rust-lang/rust-clippy/issues/6556
    33
    		 
    const JOIN_INTEREST: usize = 0b1_000;
    35
    		 
    /// A join handle waker has been set.
    36
    		 
    #[allow(clippy::unusual_byte_groupings)] // https://github.com/rust-lang/rust-clippy/issues/6556
    37
    		 
    const JOIN_WAKER: usize = 0b10_000;
    39
    		 
    /// The task has been forcibly cancelled.
    40
    		 
    #[allow(clippy::unusual_byte_groupings)] // https://github.com/rust-lang/rust-clippy/issues/6556
    41
    		 
    const CANCELLED: usize = 0b100_000;
  • tracelogging 0.1.0/tests/tests.rs
    9
    		 
    #[allow(clippy::unusual_byte_groupings)]
    10
    		 
    #[test]
  • zip 0.6.3/src/types.rs
    460
    		 
        #[test]
    461
    		 
        #[allow(clippy::unusual_byte_groupings)]
    462
    		 
        fn datetime_default() {
    469
    		 
        #[test]
    470
    		 
        #[allow(clippy::unusual_byte_groupings)]
    471
    		 
        fn datetime_max() {
  • actyxos_sdk 0.6.0/src/types/fixnum.rs
    388
    		 
    mod tests {
    389
    		 
        #![allow(clippy::unusual_byte_groupings)]
    390
    		 
        use super::*;
  • advent-of-code 2022.0.46/src/year2017/day21.rs
    76
    		 
        const fn rotate(self) -> Self {
    77
    		 
            #![allow(clippy::unusual_byte_groupings)]
    78
    		 
            // ABC      GDA
    103
    		 
        const fn flip(self) -> Self {
    104
    		 
            #![allow(clippy::unusual_byte_groupings)]
    105
    		 
            // ABC      CBA
    181
    		 
    pub fn solve(input: &Input) -> Result<u32, String> {
    182
    		 
        #![allow(clippy::unusual_byte_groupings, clippy::unreadable_literal)]
    183
    		 
        let mut from_2_to_3 = [Tile3 { bits: 0 }; 16];
    346
    		 
    pub fn tile_tests() {
    347
    		 
        #![allow(clippy::unusual_byte_groupings)]
    348
    		 
        let tile = Tile2::from("##/.#");
  • advent-of-code 2022.0.46/src/year2019/day24.rs
    106
    		 
        const fn count_bugs_at_edge(self, coming_from: Direction) -> u32 {
    107
    		 
            #![allow(clippy::unusual_byte_groupings)]
    108
    		 
            (self.value
  • advent-of-code 2022.0.46/src/year2021/day04.rs
    13
    		 
        const fn has_won(&self) -> bool {
    14
    		 
            #![allow(clippy::unusual_byte_groupings)]
    15
    		 
            self.is_bitmask_set(0b00000_00000_00000_00000_11111)
  • advent-of-code 2022.0.46/src/year2021/day20.rs
    37
    		 
        fn enhance(&self, image: &Image, steps: usize) -> u32 {
    38
    		 
            #![allow(clippy::unusual_byte_groupings)]
    39
    		 
            const fn is_pixel_lit(
  • alure 0.1.0/src/instr/instr.rs
    11
    		 
    #![allow(missing_docs)]
    12
    		 
    #![allow(clippy::unusual_byte_groupings)]
  • aluvm 0.9.0/src/isa/opcodes.rs
    12
    		 
    #![allow(missing_docs)]
    13
    		 
    #![allow(clippy::unusual_byte_groupings)]
  • arimaa_engine_step 1.0.1/src/lib.rs
    209
    		 
    #![allow(clippy::inconsistent_digit_grouping)]
    210
    		 
    #![allow(clippy::unusual_byte_groupings)]
  • board-game 0.6.0/src/lib.rs
    2
    		 
    #![allow(clippy::too_many_arguments)]
    3
    		 
    #![allow(clippy::unusual_byte_groupings)]
    4
    		 
    #![allow(clippy::derive_hash_xor_eq)]
  • dragonbox 0.1.4/src/lib.rs
    70
    		 
        clippy::unreadable_literal,
    71
    		 
        clippy::unusual_byte_groupings
    72
    		 
    )]
  • encode_unicode 1.0.0/src/lib.rs
    43
    		 
    #![allow(
    44
    		 
        clippy::unusual_byte_groupings,// I sometimes group into UTF-8 control part and codepoint part
    45
    		 
        clippy::derive_hash_xor_eq,// tested
  • hack_asm 1.0.1/src/instructions.rs
    1
    		 
    #![allow(clippy::unusual_byte_groupings)]
  • humphrey_ws 0.5.0/src/tests/frame.rs
    1
    		 
    #![allow(clippy::unusual_byte_groupings)]
  • imxrt-rt 0.1.0/tests/inspect_elf.rs
    6
    		 
    #![allow(clippy::unusual_byte_groupings)] // Spacing delimits ITCM / DTCM / OCRAM banks.
  • kafka 0.9.0/build.rs
    1
    		 
    #![allow(clippy::unusual_byte_groupings)]
    2
    		 
    use std::env;
  • max112x 0.4.0/src/register.rs
    1
    		 
    #![allow(clippy::unusual_byte_groupings)] // FIXME: https://github.com/rust-lang/rust-clippy/issues/9183
  • minicbor 0.19.0/src/decode/decoder.rs
    1
    		 
    #![allow(clippy::unusual_byte_groupings)]
  • ncursesw-win 0.6.3/src/graphics/boxdrawinggraphic.rs
    23
    		 
    #![allow(clippy::unusual_byte_groupings)]
    24
    		 
    #![allow(clippy::from_over_into)]
  • neodyn_xc 0.4.0/src/format.rs
    24
    		 
    // by Clippy, but in this (exceptional and special) case, Clippy is wrong.
    25
    		 
    #![allow(clippy::inconsistent_digit_grouping, clippy::unusual_byte_groupings)]
  • openssl 0.10.45/build.rs
    1
    		 
    #![allow(clippy::inconsistent_digit_grouping, clippy::unusual_byte_groupings)]
  • openssl-errors 0.2.0/build.rs
    1
    		 
    #![allow(clippy::inconsistent_digit_grouping, clippy::unusual_byte_groupings)]
  • openssl-sys 0.9.80/build/main.rs
    1
    		 
    #![allow(clippy::inconsistent_digit_grouping, clippy::unusual_byte_groupings)]
  • p384 0.12.0/src/arithmetic/scalar.rs
    3
    		 
    #![allow(clippy::unusual_byte_groupings)]
  • p384_rs 0.1.10/src/arithmetic.rs
    8
    		 
    #![allow(clippy::unusual_byte_groupings)]
    9
    		 
    pub(crate) mod affine;
  • pio 0.2.1/src/lib.rs
    37
    		 
    // PIO instr grouping is 3/5/3/5
    38
    		 
    #![allow(clippy::unusual_byte_groupings)]
    39
    		 
    #![allow(clippy::upper_case_acronyms)]
  • pio-parser 0.2.1/src/lib.rs
    1
    		 
    // PIO instr grouping is 3/5/3/5
    2
    		 
    #![allow(clippy::unusual_byte_groupings)]
    3
    		 
    #![allow(clippy::upper_case_acronyms)]
  • ppc750cl 0.1.0/src/lib.rs
    1
    		 
    #![allow(clippy::unusual_byte_groupings)]
  • probe-rs 0.16.0/src/architecture/riscv/assembly.rs
    1
    		 
    #![allow(clippy::unusual_byte_groupings)]
  • rfm69 0.5.0/src/tests.rs
    1
    		 
    #![allow(clippy::unusual_byte_groupings)]
  • rgb-core 0.9.0/src/vm/alure.rs
    12
    		 
    #![allow(clippy::unusual_byte_groupings)]
  • sframe 0.1.0/src/header/extended_header.rs
    4
    		 
    #![allow(clippy::unusual_byte_groupings)]
    5
    		 
    use bitfield::bitfield;
  • shellharden 4.3.0/src/main.rs
    9
    		 
    // Color codes are split between flag- and color bits on purpose, such as 0x03_789060.
    10
    		 
    #![allow(clippy::unusual_byte_groupings)]
  • skia-safe 0.58.0/examples/icon/renderer.rs
    3
    		 
    // Released under the MIT license: https://opensource.org/licenses/MIT
    4
    		 
    #![allow(clippy::unusual_byte_groupings)]
    5
    		 
    use skia_safe::{
  • spectrusty 0.4.0/src/video/render_pixels_plus.rs
    1
    		 
    #![allow(clippy::unusual_byte_groupings)]
    2
    		 
    /*
  • spectrusty-peripherals 0.4.0/src/serial/keypad.rs
    8
    		 
    #![allow(clippy::inconsistent_digit_grouping)]
    9
    		 
    #![allow(clippy::unusual_byte_groupings)]
    10
    		 
    #[cfg(feature = "snapshot")]
  • starlark 0.8.0/src/values/layout/pointer.rs
    25
    		 
    // This lint is fairly new, so have to also enable unknown-clippy-lints.
    26
    		 
    #![allow(clippy::unusual_byte_groupings)]
  • swf 0.2.0/src/test_data.rs
    1
    		 
    #![allow(clippy::unusual_byte_groupings)]
  • tgba 0.3.0/src/cpu.rs
    1
    		 
    #![allow(clippy::unusual_byte_groupings)]
  • tokio-bitstream-io 0.0.7/tests/read.rs
    1
    		 
    #![allow(clippy::unusual_byte_groupings)]
    2
    		 
    #![allow(clippy::bool_assert_comparison)]
  • tokio-bitstream-io 0.0.7/tests/write.rs
    1
    		 
    #![allow(clippy::unusual_byte_groupings)]
    2
    		 
    // Copyright 2017 Brian Langenberger
  • toml 0.7.1/tests/testsuite/macros.rs
    144
    		 
    fn test_number() {
    145
    		 
        #![allow(clippy::unusual_byte_groupings)] // Verify the macro with odd formatting
  • tps6507x 0.1.0/src/defs.rs
    1
    		 
    #![allow(clippy::unusual_byte_groupings)]
  • valence 0.1.0+mc1.19.2/src/lib.rs
    77
    		 
        clippy::derive_partial_eq_without_eq,
    78
    		 
        clippy::unusual_byte_groupings,
    79
    		 
        clippy::comparison_chain
  • valence_nbt 0.4.0/src/lib.rs
    66
    		 
    )]
    67
    		 
    #![allow(clippy::unusual_byte_groupings)]
  • vorbis_bitpack 0.1.1/src/test.rs
    1
    		 
    #![allow(clippy::unusual_byte_groupings)]
  • w5500 0.4.1/src/bus/four_wire.rs
    1
    		 
    #![allow(clippy::inconsistent_digit_grouping, clippy::unusual_byte_groupings)]
  • w5500 0.4.1/src/bus/four_wire_ref.rs
    1
    		 
    #![allow(clippy::inconsistent_digit_grouping, clippy::unusual_byte_groupings)]
  • w5500 0.4.1/src/bus/three_wire.rs
    1
    		 
    #![allow(clippy::inconsistent_digit_grouping, clippy::unusual_byte_groupings)]
  • w5500 0.4.1/src/register.rs
    1
    		 
    #![allow(clippy::inconsistent_digit_grouping, clippy::unusual_byte_groupings)]
  • web-socket 0.2.0/src/ws/mod.rs
    1
    		 
    #![allow(clippy::unusual_byte_groupings)]
    2
    		 
    use crate::frame::Frame;
  • wide 0.7.5/src/lib.rs
    6
    		 
    #![allow(clippy::let_and_return)]
    7
    		 
    #![allow(clippy::unusual_byte_groupings)]
    8
    		 
    #![allow(clippy::misrefactored_assign_op)]
  • z80emu 0.8.0/src/cpu/parse.rs
    8
    		 
    #![allow(clippy::inconsistent_digit_grouping)]
    9
    		 
    #![allow(clippy::unusual_byte_groupings)]
    10
    		 
    #![allow(clippy::upper_case_acronyms)]
  • zipng 0.20221122.0-dev.3/src/text.rs
    1
    		 
    #![allow(clippy::unusual_byte_groupings)]
  • zvariant 3.10.0/src/lib.rs
    1
    		 
    #![allow(clippy::unusual_byte_groupings)]
    2
    		 
    #![deny(rust_2018_idioms)]