• abi_stable 0.11.1/src/sabi_types/rsmallbox.rs
    353
    		 
            /// ```
    354
    		 
            #[allow(clippy::redundant_closure)]
    355
    		 
            pub fn into_inner(this: Self) -> T {
  • abscissa 0.7.0/src/commands/new.rs
    42
    		 
            let started_at = Instant::now();
    43
    		 
            #[allow(clippy::redundant_closure)]
    44
    		 
            let app_properties = self.parse_options().unwrap_or_else(|e| fatal_error(e));
    48
    		 
            #[allow(clippy::redundant_closure)]
    49
    		 
            self.create_parent_directory()
    56
    		 
            for template_file in &template_files {
    57
    		 
                #[allow(clippy::redundant_closure)]
    58
    		 
                self.render_template_file(&app_template, template_file, &app_properties)
    62
    		 
            // TODO(tarcieri): make this optional?
    63
    		 
            #[allow(clippy::redundant_closure)]
    64
    		 
            self.run_git_init(branch_name)
    67
    		 
            // TODO(tarcieri): make this optional?
    68
    		 
            #[allow(clippy::redundant_closure)]
    69
    		 
            self.generate_lockfile().unwrap_or_else(|e| fatal_error(e));
  • abscissa_core 0.7.0/src/application/cell.rs
    37
    		 
        #[allow(clippy::redundant_closure)]
    38
    		 
        fn deref(&self) -> &A {
  • abscissa_core 0.7.0/src/config/cell.rs
    29
    		 
        /// Read the current configuration.
    30
    		 
        #[allow(clippy::redundant_closure)]
    31
    		 
        pub fn read(&self) -> Reader<C> {
  • akita 0.4.3/src/mapper.rs
    231
    		 
        #[allow(clippy::redundant_closure)]
    232
    		 
        fn exec_raw<R, S: Into<String>, P: Into<Params>>(
  • aptos-types 0.2.7/src/validator_signer.rs
    81
    		 
        #[allow(clippy::redundant_closure)]
    82
    		 
        pub fn arb_signing_key() -> impl Strategy<Value = bls12381::PrivateKey> {
    102
    		 
        #[allow(clippy::redundant_closure)]
    103
    		 
        pub fn rand_signer() -> impl Strategy<Value = ValidatorSigner> {
    107
    		 
        #[allow(clippy::redundant_closure)]
    108
    		 
        pub fn arb_signer() -> impl Strategy<Value = ValidatorSigner> {
  • aptos-vm 0.2.7/src/move_vm_ext/aggregator_extension.rs
    642
    		 
        #[allow(clippy::redundant_closure)]
    643
    		 
        static TEST_RESOLVER: Lazy<FakeTestStorage> = Lazy::new(|| FakeTestStorage::new());
  • arrow-ipc 32.0.0/src/lib.rs
    28
    		 
    #[allow(clippy::redundant_closure)]
    29
    		 
    #[allow(clippy::needless_lifetimes)]
  • audio-processor-standalone 1.4.0/src/offline.rs
    64
    		 
        #[allow(clippy::redundant_closure)]
    65
    		 
        let handle = handle.unwrap_or_else(|| audio_garbage_collector::handle());
  • battop 0.2.4/src/app/ui/interface.rs
    15
    		 
    #[allow(clippy::redundant_closure)]
    16
    		 
    pub fn init(config: Arc<Config>, views: Vec<View>) -> Result<Interface<impl Backend>> {
  • bevy-inspector-egui 0.17.0/src/inspector_options/std_options.rs
    80
    		 
            NumberOptions {
    81
    		 
                #[allow(clippy::redundant_closure)] // false positive
    82
    		 
                min: self.min.as_ref().map(|min| f(min)),
  • bevy_rapier2d 0.20.0/src/plugin/context.rs
    662
    		 
        ) {
    663
    		 
            #[allow(clippy::redundant_closure)]
    664
    		 
            // False-positive, we can't move callback, closure becomes `FnOnce`
    728
    		 
            };
    729
    		 
            #[allow(clippy::redundant_closure)]
    730
    		 
            // False-positive, we can't move callback, closure becomes `FnOnce`
    860
    		 
            #[allow(clippy::redundant_closure)]
    861
    		 
            // False-positive, we can't move callback, closure becomes `FnOnce`
  • bevy_rapier3d 0.20.0/src/plugin/context.rs
    662
    		 
        ) {
    663
    		 
            #[allow(clippy::redundant_closure)]
    664
    		 
            // False-positive, we can't move callback, closure becomes `FnOnce`
    728
    		 
            };
    729
    		 
            #[allow(clippy::redundant_closure)]
    730
    		 
            // False-positive, we can't move callback, closure becomes `FnOnce`
    860
    		 
            #[allow(clippy::redundant_closure)]
    861
    		 
            // False-positive, we can't move callback, closure becomes `FnOnce`
  • bidivec 0.1.0/src/collections/bidigrowvec.rs
    492
    		 
                // avoid https://github.com/rust-lang/rust-clippy/issues/8098
    493
    		 
                #[allow(clippy::redundant_closure)]
    494
    		 
                self.push_col(std::iter::repeat_with(|| f()).take(self.height()))
    499
    		 
                // avoid https://github.com/rust-lang/rust-clippy/issues/8098
    500
    		 
                #[allow(clippy::redundant_closure)]
    501
    		 
                self.push_row(std::iter::repeat_with(|| f()).take(new_width))
  • bidivec 0.1.0/src/collections/bidivec.rs
    657
    		 
                    // avoid https://github.com/rust-lang/rust-clippy/issues/8098
    658
    		 
                    #[allow(clippy::redundant_closure)]
    659
    		 
                    self.push_col(std::iter::repeat_with(|| f()).take(self.height()))
  • cargo-espmonitor 0.10.0/src/main.rs
    165
    		 
            None => (
    166
    		 
                #[allow(clippy::redundant_closure)]
    167
    		 
                args.chip,
    168
    		 
                #[allow(clippy::redundant_closure)]
    169
    		 
                args.framework,
  • casper-contract 1.4.4/src/contract_api/system.rs
    37
    		 
            // Revert for any possible error that happened on host side
    38
    		 
            #[allow(clippy::redundant_closure)] // false positive
    39
    		 
            let contract_hash_bytes = result.unwrap_or_else(|e| runtime::revert(e));
  • cepler 0.7.13/src/cli.rs
    294
    		 
    #[allow(clippy::redundant_closure)]
    295
    		 
    fn gates_from_matches(matches: &ArgMatches) -> Result<Option<GatesConfig>> {
  • cepler 0.7.13/src/workspace.rs
    177
    		 
        #[allow(clippy::redundant_closure)]
    178
    		 
        fn construct_env_state(
  • cfn-guard 2.1.3/src/rules/parser.rs
    929
    		 
    #[allow(clippy::redundant_closure)]
    930
    		 
    fn clause_with_map<'loc, A, M, T: 'loc>(
    1226
    		 
    //
    1227
    		 
    #[allow(clippy::redundant_closure)]
    1228
    		 
    fn cnf_clauses<'loc, T, E, F, M>(
    1270
    		 
    #[allow(clippy::redundant_closure)]
    1271
    		 
    fn disjunction_clauses<'loc, E, F>(
    1416
    		 
    #[allow(clippy::redundant_closure)]
    1417
    		 
    fn when_conditions<'loc, P>(
    1443
    		 
    #[allow(clippy::redundant_closure)]
    1444
    		 
    fn block<'loc, T, P>(
  • clia-rustorm 0.19.1/src/entity.rs
    315
    		 
        #[allow(clippy::redundant_closure)]
    316
    		 
        pub fn execute_sql_with_return<'a, R>(
  • clia-rustorm 0.19.1/src/pg/numeric.rs
    166
    		 
    impl<'a> From<&'a BigDecimal> for PgNumeric {
    167
    		 
        #[allow(clippy::redundant_closure)]
    168
    		 
        fn from(decimal: &'a BigDecimal) -> Self {
  • config_file_handler 0.11.0/src/file_handler.rs
    266
    		 
        /// Read the contents of the file and decode it as JSON.
    267
    		 
        #[cfg_attr(feature = "cargo-clippy", allow(redundant_closure))] // because of lifetimes
    268
    		 
        pub fn read_file(&self) -> Result<T, Error> {
  • cortex-m-rtic-macros 1.1.5/src/codegen/software_tasks.rs
    41
    		 
            #[allow(clippy::redundant_closure)]
    42
    		 
            let (fq_ty, fq_expr, mk_uninit): (_, _, Box<dyn Fn() -> Option<_>>) = {
  • cranko 0.15.0/src/main.rs
    1065
    		 
    #[allow(clippy::redundant_closure)]
    1066
    		 
    /// Run an external command by executing a subprocess.
  • dashu-int 0.3.1/src/memory.rs
    146
    		 
        {
    147
    		 
            #[allow(clippy::redundant_closure)]
    148
    		 
            let (ptr, slice_end) = self
  • dashu-int 0.3.1/src/modular/pow.rs
    121
    		 
            // Precomputed table of small odd powers up to 2^window_len, starting from raw^3.
    122
    		 
            #[allow(clippy::redundant_closure)]
    123
    		 
            let table_words = ((1usize << (window_len - 1)) - 1)
  • dashu-int 0.3.1/src/parse/power_two.rs
    53
    		 
        let log_radix = radix.trailing_zeros();
    54
    		 
        #[allow(clippy::redundant_closure)]
    55
    		 
        let num_bits = src
  • dashu-int 0.3.1/src/third_party/serde.rs
    155
    		 
    fn len_64_to_max_len(len_64: usize) -> usize {
    156
    		 
        #[allow(clippy::redundant_closure)]
    157
    		 
        len_64
  • ddr-mount 1.1.4/src/parser.rs
    93
    		 
        #[allow(clippy::redundant_closure)]
    94
    		 
        for (line_number, line) in file_line {
  • diem-types 0.0.3/src/validator_signer.rs
    84
    		 
        #[allow(clippy::redundant_closure)]
    85
    		 
        pub fn arb_signing_key() -> impl Strategy<Value = Ed25519PrivateKey> {
    101
    		 
        #[allow(clippy::redundant_closure)]
    102
    		 
        pub fn rand_signer() -> impl Strategy<Value = ValidatorSigner> {
    106
    		 
        #[allow(clippy::redundant_closure)]
    107
    		 
        pub fn arb_signer() -> impl Strategy<Value = ValidatorSigner> {
  • diesel 2.0.3/src/pg/types/numeric.rs
    90
    		 
            // is called. There is no impl for `&i16` that would work with this closure.
    91
    		 
            #[allow(clippy::assign_op_pattern, clippy::redundant_closure)]
    92
    		 
            fn from(decimal: &'a BigDecimal) -> Self {
  • dipstick 0.9.1/src/multi.rs
    21
    		 
        fn metrics(&self) -> Self::SCOPE {
    22
    		 
            #[allow(clippy::redundant_closure)]
    23
    		 
            let scopes = self.inputs.iter().map(|input| input.input_dyn()).collect();
  • dqcsim 0.4.1/src/core/plugin/definition.rs
    80
    		 
        /// directly.
    81
    		 
        #[allow(clippy::redundant_closure)]
    82
    		 
        // Not sure how to fix the lifetime problems that resolving the above
  • dqcsim 0.4.1/tests/core.rs
    511
    		 
    #[test]
    512
    		 
    #[allow(clippy::redundant_closure)]
    513
    		 
    fn bad_simulation_pipeline_too_short() {
    542
    		 
    #[test]
    543
    		 
    #[allow(clippy::redundant_closure)]
    544
    		 
    fn bad_simulation_pipeline_fe_op_only() {
    574
    		 
    #[test]
    575
    		 
    #[allow(clippy::redundant_closure)]
    576
    		 
    fn bad_simulation_pipeline_be_op_only() {
  • dust_dds 0.1.0/src/domain/domain_participant.rs
    155
    		 
        {
    156
    		 
            #[allow(clippy::redundant_closure)]
    157
    		 
            self.0
  • dust_dds 0.1.0/src/publication/data_writer.rs
    386
    		 
        ) -> DdsResult<()> {
    387
    		 
            #[allow(clippy::redundant_closure)]
    388
    		 
            self.0.upgrade()?.set_listener(
  • dust_dds 0.1.0/src/publication/publisher.rs
    82
    		 
        {
    83
    		 
            #[allow(clippy::redundant_closure)]
    84
    		 
            self.0
  • dust_dds 0.1.0/src/subscription/data_reader.rs
    422
    		 
        ) -> DdsResult<()> {
    423
    		 
            #[allow(clippy::redundant_closure)]
    424
    		 
            self.0.upgrade()?.set_listener(
  • dust_dds 0.1.0/src/subscription/subscriber.rs
    97
    		 
                {
    98
    		 
                    #[allow(clippy::redundant_closure)]
    99
    		 
                    s.upgrade()?
  • dust_dds 0.1.0/src/topic_definition/topic.rs
    95
    		 
        ) -> DdsResult<()> {
    96
    		 
            #[allow(clippy::redundant_closure)]
    97
    		 
            self.0.upgrade()?.set_listener(
  • electrscash 3.1.0/src/mempool.rs
    38
    		 
        #[allow(clippy::redundant_closure)]
    39
    		 
        fn add(&mut self, tx: &Transaction) {
  • elrond-wasm 0.38.0/src/types/managed/multi_value/multi_value_managed_vec.rs
    89
    		 
        #[allow(clippy::redundant_closure)]
    90
    		 
        pub fn slice(&self, start_index: usize, end_index: usize) -> Option<Self> {
  • elrond-wasm-debug 0.38.0/src/tx_mock/tx_cache_balance_util.rs
    38
    		 
        #[allow(clippy::redundant_closure)] // clippy is wrong here, `.unwrap_or_else(panic_insufficient_funds)` won't compile
    39
    		 
        pub fn subtract_esdt_balance(
  • eva-ics 3.99.0/src/eapi.rs
    375
    		 
                    let mut p: ParamsState = rmp_serde::from_read_ref(payload).log_err()?;
    376
    		 
                    #[allow(clippy::redundant_closure)]
    377
    		 
                    let mask = p.i.take().unwrap_or_else(|| OIDMask::new_any());
  • eva-rjrpc 0.1.16/src/http.rs
    303
    		 
                    };
    304
    		 
                    #[allow(clippy::redundant_closure)]
    305
    		 
                    let id = qs.remove("i").map(|id| Value::String(id));
    369
    		 
            };
    370
    		 
            #[allow(clippy::redundant_closure)]
    371
    		 
            batch.process(|x, m| processor(x, m)).await;
  • eva-rjrpc 0.1.16/src/lib.rs
    674
    		 
                    }
    675
    		 
                    #[allow(clippy::redundant_closure)]
    676
    		 
                    batch.process(|x, m| processor(x, m)).await;
  • evtclib 0.7.3/src/raw/parser.rs
    480
    		 
    /// * `input` - The input stream.
    481
    		 
    #[allow(clippy::redundant_closure)]
    482
    		 
    pub fn finish_parsing<R: Read>(partial: PartialEvtc, input: R) -> ParseResult<Evtc> {
  • fastobo 0.15.1/src/ast/id/prefix.rs
    21
    		 
    /// Return whether a prefix is canonical.
    22
    		 
    #[allow(clippy::redundant_closure)]
    23
    		 
    pub fn is_canonical<S: AsRef<str>>(s: S) -> bool {
  • feo-math 0.1.0/src/utils/space.rs
    33
    		 
    impl Space {
    34
    		 
        #[allow(clippy::redundant_closure)] // Linter error: .unwrap_or_else() wants FnOnce<_> closure
    35
    		 
        pub fn new(
  • flexiber 0.1.0/src/traits.rs
    203
    		 
        fn encoded_length(&self) -> Result<Length> {
    204
    		 
            #[allow(clippy::redundant_closure)]
    205
    		 
            // if we do as clippy tells, we get:
  • flip-link 0.1.6/src/main.rs
    24
    		 
        // the function signature isn't 100% compatible so we must wrap it
    25
    		 
        #[allow(clippy::redundant_closure)]
    26
    		 
        notmain().map(|code| process::exit(code))
  • fraction 0.13.0/src/fraction/generic_fraction.rs
    565
    		 
        fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self {
    566
    		 
            #[allow(clippy::redundant_closure)]
    567
    		 
            iter.fold(GenericFraction::<T>::zero(), |ref s, x| Add::add(s, x))
    578
    		 
        fn product<I: Iterator<Item = &'a Self>>(iter: I) -> Self {
    579
    		 
            #[allow(clippy::redundant_closure)]
    580
    		 
            iter.fold(GenericFraction::<T>::one(), |ref s, x| Mul::mul(s, x))
  • fyrox-ui 0.20.0/src/ttf.rs
    354
    		 
        #[inline]
    355
    		 
        #[allow(clippy::redundant_closure)]
    356
    		 
        fn char_set(&self) -> &[Range<u32>] {
  • git_lab_cli 0.17.0/src/cmds/issue/create.rs
    89
    		 
        #[allow(clippy::redundant_closure)]  // below closure doesn't work unless called as shown below
    90
    		 
        let weight = Input::<String>::new()
    108
    		 
        #[allow(clippy::redundant_closure)]  // below closure doesn't work unless called as shown below
    109
    		 
        let due_date = Input::<String>::new()
  • good-web-game 0.6.0/src/filesystem.rs
    28
    		 
    impl Filesystem {
    29
    		 
        #[allow(clippy::redundant_closure)]
    30
    		 
        pub(crate) fn new(conf: &Conf) -> Filesystem {
  • gptman 1.0.0/src/cli/commands.rs
    727
    		 
                    } else {
    728
    		 
                        #[allow(clippy::redundant_closure)]
    729
    		 
                        break attributes.into_iter().map(|x| x.unwrap());
  • grafix-toolbox 0.8.7/gui/parts/string.rs
    48
    		 
    	}
    49
    		 
    	#[allow(clippy::redundant_closure)]
    50
    		 
    	pub fn char_at(text: &str, font: &Font, scale: f32, at_glyph: usize) -> Glyph {
  • hbbft 0.1.1/tests/net/mod.rs
    521
    		 
            // Note: Closure is not redundant, won't compile without it.
    522
    		 
            #[allow(clippy::redundant_closure)]
    523
    		 
            let (mut net, steps) = VirtualNet::new(
  • heim-cpu 0.1.0-rc.1/src/sys/linux/freq.rs
    105
    		 
    #[allow(clippy::redundant_closure)]
    106
    		 
    fn read_freq(path: PathBuf) -> Result<Frequency> {
  • heim-net 0.1.0-rc.1/src/sys/linux/counters.rs
    74
    		 
        // 0
    75
    		 
        #[allow(clippy::redundant_closure)]
    76
    		 
        fn from_str(s: &str) -> Result<IoCounters> {
  • holochain_conductor_lib 0.0.52-alpha2/src/lib.rs
    112
    		 
        clippy::suspicious_else_formatting,
    113
    		 
        clippy::redundant_closure,
    114
    		 
        clippy::let_and_return,
    119
    		 
        clippy::suspicious_else_formatting,
    120
    		 
        clippy::redundant_closure,
    121
    		 
        clippy::let_and_return,
    126
    		 
        clippy::suspicious_else_formatting,
    127
    		 
        clippy::redundant_closure,
    128
    		 
        clippy::let_and_return,
    133
    		 
        clippy::suspicious_else_formatting,
    134
    		 
        clippy::redundant_closure,
    135
    		 
        clippy::let_and_return,
    140
    		 
        clippy::suspicious_else_formatting,
    141
    		 
        clippy::redundant_closure,
    142
    		 
        clippy::let_and_return,
  • holochain_core 0.0.52-alpha2/src/lib.rs
    34
    		 
    #[macro_use]
    35
    		 
    #[allow(clippy::suspicious_else_formatting, clippy::redundant_closure)]
    36
    		 
    pub mod macros;
    38
    		 
    // #[autotrace]
    39
    		 
    #[allow(clippy::suspicious_else_formatting, clippy::redundant_closure)]
    40
    		 
    pub mod action;
    41
    		 
    // #[autotrace]
    42
    		 
    #[allow(clippy::suspicious_else_formatting, clippy::redundant_closure)]
    43
    		 
    pub mod agent;
    44
    		 
    // #[autotrace]
    45
    		 
    #[allow(clippy::suspicious_else_formatting, clippy::redundant_closure)]
    46
    		 
    pub mod consistency;
    47
    		 
    // #[autotrace]
    48
    		 
    #[allow(clippy::suspicious_else_formatting, clippy::redundant_closure)]
    49
    		 
    pub mod content_store;
  • humthreads 0.2.1/src/handles/mod.rs
    121
    		 
                // Clippy is not too happy about it though.
    122
    		 
                #[allow(clippy::redundant_closure)]
    123
    		 
                join.join()
  • i-slint-core 0.3.4/properties.rs
    1464
    		 
    #[test]
    1465
    		 
    #[allow(clippy::redundant_closure)]
    1466
    		 
    fn test_nested_property_tracker_evaluate_if_dirty() {
  • ibig 0.3.6/src/memory.rs
    133
    		 
        {
    134
    		 
            #[allow(clippy::redundant_closure)]
    135
    		 
            let (ptr, slice_end) = self
  • ibig 0.3.6/src/modular/pow.rs
    145
    		 
            // Precomputed table of small odd powers up to 2^window_len, starting from self^3.
    146
    		 
            #[allow(clippy::redundant_closure)]
    147
    		 
            let table_words = ((1usize << (window_len - 1)) - 1)
  • ibig 0.3.6/src/parse/power_two.rs
    49
    		 
        let log_radix = radix.trailing_zeros();
    50
    		 
        #[allow(clippy::redundant_closure)]
    51
    		 
        let num_bits = src
  • ibig 0.3.6/src/serde.rs
    88
    		 
        const_assert!(Buffer::MAX_CAPACITY - UBig::MAX_LEN >= WORDS_PER_U64 - 1);
    89
    		 
        #[allow(clippy::redundant_closure)]
    90
    		 
        len_64
  • ink_codegen 4.0.0-beta.1/src/generator/metadata.rs
    120
    		 
        /// Generates ink! metadata for all ink! smart contract constructors.
    121
    		 
        #[allow(clippy::redundant_closure)] // We are getting arcane lifetime errors otherwise.
    122
    		 
        fn generate_constructors(&self) -> impl Iterator<Item = TokenStream2> + '_ {
  • ink_lang_codegen 4.0.0-alpha.1/src/generator/metadata.rs
    97
    		 
        /// Generates ink! metadata for all ink! smart contract constructors.
    98
    		 
        #[allow(clippy::redundant_closure)] // We are getting arcane lifetime errors otherwise.
    99
    		 
        fn generate_constructors(&self) -> impl Iterator<Item = TokenStream2> + '_ {
  • isahc 1.7.2/src/response.rs
    95
    		 
    impl<T> ResponseExt<T> for Response<T> {
    96
    		 
        #[allow(clippy::redundant_closure)]
    97
    		 
        fn trailer(&self) -> &Trailer {
  • isahc-opendal-workaround 2.0.0-opendal.1/src/response.rs
    95
    		 
    impl<T> ResponseExt<T> for Response<T> {
    96
    		 
        #[allow(clippy::redundant_closure)]
    97
    		 
        fn trailer(&self) -> &Trailer {
  • k8-metadata-client 5.0.0/src/client.rs
    85
    		 
    #[allow(clippy::redundant_closure)]
    86
    		 
    pub fn as_token_stream_result<S, E>(events: Vec<K8Watch<S>>) -> TokenStreamResult<S, E>
  • kitsune_p2p_types 0.1.0/src/tx2/tx2_utils/active.rs
    85
    		 
                // but clippy doesn't get it.
    86
    		 
                #[allow(clippy::redundant_closure)]
    87
    		 
                i.register_kill_cb(move || cb());
  • klondike-rs 1.1.0/src/model/area_list.rs
    207
    		 
        #[allow(clippy::redundant_closure)]
    208
    		 
        pub fn iter<'b>(&'b self) -> impl Iterator<Item = &'b dyn Area> + 'b {
    217
    		 
        #[allow(clippy::redundant_closure)]
    218
    		 
        pub fn iter_left_from_selection<'b>(&'b self) -> impl Iterator<Item = &'b dyn Area> + 'b {
    227
    		 
        #[allow(clippy::redundant_closure)]
    228
    		 
        pub fn iter_right_from_selection<'b>(&'b self) -> impl Iterator<Item = &'b dyn Area> + 'b {
    404
    		 
            // We don't assume that Areas implement Debug, so we'll just format them as their area ids.
    405
    		 
            #[allow(clippy::redundant_closure)]
    406
    		 
            let before_area_ids = self
    412
    		 
            #[allow(clippy::redundant_closure)]
    413
    		 
            let selected_area_id = self.selected_area.as_ref().map(|area| area.id());
  • kstring 2.0.0/examples/bench.rs
    10
    		 
            .unwrap();
    11
    		 
        #[allow(clippy::redundant_closure)] // Needed for consistent type
    12
    		 
        let method = match method.as_str() {
  • kube-client 0.78.0/src/config/file_config.rs
    448
    		 
    #[allow(clippy::redundant_closure)]
    449
    		 
    fn append_new_named<T, F>(base: &mut Vec<T>, next: Vec<T>, f: F)
  • ln-websocket-proxy 0.3.0/src/main.rs
    218
    		 
        // this socket.
    219
    		 
        #[allow(clippy::redundant_closure)]
    220
    		 
        let owner_id_bytes = FromHex::from_hex(identifier.as_str())
  • mcsdf-font-tech-demo 1.0.1/src/ui/block.rs
    29
    		 
    impl UIBlockContext {
    30
    		 
        #[allow(clippy::redundant_closure)]
    31
    		 
        pub fn new<F: ?Sized + Facade>(facade: &F) -> Self {
  • mcsdf-font-tech-demo 1.0.1/src/ui/label.rs
    25
    		 
    impl UILabelContext {
    26
    		 
        #[allow(clippy::redundant_closure)]
    27
    		 
        pub fn new<F: ?Sized + Facade>(facade: &F, font: Font) -> Self {
  • mcsdf-font-tech-demo 1.0.1/src/ui/text_area.rs
    96
    		 
    impl UITextAreaContext {
    97
    		 
        #[allow(clippy::redundant_closure)]
    98
    		 
        pub fn new<F: ?Sized + Facade>(facade: &F, font: Font) -> Self {
  • melib 0.7.2/src/lib.rs
    60
    		 
        #[allow(clippy::redundant_closure)]
    61
    		 
        #[macro_export]
  • memega 0.1.0/src/run/runner.rs
    50
    		 
        pub fn new(eval: E, cfg: Cfg, mut rand_genome: impl RandGenome<E::Genome> + 'static) -> Self {
    51
    		 
            #[allow(clippy::redundant_closure)] // This closure is actually necessary.
    52
    		 
            let gen = UnevaluatedGen::initial::<E>(rand_vec(cfg.pop_size, || rand_genome()), &cfg);
  • messages 0.3.1/examples/04_ring.rs
    119
    		 
    #[allow(clippy::redundant_closure)] // Generates false positive to `-> !` functions.
    120
    		 
    fn parse_args() -> (usize, usize) {
  • mexprp 0.3.1/src/term.rs
    232
    		 
    /// Insert multiplication operations in between operands that are right next to each other
    233
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(redundant_closure))]
    234
    		 
    fn insert_operators(mut raw: Vec<Expr>) -> Vec<Expr> {
  • mfight_sdk 0.3.0/src/event.rs
    23
    		 
            // Events cannot fail to serialize so fine to panic on error
    24
    		 
            #[allow(clippy::redundant_closure)]
    25
    		 
            serde_json
  • mp4ameta 0.11.0/src/tag/genre.rs
    144
    		 
        pub fn genres(&self) -> impl Iterator<Item = &str> + '_ {
    145
    		 
            #[allow(clippy::redundant_closure)]
    146
    		 
            self.standard_genres().filter_map(|c| stanard_genre(c)).chain(self.custom_genres())
  • multiversx-chain-vm 0.1.4/src/tx_mock/tx_cache_balance_util.rs
    38
    		 
        #[allow(clippy::redundant_closure)] // clippy is wrong here, `.unwrap_or_else(panic_insufficient_funds)` won't compile
    39
    		 
        pub fn subtract_esdt_balance(
  • multiversx-sc 0.39.4/src/types/managed/multi_value/multi_value_managed_vec.rs
    89
    		 
        #[allow(clippy::redundant_closure)]
    90
    		 
        pub fn slice(&self, start_index: usize, end_index: usize) -> Option<Self> {
  • myelin-engine 0.14.1/src/simulation/simulation_impl.rs
    521
    		 
            #[allow(clippy::redundant_closure)]
    522
    		 
            object_behavior.expect_step(|arg| arg.any()).returns(None);
    722
    		 
            #[allow(clippy::redundant_closure)]
    723
    		 
            child_object_behavior
    730
    		 
            object_behavior.expect_step_calls_in_order();
    731
    		 
            #[allow(clippy::redundant_closure)]
    732
    		 
            object_behavior
    737
    		 
                )));
    738
    		 
            #[allow(clippy::redundant_closure)]
    739
    		 
            object_behavior.expect_step(|arg| arg.any()).returns(None);
    789
    		 
            #[allow(clippy::redundant_closure)]
    790
    		 
            object_behavior
  • ncm_api 0.1.3/src/crypto.rs
    33
    		 
    #[allow(dead_code, clippy::redundant_closure)]
    34
    		 
    impl Crypto {
  • near-contract-standards 4.1.1/src/event.rs
    15
    		 
            // Events cannot fail to serialize so fine to panic on error
    16
    		 
            #[allow(clippy::redundant_closure)]
    17
    		 
            serde_json::to_string(self).ok().unwrap_or_else(|| env::abort())
  • near-contract-standards-sbt 4.1.6/src/event.rs
    15
    		 
            // Events cannot fail to serialize so fine to panic on error
    16
    		 
            #[allow(clippy::redundant_closure)]
    17
    		 
            serde_json::to_string(self).ok().unwrap_or_else(|| env::abort())
  • near-non-transferable-token 0.0.4/src/event.rs
    15
    		 
            // Events cannot fail to serialize so fine to panic on error
    16
    		 
            #[allow(clippy::redundant_closure)]
    17
    		 
            serde_json::to_string(self).ok().unwrap_or_else(|| env::abort())
  • near-non-transferrable-token 0.0.4/src/event.rs
    15
    		 
            // Events cannot fail to serialize so fine to panic on error
    16
    		 
            #[allow(clippy::redundant_closure)]
    17
    		 
            serde_json::to_string(self).ok().unwrap_or_else(|| env::abort())
  • nebula-fbthrift-graph-v1 0.3.0/src/lib.rs
    1721
    		 
                #[allow(clippy::redundant_closure)]
    1722
    		 
                impl<'mock> authenticate<'mock> {
    1766
    		 
                #[allow(clippy::redundant_closure)]
    1767
    		 
                impl<'mock> signout<'mock> {
    1811
    		 
                #[allow(clippy::redundant_closure)]
    1812
    		 
                impl<'mock> execute<'mock> {
  • nebula-fbthrift-graph-v2 0.3.0/src/lib.rs
    2509
    		 
                #[allow(clippy::redundant_closure)]
    2510
    		 
                impl<'mock> authenticate<'mock> {
    2554
    		 
                #[allow(clippy::redundant_closure)]
    2555
    		 
                impl<'mock> signout<'mock> {
    2599
    		 
                #[allow(clippy::redundant_closure)]
    2600
    		 
                impl<'mock> execute<'mock> {
    2644
    		 
                #[allow(clippy::redundant_closure)]
    2645
    		 
                impl<'mock> executeJson<'mock> {
    2689
    		 
                #[allow(clippy::redundant_closure)]
    2690
    		 
                impl<'mock> verifyClientVersion<'mock> {
  • nebula-fbthrift-graph-v3 0.3.0/src/lib.rs
    3375
    		 
                #[allow(clippy::redundant_closure)]
    3376
    		 
                impl<'mock> authenticate<'mock> {
    3420
    		 
                #[allow(clippy::redundant_closure)]
    3421
    		 
                impl<'mock> signout<'mock> {
    3465
    		 
                #[allow(clippy::redundant_closure)]
    3466
    		 
                impl<'mock> execute<'mock> {
    3510
    		 
                #[allow(clippy::redundant_closure)]
    3511
    		 
                impl<'mock> executeWithParameter<'mock> {
    3555
    		 
                #[allow(clippy::redundant_closure)]
    3556
    		 
                impl<'mock> executeJson<'mock> {
  • nebula-fbthrift-meta-v1 0.3.0/src/lib.rs
    21487
    		 
                #[allow(clippy::redundant_closure)]
    21488
    		 
                impl<'mock> createSpace<'mock> {
    21532
    		 
                #[allow(clippy::redundant_closure)]
    21533
    		 
                impl<'mock> dropSpace<'mock> {
    21577
    		 
                #[allow(clippy::redundant_closure)]
    21578
    		 
                impl<'mock> getSpace<'mock> {
    21622
    		 
                #[allow(clippy::redundant_closure)]
    21623
    		 
                impl<'mock> listSpaces<'mock> {
    21667
    		 
                #[allow(clippy::redundant_closure)]
    21668
    		 
                impl<'mock> createTag<'mock> {
  • nebula-fbthrift-meta-v2 0.3.0/src/lib.rs
    34822
    		 
                #[allow(clippy::redundant_closure)]
    34823
    		 
                impl<'mock> createSpace<'mock> {
    34867
    		 
                #[allow(clippy::redundant_closure)]
    34868
    		 
                impl<'mock> dropSpace<'mock> {
    34912
    		 
                #[allow(clippy::redundant_closure)]
    34913
    		 
                impl<'mock> getSpace<'mock> {
    34957
    		 
                #[allow(clippy::redundant_closure)]
    34958
    		 
                impl<'mock> listSpaces<'mock> {
    35002
    		 
                #[allow(clippy::redundant_closure)]
    35003
    		 
                impl<'mock> createSpaceAs<'mock> {
  • nebula-fbthrift-meta-v3 0.3.0/src/lib.rs
    32917
    		 
                #[allow(clippy::redundant_closure)]
    32918
    		 
                impl<'mock> createSpace<'mock> {
    32962
    		 
                #[allow(clippy::redundant_closure)]
    32963
    		 
                impl<'mock> dropSpace<'mock> {
    33007
    		 
                #[allow(clippy::redundant_closure)]
    33008
    		 
                impl<'mock> clearSpace<'mock> {
    33052
    		 
                #[allow(clippy::redundant_closure)]
    33053
    		 
                impl<'mock> getSpace<'mock> {
    33097
    		 
                #[allow(clippy::redundant_closure)]
    33098
    		 
                impl<'mock> listSpaces<'mock> {
  • nebula-fbthrift-raftex-v1 0.3.0/src/lib.rs
    1675
    		 
                #[allow(clippy::redundant_closure)]
    1676
    		 
                impl<'mock> askForVote<'mock> {
    1720
    		 
                #[allow(clippy::redundant_closure)]
    1721
    		 
                impl<'mock> appendLog<'mock> {
    1765
    		 
                #[allow(clippy::redundant_closure)]
    1766
    		 
                impl<'mock> sendSnapshot<'mock> {
  • nebula-fbthrift-raftex-v2 0.3.0/src/lib.rs
    2055
    		 
                #[allow(clippy::redundant_closure)]
    2056
    		 
                impl<'mock> askForVote<'mock> {
    2100
    		 
                #[allow(clippy::redundant_closure)]
    2101
    		 
                impl<'mock> appendLog<'mock> {
    2145
    		 
                #[allow(clippy::redundant_closure)]
    2146
    		 
                impl<'mock> sendSnapshot<'mock> {
    2190
    		 
                #[allow(clippy::redundant_closure)]
    2191
    		 
                impl<'mock> heartbeat<'mock> {
  • nebula-fbthrift-raftex-v3 0.3.0/src/lib.rs
    2437
    		 
                #[allow(clippy::redundant_closure)]
    2438
    		 
                impl<'mock> askForVote<'mock> {
    2482
    		 
                #[allow(clippy::redundant_closure)]
    2483
    		 
                impl<'mock> appendLog<'mock> {
    2527
    		 
                #[allow(clippy::redundant_closure)]
    2528
    		 
                impl<'mock> sendSnapshot<'mock> {
    2572
    		 
                #[allow(clippy::redundant_closure)]
    2573
    		 
                impl<'mock> heartbeat<'mock> {
    2617
    		 
                #[allow(clippy::redundant_closure)]
    2618
    		 
                impl<'mock> getState<'mock> {
  • nebula-fbthrift-storage-v1 0.3.0/src/lib.rs
    12343
    		 
                #[allow(clippy::redundant_closure)]
    12344
    		 
                impl<'mock> getBound<'mock> {
    12388
    		 
                #[allow(clippy::redundant_closure)]
    12389
    		 
                impl<'mock> boundStats<'mock> {
    12433
    		 
                #[allow(clippy::redundant_closure)]
    12434
    		 
                impl<'mock> getProps<'mock> {
    12478
    		 
                #[allow(clippy::redundant_closure)]
    12479
    		 
                impl<'mock> getEdgeProps<'mock> {
    12523
    		 
                #[allow(clippy::redundant_closure)]
    12524
    		 
                impl<'mock> addVertices<'mock> {
  • nebula-fbthrift-storage-v2 0.3.0/src/lib.rs
    15830
    		 
                #[allow(clippy::redundant_closure)]
    15831
    		 
                impl<'mock> getNeighbors<'mock> {
    15875
    		 
                #[allow(clippy::redundant_closure)]
    15876
    		 
                impl<'mock> getProps<'mock> {
    15920
    		 
                #[allow(clippy::redundant_closure)]
    15921
    		 
                impl<'mock> addVertices<'mock> {
    15965
    		 
                #[allow(clippy::redundant_closure)]
    15966
    		 
                impl<'mock> addEdges<'mock> {
    16010
    		 
                #[allow(clippy::redundant_closure)]
    16011
    		 
                impl<'mock> deleteEdges<'mock> {
  • nebula-fbthrift-storage-v3 0.3.0/src/lib.rs
    15811
    		 
                #[allow(clippy::redundant_closure)]
    15812
    		 
                impl<'mock> getNeighbors<'mock> {
    15856
    		 
                #[allow(clippy::redundant_closure)]
    15857
    		 
                impl<'mock> getDstBySrc<'mock> {
    15901
    		 
                #[allow(clippy::redundant_closure)]
    15902
    		 
                impl<'mock> getProps<'mock> {
    15946
    		 
                #[allow(clippy::redundant_closure)]
    15947
    		 
                impl<'mock> addVertices<'mock> {
    15991
    		 
                #[allow(clippy::redundant_closure)]
    15992
    		 
                impl<'mock> addEdges<'mock> {
  • noria 0.6.1/src/channel/tcp.rs
    237
    		 
            // https://github.com/rust-lang/rust-clippy/issues/3071
    238
    		 
            #[allow(clippy::redundant_closure)]
    239
    		 
            match self.project() {
  • ntex-service 1.0.1/src/map_config.rs
    140
    		 
    #[cfg(test)]
    141
    		 
    #[allow(clippy::redundant_closure)]
    142
    		 
    mod tests {
  • oso 0.26.4/tests/test_polar_rust.rs
    265
    		 
        test.oso.register_class(Foo::get_polar_class()).unwrap();
    266
    		 
        #[allow(clippy::redundant_closure)]
    267
    		 
        // @TODO: Not sure how to get the default call to typecheck without the closure wrapper.
  • otdrs 1.0.0/src/parser.rs
    87
    		 
    fn null_terminated_str(i: &[u8]) -> IResult<&[u8], &str> {
    88
    		 
        #[allow(clippy::redundant_closure)]
    89
    		 
        map_res(null_terminated_chunk,  |s|str::from_utf8(s))(i)
    94
    		 
    fn fixed_length_str(i: &[u8], n_bytes: usize) -> IResult<&[u8], &str> {
    95
    		 
        #[allow(clippy::redundant_closure)]
    96
    		 
        map_res(take(n_bytes * (1u8 as usize)),  |s|str::from_utf8(s))(i)
  • parse-mediawiki-sql 0.10.0/examples/category_members.rs
    16
    		 
        #[allow(clippy::redundant_closure)]
    17
    		 
        let mut get_arg = |keys: [&'static str; 2], default: &'static str| {
  • parse-mediawiki-sql 0.10.0/examples/categorylinks.rs
    13
    		 
    #[allow(clippy::redundant_closure)]
    14
    		 
    fn opt_path_from_args(args: &mut Arguments, keys: [&'static str; 2]) -> Result<Option<PathBuf>> {
  • parse-mediawiki-sql 0.10.0/examples/page_props.rs
    47
    		 
    #[allow(clippy::redundant_closure)]
    48
    		 
    fn opt_path_from_args(args: &mut Arguments, keys: [&'static str; 2]) -> Result<Option<PathBuf>> {
  • parse-mediawiki-sql 0.10.0/examples/redirects_by_namespace.rs
    44
    		 
        #[allow(clippy::redundant_closure)]
    45
    		 
        fn path_from_args(
  • pbjson-types 0.5.1/src/lib.rs
    23
    		 
        clippy::redundant_static_lifetimes,
    24
    		 
        clippy::redundant_closure,
    25
    		 
        clippy::redundant_field_names,
  • pbjson-types-any 0.2.3/src/lib.rs
    23
    		 
        clippy::redundant_static_lifetimes,
    24
    		 
        clippy::redundant_closure,
    25
    		 
        clippy::redundant_field_names,
  • pime 0.0.17/src/lib.rs
    368
    		 
    impl PyTaskResult {
    369
    		 
        #[allow(clippy::redundant_closure)]
    370
    		 
        fn set_result(&mut self, result: Option<Value>) {
  • plotchart 0.2.12/src/series/histogram.rs
    120
    		 
        /// Returns the newly created histogram series
    121
    		 
        #[allow(clippy::redundant_closure)]
    122
    		 
        pub fn new<S: Into<ShapeStyle>, I: IntoIterator<Item = (BR::ValueType, A)>>(
  • polars_arrow_rvsry99dx 0.17.1/src/lib.rs
    37
    		 
    // pub mod flight;
    38
    		 
    #[allow(clippy::redundant_closure)]
    39
    		 
    #[allow(clippy::needless_lifetimes)]
  • prexel 0.1.9/src/context.rs
    748
    		 
        #[allow(clippy::redundant_closure)]
    749
    		 
        pub fn check_token_name(kind: TokenKind, name: &str) -> Result<()> {
  • probe-run 0.3.6/src/main.rs
    42
    		 
        #[allow(clippy::redundant_closure)]
    43
    		 
        cli::handle_arguments().map(|code| process::exit(code))
  • pyoxidizer 0.24.0/src/environment.rs
    358
    		 
                    // Compiler complains about lifetimes without the closure.
    359
    		 
                    #[allow(clippy::redundant_closure)]
    360
    		 
                    let target_triple = target_triple.unwrap_or_else(|| default_target_triple());
  • ratmom 0.1.0/src/response.rs
    100
    		 
    impl<T> ResponseExt<T> for Response<T> {
    101
    		 
        #[allow(clippy::redundant_closure)]
    102
    		 
        fn trailer(&self) -> &Trailer {
  • recursion-schemes 0.1.3/src/functor.rs
    24
    		 
        {
    25
    		 
            #[allow(clippy::redundant_closure)] // this lint is wrong here
    26
    		 
            F1::fmap(input, move |x| F2::fmap(x, |x| f(x)))
  • replicante_logging 0.1.4/src/lib.rs
    48
    		 
                // Without this allow, clipply complainants that we do not use Record::module.
    49
    		 
                #[allow(clippy::redundant_closure)]
    50
    		 
                let drain = Json::new(stdout())
    69
    		 
        // Without this allow, clipply complainants that we do not use Record::module.
    70
    		 
        #[allow(clippy::redundant_closure)]
    71
    		 
        let drain = Json::new(stdout())
  • resufancy 0.1.1/src/commands/mod.rs
    23
    		 
        #[allow(clippy::redundant_closure)] // Command::build expects an unboxed command
    24
    		 
        pub fn build(&self) -> Vec<App> {
  • rlbot 0.5.0/src/physicist.rs
    93
    		 
        /// returned. Otherwise, `None` is returned.
    94
    		 
        #[allow(clippy::redundant_closure)]
    95
    		 
        pub fn try_next_flat<'fb>(&mut self) -> Option<flat::RigidBodyTick<'fb>> {
  • rostrum 8.0.0/src/query/status.rs
    242
    		 
        #[allow(clippy::redundant_closure)]
    243
    		 
        let balance: HashMap<TokenID, i64> = outputs
    288
    		 
        // Find inputs that spends from confirmed outputs as well
    289
    		 
        #[allow(clippy::redundant_closure)]
    290
    		 
        let spends_of_confirmed = confirmed_outputs
  • rquickjs-core 0.1.7/src/loader/module_loader.rs
    30
    		 
                name.into(),
    31
    		 
                #[allow(clippy::redundant_closure)]
    32
    		 
                ModuleInit(Box::new(|ctx, name| Module::new_def::<M, _>(ctx, name))),
  • rustop 1.1.2/src/rustop.rs
    551
    		 
        fn write_name(&self, name: Option<&str>) -> Option<String> {
    552
    		 
            #[allow(clippy::redundant_closure)]
    553
    		 
            name.or_else(|| T::default_name()).map(|n| n.to_string())
    590
    		 
        fn write_name(&self, name: Option<&str>) -> Option<String> {
    591
    		 
            #[allow(clippy::redundant_closure)]
    592
    		 
            name.or_else(|| T::default_name()).map(|n| format!("[{}]", n))
    628
    		 
        fn write_name(&self, name: Option<&str>) -> Option<String> {
    629
    		 
            #[allow(clippy::redundant_closure)]
    630
    		 
            name.or_else(|| T::default_name()).map(|n| format!("[{}...]", n))
  • rustorm 0.20.0/src/entity.rs
    308
    		 
        #[allow(clippy::redundant_closure)]
    309
    		 
        pub fn execute_sql_with_return<'a, R>(
  • rustorm 0.20.0/src/pg/numeric.rs
    146
    		 
    impl<'a> From<&'a BigDecimal> for PgNumeric {
    147
    		 
        #[allow(clippy::redundant_closure)]
    148
    		 
        fn from(decimal: &'a BigDecimal) -> Self {
  • rusty_pandas 0.0.2/src/series/mod.rs
    119
    		 
        #[allow(clippy::redundant_closure, dead_code)]
    120
    		 
        fn new_with_index(array: &[T], index: &[K], name: Option<String>) -> Option<Self> {
  • rusty_ulid 2.0.0/benches/my_benchmark.rs
    47
    		 
    #[allow(clippy::redundant_closure)]
    48
    		 
    fn criterion_benchmark(c: &mut Criterion) {
  • safecoin-client 1.14.3/src/blockhash_query.rs
    36
    		 
                Self::NonceAccount(ref pubkey) => {
    37
    		 
                    #[allow(clippy::redundant_closure)]
    38
    		 
                    let data = nonce_utils::get_account_with_commitment(rpc_client, pubkey, commitment)
    83
    		 
                Self::NonceAccount(ref pubkey) => {
    84
    		 
                    #[allow(clippy::redundant_closure)]
    85
    		 
                    let data = nonce_utils::get_account_with_commitment(rpc_client, pubkey, commitment)
    100
    		 
                Self::NonceAccount(ref pubkey) => {
    101
    		 
                    #[allow(clippy::redundant_closure)]
    102
    		 
                    let _ = nonce_utils::get_account_with_commitment(rpc_client, pubkey, commitment)
  • safecoin-client 1.14.3/src/nonblocking/blockhash_query.rs
    31
    		 
                Self::NonceAccount(ref pubkey) => {
    32
    		 
                    #[allow(clippy::redundant_closure)]
    33
    		 
                    let data = nonce_utils::get_account_with_commitment(rpc_client, pubkey, commitment)
    49
    		 
                Self::NonceAccount(ref pubkey) => {
    50
    		 
                    #[allow(clippy::redundant_closure)]
    51
    		 
                    let _ = nonce_utils::get_account_with_commitment(rpc_client, pubkey, commitment)
  • sandboxfs 0.2.0/src/nodes/dir.rs
    775
    		 
            // TODO(jmmv): Figure out how to remove the redundant closure.
    776
    		 
            #[allow(clippy::redundant_closure)]
    777
    		 
            self.remove_any(name, |p| fs::remove_dir(p), cache)
    805
    		 
            // TODO(jmmv): Figure out how to remove the redundant closure.
    806
    		 
            #[allow(clippy::redundant_closure)]
    807
    		 
            self.remove_any(name, |p| fs::remove_file(p), cache)
  • sbrd-gen 0.1.0/src/builder/bound.rs
    95
    		 
                start: start.map(|s| {
    96
    		 
                    #[allow(clippy::redundant_closure)]
    97
    		 
                    convert(s)
    100
    		 
                end: end.map(|e| {
    101
    		 
                    #[allow(clippy::redundant_closure)]
    102
    		 
                    convert(e)
  • sbrd-gen 0.1.0/src/builder/step.rs
    48
    		 
                step: step.map(|e| {
    49
    		 
                    #[allow(clippy::redundant_closure)]
    50
    		 
                    convert(e)
  • seed 0.9.2/src/app/orders/container.rs
    46
    		 
        #[allow(clippy::redundant_closure)]
    47
    		 
        fn proxy<ChildMs: 'static>(
    142
    		 
        ) -> &mut Self {
    143
    		 
            #[allow(clippy::redundant_closure)]
    144
    		 
            let handler = map_callback_return_to_option_ms!(
    151
    		 
            #[allow(clippy::redundant_closure)]
    152
    		 
            self.app
    171
    		 
            #[allow(clippy::redundant_closure)]
    172
    		 
            self.app
  • seed 0.9.2/src/app/orders/proxy.rs
    82
    		 
        #[allow(clippy::redundant_closure)]
    83
    		 
        fn send_msg(&mut self, msg: Ms) -> &mut Self {
    89
    		 
        #[allow(clippy::redundant_closure)]
    90
    		 
        fn perform_cmd<MsU: 'static>(&mut self, cmd: impl Future<Output = MsU> + 'static) -> &mut Self {
    120
    		 
            #[allow(clippy::redundant_closure)]
    121
    		 
            let cmd = cmd.map(move |msg| app.mailbox().send(handler(msg).map(|msg| f(msg))));
    129
    		 
        #[allow(clippy::redundant_closure)]
    130
    		 
        fn msg_mapper(&self) -> Rc<dyn Fn(Ms) -> Self::AppMs> {
    146
    		 
            let f = self.f.clone();
    147
    		 
            #[allow(clippy::redundant_closure)]
    148
    		 
            self.clone_app()
  • seed 0.9.2/src/app/orders.rs
    172
    		 
            let (app, msg_mapper) = (self.clone_app(), self.msg_mapper());
    173
    		 
            #[allow(clippy::redundant_closure)]
    174
    		 
            let msg_sender =
  • seize 0.2.5/src/tls/mod.rs
    237
    		 
    #[cfg(test)]
    238
    		 
    #[allow(clippy::redundant_closure)]
    239
    		 
    mod tests {
  • sentry 0.29.2/tests/test_tower.rs
    32
    		 
            #[allow(clippy::redundant_closure)]
    33
    		 
            let hub = Arc::new(Hub::with(|hub| Hub::new_from_top(hub)));
  • sentry-tower 0.29.2/src/lib.rs
    184
    		 
            //         |         ^^^^^^^^^ implementation of `std::ops::FnOnce` is not general enough
    185
    		 
            #[allow(clippy::redundant_closure)]
    186
    		 
            Hub::with(|hub| Hub::new_from_top(hub)).into()
  • sierra 0.6.0/src/backend/vulkan/device.rs
    2300
    		 
            #[allow(clippy::redundant_closure)]
    2301
    		 
            let total_size_usize = group_size_usize
  • simple-tlv 0.1.0/src/traits.rs
    182
    		 
        fn encoded_length(&self) -> Result<Length> {
    183
    		 
            #[allow(clippy::redundant_closure)]
    184
    		 
            // if we do as clippy tells, we get:
  • sixtyfps-corelib 0.1.6/properties.rs
    1979
    		 
    #[test]
    1980
    		 
    #[allow(clippy::redundant_closure)]
    1981
    		 
    fn test_nested_property_tracker_evaluate_if_dirty() {
  • smarthub-sdk 0.1.0/src/event.rs
    24
    		 
            // Events cannot fail to serialize so fine to panic on error
    25
    		 
            #[allow(clippy::redundant_closure)]
    26
    		 
            serde_json
  • solana-cli 1.14.13/src/nonce.rs
    570
    		 
    ) -> ProcessResult {
    571
    		 
        #[allow(clippy::redundant_closure)]
    572
    		 
        match get_account_with_commitment(rpc_client, nonce_account_pubkey, config.commitment)
  • solana-cli 1.14.13/tests/nonce.rs
    245
    		 
    #[test]
    246
    		 
    #[allow(clippy::redundant_closure)]
    247
    		 
    fn test_create_account_with_seed() {
  • solana-client 1.14.13/src/blockhash_query.rs
    36
    		 
                Self::NonceAccount(ref pubkey) => {
    37
    		 
                    #[allow(clippy::redundant_closure)]
    38
    		 
                    let data = nonce_utils::get_account_with_commitment(rpc_client, pubkey, commitment)
    83
    		 
                Self::NonceAccount(ref pubkey) => {
    84
    		 
                    #[allow(clippy::redundant_closure)]
    85
    		 
                    let data = nonce_utils::get_account_with_commitment(rpc_client, pubkey, commitment)
    100
    		 
                Self::NonceAccount(ref pubkey) => {
    101
    		 
                    #[allow(clippy::redundant_closure)]
    102
    		 
                    let _ = nonce_utils::get_account_with_commitment(rpc_client, pubkey, commitment)
  • solana-client 1.14.13/src/nonblocking/blockhash_query.rs
    31
    		 
                Self::NonceAccount(ref pubkey) => {
    32
    		 
                    #[allow(clippy::redundant_closure)]
    33
    		 
                    let data = nonce_utils::get_account_with_commitment(rpc_client, pubkey, commitment)
    49
    		 
                Self::NonceAccount(ref pubkey) => {
    50
    		 
                    #[allow(clippy::redundant_closure)]
    51
    		 
                    let _ = nonce_utils::get_account_with_commitment(rpc_client, pubkey, commitment)
  • solana-client-wasm 1.14.11/src/utils/rpc_config.rs
    51
    		 
                Self::NonceAccount(ref pubkey) => {
    52
    		 
                    #[allow(clippy::redundant_closure)]
    53
    		 
                    let data =
    74
    		 
                Self::NonceAccount(ref pubkey) => {
    75
    		 
                    #[allow(clippy::redundant_closure)]
    76
    		 
                    let _ =
  • solana_libra_types 0.0.1-sol5/src/validator_signer.rs
    91
    		 
        #[allow(clippy::redundant_closure)]
    92
    		 
        pub fn arb_signing_key<PrivateKey: SigningKey + Uniform + Genesis + 'static>(
    108
    		 
        #[allow(clippy::redundant_closure)]
    109
    		 
        pub fn rand_signer<PrivateKey: SigningKey + Uniform + Genesis + 'static>(
    114
    		 
        #[allow(clippy::redundant_closure)]
    115
    		 
        pub fn arb_signer<PrivateKey: SigningKey + Uniform + Genesis + 'static>(
  • source 0.2.1/src/lib.rs
    46
    		 
        pub fn map<B, F: FnMut(A) -> B + 'static>(mut self, mut function: F) -> Source<B> {
    47
    		 
            #[allow(clippy::redundant_closure)]
    48
    		 
            Source::new(move || self.next().map(|x| function(x)))
  • ssb_parser 0.4.0/src/parsers/ssb_render.rs
    120
    		 
        for (tag_name, tag_value) in TagsIterator::new(data) {
    121
    		 
            #[allow(clippy::redundant_closure)] // Remove wrong hint because of missing lifetime on closure reduction
    122
    		 
            match tag_name {
  • ssi-ldp 0.1.0/src/eip712.rs
    714
    		 
            let mut doc_statements_normalized = doc_dataset_normalized.statements();
    715
    		 
            #[allow(clippy::redundant_closure)]
    716
    		 
            doc_statements_normalized.sort_by_cached_key(|x| String::from(x));
    723
    		 
            let mut sigopts_statements_normalized = sigopts_dataset_normalized.statements();
    724
    		 
            #[allow(clippy::redundant_closure)]
    725
    		 
            sigopts_statements_normalized.sort_by_cached_key(|x| String::from(x));
  • stream_lib 0.3.0/src/stream.rs
    369
    		 
                    #[allow(clippy::redundant_closure)]
    370
    		 
                    let master_iter: Vec<String> = master_playlist
  • sycamore 0.8.2/src/builder.rs
    592
    		 
                        let cond = Rc::clone(&cond);
    593
    		 
                        #[allow(clippy::redundant_closure)] // FIXME: clippy false positive
    594
    		 
                        move || cond()
  • t-rust-less-lib 0.2.16/src/lib.rs
    18
    		 
      clippy::wrong_self_convention,
    19
    		 
      clippy::redundant_closure,
    20
    		 
      clippy::redundant_field_names,
  • tauri-cli 2.0.0-alpha.1/src/mobile/init.rs
    205
    		 
              val.as_str().map(
    206
    		 
                #[allow(clippy::redundant_closure)]
    207
    		 
                |s| formatter(s),
  • tfhe 0.1.7/src/c_api/shortint/server_key/pbs.rs
    32
    		 
            // Closure is required as extern "C" fn does not implement the Fn trait
    33
    		 
            #[allow(clippy::redundant_closure)]
    34
    		 
            let heap_allocated_accumulator = Box::new(ShortintPBSAccumulator(
    106
    		 
            // Closure is required as extern "C" fn does not implement the Fn trait
    107
    		 
            #[allow(clippy::redundant_closure)]
    108
    		 
            let heap_allocated_accumulator = Box::new(ShortintBivariatePBSAccumulator(
  • tinyparse 0.2.3/src/lib.rs
    55
    		 
            (move |span| {
    56
    		 
                #[allow(clippy::redundant_closure)] // The closure consumes self if we just replace |err| map_fn(err) with the shorthand.
    57
    		 
                self.parse(span).map_err(|err| map_fn(err))
  • tokio 1.25.0/src/runtime/scheduler/current_thread.rs
    295
    		 
                // cannot be passed as an argument to `enter`.
    296
    		 
                #[allow(clippy::redundant_closure)]
    297
    		 
                let (c, _) = self.enter(core, || f());
    319
    		 
                // cannot be passed as an argument to `enter`.
    320
    		 
                #[allow(clippy::redundant_closure)]
    321
    		 
                let (c, _) = self.enter(core, || f());
  • tokio_wasi 1.23.0/src/runtime/scheduler/current_thread.rs
    295
    		 
                // cannot be passed as an argument to `enter`.
    296
    		 
                #[allow(clippy::redundant_closure)]
    297
    		 
                let (c, _) = self.enter(core, || f());
    319
    		 
                // cannot be passed as an argument to `enter`.
    320
    		 
                #[allow(clippy::redundant_closure)]
    321
    		 
                let (c, _) = self.enter(core, || f());
  • tracers-codegen 0.1.0/src/error.rs
    289
    		 
        /// Builds an error string with all the relevant info from a `Fail` implementation
    290
    		 
        #[allow(clippy::redundant_closure)] //clippy's proposed alterstatic won't compile here
    291
    		 
        fn error_string(e: &Error) -> String {
    296
    		 
        #[allow(clippy::redundant_closure)] //clippy's proposed alterstatic won't compile here
    297
    		 
        fn fail_string(f: &dyn Fail) -> String {
  • tsukuyomi 0.5.3/src/extractor/ext.rs
    422
    		 
        #[allow(clippy::redundant_closure)]
    423
    		 
        impl<Fut, F, U> TryFuture for MapErrFuture<Fut, F>
  • tsukuyomi 0.5.3/src/modifiers.rs
    172
    		 
        #[allow(clippy::redundant_closure)]
    173
    		 
        impl<H, F, T> TryFuture for HandleMapOutput<H, F>
  • under 0.3.5/src/sse.rs
    150
    		 
            // `h` would be bound to the lifetime of this function.
    151
    		 
            #[allow(clippy::redundant_closure)]
    152
    		 
            Ok(handle_sse(request, move |r, s| h(r, s)))
  • verneuil 0.6.4/src/replication_buffer.rs
    839
    		 
        #[allow(clippy::redundant_closure)] // we need to adjust hostname()'s lifetime
    840
    		 
        let hostname: &str = hostname_or.unwrap_or_else(|| instance_id::hostname());
  • wasmbus-rpc 0.11.2/src/provider.rs
    718
    		 
        ) -> Self {
    719
    		 
            #[allow(clippy::redundant_closure)]
    720
    		 
            let bridge = bridge.unwrap_or_else(|| crate::provider_main::get_host_bridge());
  • wasmdbg 0.1.0/src/vm.rs
    652
    		 
        #[allow(clippy::float_cmp, clippy::redundant_closure)]
    653
    		 
        fn execute_step_internal(&mut self) -> VMResult<()> {
  • websocat 1.11.0/src/util.rs
    17
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(redundant_closure))]
    18
    		 
    impl PeerConstructor {
  • wendy-k8-metadata-client 3.3.1/src/client.rs
    87
    		 
    #[allow(clippy::redundant_closure)]
    88
    		 
    pub fn as_token_stream_result<S, E>(events: Vec<K8Watch<S>>) -> TokenStreamResult<S, E>
  • widestring 1.0.2/src/lib.rs
    646
    		 
    #[track_caller]
    647
    		 
    #[allow(dead_code, clippy::redundant_closure)]
    648
    		 
    fn range<R>(range: R, bounds: core::ops::RangeTo<usize>) -> core::ops::Range<usize>
  • wiki-tui 0.6.1/src/main.rs
    91
    		 
        let siv_box = std::sync::Mutex::new(siv);
    92
    		 
        #[allow(clippy::redundant_closure)]
    93
    		 
        if std::panic::catch_unwind(|| siv_box.lock().unwrap().run_with(|| backend())).is_err() {
  • xenctrl 0.4.9/src/lib.rs
    145
    		 
            #[allow(clippy::redundant_closure)]
    146
    		 
            let xc_handle = (libxenctrl.interface_open)(
  • yew 0.20.0/tests/use_effect.rs
    44
    		 
                    effect_called();
    45
    		 
                    #[allow(clippy::redundant_closure)] // Otherwise there is a build error
    46
    		 
                    move || destroy_called()
  • zcash_primitives 0.10.0/src/merkle_tree/incremental.rs
    97
    		 
    #[allow(clippy::redundant_closure)]
    98
    		 
    pub fn read_nonempty_frontier_v1<H: HashSer + Clone, R: Read>(
    126
    		 
    #[allow(clippy::redundant_closure)]
    127
    		 
    pub fn read_frontier_v1<H: HashSer + Clone, R: Read>(reader: R) -> io::Result<Frontier<H, 32>> {
    148
    		 
    #[allow(clippy::redundant_closure)]
    149
    		 
    pub fn read_auth_fragment_v1<H: HashSer, R: Read>(mut reader: R) -> io::Result<AuthFragment<H>> {
  • zcash_primitives 0.10.0/src/merkle_tree.rs
    357
    		 
        /// Reads an `IncrementalWitness` from its serialized form.
    358
    		 
        #[allow(clippy::redundant_closure)]
    359
    		 
        pub fn read<R: Read>(mut reader: R) -> io::Result<Self> {
  • zcash_primitives 0.10.0/src/transaction/components/orchard.rs
    58
    		 
    ) -> io::Result<Option<orchard::Bundle<Authorized, Amount>>> {
    59
    		 
        #[allow(clippy::redundant_closure)]
    60
    		 
        let actions_without_auth = Vector::read(&mut reader, |r| read_action_without_auth(r))?;
  • zcash_primitives 0.10.0/src/transaction/mod.rs
    581
    		 
        #[allow(clippy::redundant_closure)]
    582
    		 
        fn read_v4<R: Read>(
    597
    		 
                let vb = Self::read_amount(&mut reader)?;
    598
    		 
                #[allow(clippy::redundant_closure)]
    599
    		 
                let ss: Vec<SpendDescription<sapling::Authorized>> =
    600
    		 
                    Vector::read(&mut reader, |r| SpendDescription::read(r))?;
    601
    		 
                #[allow(clippy::redundant_closure)]
    602
    		 
                let so: Vec<OutputDescription<sapling::GrothProofBytes>> =
    733
    		 
        #[allow(clippy::redundant_closure)]
    734
    		 
        fn read_v5_sapling<R: Read>(
  • zcash_script 0.1.8/depend/zcash/src/rust/src/incremental_merkle_tree.rs
    101
    		 
    #[allow(clippy::redundant_closure)]
    102
    		 
    pub fn read_tree<H: Hashable + HashSer + Ord + Clone, R: Read>(
  • zerostash 0.4.1/src/application.rs
    99
    		 
        /// * `pathy` - Can be a path or an alias stored in the config
    100
    		 
        #[allow(clippy::redundant_closure)]
    101
    		 
        pub(crate) fn open_stash(&self, pathy: impl AsRef<str>) -> Stash {
  • async-mq 1.1.0/examples/mqctl.rs
    419
    		 
            clippy::needless_lifetimes,
    420
    		 
            clippy::redundant_closure,
    421
    		 
            clippy::redundant_static_lifetimes
  • auto-diff 0.5.9/src/compute_graph.rs
    1
    		 
    #![allow(clippy::redundant_closure)]
    2
    		 
    use std::collections::{BTreeSet, BTreeMap};
  • azalea-physics 0.5.0/src/collision/blocks.rs
    6
    		 
    #![allow(clippy::explicit_auto_deref)]
    7
    		 
    #![allow(clippy::redundant_closure)]
  • bcder 0.7.1/src/lib.rs
    35
    		 
    // a function would also work) that cannot be removed due to lifetime issues.
    36
    		 
    #![allow(clippy::redundant_closure)]
  • black_marlin 0.3.4/src/lib.rs
    35
    		 
    #![cfg_attr(docsrs, feature(doc_cfg))]
    36
    		 
    #![allow(clippy::redundant_closure)]
    37
    		 
    #![deny(missing_docs)]
  • cage 0.3.6/src/errors.rs
    8
    		 
    #![allow(missing_docs, clippy::redundant_closure)]
  • cargo-lipo 3.2.0/src/main.rs
    3
    		 
        clippy::new_ret_no_self,
    4
    		 
        clippy::redundant_closure,
    5
    		 
        clippy::single_char_pattern
  • cargo-semverver 0.34.0/src/bin/cargo/main.rs
    2
    		 
    #![allow(clippy::too_many_arguments)] // large project
    3
    		 
    #![allow(clippy::redundant_closure)] // there's a false positive
  • cbe-sdk 1.15.0/src/precompiles.rs
    59
    		 
        {
    60
    		 
            #![allow(clippy::redundant_closure)]
    61
    		 
            self.feature
  • ckb-app-config 0.107.0/src/tests/app_config.rs
    1
    		 
    #![allow(clippy::redundant_closure)]
  • clapi_macros 0.1.1/src/arg.rs
    1
    		 
    #![allow(clippy::len_zero, clippy::redundant_closure)]
    2
    		 
    use crate::command::{is_option_bool_flag, FnArgData};
  • clapi_macros 0.1.1/src/command.rs
    1
    		 
    #![allow(clippy::len_zero, clippy::redundant_closure, clippy::bool_comparison)]
  • coap-handler 0.1.4/src/implementations.rs
    10
    		 
        clippy::useless_conversion,
    11
    		 
        clippy::redundant_closure,
    12
    		 
        clippy::unwrap_or_else_default,
  • credentials 1.0.0-beta.1/src/lib.rs
    17
    		 
    #![warn(missing_docs)]
    18
    		 
    #![allow(clippy::redundant_closure)]
  • dbs-fuse 0.2.0/src/tokio_uring/mod.rs
    62
    		 
    #![allow(clippy::useless_conversion)]
    63
    		 
    #![allow(clippy::redundant_closure)]
    64
    		 
    #![allow(clippy::needless_doctest_main)]
  • dcpu 0.5.0/src/lib.rs
    8
    		 
    #![cfg_attr(feature="clippy", allow(redundant_closure))]
    9
    		 
    #![cfg_attr(feature="cargo-clippy", allow(redundant_closure))]
  • derivative 2.2.0/src/lib.rs
    9
    		 
    #![allow(clippy::cognitive_complexity)] // in code generated by macros
    10
    		 
    #![allow(clippy::redundant_closure)]
  • derivative 2.2.0/tests/rustc-issue-24085.rs
    15
    		 
    #![allow(clippy::redundant_closure)]
  • duckdb 0.6.1/src/row.rs
    680
    		 
    mod tests {
    681
    		 
        #![allow(clippy::redundant_closure)] // false positives due to lifetime issues; clippy issue #5594
    682
    		 
        use crate::{Connection, Result};
  • eggsecutor 2.0.0/src/main.rs
    5
    		 
    // our closures actually -> !, so they can't be unwrapped easily
    6
    		 
    #![allow(clippy::redundant_closure)]
    7
    		 
    extern crate clap;
  • gfx_glyph 0.17.0/src/lib.rs
    4
    		 
        clippy::cognitive_complexity,
    5
    		 
        clippy::redundant_closure
    6
    		 
    )]
  • iced-x86 1.18.0/src/lib.rs
    37
    		 
    #![allow(clippy::ptr_eq)]
    38
    		 
    #![allow(clippy::redundant_closure)] // Clippy is buggy
    39
    		 
    #![allow(clippy::too_many_arguments)]
  • lang_tester 0.7.2/src/lib.rs
    209
    		 
    #![allow(clippy::new_without_default)]
    210
    		 
    #![allow(clippy::redundant_closure)]
    211
    		 
    #![allow(clippy::type_complexity)]
  • libical 0.1.0/src/lib.rs
    1
    		 
    #![warn(unused_extern_crates)]
    2
    		 
    #![allow(clippy::redundant_closure)] // disable "redundant closure" lint
  • minivec 0.4.0/tests/vec.rs
    17
    		 
      clippy::assign_op_pattern,
    18
    		 
      clippy::redundant_closure
    19
    		 
    )]
  • ndarray 0.15.6/src/lib.rs
    17
    		 
        clippy::from_iter_instead_of_collect, // using from_iter is good style
    18
    		 
        clippy::redundant_closure, // false positives clippy #7812
    19
    		 
    )]
  • near-sdk 4.1.1/src/lib.rs
    2
    		 
    //* https://github.com/rust-lang/rust-clippy/issues/8091
    3
    		 
    #![allow(clippy::redundant_closure)]
  • nebula-fbthrift-common-v1 0.3.0/src/types.rs
    6
    		 
    #![allow(clippy::redundant_closure)]
  • nebula-fbthrift-common-v2 0.3.0/src/types.rs
    6
    		 
    #![allow(clippy::redundant_closure)]
  • nebula-fbthrift-common-v3 0.3.0/src/types.rs
    6
    		 
    #![allow(clippy::redundant_closure)]
  • nebula-fbthrift-graph-v1 0.3.0/src/types.rs
    6
    		 
    #![allow(clippy::redundant_closure)]
  • nebula-fbthrift-graph-v2 0.3.0/src/types.rs
    6
    		 
    #![allow(clippy::redundant_closure)]
  • nebula-fbthrift-graph-v3 0.3.0/src/types.rs
    6
    		 
    #![allow(clippy::redundant_closure)]
  • nebula-fbthrift-meta-v1 0.3.0/src/types.rs
    6
    		 
    #![allow(clippy::redundant_closure)]
  • nebula-fbthrift-meta-v2 0.3.0/src/types.rs
    6
    		 
    #![allow(clippy::redundant_closure)]
  • nebula-fbthrift-meta-v3 0.3.0/src/types.rs
    6
    		 
    #![allow(clippy::redundant_closure)]
  • nebula-fbthrift-raftex-v1 0.3.0/src/types.rs
    6
    		 
    #![allow(clippy::redundant_closure)]
  • nebula-fbthrift-raftex-v2 0.3.0/src/types.rs
    6
    		 
    #![allow(clippy::redundant_closure)]
  • nebula-fbthrift-raftex-v3 0.3.0/src/types.rs
    6
    		 
    #![allow(clippy::redundant_closure)]
  • nebula-fbthrift-storage-v1 0.3.0/src/types.rs
    6
    		 
    #![allow(clippy::redundant_closure)]
  • nebula-fbthrift-storage-v2 0.3.0/src/types.rs
    6
    		 
    #![allow(clippy::redundant_closure)]
  • nebula-fbthrift-storage-v3 0.3.0/src/types.rs
    6
    		 
    #![allow(clippy::redundant_closure)]
  • nebula-graph-fbthrift-common 0.1.1/src/lib.rs
    19
    		 
    pub mod types {
    20
    		 
        #![allow(clippy::redundant_closure)]
  • nebula-graph-fbthrift-common-v2 0.1.2/src/lib.rs
    8
    		 
    pub mod types {
    9
    		 
        #![allow(clippy::redundant_closure)]
  • nebula-graph-fbthrift-graph 0.1.1/src/lib.rs
    8
    		 
    pub mod types {
    9
    		 
        #![allow(clippy::redundant_closure)]
  • nebula-graph-fbthrift-graph-v2 0.1.2/src/lib.rs
    8
    		 
    pub mod types {
    9
    		 
        #![allow(clippy::redundant_closure)]
  • nebula-graph-fbthrift-meta 0.1.1/src/lib.rs
    8
    		 
    pub mod types {
    9
    		 
        #![allow(clippy::redundant_closure)]
  • nebula-graph-fbthrift-meta-v2 0.1.2/src/lib.rs
    8
    		 
    pub mod types {
    9
    		 
        #![allow(clippy::redundant_closure)]
  • nebula-graph-fbthrift-raftex 0.1.1/src/lib.rs
    8
    		 
    pub mod types {
    9
    		 
        #![allow(clippy::redundant_closure)]
  • nebula-graph-fbthrift-raftex-v2 0.1.2/src/lib.rs
    8
    		 
    pub mod types {
    9
    		 
        #![allow(clippy::redundant_closure)]
  • nebula-graph-fbthrift-storage 0.1.1/src/lib.rs
    8
    		 
    pub mod types {
    9
    		 
        #![allow(clippy::redundant_closure)]
  • nebula-graph-fbthrift-storage-v2 0.1.2/src/lib.rs
    8
    		 
    pub mod types {
    9
    		 
        #![allow(clippy::redundant_closure)]
  • nebula-rust 2.0.0-alpha/src/interface/common.rs
    9
    		 
    pub mod types {
    10
    		 
        #![allow(clippy::redundant_closure)]
  • nebula-rust 2.0.0-alpha/src/interface/meta.rs
    9
    		 
    pub mod types {
    10
    		 
        #![allow(clippy::redundant_closure)]
  • nebula-rust 2.0.0-alpha/src/interface/storage.rs
    9
    		 
    pub mod types {
    10
    		 
        #![allow(clippy::redundant_closure)]
  • nhl-stats 0.1.2/src/lib.rs
    6
    		 
        clippy::needless_return,
    7
    		 
        clippy::redundant_closure,
    8
    		 
        dead_code,
  • nom 7.1.3/tests/issues.rs
    2
    		 
    #![allow(dead_code)]
    3
    		 
    #![cfg_attr(feature = "cargo-clippy", allow(redundant_closure))]
  • nom8 0.2.0/tests/issues.rs
    2
    		 
    #![allow(dead_code)]
    3
    		 
    #![cfg_attr(feature = "cargo-clippy", allow(redundant_closure))]
  • noria-dataflow 0.6.0/src/lib.rs
    4
    		 
    #![deny(unused_extern_crates)]
    5
    		 
    #![allow(clippy::redundant_closure)]
  • noria-server 0.6.0/src/lib.rs
    351
    		 
    #![allow(clippy::type_complexity)]
    352
    		 
    #![allow(clippy::redundant_closure)]
  • oqueue 0.1.5/src/sequencer.rs
    2
    		 
    // https://github.com/rust-lang/rust-clippy/issues/3071
    3
    		 
    #![allow(clippy::redundant_closure)]
  • oxidebpf 0.2.7/src/bpf/syscall.rs
    96
    		 
    ) -> Result<RawFd, OxidebpfError> {
    97
    		 
        #![allow(clippy::redundant_closure)] // it's not a function clippy
    98
    		 
        let insn_cnt = insns.0.len();
  • oxidebpf 0.2.7/src/perf/syscall.rs
    255
    		 
    pub(crate) fn perf_event_ioc_set_bpf(perf_fd: RawFd, data: u32) -> Result<i32, OxidebpfError> {
    256
    		 
        #![allow(clippy::useless_conversion, clippy::redundant_closure)] // fails to compile otherwise
    257
    		 
        let data_unwrapped = match data.try_into() {
    333
    		 
    ) -> Result<RawFd, OxidebpfError> {
    334
    		 
        #![allow(clippy::redundant_closure)]
    335
    		 
        let ap_cstring =
  • pin-list 0.1.0/src/lib.rs
    173
    		 
        // Has false positives: https://github.com/rust-lang/rust-clippy/issues/7812
    174
    		 
        clippy::redundant_closure,
  • pipe_downloader_lib 0.4.4/src/lib.rs
    1
    		 
    #![allow(clippy::redundant_closure)]
    2
    		 
    #[deny(missing_docs)]
  • pipitor 0.3.0-alpha.15/src/bin/pipitor/main.rs
    2
    		 
    // <https://github.com/rust-lang/rust-clippy/issues/5594>
    3
    		 
    #![allow(clippy::redundant_closure)]
  • plotka 0.1.0/src/main.rs
    1
    		 
    #![warn(missing_docs)]
    2
    		 
    #![allow(clippy::redundant_closure)]
    3
    		 
    #![allow(clippy::new_without_default)]
  • posixmq 1.0.0/posixmq.rs
    227
    		 
    #![allow(clippy::needless_return, clippy::redundant_closure, clippy::needless_lifetimes)] // style
    228
    		 
    #![allow(clippy::range_plus_one)] // edge case: I think 1..x+1 is clearer than 1..=x
  • ptth_relay 2.0.0/src/config.rs
    1
    		 
    // False positive with itertools::process_results
    2
    		 
    #![allow (clippy::redundant_closure)]
  • pyxel-core 1.9.11/src/lib.rs
    17
    		 
        clippy::range_plus_one,
    18
    		 
        clippy::redundant_closure,
    19
    		 
        clippy::suboptimal_flops,
  • pyxel-engine 1.8.2/src/lib.rs
    14
    		 
        clippy::range_plus_one,
    15
    		 
        clippy::redundant_closure,
    16
    		 
        clippy::suboptimal_flops,
  • ratsio 0.4.1/src/parser.rs
    1
    		 
    #![allow(clippy::redundant_closure)]
  • ratsio_fork_040 0.4.1/src/parser.rs
    1
    		 
    #![allow(clippy::redundant_closure)]
  • reg-index 0.5.0/src/lib.rs
    1
    		 
    #![warn(missing_docs)]
    2
    		 
    #![allow(clippy::redundant_closure)]
  • ronfmt 0.1.0/src/main.rs
    1
    		 
    #![allow(clippy::redundant_closure)] // blame pest
  • rst_parser 0.4.0/src/pest_rst.rs
    1
    		 
    #![allow(clippy::redundant_closure)]
  • rusqlite 0.28.0/src/row.rs
    433
    		 
    mod tests {
    434
    		 
        #![allow(clippy::redundant_closure)] // false positives due to lifetime issues; clippy issue #5594
    435
    		 
        use crate::{Connection, Result};
  • rusqlite-ic 0.28.1/src/row.rs
    433
    		 
    mod tests {
    434
    		 
        #![allow(clippy::redundant_closure)] // false positives due to lifetime issues; clippy issue #5594
    435
    		 
        use crate::{Connection, Result};
  • rusqlite-le 0.24.2/src/row.rs
    428
    		 
    mod tests {
    429
    		 
        #![allow(clippy::redundant_closure)] // false positives due to lifetime issues; clippy issue #5594
    430
    		 
        use crate::{Connection, Result};
  • rustmq 1.0.0/examples/rustmq/main.rs
    403
    		 
            clippy::needless_lifetimes,
    404
    		 
            clippy::redundant_closure,
    405
    		 
            clippy::redundant_static_lifetimes
  • s3-ext 0.5.1/src/lib.rs
    22
    		 
    #![allow(clippy::module_name_repetitions)]
    23
    		 
    #![allow(clippy::redundant_closure)]
    24
    		 
    #![allow(clippy::redundant_closure_for_method_calls)]
  • s4 0.0.15/src/lib.rs
    21
    		 
    #![allow(clippy::module_name_repetitions)]
    22
    		 
    #![allow(clippy::redundant_closure)]
    23
    		 
    #![allow(clippy::redundant_closure_for_method_calls)]
  • safecoin-sdk 1.14.3/src/precompiles.rs
    62
    		 
        {
    63
    		 
            #![allow(clippy::redundant_closure)]
    64
    		 
            self.feature
  • sailfish 0.6.0/src/lib.rs
    35
    		 
    #![cfg_attr(docsrs, feature(doc_cfg))]
    36
    		 
    #![allow(clippy::redundant_closure)]
    37
    		 
    #![deny(missing_docs)]
  • shred 0.14.1/src/world/mod.rs
    538
    		 
            // False-positive
    539
    		 
            #![allow(clippy::redundant_closure)]
  • solana-cli 1.14.13/tests/stake.rs
    1
    		 
    #![allow(clippy::integer_arithmetic)]
    2
    		 
    #![allow(clippy::redundant_closure)]
    3
    		 
    use {
  • solana-cli 1.14.13/tests/transfer.rs
    1
    		 
    #![allow(clippy::integer_arithmetic)]
    2
    		 
    #![allow(clippy::redundant_closure)]
    3
    		 
    use {
  • solana-sdk 1.14.13/src/precompiles.rs
    62
    		 
        {
    63
    		 
            #![allow(clippy::redundant_closure)]
    64
    		 
            self.feature
  • solders 0.14.3/src/account.rs
    1
    		 
    #![allow(clippy::redundant_closure)]
    2
    		 
    use std::str::FromStr;
  • spandex 0.0.4/src/parser/combinators.rs
    5
    		 
    // Allow redundant closure because of nom.
    6
    		 
    #![allow(clippy::redundant_closure)]
  • spritec 0.1.0/src/bin/spritec/main.rs
    8
    		 
        clippy::cast_lossless,
    9
    		 
        clippy::redundant_closure,
    10
    		 
        clippy::len_without_is_empty,
  • spritec 0.1.0/src/lib.rs
    17
    		 
        clippy::cast_lossless,
    18
    		 
        clippy::redundant_closure,
    19
    		 
        clippy::len_without_is_empty,
  • standalone-syn 0.13.0/src/lib.rs
    261
    		 
                allow(const_static_lifetime, doc_markdown, large_enum_variant, match_bool,
    262
    		 
                      redundant_closure, needless_pass_by_value))]
  • starlark 0.8.0/src/syntax/uniplate.rs
    21
    		 
    // Most consistent to use the closure everywhere.
    22
    		 
    #![allow(clippy::redundant_closure)]
  • tox_core 0.1.1/src/lib.rs
    11
    		 
    // Remove it when it will be fixed in nom parser
    12
    		 
    #![allow(clippy::redundant_closure)]
  • treefmt 0.5.0/src/command/mod.rs
    1
    		 
    //! CLI command structures for formatter
    2
    		 
    #![allow(clippy::redundant_closure)]
  • treefmt 0.5.0/src/main.rs
    1
    		 
    #![allow(clippy::redundant_closure, clippy::redundant_pattern_matching)]
  • tsxlib 0.1.3/src/timeseries.rs
    581
    		 
            T3 : Clone
    582
    		 
        { #![allow(clippy::type_complexity)] #![allow(clippy::redundant_closure)]
    583
    		 
            match merge_mode {
  • tulip-derivative 2.2.1/src/lib.rs
    8
    		 
    #![allow(clippy::cognitive_complexity)] // in code generated by macros
    9
    		 
    #![allow(clippy::redundant_closure)]
  • tulip-derivative 2.2.1/tests/rustc-issue-24085.rs
    15
    		 
    #![allow(clippy::redundant_closure)]
  • ux-dx 0.2.1/src/lib.rs
    13
    		 
        clippy::option_map_unit_fn,
    14
    		 
        clippy::redundant_closure,
    15
    		 
        clippy::if_same_then_else,
  • vkcargo 0.45.1/src/bin/cargo/main.rs
    1
    		 
    #![warn(rust_2018_idioms)] // while we're getting used to 2018
    2
    		 
    #![allow(clippy::redundant_closure)] // there's a false positive
    3
    		 
    #![warn(clippy::needless_borrow)]
  • vkcargo 0.45.1/src/cargo/lib.rs
    13
    		 
    #![allow(clippy::new_without_default)] // explicit is maybe clearer
    14
    		 
    #![allow(clippy::redundant_closure)] // closures can be less verbose
    15
    		 
    #![allow(clippy::redundant_closure_call)] // closures over try catch blocks
  • vkcargo 0.45.1/tests/testsuite/main.rs
    4
    		 
    #![allow(clippy::explicit_iter_loop)]
    5
    		 
    #![allow(clippy::redundant_closure)]
    6
    		 
    #![allow(clippy::block_in_if_condition_stmt)] // clippy doesn't agree with rustfmt 😂
  • waffles-solana-sdk 1.15.0/src/precompiles.rs
    59
    		 
        {
    60
    		 
            #![allow(clippy::redundant_closure)]
    61
    		 
            self.feature
  • wasm-pack 0.10.3/src/command/mod.rs
    1
    		 
    //! CLI command structures, parsing, and execution.
    2
    		 
    #![allow(clippy::redundant_closure)]
  • wasm-pack 0.10.3/src/command/utils.rs
    1
    		 
    //! Utility functions for commands.
    2
    		 
    #![allow(clippy::redundant_closure)]
  • wasm-pack 0.10.3/src/main.rs
    1
    		 
    #![allow(clippy::redundant_closure, clippy::redundant_pattern_matching)]
  • wasm-pack 0.10.3/src/manifest/mod.rs
    5
    		 
        clippy::needless_pass_by_value,
    6
    		 
        clippy::redundant_closure
    7
    		 
    )]
  • yapay-sdk-rust 0.3.3/src/lib.rs
    88
    		 
        clippy::non_ascii_literal,
    89
    		 
        clippy::redundant_closure,
    90
    		 
        clippy::use_self,
  • yewprint 0.4.1/src/lib.rs
    1
    		 
    #![allow(
    2
    		 
        clippy::redundant_closure,
    3
    		 
        clippy::needless_update,