595  | 
              
                #[cfg(test)]
                 | 
            
596  | 
              
                #[allow(clippy::len_zero)]
                 | 
            
597  | 
              
                mod arb_tests {
                 | 
            
92  | 
              
                        unsafe {
                 | 
            
93  | 
              
                            #[allow(clippy::len_zero)]
                 | 
            
94  | 
              
                            if buffer.len() == 0 {
                  
                 | 
            
115  | 
              
                        unsafe {
                 | 
            
116  | 
              
                            #[allow(clippy::len_zero)]
                 | 
            
117  | 
              
                            if buffer.len() == 0 {
                 | 
            
235  | 
              
                    /// The cursor's offset is ignored. The cursor ends up at the end of the inserted items.
                 | 
            
236  | 
              
                    #[allow(clippy::len_zero)]
                 | 
            
237  | 
              
                    unsafe fn replace_entry<F>(cursor: &mut UnsafeCursor<E, I, IE, LE>, items: &[E], flush_marker: &mut I::Update, notify: &mut F)
                 | 
            
302  | 
              
                    // This is analogous to GlyphLine::evict_width, but for lines.
                 | 
            
303  | 
              
                    #[allow(clippy::len_zero)]
                 | 
            
304  | 
              
                    fn evict_line(&mut self, height: i32) -> Option<&mut GlyphLine> {
                  
                 | 
            
450  | 
              
                    ///      left neighbor.
                 | 
            
451  | 
              
                    #[allow(clippy::len_zero)]
                 | 
            
452  | 
              
                    // This is analogous to GlyphColumn::evict_line, but for glyphs.
                 | 
            
138  | 
              
                    #[allow(clippy::len_zero)]
                 | 
            
139  | 
              
                    fn find_property_size(&self, property: &Property, remaining_user_buffer: &[u8]) -> ParserResult<usize> {
                 | 
            
308  | 
              
                /// Authentication method is specified by `Auth` object.
                 | 
            
309  | 
              
                #[allow(clippy::len_zero)]
                 | 
            
310  | 
              
                async fn connect_with_auth<S>(
                 | 
            
302  | 
              
                /// Authentication method is specified by `Auth` object.
                 | 
            
303  | 
              
                #[allow(clippy::len_zero)]
                 | 
            
304  | 
              
                fn connect_with_auth<S>(server: &mut S, auth: Auth, destination: SocketAddr) -> Result<SocketAddr>
                 | 
            
58  | 
              
                // it matches the adjoining len() >= 2
                 | 
            
59  | 
              
                #[allow(clippy::len_zero)]
                 | 
            
60  | 
              
                pub(crate) async fn read_piped_passphrase() -> LairResult<sodoken::BufRead> {
                 | 
            
6  | 
              
                    clippy::cyclomatic_complexity,
                 | 
            
7  | 
              
                    clippy::len_zero,
                 | 
            
8  | 
              
                    clippy::single_match,
                 | 
            
540  | 
              
                    #[allow(clippy::len_zero)]
                 | 
            
541  | 
              
                    fn read(raw: &mut &'a [u8]) -> Result<MetaMessage<'a>> {
                 | 
            
231  | 
              
                impl<'a> SystemCommon<'a> {
                 | 
            
232  | 
              
                    #[allow(clippy::len_zero)]
                 | 
            
233  | 
              
                    fn read(status: u8, data: &'a [u7]) -> Result<SystemCommon<'a>> {
                 | 
            
4075  | 
              
                    #[test]
                 | 
            
4076  | 
              
                    #[allow(clippy::len_zero)]
                 | 
            
4077  | 
              
                    fn bytes() {
                 | 
            
149  | 
              
                        #[allow(clippy::len_zero)]
                 | 
            
150  | 
              
                        if 0 < byline.len() && byline.len() < 100 {
                 | 
            
298  | 
              
                                    let leading = offset..start;
                 | 
            
299  | 
              
                                    #[allow(clippy::len_zero)]
                 | 
            
300  | 
              
                                    if leading.len() > 0 {
                  
                 | 
            
346  | 
              
                                let trailing = offset..lines_bytes.len();
                 | 
            
347  | 
              
                                #[allow(clippy::len_zero)]
                 | 
            
348  | 
              
                                if trailing.len() > 0 {
                 | 
            
30  | 
              
                    let numbers: Vec<&str> = string.split('.').collect();
                 | 
            
31  | 
              
                    #[allow(clippy::len_zero)]
                 | 
            
32  | 
              
                    if numbers.len() > 0 {
                 | 
            
48  | 
              
                    // characters between 1 and 2 required
                 | 
            
49  | 
              
                    #[allow(clippy::len_zero)]
                 | 
            
50  | 
              
                    fn from_str(s: &str) -> Result<Self, Self::Err> {
                 | 
            
666  | 
              
                  // sure.
                 | 
            
667  | 
              
                  #[allow(clippy::len_zero)]
                 | 
            
668  | 
              
                  #[inline(always)]
                 | 
            
434  | 
              
                  // sure.
                 | 
            
435  | 
              
                  #[allow(clippy::len_zero)]
                 | 
            
436  | 
              
                  #[inline(always)]
                 | 
            
195  | 
              
                                for (mask, range) in self.channels.iter() {
                 | 
            
196  | 
              
                                    #[allow(clippy::len_zero)]
                 | 
            
197  | 
              
                                    if range.len() > 0 {
                 | 
            
69  | 
              
                /// can be used to perform such a check at compile time.
                 | 
            
70  | 
              
                #[allow(clippy::len_zero)]
                 | 
            
71  | 
              
                pub const fn check_compatible_version(bindgen_version: &'static str) -> bool {
                 | 
            
44  | 
              
                    fn read_u8(rest: &mut &'static [u8]) -> Result<&'static [u8], Error> {
                 | 
            
45  | 
              
                        #[allow(clippy::len_zero)]
                 | 
            
46  | 
              
                        if rest.len() < 1 {
                 | 
            
52  | 
              
                    #[allow(clippy::len_zero)]
                 | 
            
53  | 
              
                    let sa_0 = if sub_auths.len() > 0 { sub_auths[0] } else { 0 };
                 | 
            
321  | 
              
                    #[inline]
                 | 
            
322  | 
              
                    #[allow(clippy::len_zero)] // more explicit to enforce safety invariants
                 | 
            
323  | 
              
                    fn check_indices_and_things(self) -> Result<(), ZeroVecError> {
                 | 
            
137  | 
              
                        #[allow(clippy::len_zero)]
                 | 
            
138  | 
              
                        if bytes.len() >= USIZE_BYTES {
                 | 
            
95  | 
              
                #![allow(clippy::if_same_then_else)]
                 | 
            
96  | 
              
                #![allow(clippy::len_zero)]
                 | 
            
97  | 
              
                #![allow(clippy::match_bool)]
                 | 
            
2  | 
              
                #![allow(unused_mut)]
                 | 
            
3  | 
              
                #![allow(clippy::len_zero)]
                 | 
            
4  | 
              
                use std::{
                 | 
            
1  | 
              
                #![allow(clippy::len_zero)]
                 | 
            
2  | 
              
                use crate::error::Result;
                 | 
            
1  | 
              
                #![allow(clippy::type_complexity, clippy::len_zero)]
                 | 
            
2  | 
              
                use crate::args::{Argument, ArgumentList};
                 | 
            
1  | 
              
                #![allow(clippy::len_zero)]
                 | 
            
2  | 
              
                use crate::command::Command;
                 | 
            
1  | 
              
                #![allow(clippy::len_zero)]
                 | 
            
2  | 
              
                use crate::args::{Argument, ArgumentList};
                 | 
            
1  | 
              
                #![allow(clippy::collapsible_if, clippy::len_zero)]
                 | 
            
2  | 
              
                use std::borrow::Borrow;
                 | 
            
1  | 
              
                #![allow(clippy::len_zero, clippy::redundant_closure)]
                 | 
            
2  | 
              
                use crate::command::{is_option_bool_flag, FnArgData};
                 | 
            
1  | 
              
                #![allow(clippy::len_zero, clippy::redundant_closure, clippy::bool_comparison)]
                 | 
            
1  | 
              
                #![allow(clippy::len_zero)]
                 | 
            
2  | 
              
                use std::fmt::{Display, Formatter};
                 | 
            
2  | 
              
                #![allow(clippy::int_plus_one)]
                 | 
            
3  | 
              
                #![allow(clippy::len_zero)]
                 | 
            
4  | 
              
                #![cfg_attr(feature = "bench", feature(test))]
                 | 
            
3  | 
              
                #![allow(clippy::type_complexity)]
                 | 
            
4  | 
              
                #![allow(clippy::len_zero)]
                 | 
            
5  | 
              
                #![allow(clippy::unnecessary_wraps)]
                 | 
            
1  | 
              
                #![allow(
                 | 
            
2  | 
              
                	clippy::len_zero,
                 | 
            
3  | 
              
                	clippy::tabs_in_doc_comments,
                 | 
            
1  | 
              
                #![allow(
                 | 
            
2  | 
              
                	clippy::len_zero,
                 | 
            
3  | 
              
                	clippy::tabs_in_doc_comments,
                 | 
            
1  | 
              
                #![allow(clippy::if_same_then_else)]
                 | 
            
2  | 
              
                #![allow(clippy::len_zero)]
                 | 
            
3  | 
              
                #![allow(clippy::redundant_pattern_matching)]
                 | 
            
46  | 
              
                  clippy::needless_return,
                 | 
            
47  | 
              
                  clippy::len_zero,
                 | 
            
48  | 
              
                  clippy::len_without_is_empty,  
                 | 
            
5  | 
              
                  clippy::needless_return,
                 | 
            
6  | 
              
                  clippy::len_zero,
                 | 
            
7  | 
              
                  clippy::let_and_return
                 | 
            
10  | 
              
                    clippy::float_cmp,
                 | 
            
11  | 
              
                    clippy::len_zero,
                 | 
            
12  | 
              
                    clippy::double_neg,
                 | 
            
5  | 
              
                    clippy::float_cmp,
                 | 
            
6  | 
              
                    clippy::len_zero,
                 | 
            
7  | 
              
                    clippy::double_neg,
                 | 
            
5  | 
              
                    clippy::float_cmp,
                 | 
            
6  | 
              
                    clippy::len_zero,
                 | 
            
7  | 
              
                    clippy::double_neg,
                 | 
            
106  | 
              
                    clippy::new_without_default,
                 | 
            
107  | 
              
                    clippy::len_zero,
                 | 
            
108  | 
              
                    clippy::len_without_is_empty,
                 | 
            
16  | 
              
                #![cfg_attr(doc_cfg, feature(doc_cfg))]
                 | 
            
17  | 
              
                #![allow(clippy::len_zero)]
                 | 
            
18  | 
              
                #![allow(clippy::type_complexity)]
                 | 
            
95  | 
              
                #![allow(clippy::if_same_then_else)]
                 | 
            
96  | 
              
                #![allow(clippy::len_zero)]
                 | 
            
97  | 
              
                #![allow(clippy::match_bool)]
                 | 
            
1  | 
              
                #![warn(clippy::clone_double_ref)]
                 | 
            
2  | 
              
                #![allow(clippy::len_zero)]
                 | 
            
1  | 
              
                #![warn(clippy::clone_double_ref)]
                 | 
            
2  | 
              
                #![allow(clippy::len_zero)]
                 | 
            
4  | 
              
                    clippy::large_enum_variant,
                 | 
            
5  | 
              
                    clippy::len_zero,
                 | 
            
6  | 
              
                    clippy::needless_return,
                 | 
            
2  | 
              
                #![allow(unused_results)]
                 | 
            
3  | 
              
                #![allow(clippy::needless_return, clippy::similar_names, clippy::use_self, clippy::len_zero,clippy::explicit_iter_loop)]
                 | 
            
2  | 
              
                #![allow(unused_doc_comments)] // /* TODO temporary because of err.rs */
                 | 
            
3  | 
              
                #![allow(clippy::len_zero, clippy::should_implement_trait, clippy::manual_map, clippy::from_over_into)]
                 | 
            
8  | 
              
                  clippy::derive_partial_eq_without_eq,
                 | 
            
9  | 
              
                  clippy::len_zero,
                 | 
            
10  | 
              
                  clippy::manual_range_contains,
                 | 
            
8  | 
              
                  clippy::derive_partial_eq_without_eq,
                 | 
            
9  | 
              
                  clippy::len_zero,
                 | 
            
10  | 
              
                  clippy::manual_range_contains,
                 | 
            
1  | 
              
                #![allow(clippy::len_zero)]
                 | 
            
24  | 
              
                #![allow(clippy::redundant_field_names)]
                 | 
            
25  | 
              
                #![allow(clippy::len_zero)]
                 | 
            
1  | 
              
                // chunked decoder module is largely from async-h1, with modifications to use http lib
                 | 
            
2  | 
              
                #![allow(clippy::len_zero)]
                 | 
            
3  | 
              
                #![allow(clippy::reversed_empty_ranges)]
                 | 
            
1  | 
              
                // chunked encoder module is largely from async-h1, with modifications to use http lib
                 | 
            
2  | 
              
                #![allow(clippy::len_zero)]
                 | 
            
3  | 
              
                #![allow(clippy::manual_saturating_arithmetic)]
                 | 
            
1  | 
              
                #![allow(clippy::len_zero)]
                 | 
            
2  | 
              
                #[macro_use]
                 | 
            
1  | 
              
                #![allow(clippy::len_zero)]
                 | 
            
2  | 
              
                #![allow(clippy::missing_safety_doc)]
                 | 
            
1  | 
              
                #![allow(clippy::len_zero)]
                 | 
            
2  | 
              
                #![allow(clippy::missing_safety_doc)]
                 | 
            
1  | 
              
                #![allow(clippy::len_zero)]
                 | 
            
2  | 
              
                #[macro_use]
                 | 
            
1  | 
              
                #![allow(clippy::len_zero)]
                 | 
            
2  | 
              
                #[macro_use]
                 | 
            
1  | 
              
                #![allow(clippy::len_zero)]
                 | 
            
2  | 
              
                #[macro_use]
                 | 
            
1  | 
              
                #![allow(clippy::len_zero)]
                 | 
            
2  | 
              
                #[allow(unused_imports)]
                 | 
            
1  | 
              
                #![allow(clippy::len_zero)]
                 | 
            
2  | 
              
                #[macro_use]
                 | 
            
1  | 
              
                #![allow(clippy::len_zero)]
                 | 
            
2  | 
              
                #[macro_use]
                 | 
            
1  | 
              
                #![allow(clippy::len_zero)]
                 | 
            
2  | 
              
                //! # Tract TensorFlow module
                 | 
            
31  | 
              
                    clippy::iter_nth_zero,
                 | 
            
32  | 
              
                    clippy::len_zero,
                 | 
            
33  | 
              
                    clippy::assign_op_pattern,
                 |