• amadeus-derive 0.4.3/src/lib.rs
    676
    		 
    		for meta_items in field.attrs.iter().filter_map(get_amadeus_meta_items) {
    677
    		 
    			#[allow(clippy::never_loop)]
    678
    		 
    			for meta_item in meta_items {
  • amadeus-parquet-derive 0.1.1/src/lib.rs
    316
    		 
    		for meta_items in field.attrs.iter().filter_map(get_parquet_meta_items) {
    317
    		 
    			#[allow(clippy::never_loop)]
    318
    		 
    			for meta_item in meta_items {
  • assets_manager 0.9.4/src/entry.rs
    189
    		 
        {
    190
    		 
            #[allow(clippy::never_loop)]
    191
    		 
            let inner = loop {
  • basalt 0.19.1/src/interface/bin/mod.rs
    2299
    		 
                // TODO: When stabilized: https://github.com/rust-lang/rust/issues/48594
    2300
    		 
                #[allow(clippy::never_loop)]
    2301
    		 
                loop {
  • beryllium 0.9.0/examples/gl_window.rs
    35
    		 
        // Process events from this frame.
    36
    		 
        #[allow(clippy::never_loop)]
    37
    		 
        while let Some((event, _timestamp)) = sdl.poll_events() {
  • bio 1.1.0/src/pattern_matching/myers/traceback.rs
    307
    		 
                // which would use more space.
    308
    		 
                #[allow(clippy::never_loop)]
    309
    		 
                loop {
  • cedarwood 0.4.6/src/lib.rs
    198
    		 
        fn next_until_none(&mut self) -> Option<(i32, usize)> {
    199
    		 
            #[allow(clippy::never_loop)]
    200
    		 
            while let Some(value) = self.value {
  • cfn-guard 2.1.3/src/commands/test.rs
    281
    		 
    #[allow(clippy::never_loop)]
    282
    		 
    fn test_with_data(
  • cglue-gen 0.2.7/src/func.rs
    1282
    		 
    impl ParsedReturnType {
    1283
    		 
        #[allow(clippy::never_loop)]
    1284
    		 
        fn new(
  • czkawka_core 5.0.2/src/similar_images.rs
    564
    		 
                    #[allow(clippy::never_loop)] // Required to implement nice if/else
    565
    		 
                    'krztyna: loop {
  • czkawka_gui 5.0.2/src/connect_things/connect_button_compare.rs
    362
    		 
            if is_heic || is_webp {
    363
    		 
                #[allow(clippy::never_loop)]
    364
    		 
                'czystka: loop {
    415
    		 
            #[allow(clippy::never_loop)]
    416
    		 
            loop {
  • czkawka_gui 5.0.2/src/initialize_gui.rs
    573
    		 
            // TODO labels on {} are in testing stage, so we just ignore for now this warning until found better idea how to fix this
    574
    		 
            #[allow(clippy::never_loop)]
    575
    		 
            'dir: loop {
  • d4 0.3.7/src/stab/sparse_array/reader.rs
    244
    		 
            #[inline(never)]
    245
    		 
            #[allow(clippy::never_loop)]
    246
    		 
            fn seek(&mut self, pos: u32, seq_hint: bool) -> Option<i32> {
  • dcc-tiler 0.1.2/src/graph.rs
    36
    		 
        #[allow(clippy::never_loop)]
    37
    		 
        pub fn get_complete_index(&self) -> Option<usize> {
  • dittolive-ditto 4.0.0-beta1/tests/snippets.rs
    309
    		 
                //@ditto/snippet-ignore-next-line
    310
    		 
                #[allow(clippy::never_loop)]
    311
    		 
                for doc in rx.iter() {
  • drone 0.14.0/src/utils.rs
    91
    		 
    /// Run the closure in a different thread, periodically checking the signals.
    92
    		 
    #[allow(clippy::never_loop)]
    93
    		 
    pub fn block_with_signals<F, R>(signals: &mut Signals, ignore_sigint: bool, f: F) -> Result<R>
  • encoding_rs 0.8.31/src/utf_8.rs
    231
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(never_loop, cyclomatic_complexity))]
    232
    		 
    pub fn convert_utf8_to_utf16_up_to_invalid(src: &[u8], dst: &mut [u16]) -> (usize, usize) {
    608
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(never_loop))]
    609
    		 
    #[inline(never)]
  • erc20_payment_lib 0.1.0/src/service.rs
    732
    		 
            //TODO - This loop is getting only first element, fix code so only one transaction is taken from db
    733
    		 
            #[allow(clippy::never_loop)]
    734
    		 
            for tx in &mut transactions {
  • esl01-dag 0.3.0/src/default_impl.rs
    261
    		 
        while let Some(v) = to_visit.pop() {
    262
    		 
            #[allow(clippy::never_loop)]
    263
    		 
            if let Some(parent) = this.parent_names(v).await?.into_iter().next() {
  • esl01-indexedlog 0.3.0/src/log/repair.rs
    64
    		 
                (|| -> crate::Result<()> {
    65
    		 
                    #[allow(clippy::never_loop)]
    66
    		 
                    let header_corrupted = loop {
  • etty 0.0.0/src/evt.rs
    355
    		 
        };
    356
    		 
        #[allow(clippy::never_loop)] // it does loop idk why clippy yell at it.
    357
    		 
        for next_b in iter.by_ref() {
  • forgiving-semver-parser 0.10.1/src/lexer.rs
    211
    		 
        fn next(&mut self) -> Option<Self::Item> {
    212
    		 
            #[allow(clippy::never_loop)]
    213
    		 
            loop {
  • frawk 0.4.7/src/interp.rs
    640
    		 
        #[allow(clippy::never_loop)]
    641
    		 
        pub(crate) fn run_at(&mut self, mut cur_fn: usize) -> Result<i32> {
  • frawk 0.4.7/src/lexer.rs
    511
    		 
        #[allow(clippy::never_loop)]
    512
    		 
        fn consume_ws(&mut self) {
  • frawk 0.4.7/src/runtime/str_impl.rs
    812
    		 
        #[allow(clippy::never_loop)]
    813
    		 
        unsafe fn force(&self) {
  • gles31 1.0.1/examples/beryllium_ex.rs
    55
    		 
        // Process events from this frame.
    56
    		 
        #[allow(clippy::never_loop)]
    57
    		 
        while let Some((event, _timestamp)) = sdl.poll_events() {
  • hexpm 2.0.0/src/version/lexer.rs
    209
    		 
        fn next(&mut self) -> Option<Self::Item> {
    210
    		 
            #[allow(clippy::never_loop)]
    211
    		 
            loop {
  • html5ever 0.26.0/src/tokenizer/mod.rs
    685
    		 
        // (this just simplifies control flow vs. break / continue).
    686
    		 
        #[allow(clippy::never_loop)]
    687
    		 
        fn step(&mut self, input: &mut BufferQueue) -> ProcessResult<Sink::Handle> {
  • hyperpom 0.1.2/src/core.rs
    719
    		 
        /// Starts the fuzzing loop.
    720
    		 
        #[allow(clippy::never_loop)]
    721
    		 
        fn run(&mut self, init_corpus: bool, mut iterations: Option<u64>) -> Result<()> {
  • iced-x86 1.18.0/src/decoder/handlers.rs
    280
    		 
    	#[allow(clippy::never_loop)]
    281
    		 
    	fn decode(self_ptr: *const OpCodeHandler, decoder: &mut Decoder<'_>, instruction: &mut Instruction) {
  • iced-x86 1.18.0/src/decoder.rs
    2095
    		 
    	#[cfg(not(feature = "__internal_flip"))]
    2096
    		 
    	#[allow(clippy::never_loop)]
    2097
    		 
    	fn read_op_mem_1(instruction: &mut Instruction, this: &mut Decoder<'_>) -> bool {
    2116
    		 
    	#[cfg(not(feature = "__internal_flip"))]
    2117
    		 
    	#[allow(clippy::never_loop)]
    2118
    		 
    	fn read_op_mem_1_4(instruction: &mut Instruction, this: &mut Decoder<'_>) -> bool {
    2169
    		 
    	#[cfg(not(feature = "__internal_flip"))]
    2170
    		 
    	#[allow(clippy::never_loop)]
    2171
    		 
    	fn read_op_mem_0_5(instruction: &mut Instruction, this: &mut Decoder<'_>) -> bool {
    2197
    		 
    	#[cfg(not(feature = "__internal_flip"))]
    2198
    		 
    	#[allow(clippy::never_loop)]
    2199
    		 
    	fn read_op_mem_2_4(instruction: &mut Instruction, this: &mut Decoder<'_>) -> bool {
    2238
    		 
    	#[cfg(not(feature = "__internal_flip"))]
    2239
    		 
    	#[allow(clippy::never_loop)]
    2240
    		 
    	fn read_op_mem_2(instruction: &mut Instruction, this: &mut Decoder<'_>) -> bool {
  • icu_normalizer 1.1.0/src/lib.rs
    1026
    		 
                // The loop is only broken out of as goto forward
    1027
    		 
                #[allow(clippy::never_loop)]
    1028
    		 
                loop {
  • icu_normalizer 1.1.0/src/properties.rs
    176
    		 
            // The loop is only broken out of as goto forward
    177
    		 
            #[allow(clippy::never_loop)]
    178
    		 
            loop {
  • jatsl 0.2.0/src/scheduler.rs
    92
    		 
            spawn_abortable(async move {
    93
    		 
                #[allow(clippy::never_loop)]
    94
    		 
                while let Some(status) = rx.next().await {
  • juniper-from-schema-code-gen 0.5.2/src/parse_input.rs
    50
    		 
            #[allow(clippy::never_loop)]
    51
    		 
            for (name, (_, span)) in configs {
  • leo-asg 1.5.3/src/program/function.rs
    167
    		 
            #[allow(clippy::never_loop)] // TODO @Protryon: How should we return multiple errors?
    168
    		 
            for (span, error) in director.reducer().errors {
  • lib-ruby-parser 4.0.4+ruby-3.1.1/src/lexer/main.rs
    273
    		 
                            #[allow(clippy::never_loop)]
    274
    		 
                            // emulate ugly C switch with fall-through logic
  • libosu 0.0.28/src/spline/mod.rs
    149
    		 
                    // TODO: hack to allow breaks
    150
    		 
                    #[allow(clippy::never_loop)]
    151
    		 
                    'outer: loop {
  • longshot 0.1.4/src/ecam/ecam_wrapper.rs
    82
    		 
            }
    83
    		 
            #[allow(clippy::never_loop)]
    84
    		 
            for alarm in state.alarms.set() {
  • mediator 0.2.2/src/futures/stream/generate_stream.rs
    91
    		 
        #[allow(clippy::never_loop)]
    92
    		 
        fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
  • mediator 0.2.2/src/futures/stream/generate_try_stream.rs
    58
    		 
        #[allow(clippy::never_loop)]
    59
    		 
        fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
  • meli 0.7.2/src/terminal/cells.rs
    1365
    		 
        #[allow(clippy::never_loop)]
    1366
    		 
        fn set_and_join_vert(grid: &mut CellBuffer, idx: Pos) -> u32 {
    1459
    		 
        #[allow(clippy::never_loop)]
    1460
    		 
        fn set_and_join_horz(grid: &mut CellBuffer, idx: Pos) -> u32 {
  • mprober 0.11.0-beta.12/src/main.rs
    835
    		 
        #[allow(clippy::never_loop)]
    836
    		 
        loop {
  • nettfiske 0.3.0/src/nettfiske.rs
    93
    		 
        #[allow(clippy::never_loop)]
    94
    		 
        fn search_tldl_on_subdomain(&self, sub_domain: &[&str]) -> usize {
  • noctilucent 0.2.0/src/parser/condition.rs
    89
    		 
        // the keys
    90
    		 
        #[allow(clippy::never_loop)]
    91
    		 
        for (condition_name, condition_object) in val {
  • noctilucent 0.2.0/src/parser/lookup_table.rs
    97
    		 
        let mut outer_mapping: MappingParseTree = MappingParseTree::new();
    98
    		 
        #[allow(clippy::never_loop)]
    99
    		 
        for (outer_key, inner_mapping_obj) in val {
    112
    		 
        let mut inner_mapping: HashMap<String, MappingInnerValue> = HashMap::new();
    113
    		 
        #[allow(clippy::never_loop)]
    114
    		 
        for (inner_key, inner_mapping_obj) in val {
  • noctilucent 0.2.0/src/parser/resource.rs
    182
    		 
        } else {
    183
    		 
            #[allow(clippy::never_loop)]
    184
    		 
            for (resource_name, resource_object) in val {
  • noria-dataflow 0.6.0/src/domain/mod.rs
    1796
    		 
            // this loop is just here so we have a way of giving up the borrow of self.replay_paths
    1797
    		 
            #[allow(clippy::never_loop)]
    1798
    		 
            'outer: loop {
  • observer 0.2.5/src/sql_parse.rs
    39
    		 
            {
    40
    		 
                #[allow(clippy::never_loop)]
    41
    		 
                for x in ast {
  • opencv-binding-generator 0.55.0/src/writer/rust_native/func.rs
    317
    		 
    			let args = self.arguments();
    318
    		 
    			#[allow(clippy::never_loop)] // fixme use named block when MSRV is 1.65
    319
    		 
    			'ctor_name: loop {
  • opencv-binding-generator 0.55.0/src/writer/rust_native/type_ref.rs
    139
    		 
    	fn rust_arg_func_decl(&self, name: &str) -> String {
    140
    		 
    		#[allow(clippy::never_loop)] // fixme use named block when MSRV is 1.65
    141
    		 
    		let typ = 'decl_type: loop {
    360
    		 
    		};
    361
    		 
    		#[allow(clippy::never_loop)] // fixme use named block when MSRV is 1.65
    362
    		 
    		'typ: loop {
  • oxigen 2.2.2/src/lib.rs
    610
    		 
        #[allow(clippy::never_loop)]
    611
    		 
        fn not_found_yet_solution(solutions: &[Ind], other: &Ind) -> bool {
  • p256-cm4 0.3.0/src/lib.rs
    636
    		 
    pub fn sign_step1(result: &mut SignPrecomp, k: &[u32; 8]) -> bool {
    637
    		 
        #[allow(clippy::never_loop)]
    638
    		 
        loop {
    691
    		 
    ) -> bool {
    692
    		 
        #[allow(clippy::never_loop)]
    693
    		 
        loop {
  • palaver 0.3.0-alpha.3/src/file.rs
    31
    		 
    	loop {
    32
    		 
    		#[allow(clippy::never_loop)]
    33
    		 
    		let i = 'a: loop {
  • plotters 0.3.4/src/data/float.rs
    16
    		 
    #[allow(clippy::never_loop)]
    17
    		 
    fn float_to_string(n: f64, max_precision: usize, min_decimal: usize) -> String {
  • printpdf 0.5.3/src/extgstate.rs
    1513
    		 
    impl Into<(Vec<i64>, i64)> for LineDashPattern {
    1514
    		 
        #[cfg_attr(feature = "cargo-clippy", allow(never_loop))]
    1515
    		 
        #[cfg_attr(feature = "cargo-clippy", allow(while_let_loop))]
  • regress 0.4.1/src/classicalbacktrack.rs
    533
    		 
            // to.
    534
    		 
            #[allow(clippy::never_loop)]
    535
    		 
            'nextinsn: loop {
  • rlsf 0.2.0/src/tlsf.rs
    1299
    		 
            // Grow into the next free block. Fail if there isn't such a block.
    1300
    		 
            #[allow(clippy::never_loop)]
    1301
    		 
            'nonmoving: loop {
  • rocketmq 0.0.4/src/remoting/connection.rs
    129
    		 
            }
    130
    		 
            #[allow(clippy::never_loop)]
    131
    		 
            loop {
  • rune 0.12.0/src/compile/v1/assemble.rs
    2937
    		 
            // NB: loop is actually useful.
    2938
    		 
            #[allow(clippy::never_loop)]
    2939
    		 
            loop {
  • rune 0.12.0/src/parse/lexer.rs
    96
    		 
                // This loop is useful.
    97
    		 
                #[allow(clippy::never_loop)]
    98
    		 
                loop {
    524
    		 
                // This loop is useful, at least until it's rewritten.
    525
    		 
                #[allow(clippy::never_loop)]
    526
    		 
                let kind = loop {
  • rune 0.12.0/src/runtime/vm.rs
    1826
    		 
            // This is a useful pattern.
    1827
    		 
            #[allow(clippy::never_loop)]
    1828
    		 
            loop {
  • rune-languageserver 0.12.0/src/main.rs
    84
    		 
        #[allow(clippy::never_loop)]
    85
    		 
        for arg in it {
  • rune-macros 0.12.0/src/context.rs
    228
    		 
            for attr in input {
    229
    		 
                #[allow(clippy::never_loop)] // I guess this is on purpose?
    230
    		 
                for meta in self.get_meta_items(attr, RUNE)? {
  • runestick 0.9.1/src/vm.rs
    1856
    		 
            // This is a useful pattern.
    1857
    		 
            #[allow(clippy::never_loop)]
    1858
    		 
            loop {
  • russh-keys 0.24.0/src/format/openssh.rs
    33
    		 
            let _check1 = position.read_u32()?;
    34
    		 
            #[allow(clippy::never_loop)]
    35
    		 
            for _ in 0..nkeys {
  • rusty_sword_arena 2.0.0/src/bin/server.rs
    397
    		 
    #[allow(clippy::never_loop)]
    398
    		 
    fn process_game_control_requests(
  • sanitise-file-name 1.0.0/src/lib.rs
    796
    		 
        // When label-break-value stabilises I’ll switch to that, but until then, loop it is.
    797
    		 
        #[allow(clippy::never_loop)]
    798
    		 
        loop {  // breaks after exactly one iteration.
  • sea-schema 0.11.0/src/mysql/discovery/mod.rs
    55
    		 
            #[allow(clippy::never_loop)]
    56
    		 
            for row in rows.iter() {
  • semver-parser 0.10.2/src/lexer.rs
    211
    		 
        fn next(&mut self) -> Option<Self::Item> {
    212
    		 
            #[allow(clippy::never_loop)]
    213
    		 
            loop {
  • sequoia-sq 0.27.0/src/sq.rs
    214
    		 
    /// armor::Kind::File is returned as safe default.
    215
    		 
    #[allow(clippy::never_loop)]
    216
    		 
    fn detect_armor_kind(input: Box<dyn BufferedReader<()>>)
  • serde_taml 0.0.3/tests/data_literals.rs
    32
    		 
    				let mut chars = text.char_indices();
    33
    		 
    				#[allow(clippy::never_loop)]
    34
    		 
    				let mut error_start = 'success: loop {
  • sewup 0.1.14/src/types/row.rs
    92
    		 
        #[allow(clippy::never_loop)]
    93
    		 
        fn next(&mut self) -> Option<Self::Item> {
    106
    		 
        #[allow(clippy::never_loop)]
    107
    		 
        fn next(&mut self) -> Option<Self::Item> {
  • shadowsocks 1.15.2/src/relay/tcprelay/proxy_stream/client.rs
    207
    		 
            #[allow(clippy::never_loop)]
    208
    		 
            loop {
  • shadowsocks 1.15.2/src/relay/tcprelay/proxy_stream/server.rs
    174
    		 
            #[allow(clippy::never_loop)]
    175
    		 
            loop {
  • shio 0.3.0/src/shio.rs
    59
    		 
        #[cfg_attr(feature = "cargo-clippy", allow(use_debug, never_loop))]
    60
    		 
        pub fn run<A: ToSocketAddrsExt>(&self, addr: A) -> Result<(), ListenError> {
  • snakesss 0.1.2/src/food.rs
    21
    		 
            // It's not true that it never loops!
    22
    		 
            #[allow(clippy::never_loop)]
    23
    		 
            let p = loop {
  • sonic-server 1.4.0/src/channel/handle.rs
    194
    		 
        fn ensure_start(mut stream: &TcpStream) -> Result<ChannelMode, ChannelHandleError> {
    195
    		 
            #[allow(clippy::never_loop)]
    196
    		 
            loop {
  • spectrusty-formats 0.4.0/src/mdr.rs
    759
    		 
            let mut sector_iter = self.file_sectors(file_name);
    760
    		 
            #[allow(clippy::never_loop)]
    761
    		 
            let mut tran = loop {
  • starlark 0.8.0/src/stdlib/funcs.rs
    444
    		 
            // Most strings are ASCII strings, try them first.
    445
    		 
            #[allow(clippy::never_loop)]
    446
    		 
            'ascii: loop {
  • stylua 0.16.0/src/formatters/functions.rs
    880
    		 
        // Add trailing trivia to the first line of the function body
    881
    		 
        #[allow(clippy::never_loop)]
    882
    		 
        #[allow(unused_variables)]
  • super_speedy_syslog_searcher 0.2.50/src/readers/blockreader.rs
    967
    		 
                    //       header/blocks of the underlying .xz file
    968
    		 
                    #[allow(clippy::never_loop)]
    969
    		 
                    loop {
  • symphonia-format-mkv 0.5.2/src/ebml.rs
    19
    		 
    /// and a flag indicating whether any data was ignored, or an error.
    20
    		 
    #[allow(clippy::never_loop)]
    21
    		 
    pub(crate) fn read_tag<R: ReadBytes>(mut reader: R) -> Result<(u32, u32, bool)> {
  • taplo 1.0.0-alpha.6/src/dom.rs
    434
    		 
            #[allow(clippy::never_loop)]
    435
    		 
            'outer: for (group_idx, group) in grouped_by_index.iter().enumerate() {
  • tokio-newrelic 0.1.0/src/sql_parser.rs
    36
    		 
            {
    37
    		 
                #[allow(clippy::never_loop)]
    38
    		 
                for x in ast {
  • tor-proto 0.8.0/src/circuit/reactor.rs
    551
    		 
                    // (using this as a named block for early returns; not actually a loop)
    552
    		 
                    #[allow(clippy::never_loop)]
    553
    		 
                    'outer: loop {
  • utf8_iter 1.0.3/src/lib.rs
    162
    		 
            // This loop is only broken out of as goto forward
    163
    		 
            #[allow(clippy::never_loop)]
    164
    		 
            loop {
  • vkgen 2.2.1/src/parse.rs
    922
    		 
    pub fn convert_c_type(ty: &str, outer: &str) -> String {
    923
    		 
    	#[allow(clippy::never_loop)]
    924
    		 
    		let ty = 'outer: loop {
  • xml5ever 0.17.0/src/tokenizer/mod.rs
    641
    		 
        // (this just simplifies control flow vs. break / continue).
    642
    		 
        #[allow(clippy::never_loop)]
    643
    		 
        fn step(&mut self, input: &mut BufferQueue) -> bool {
  • xshell-venv 1.1.0/src/lib.rs
    103
    		 
    fn find_directory(name: &str) -> PathBuf {
    104
    		 
        #[allow(clippy::never_loop)]
    105
    		 
        let mut venv_dir = loop {
  • z80emu 0.8.0/src/z80.rs
    448
    		 
            #[allow(clippy::never_loop)]
    449
    		 
            let reason: LoopExitReason<_,_> = 'main: loop {
  • zi 0.3.2/src/app.rs
    674
    		 
            #[allow(clippy::never_loop)]
    675
    		 
            loop {
  • abscissa 0.7.0/src/commands/new.rs
    3
    		 
    #![allow(clippy::never_loop)]
  • anyhow 1.0.68/tests/test_ensure.rs
    8
    		 
        clippy::match_bool,
    9
    		 
        clippy::never_loop,
    10
    		 
        clippy::overly_complex_bool_expr,
  • auto_enums 0.8.0/tests/auto_enum.rs
    14
    		 
        clippy::needless_return,
    15
    		 
        clippy::never_loop,
    16
    		 
        clippy::unnecessary_wraps,
  • baryon-core 0.1.0/src/lib.rs
    2
    		 
        // We use loops for getting early-out of scope without closures.
    3
    		 
        clippy::never_loop,
    4
    		 
        // We don't use syntax sugar where it's not necessary.
  • canister 0.1.0/src/commands/version.rs
    2
    		 
    //!
    3
    		 
    #![allow(clippy::never_loop)]
  • cargo-move 0.0.0/src/commands/version.rs
    3
    		 
    #![allow(clippy::never_loop)]
  • cargo-movemint 0.0.0/src/commands/version.rs
    3
    		 
    #![allow(clippy::never_loop)]
  • cargo-rpm 0.8.0/src/commands/version.rs
    3
    		 
    #![allow(clippy::never_loop)]
  • db-dump 0.4.1/src/lib.rs
    10
    		 
        clippy::needless_lifetimes,
    11
    		 
        clippy::never_loop,
    12
    		 
        clippy::too_many_lines,
  • db-dump-concat 0.1.1/main.rs
    21
    		 
        clippy::let_underscore_drop,
    22
    		 
        clippy::never_loop,
    23
    		 
        clippy::too_many_lines,
  • delphi 0.0.5/src/commands/version.rs
    3
    		 
    #![allow(clippy::never_loop)]
  • dragonbox 0.1.4/src/lib.rs
    63
    		 
        clippy::must_use_candidate,
    64
    		 
        clippy::never_loop,
    65
    		 
        clippy::ptr_as_ptr,
  • genemichaels 0.1.17/src/lib.rs
    3
    		 
        clippy::field_reassign_with_default,
    4
    		 
        clippy::never_loop,
    5
    		 
        clippy::derive_hash_xor_eq,
  • iced-x86 1.18.0/src/decoder/handlers/legacy.rs
    4
    		 
    #![allow(clippy::never_loop)]
    5
    		 
    #![allow(clippy::useless_let_if_seq)]
  • inside-baseball 0.1.0/src/lib.rs
    7
    		 
        clippy::module_name_repetitions,
    8
    		 
        clippy::never_loop,
    9
    		 
        clippy::single_match,
  • inside-baseball 0.1.0/src/main.rs
    5
    		 
        clippy::module_name_repetitions,
    6
    		 
        clippy::never_loop,
    7
    		 
        clippy::single_match,
  • kas-text 0.6.0/src/display/glyph_pos.rs
    9
    		 
    #![allow(clippy::or_fun_call)]
    10
    		 
    #![allow(clippy::never_loop)]
    11
    		 
    #![allow(clippy::needless_range_loop)]
  • kitsune_p2p_types 0.1.0/src/tx2/mem.rs
    1
    		 
    #![allow(clippy::new_ret_no_self)]
    2
    		 
    #![allow(clippy::never_loop)]
  • kitsune_p2p_types 0.1.0/src/tx2/tx2_utils.rs
    1
    		 
    #![allow(clippy::never_loop)] // using for block breaking
    2
    		 
    //! Utilities to help with developing / testing tx2.
  • ncursesw-win 0.6.3/src/gen/graphicstransform.rs
    23
    		 
    #![allow(clippy::never_loop)]
  • nj-derive 3.4.1/src/lib.rs
    1
    		 
    #![allow(clippy::never_loop)]
    2
    		 
    extern crate proc_macro;
  • pagefind_stem 0.2.0/src/lib.rs
    1
    		 
    #![allow(clippy::if_same_then_else)]
    2
    		 
    #![allow(clippy::never_loop)]
    3
    		 
    #![allow(clippy::almost_swapped)]
  • pbcodec 0.0.8/src/lib.rs
    1
    		 
    #![cfg_attr(feature = "cargo-clippy", allow(type_complexity, useless_format, never_loop))]
  • pilka_ash 0.7.11/src/lib.rs
    3
    		 
        // We use loops for getting early-out of scope without closures.
    4
    		 
        clippy::never_loop,
    5
    		 
        // We don't use syntax sugar where it's not necessary.
  • pilka_wgpu 0.7.11/src/lib.rs
    4
    		 
        // We use loops for getting early-out of scope without closures.
    5
    		 
        clippy::never_loop,
    6
    		 
        // We don't use syntax sugar where it's not necessary.
  • pitchfork 0.0.1/src/commands/version.rs
    3
    		 
    #![allow(clippy::never_loop)]
  • rune 0.12.0/src/lib.rs
    163
    		 
    #![allow(clippy::needless_doctest_main)]
    164
    		 
    #![allow(clippy::never_loop)]
    165
    		 
    #![allow(clippy::too_many_arguments)]
  • rustsec-admin 0.8.5/src/commands/list_affected_versions.rs
    6
    		 
    #![allow(clippy::never_loop)]
    7
    		 
    #![allow(unused_variables)] //TODO
  • rustsec-admin 0.8.5/src/commands/version.rs
    3
    		 
    #![allow(clippy::never_loop)]
  • serde_yaml 0.9.17/src/lib.rs
    151
    		 
        clippy::missing_panics_doc,
    152
    		 
        clippy::never_loop,
    153
    		 
        clippy::return_self_not_must_use,
  • somm_gorc 0.1.1/src/commands/version.rs
    3
    		 
    #![allow(clippy::never_loop)]
  • syn 1.0.107/src/lib.rs
    279
    		 
        clippy::needless_pass_by_value,
    280
    		 
        clippy::never_loop,
    281
    		 
        clippy::redundant_else,
  • syn-impersonated 0.1.18/src/lib.rs
    256
    		 
        clippy::needless_pass_by_value,
    257
    		 
        clippy::never_loop,
    258
    		 
        clippy::suspicious_op_assign_impl,
  • syn-next 1.0.0-rc4/src/lib.rs
    255
    		 
        clippy::needless_pass_by_value,
    256
    		 
        clippy::never_loop,
    257
    		 
        clippy::suspicious_op_assign_impl,
  • syn-pub-items 0.15.30/src/lib.rs
    240
    		 
            needless_pass_by_value,
    241
    		 
            never_loop,
    242
    		 
            redundant_field_names,
  • synchronicity 0.0.1/src/commands/version.rs
    3
    		 
    #![allow(clippy::never_loop)]
  • tendermint-light-node 0.19.0/src/commands/version.rs
    3
    		 
    #![allow(clippy::never_loop)]
  • tuifw-screen-ncurses 0.21.1/src/unicode.rs
    1
    		 
    #![allow(clippy::never_loop)]
  • utf8-chars 2.0.3/src/lib.rs
    4
    		 
    #![doc(test(attr(allow(unused_variables))))]
    5
    		 
    #![allow(clippy::never_loop)]
  • wgpu-core 0.15.0/src/lib.rs
    10
    		 
        // We use loops for getting early-out of scope without closures.
    11
    		 
        clippy::never_loop,
    12
    		 
        // We don't use syntax sugar where it's not necessary.
  • wgpu-hal 0.15.1/src/lib.rs
    21
    		 
        // We use loops for getting early-out of scope without closures.
    22
    		 
        clippy::never_loop,
    23
    		 
        // We don't use syntax sugar where it's not necessary.
  • yarte_html 0.15.2/src/tokenizer/mod.rs
    9
    		 
    //! The HTML5 tokenizer.
    10
    		 
    #![allow(clippy::never_loop, clippy::cognitive_complexity, clippy::single_match)]
    11
    		 
    #![allow(clippy::unnested_or_patterns)]