• actix-cors 0.6.4/tests/tests.rs
    278
    		 
        #[allow(clippy::needless_collect)]
    279
    		 
        {
  • actyx_sdk 0.3.0/src/offset.rs
    543
    		 
        /// Compute the intersection of two sets of events described by OffsetMaps
    544
    		 
        #[allow(clippy::needless_collect)]
    545
    		 
        pub fn intersection_with(&mut self, other: &OffsetMap) {
  • actyxos_sdk 0.6.0/src/event/offsets.rs
    516
    		 
        /// Compute the intersection of two sets of events described by OffsetMaps
    517
    		 
        #[allow(clippy::needless_collect)]
    518
    		 
        pub fn intersection_with(&mut self, other: &OffsetMap) {
  • aiken-lang 0.0.28/src/tipo/hydrator.rs
    149
    		 
                    let mut type_vars = HashMap::new();
    150
    		 
                    #[allow(clippy::needless_collect)] // Not needless, used for size effects
    151
    		 
                    let parameter_types: Vec<_> = parameters
  • akd_mysql 0.8.8/src/mysql.rs
    416
    		 
            #[allow(clippy::needless_collect)]
    417
    		 
            let chunked = records
  • ansi-str 0.7.2/src/lib.rs
    814
    		 
        #[allow(clippy::needless_collect)]
    815
    		 
        let tokens: Vec<_> = parse_ansi(text).collect();
  • antimony-lang 0.7.0/src/parser/parser.rs
    35
    		 
    impl Parser {
    36
    		 
        #[allow(clippy::needless_collect)] // TODO
    37
    		 
        pub fn new(tokens: Vec<Token>, raw: Option<String>, file_name: String) -> Parser {
  • aocoracle 0.1.2/src/day_22.rs
    87
    		 
    #[allow(clippy::needless_collect)]
    88
    		 
    fn _num_on(steps: Vec<(bool, Cuboid)>) -> i64 {
  • arrow-row 32.0.0/src/interner.rs
    355
    		 
        // Clippy isn't smart enough to understand dropping mutability
    356
    		 
        #[allow(clippy::needless_collect)]
    357
    		 
        fn test_intern_values(values: &[u64]) {
  • arrow2 0.15.0/src/compute/sort/row/interner.rs
    364
    		 
        // Clippy isn't smart enough to understand dropping mutability
    365
    		 
        #[allow(clippy::needless_collect)]
    366
    		 
        fn test_intern_values(values: &[u64]) {
  • arrow2 0.15.0/src/io/parquet/read/deserialize/binary/basic.rs
    57
    		 
            #[allow(clippy::needless_collect)] // we need to consume it to get the values
    58
    		 
            let lengths = lengths_iter
  • arrow2 0.15.0/src/io/parquet/write/mod.rs
    203
    		 
    /// Returns an iterator of [`Page`].
    204
    		 
    #[allow(clippy::needless_collect)]
    205
    		 
    pub fn array_to_pages(
  • atomic-interval 0.1.3/examples/stress.rs
    23
    		 
            #[allow(clippy::needless_collect)]
    24
    		 
            let threads = (0..num_threads)
  • autocxx-engine 0.24.0/src/conversion/analysis/tdef.rs
    42
    		 
    #[allow(clippy::needless_collect)] // we need the extra collect because the closure borrows extra_apis
    43
    		 
    pub(crate) fn convert_typedef_targets(
  • avalanche 0.1.0/src/tracked.rs
    332
    		 
        #[allow(clippy::needless_collect)]
    333
    		 
        fn into_iter(self) -> Self::IntoIter {
  • bdk 0.26.0/src/wallet/mod.rs
    1642
    		 
            // Clippy complains that the collect is not required, but that's wrong
    1643
    		 
            #[allow(clippy::needless_collect)]
    1644
    		 
            let utxos = (0..psbt.inputs.len())
  • bellperson 0.24.1/src/gadgets/sha256.rs
    283
    		 
        #[test]
    284
    		 
        #[allow(clippy::needless_collect)]
    285
    		 
        fn test_blank_hash() {
  • bellperson 0.24.1/src/groth16/prover.rs
    263
    		 
    /// predefined
    264
    		 
    #[allow(clippy::needless_collect)]
    265
    		 
    pub fn create_proof_batch_priority<E, C, P: ParameterSource<E>>(
    282
    		 
    #[allow(clippy::type_complexity)]
    283
    		 
    #[allow(clippy::needless_collect)]
    284
    		 
    fn create_proof_batch_priority_inner<E, C, P: ParameterSource<E>>(
  • bevy_assets_bundler 0.5.0/src/plugin/bundled_asset_io.rs
    120
    		 
                if let Some(entries) = mappings.get(&path_str) {
    121
    		 
                    #[allow(clippy::needless_collect)]
    122
    		 
                    let vec: Vec<_> = entries.iter().map(|e| e.path()).collect();
  • bevy-embasset 0.5.0/src/lib.rs
    500
    		 
        if bevasset.is_directory(path) {
    501
    		 
            #[allow(clippy::needless_collect)]
    502
    		 
            let paths: Vec<_> = bevasset
  • bevy_embedded_assets 0.6.2/src/lib.rs
    90
    		 
        #[allow(clippy::needless_collect)]
    91
    		 
        fn read_directory(
  • bevy_simple_tilemap 0.10.1/src/tilemap.rs
    165
    		 
                // within the loop.
    166
    		 
                #[allow(clippy::needless_collect)]
    167
    		 
                let clear_layers: Vec<i32> = tilemap.clear_layers.drain().collect();
  • big-brain 0.16.0/src/scorers.rs
    393
    		 
        #[allow(clippy::needless_collect)]
    394
    		 
        fn build(&self, cmd: &mut Commands, scorer: Entity, actor: Entity) {
    552
    		 
        #[allow(clippy::needless_collect)]
    553
    		 
        fn build(&self, cmd: &mut Commands, scorer: Entity, actor: Entity) {
    683
    		 
        #[allow(clippy::needless_collect)]
    684
    		 
        fn build(&self, cmd: &mut Commands, scorer: Entity, actor: Entity) {
    961
    		 
        #[allow(clippy::needless_collect)]
    962
    		 
        fn build(&self, cmd: &mut Commands, scorer: Entity, actor: Entity) {
  • birli 0.8.0/src/cli.rs
    189
    		 
            let ant_pairs = self.vis_sel.get_ant_pairs(&self.corr_ctx.metafits_context);
    190
    		 
            #[allow(clippy::needless_collect)]
    191
    		 
            let baseline_flag_idxs: Vec<usize> = self
  • cargo-release 0.24.4/src/steps/mod.rs
    609
    		 
            let inner_parser = clap::builder::EnumValueParser::<BumpLevel>::new();
    610
    		 
            #[allow(clippy::needless_collect)] // Erasing a lifetime
    611
    		 
            inner_parser.possible_values().map(|ps| {
  • caro 0.7.1/src/lib.rs
    430
    		 
                let remote_id = remote.id.clone();
    431
    		 
                #[allow(clippy::needless_collect)]
    432
    		 
                let all_state_infoes = (*self.0)
  • cddl 0.9.1/src/validator/cbor.rs
    1668
    		 
              #[allow(clippy::needless_collect)]
    1669
    		 
              let m = m.iter().map(|entry| entry.0.clone()).collect::<Vec<_>>();
  • cddl 0.9.1/src/validator/json.rs
    1529
    		 
            Value::Object(o) => {
    1530
    		 
              #[allow(clippy::needless_collect)]
    1531
    		 
              let o = o.keys().cloned().collect::<Vec<_>>();
  • cfb 0.7.3/tests/malformed.rs
    42
    		 
        #[allow(clippy::needless_collect)]
    43
    		 
        let stream_paths = cfb
  • cgats 0.2.0/src/lib.rs
    570
    		 
            } else {
    571
    		 
                #[allow(clippy::needless_collect)]
    572
    		 
                let row = self.remove_row(from_row)
  • chronofold 0.4.0/src/session.rs
    84
    		 
        #[allow(clippy::needless_collect)] // collect is needed due to borrowing
    85
    		 
        /// Replaces the specified range in the chronofold with the given
  • cinnabar 0.2.0/tests/grid.rs
    30
    		 
        let grid = create_grid();
    31
    		 
        #[allow(clippy::needless_collect)]
    32
    		 
        let ids = grid.traverse_by_rows().collect::<Vec<_>>();
  • ckb-network-alert 0.107.0/src/alert_relayer.rs
    97
    		 
        #[allow(clippy::needless_collect)]
    98
    		 
        async fn received(
  • ckb-sync 0.107.0/src/relayer/get_block_transactions_process.rs
    32
    		 
        #[allow(clippy::needless_collect)]
    33
    		 
        pub fn execute(self) -> Status {
  • ckb-sync 0.107.0/src/relayer/mod.rs
    250
    		 
        /// Accept a new block from network
    251
    		 
        #[allow(clippy::needless_collect)]
    252
    		 
        pub fn accept_block(
  • cli-xtask 0.6.1/src/subcommand/dist_build_man.rs
    111
    		 
    fn iterate_commands(cmd: clap::Command) -> Box<dyn Iterator<Item = clap::Command>> {
    112
    		 
        #[allow(clippy::needless_collect)]
    113
    		 
        let subcommands = cmd.get_subcommands().cloned().collect::<Vec<_>>();
  • commit_verify 0.9.0/src/lnpbp4.rs
    333
    		 
        #[allow(clippy::needless_collect)]
    334
    		 
        fn into_iter(self) -> Self::IntoIter {
    568
    		 
        #[allow(clippy::needless_collect)]
    569
    		 
        fn into_iter(self) -> Self::IntoIter {
  • coupe 0.1.0/src/algorithms/vn/first.rs
    303
    		 
        #[allow(clippy::needless_collect)] // clippy bug
    304
    		 
        #[test]
  • crepe 0.1.7/src/lib.rs
    961
    		 
            let mut datalog_vars: HashSet<String> = HashSet::new();
    962
    		 
            #[allow(clippy::needless_collect)]
    963
    		 
            let fragments: Vec<_> = rule
    979
    		 
                let mut datalog_vars: HashSet<String> = HashSet::new();
    980
    		 
                #[allow(clippy::needless_collect)]
    981
    		 
                let fragments: Vec<_> = rule
  • cuid2 0.1.0/src/lib.rs
    459
    		 
            // collect to force spawning the threads instead of just holding them lazily
    460
    		 
            #[allow(clippy::needless_collect)]
    461
    		 
            let threads = (0..cores)
  • datacake-cluster 0.1.0/src/storage.rs
    646
    		 
            #[allow(clippy::needless_collect)]
    647
    		 
            let res = storage
    754
    		 
                .expect("Delete documents from store.");
    755
    		 
            #[allow(clippy::needless_collect)]
    756
    		 
            let res = storage
  • datacake-cluster 0.1.0/src/test_utils.rs
    280
    		 
                self.mock_counters.inc(name);
    281
    		 
                #[allow(clippy::needless_collect)]
    282
    		 
                let items = keys.collect::<Vec<_>>();
    316
    		 
                self.mock_counters.inc(name);
    317
    		 
                #[allow(clippy::needless_collect)]
    318
    		 
                let items = documents.collect::<Vec<_>>();
    330
    		 
                self.mock_counters.inc(name);
    331
    		 
                #[allow(clippy::needless_collect)]
    332
    		 
                let items = documents.collect::<Vec<_>>();
    357
    		 
                self.mock_counters.inc(name);
    358
    		 
                #[allow(clippy::needless_collect)]
    359
    		 
                let items = documents.collect::<Vec<_>>();
    383
    		 
                self.mock_counters.inc(name);
    384
    		 
                #[allow(clippy::needless_collect)]
    385
    		 
                let items = doc_ids.collect::<Vec<_>>();
  • datacake-eventual-consistency 0.2.1/src/storage.rs
    638
    		 
            #[allow(clippy::needless_collect)]
    639
    		 
            let res = storage
    746
    		 
                .expect("Delete documents from store.");
    747
    		 
            #[allow(clippy::needless_collect)]
    748
    		 
            let res = storage
  • datacake-eventual-consistency 0.2.1/src/test_utils.rs
    285
    		 
                self.mock_counters.inc(name);
    286
    		 
                #[allow(clippy::needless_collect)]
    287
    		 
                let items = keys.collect::<Vec<_>>();
    321
    		 
                self.mock_counters.inc(name);
    322
    		 
                #[allow(clippy::needless_collect)]
    323
    		 
                let items = documents.collect::<Vec<_>>();
    335
    		 
                self.mock_counters.inc(name);
    336
    		 
                #[allow(clippy::needless_collect)]
    337
    		 
                let items = documents.collect::<Vec<_>>();
    362
    		 
                self.mock_counters.inc(name);
    363
    		 
                #[allow(clippy::needless_collect)]
    364
    		 
                let items = documents.collect::<Vec<_>>();
    388
    		 
                self.mock_counters.inc(name);
    389
    		 
                #[allow(clippy::needless_collect)]
    390
    		 
                let items = doc_ids.collect::<Vec<_>>();
  • dexios-domain 1.0.1/src/erase_dir.rs
    51
    		 
        #[allow(clippy::needless_collect)] // 🚫 we have to collect in order to propertly join threads!
    52
    		 
        let handlers = files
  • dexios-domain 1.0.1/src/storage.rs
    352
    		 
            #[allow(clippy::needless_collect)] // 🚫 we have to collect to close read lock guard!
    353
    		 
            let file_paths = self
  • dexios-domain 1.0.1/src/unpack.rs
    118
    		 
            // 5. create dirs
    119
    		 
            #[allow(clippy::needless_collect)]
    120
    		 
            let create_dirs_jobs = entities
  • diesel 2.0.3/src/connection/transaction_manager.rs
    789
    		 
        // so clippy is wrong here
    790
    		 
        #[allow(clippy::needless_collect)]
    791
    		 
        fn mysql_transaction_depth_commits_tracked_properly_on_serialization_failure() {
    895
    		 
        // so clippy is wrong here
    896
    		 
        #[allow(clippy::needless_collect)]
    897
    		 
        fn mysql_nested_transaction_depth_commits_tracked_properly_on_serialization_failure() {
  • diesel 2.0.3/src/pg/connection/mod.rs
    751
    		 
        // so this is a false positive from clippy
    752
    		 
        #[allow(clippy::needless_collect)]
    753
    		 
        fn postgres_transaction_depth_is_tracked_properly_on_serialization_failure() {
    858
    		 
        // so this is a false positive from clippy
    859
    		 
        #[allow(clippy::needless_collect)]
    860
    		 
        fn postgres_transaction_depth_is_tracked_properly_on_nested_serialization_failure() {
  • druid-shell 0.8.0/src/backend/x11/clipboard.rs
    213
    		 
        #[allow(clippy::needless_collect)]
    214
    		 
        fn available_type_names(&self) -> Vec<String> {
  • druid-shell 0.8.0/src/backend/x11/screen.rs
    125
    		 
    // replies. This saves round-trips. Without the collect(), there would be one round-trip per CRTC.
    126
    		 
    #[allow(clippy::needless_collect)]
    127
    		 
    fn get_monitors_randr_crtcs_timestamp(
  • elastic-elgamal 0.2.1/src/proofs/mul.rs
    107
    		 
        /// will not verify.
    108
    		 
        #[allow(clippy::needless_collect)] // false positive
    109
    		 
        pub fn new<'a, R: RngCore + CryptoRng>(
  • elastic-elgamal 0.2.1/src/proofs/ring.rs
    763
    		 
        #[test]
    764
    		 
        #[allow(clippy::needless_collect)]
    765
    		 
        // ^-- false positive; `builder` is captured by the iterator and moved by creating a `proof`
  • electrscash 3.1.0/src/bulk.rs
    251
    		 
        let rows_chan = SyncChannel::new(0);
    252
    		 
        #[allow(clippy::needless_collect)]
    253
    		 
        let indexers: Vec<JoinHandle> = (0..index_threads)
  • elfshaker 0.9.0/src/repo/pack.rs
    403
    		 
        #[allow(unused_mut)]
    404
    		 
        #[allow(clippy::needless_collect)]
    405
    		 
        pub(crate) fn extract_entries<P>(
  • emojifinder 0.2.2/src/main.rs
    60
    		 
    fn find_language(index: &Index) -> Result<String, Error> {
    61
    		 
    	#[allow(clippy::needless_collect)]
    62
    		 
    	let index_langs: Vec<LanguageRange> = index
  • erdos 0.4.0/src/scheduler/channel_manager.rs
    155
    		 
        /// other nodes.
    156
    		 
        #[allow(clippy::needless_collect)]
    157
    		 
        pub async fn new(
  • etk-analyze 0.2.1/src/cfg.rs
    252
    		 
        // https://github.com/rust-lang/rust-clippy/issues/6420
    253
    		 
        #[allow(clippy::needless_collect)]
    254
    		 
        pub fn refine_shallow(&mut self) {
  • externref 0.1.0/src/processor/state.rs
    143
    		 
        )]
    144
    		 
        #[allow(clippy::needless_collect)] // false positive
    145
    		 
        fn transform_export(
  • fe2o3-amqp 0.8.13/src/link/sender_link.rs
    495
    		 
        #[allow(clippy::needless_collect)]
    496
    		 
        fn handle_unsettled_in_attach(
  • foca 0.10.0/src/lib.rs
    2564
    		 
            // otherwise foca remains borrowed
    2565
    		 
            #[allow(clippy::needless_collect)]
    2566
    		 
            let updates = foca
  • frenderer 0.5.8/src/assets.rs
    127
    		 
                    // This is safe to allow because we need an ExactSizeIterator of faces
    128
    		 
                    #[allow(clippy::needless_collect)]
    129
    		 
                    let faces: Vec<u32> = mesh
    220
    		 
                    // This is safe to allow because we need an ExactSizeIterator of faces
    221
    		 
                    #[allow(clippy::needless_collect)]
    222
    		 
                    let faces: Vec<u32> = mesh
    364
    		 
                    // This is safe to allow because we need an ExactSizeIterator of faces
    365
    		 
                    #[allow(clippy::needless_collect)]
    366
    		 
                    let faces: Vec<u32> = mesh
  • fuel-vm 0.25.2/src/interpreter/executors/main.rs
    61
    		 
            // Needed for now because checked is only freed once the value is collected into a Vec
    62
    		 
            #[allow(clippy::needless_collect)]
    63
    		 
            let predicates: Vec<_> = (0..checked.transaction().inputs().len())
  • fvm-wasm-instrument 0.4.0/src/stack_limiter/mod.rs
    249
    		 
    /// ```
    250
    		 
    #[allow(clippy::needless_collect)]
    251
    		 
    fn instrument_function(ctx: &mut Context, func: FunctionBody) -> Result<wasm_encoder::Function> {
  • gemachain-gossip 1.8.0/src/cluster_info.rs
    2157
    		 
        #[allow(clippy::needless_collect)]
    2158
    		 
        fn handle_batch_push_messages(
    3111
    		 
        #[test]
    3112
    		 
        #[allow(clippy::needless_collect)]
    3113
    		 
        fn test_handle_ping_messages() {
    3820
    		 
        #[test]
    3821
    		 
        #[allow(clippy::needless_collect)]
    3822
    		 
        fn test_split_messages_packet_size() {
  • gemachain-gossip 1.8.0/src/crds.rs
    1080
    		 
        #[test]
    1081
    		 
        #[allow(clippy::needless_collect)]
    1082
    		 
        fn test_drop() {
  • gemachain-perf 1.8.0/src/recycler.rs
    73
    		 
    impl<T: Default + Reset + Sized> Recycler<T> {
    74
    		 
        #[allow(clippy::needless_collect)]
    75
    		 
        pub fn warmed(num: usize, size_hint: usize) -> Self {
  • gemachain-runtime 1.8.2/src/accounts.rs
    915
    		 
        #[must_use]
    916
    		 
        #[allow(clippy::needless_collect)]
    917
    		 
        pub fn lock_accounts<'a>(
    931
    		 
        /// Once accounts are unlocked, new transactions that modify that state can enter the pipeline
    932
    		 
        #[allow(clippy::needless_collect)]
    933
    		 
        pub fn unlock_accounts<'a>(
  • gemachain-runtime 1.8.2/src/accounts_db.rs
    3953
    		 
        #[allow(clippy::needless_collect)]
    3954
    		 
        fn purge_slots<'a>(&self, slots: impl Iterator<Item = &'a Slot>) {
    6400
    		 
        #[allow(clippy::needless_collect)]
    6401
    		 
        pub fn generate_index(&self, limit_load_slot_count_from_snapshot: Option<usize>, verify: bool) {
  • gemachain-runtime 1.8.2/src/accounts_index.rs
    1549
    		 
        // This is designed to be called at startup time.
    1550
    		 
        #[allow(clippy::needless_collect)]
    1551
    		 
        pub(crate) fn insert_new_if_missing_into_primary_index(
  • gemachain-runtime 1.8.2/src/bank.rs
    3702
    		 
        // Ref: collect_fees
    3703
    		 
        #[allow(clippy::needless_collect)]
    3704
    		 
        fn distribute_rent_to_validators(
  • ggez 0.9.0-rc0/src/vfs.rs
    810
    		 
        #[allow(clippy::needless_collect)]
    811
    		 
        /// Zip files don't have real directories, so we (incorrectly) hack it by
  • git-checks 4.2.1/src/formatting.rs
    313
    		 
        /// Create a message for the given paths.
    314
    		 
        #[allow(clippy::needless_collect)]
    315
    		 
        fn message_for_paths<P>(
  • git-stack 0.10.11/src/bin/git-stack/ops.rs
    186
    		 
        let stdout = String::from_utf8(output.stdout).wrap_err("Could not run `git fetch`")?;
    187
    		 
        #[allow(clippy::needless_collect)]
    188
    		 
        let remote_branches: Vec<_> = stdout
  • git-stack 0.10.11/src/bin/git-stack/stack.rs
    960
    		 
        let stdout = String::from_utf8(output.stdout).wrap_err("Could not run `git fetch`")?;
    961
    		 
        #[allow(clippy::needless_collect)]
    962
    		 
        let remote_branches: Vec<_> = stdout
  • golang-type-decl-macro 0.3.0/src/gen_json_struct/mod.rs
    15
    		 
    #[allow(clippy::needless_collect)]
    16
    		 
    pub fn get_output(input: Input) -> TokenStream {
  • governor 0.5.1/src/state/in_memory.rs
    71
    		 
    #[cfg(test)]
    72
    		 
    #[allow(clippy::needless_collect)]
    73
    		 
    mod test {
  • grid_pathfinding 0.1.1/src/astar_jps.rs
    41
    		 
    }
    42
    		 
    #[allow(clippy::needless_collect)]
    43
    		 
    fn reverse_path<N, V, F>(parents: &IndexMap<N, V>, mut parent: F, start: usize) -> Vec<N>
  • gzp 0.11.3/src/par/compress.rs
    167
    		 
        /// to the writer.
    168
    		 
        #[allow(clippy::needless_collect)]
    169
    		 
        fn run<W>(
  • gzp 0.11.3/src/par/decompress.rs
    125
    		 
        #[allow(clippy::needless_collect)]
    126
    		 
        fn run<R>(
  • h3o 0.3.0/src/geom/geometry/polygon.rs
    222
    		 
            // the mutable borrow on `seen`.
    223
    		 
            #[allow(clippy::needless_collect)]
    224
    		 
            // Compute the initial set of cell, using polygon edges.
  • hapi-rs 0.9.0/tests/geometry.rs
    297
    		 
        let pt_groups = geo.get_group_names(GroupType::Point).unwrap();
    298
    		 
        #[allow(clippy::needless_collect)]
    299
    		 
        {
  • hematita 0.1.0/src/compiler/mod.rs
    885
    		 
    		// We need to realize all values...
    886
    		 
    		#[allow(clippy::needless_collect)] // Needed by borrow checker.
    887
    		 
    		let evaluated = self.evaluated_variables.iter()
  • holochain 0.1.0/src/conductor/conductor/graft_records_onto_source_chain.rs
    84
    		 
                        // Clippy is wrong :(
    85
    		 
                        #[allow(clippy::needless_collect)]
    86
    		 
                        let basis = ops
  • holochain_p2p 0.1.0/src/spawn/actor.rs
    892
    		 
        #[allow(clippy::needless_collect)]
    893
    		 
        #[tracing::instrument(skip(self), level = "trace")]
  • horned-owl 0.14.0/src/ontology/axiom_mapped.rs
    219
    		 
            // The collect switches the type which shows up in the API. Blegh.
    220
    		 
            #[allow(clippy::needless_collect)]
    221
    		 
            let v: Vec<AnnotatedAxiom<A>> = btreemap
  • horned-owl 0.14.0/src/ontology/set.rs
    211
    		 
        fn into_iter(self) -> Self::IntoIter {
    212
    		 
            #[allow(clippy::needless_collect)]
    213
    		 
            let v: Vec<AnnotatedAxiom<_>> = self.0.into_iter().map(|fi| fi.unwrap()).collect();
    221
    		 
        fn into_iter(self) -> Self::IntoIter {
    222
    		 
            #[allow(clippy::needless_collect)]
    223
    		 
            let v: Vec<&'a AnnotatedAxiom<A>> = self.0.iter().map(|fiac| fiac.borrow()).collect();
  • hytra 0.1.2/benches/hytra.rs
    36
    		 
    /// A local counter in each thread (manual implementation).
    37
    		 
    #[allow(clippy::needless_collect)]
    38
    		 
    fn simple_add(tot: i64, n: u32) -> i64 {
  • icu_provider_cldr 0.5.0/src/transform/datetime/common.rs
    82
    		 
    impl CommonDateProvider {
    83
    		 
        #[allow(clippy::needless_collect)] // https://github.com/rust-lang/rust-clippy/issues/7526
    84
    		 
        pub fn supported_options_for_key(
  • icu_provider_cldr 0.5.0/src/transform/datetime/patterns.rs
    63
    		 
    impl IterableProvider for DatePatternsProvider {
    64
    		 
        #[allow(clippy::needless_collect)] // https://github.com/rust-lang/rust-clippy/issues/7526
    65
    		 
        fn supported_options_for_key(
  • icu_provider_cldr 0.5.0/src/transform/datetime/skeletons.rs
    62
    		 
    impl IterableProvider for DateSkeletonPatternsProvider {
    63
    		 
        #[allow(clippy::needless_collect)] // https://github.com/rust-lang/rust-clippy/issues/7526
    64
    		 
        fn supported_options_for_key(
  • icu_provider_cldr 0.5.0/src/transform/datetime/symbols.rs
    68
    		 
    impl IterableProvider for DateSymbolsProvider {
    69
    		 
        #[allow(clippy::needless_collect)] // https://github.com/rust-lang/rust-clippy/issues/7526
    70
    		 
        fn supported_options_for_key(
  • icu_provider_cldr 0.5.0/src/transform/decimal/mod.rs
    138
    		 
    impl IterableProvider for NumbersProvider {
    139
    		 
        #[allow(clippy::needless_collect)] // https://github.com/rust-lang/rust-clippy/issues/7526
    140
    		 
        fn supported_options_for_key(
  • icu_provider_cldr 0.5.0/src/transform/list/mod.rs
    147
    		 
    impl IterableProvider for ListProvider {
    148
    		 
        #[allow(clippy::needless_collect)] // https://github.com/rust-lang/rust-clippy/issues/7526
    149
    		 
        fn supported_options_for_key(
  • icu_provider_cldr 0.5.0/src/transform/plurals/mod.rs
    108
    		 
    impl IterableProvider for PluralsProvider {
    109
    		 
        #[allow(clippy::needless_collect)] // https://github.com/rust-lang/rust-clippy/issues/7526
    110
    		 
        fn supported_options_for_key(
  • icu_provider_cldr 0.5.0/src/transform/time_zones/mod.rs
    83
    		 
    impl IterableProvider for TimeZonesProvider {
    84
    		 
        #[allow(clippy::needless_collect)] // https://github.com/rust-lang/rust-clippy/issues/7526
    85
    		 
        fn supported_options_for_key(
  • indradb-sled 0.1.0/src/datastore.rs
    158
    		 
        #[allow(clippy::needless_collect)]
    159
    		 
        fn vertex_query_to_iterator<'iter, 'trans: 'iter>(
  • instruct 0.1.0/src/interpreter/executor/block.rs
    57
    		 
        #[allow(clippy::needless_collect)]
    58
    		 
        fn execute(&mut self, mut parent_stack: StackRef, ctx: ContextRef) -> anyhow::Result<()> {
  • ipfs-sqlite-block-store 0.13.0/src/cache/sqlite_tracker.rs
    168
    		 
    {
    169
    		 
        #[allow(clippy::needless_collect)]
    170
    		 
        fn blocks_accessed(&self, blocks: Vec<BlockInfo>) {
  • iroh-p2p 0.2.0/src/node.rs
    845
    		 
                RpcMessage::NetPeers(response_channel) => {
    846
    		 
                    #[allow(clippy::needless_collect)]
    847
    		 
                    let peers = self.swarm.connected_peers().copied().collect::<Vec<_>>();
  • jammdb 0.9.0/src/node.rs
    337
    		 
            // Create new vector of data to go on it's own pages
    338
    		 
            #[allow(clippy::needless_collect)]
    339
    		 
            let new_data: Vec<NodeData> = split_indexes
  • jsonschema 0.16.1/src/keywords/additional_items.rs
    42
    		 
        #[allow(clippy::needless_collect)]
    43
    		 
        fn validate<'instance>(
  • jsonschema 0.16.1/src/keywords/additional_properties.rs
    197
    		 
        #[allow(clippy::needless_collect)]
    198
    		 
        fn validate<'instance>(
  • jsonschema 0.16.1/src/keywords/all_of.rs
    40
    		 
        #[allow(clippy::needless_collect)]
    41
    		 
        fn validate<'instance>(
  • jsonschema 0.16.1/src/keywords/dependencies.rs
    64
    		 
        #[allow(clippy::needless_collect)]
    65
    		 
        fn validate<'instance>(
  • jsonschema 0.16.1/src/keywords/if_.rs
    45
    		 
        #[allow(clippy::needless_collect)]
    46
    		 
        fn validate<'instance>(
    120
    		 
        #[allow(clippy::needless_collect)]
    121
    		 
        fn validate<'instance>(
    201
    		 
        #[allow(clippy::needless_collect)]
    202
    		 
        fn validate<'instance>(
  • jsonschema 0.16.1/src/keywords/items.rs
    42
    		 
        #[allow(clippy::needless_collect)]
    43
    		 
        fn validate<'instance>(
    96
    		 
        #[allow(clippy::needless_collect)]
    97
    		 
        fn validate<'instance>(
    179
    		 
        #[allow(clippy::needless_collect)]
    180
    		 
        fn validate<'instance>(
  • jujutsu-lib 0.6.1/src/revset.rs
    1621
    		 
            // reverse
    1622
    		 
            #[allow(clippy::needless_collect)]
    1623
    		 
            RevsetExpression::DagRange { roots, heads } => {
  • kanata 1.2.0-prerelease-1/src/cfg/mod.rs
    385
    		 
        #[allow(clippy::needless_collect)]
    386
    		 
        // Clippy suggests using the sorted_idxs iter directly and manipulating it
  • kompact 0.11.0/src/dispatch/lookup/path_trie.rs
    332
    		 
        #[test]
    333
    		 
        #[allow(clippy::needless_collect)]
    334
    		 
        fn test_iter() {
  • kompact 0.11.0/src/routing/mod.rs
    103
    		 
        #[test]
    104
    		 
        #[allow(clippy::needless_collect)]
    105
    		 
        fn test_explicit_round_robin_select() {
    152
    		 
        #[test]
    153
    		 
        #[allow(clippy::needless_collect)]
    154
    		 
        fn test_explicit_hash_select() {
    220
    		 
        #[test]
    221
    		 
        #[allow(clippy::needless_collect)]
    222
    		 
        fn test_implicit_select() {
    284
    		 
        #[test]
    285
    		 
        #[allow(clippy::needless_collect)]
    286
    		 
        fn test_explicit_broadcast() {
    344
    		 
        #[test]
    345
    		 
        #[allow(clippy::needless_collect)]
    346
    		 
        fn test_implicit_broadcast() {
  • krecik 1.0.4/src/actors/generic_checker.rs
    81
    		 
                        // collect tuple of page-checks and Curl handler:
    82
    		 
                        #[allow(clippy::needless_collect)] // Clippy BUG: not needless!
    83
    		 
                        let process_handlers: Vec<_> = all_pages
  • lettre 0.10.2/src/transport/smtp/pool/async_impl.rs
    60
    		 
                            Some(pool) => {
    61
    		 
                                #[allow(clippy::needless_collect)]
    62
    		 
                                let (count, dropped) = {
  • lettre 0.10.2/src/transport/smtp/pool/sync_impl.rs
    54
    		 
                            #[allow(clippy::needless_collect)]
    55
    		 
                            let (count, dropped) = {
  • libipld-cbor-derive 0.16.0/src/gen.rs
    179
    		 
    #[allow(clippy::needless_collect)]
    180
    		 
    fn gen_encode_union(u: &Union) -> TokenStream {
  • libp2p-autonat 0.9.1/tests/test_client.rs
    493
    		 
            #[allow(clippy::needless_collect)] // Drop the handles of the inactive servers to kill them.
    494
    		 
            let inactive_ids: Vec<_> = inactive.into_iter().map(|(id, _handle)| id).collect();
  • libp2p-episub 0.1.13/src/behaviour.rs
    464
    		 
            // mut borrow to self.
    465
    		 
            #[allow(clippy::needless_collect)]
    466
    		 
            let early_peers: Vec<PeerId> = self.early_peers.drain().collect();
  • libp2p-episub 0.1.13/src/view.rs
    288
    		 
          // mut borrow to self.
    289
    		 
          #[allow(clippy::needless_collect)]
    290
    		 
          let selected: Vec<_> = self
  • libp2p-kad 0.42.1/src/query/peers/fixed.rs
    60
    		 
    impl FixedPeersIter {
    61
    		 
        #[allow(clippy::needless_collect)]
    62
    		 
        pub fn new<I>(peers: I, parallelism: NonZeroUsize) -> Self
  • lucky_commit 2.2.1/src/lib.rs
    298
    		 
        #[allow(clippy::needless_collect)]
    299
    		 
        fn search_with_cpus(self) -> Option<GitCommit<H>> {
  • ludusavi 0.15.2/src/layout.rs
    1450
    		 
        fn find_irrelevant_backup_files(&self, backup: &str, relevant_files: &[StrictPath]) -> Vec<StrictPath> {
    1451
    		 
            #[allow(clippy::needless_collect)]
    1452
    		 
            let relevant_files: Vec<_> = relevant_files.iter().map(|x| x.interpret()).collect();
  • lunatic-networking-api 0.13.0/src/dns.rs
    88
    		 
                        // This is a bug in clippy, this collect is not needless
    89
    		 
                        #[allow(clippy::needless_collect)]
    90
    		 
                        let id = state.dns_resources_mut().add(DnsIterator::new(
  • lurk-ipld-cbor-derive 0.3.0/src/gen.rs
    179
    		 
    #[allow(clippy::needless_collect)]
    180
    		 
    fn gen_encode_union(u: &Union) -> TokenStream {
  • mail-auth 0.3.0/src/dkim/canonicalize.rs
    211
    		 
        #[test]
    212
    		 
        #[allow(clippy::needless_collect)]
    213
    		 
        fn dkim_canonicalize() {
  • marlu 0.8.0/src/context.rs
    409
    		 
        // TODO: these collects are needed because of https://github.com/nyx-space/hifitime/issues/131
    410
    		 
        #[allow(clippy::needless_collect)]
    411
    		 
        fn vis_ctx_timeseries_length() {
  • matrix-sdk-indexeddb 0.2.0/src/state_store.rs
    1543
    		 
            let end_token = tlm.end;
    1544
    		 
            #[allow(clippy::needless_collect)]
    1545
    		 
            let timeline: Vec<StoreResult<SyncTimelineEvent>> = timeline
  • messaging_thread_pool 3.0.20-alpha/src/sender_and_receiver/sender_and_receiver_mock.rs
    78
    		 
    {
    79
    		 
        #[allow(clippy::needless_collect)]
    80
    		 
        fn send_and_receive<'a, T>(
  • messaging_thread_pool 3.0.20-alpha/src/sender_and_receiver/sender_and_receiver_raw_mock.rs
    80
    		 
    {
    81
    		 
        #[allow(clippy::needless_collect)]
    82
    		 
        fn send_and_receive<'a, T>(
  • mimicry 0.1.0/tests/integration.rs
    421
    		 
    #[test]
    422
    		 
    #[allow(clippy::needless_collect)] // needed for threads to be spawned concurrently
    423
    		 
    fn single_shared_mock_in_multi_thread_env() {
    438
    		 
    #[test]
    439
    		 
    #[allow(clippy::needless_collect)] // needed for threads to be spawned concurrently
    440
    		 
    fn per_thread_mock_in_multi_thread_env() {
  • minfac 0.0.1/src/lib.rs
    477
    		 
    #[cfg(debug_assertions)]
    478
    		 
    #[allow(clippy::needless_collect)]
    479
    		 
    impl Drop for ServiceProvider {
  • mini-moka 0.10.0/src/sync/cache.rs
    793
    		 
            // https://rust-lang.github.io/rust-clippy/master/index.html#needless_collect
    794
    		 
            #[allow(clippy::needless_collect)]
    795
    		 
            let handles = (0..num_threads)
    1057
    		 
            // https://rust-lang.github.io/rust-clippy/master/index.html#needless_collect
    1058
    		 
            #[allow(clippy::needless_collect)]
    1059
    		 
            let handles = (0..NUM_THREADS)
  • mini-moka 0.10.0/src/unsync/cache.rs
    433
    		 
        // clippy 0.1.52 (9a1dfd2dc5c 2021-04-30) in Rust 1.52.0-beta.7
    434
    		 
        #[allow(clippy::needless_collect)]
    435
    		 
        pub fn invalidate_entries_if(&mut self, mut predicate: impl FnMut(&K, &V) -> bool) {
  • minitrace 0.4.0/src/local/span_id.rs
    52
    		 
        #[test]
    53
    		 
        #[allow(clippy::needless_collect)]
    54
    		 
        fn unique_id() {
  • misskey-util 0.2.0-rc.1/src/client.rs
    1063
    		 
        /// ```
    1064
    		 
        #[allow(clippy::needless_collect)]
    1065
    		 
        fn poll(
  • mithril-stm 0.2.1/src/stm.rs
    910
    		 
            #[allow(clippy::needless_collect)]
    911
    		 
            let ps = stake
  • modelator 0.4.2/src/lib.rs
    215
    		 
            #[allow(clippy::needless_collect)]
    216
    		 
            // rust iterators are lazy
  • moka 0.9.6/src/cht/segment.rs
    655
    		 
            #[allow(clippy::needless_collect)]
    656
    		 
            let threads: Vec<_> = (0..NUM_THREADS)
    782
    		 
            #[allow(clippy::needless_collect)]
    783
    		 
            let threads: Vec<_> = (0..NUM_THREADS)
    822
    		 
            #[allow(clippy::needless_collect)]
    823
    		 
            let threads: Vec<_> = (0..NUM_THREADS)
    892
    		 
            #[allow(clippy::needless_collect)]
    893
    		 
            let threads: Vec<_> = (0..NUM_THREADS)
    938
    		 
            #[allow(clippy::needless_collect)]
    939
    		 
            let insert_threads: Vec<_> = (0..NUM_THREADS)
  • moka 0.9.6/src/dash/cache.rs
    785
    		 
            // https://rust-lang.github.io/rust-clippy/master/index.html#needless_collect
    786
    		 
            #[allow(clippy::needless_collect)]
    787
    		 
            let handles = (0..num_threads)
    1049
    		 
            // https://rust-lang.github.io/rust-clippy/master/index.html#needless_collect
    1050
    		 
            #[allow(clippy::needless_collect)]
    1051
    		 
            let handles = (0..NUM_THREADS)
  • moka 0.9.6/src/sync/cache.rs
    2031
    		 
            // https://rust-lang.github.io/rust-clippy/master/index.html#needless_collect
    2032
    		 
            #[allow(clippy::needless_collect)]
    2033
    		 
            let handles = (0..num_threads)
    2461
    		 
            // https://rust-lang.github.io/rust-clippy/master/index.html#needless_collect
    2462
    		 
            #[allow(clippy::needless_collect)]
    2463
    		 
            let handles = (0..NUM_THREADS)
  • moka 0.9.6/src/sync/segment.rs
    1027
    		 
            // https://rust-lang.github.io/rust-clippy/master/index.html#needless_collect
    1028
    		 
            #[allow(clippy::needless_collect)]
    1029
    		 
            let handles = (0..num_threads)
  • monorail 1.1.0/src/lib.rs
    986
    		 
        // TODO: refactor this
    987
    		 
        #[allow(clippy::needless_collect)]
    988
    		 
        fn into_iter(self) -> Self::IntoIter {
  • mownstr 0.1.3/benches/bench1.rs
    19
    		 
                    // as suggested by clippy, causes this test to crash :-/
    20
    		 
                    #[allow(clippy::needless_collect)]
    21
    		 
                    let v = i.iter().cloned().collect::<Vec<_>>();
    33
    		 
                b.iter(|| {
    34
    		 
                    #[allow(clippy::needless_collect)]
    35
    		 
                    let v = i.iter().map(|r| MownStr::from(*r)).collect::<Vec<_>>();
    47
    		 
                b.iter(|| {
    48
    		 
                    #[allow(clippy::needless_collect)]
    49
    		 
                    let v = i
    65
    		 
                b.iter(|| {
    66
    		 
                    #[allow(clippy::needless_collect)]
    67
    		 
                    let v = i
  • multisql 0.4.3/src/databases/csv/base.rs
    23
    		 
    		#[allow(clippy::needless_collect)]
    24
    		 
    		// Clippy doesn't understand the need. Needed because we have borrowed values within.
  • mv-compiler 0.3.2/src/cfgir/inline_blocks.rs
    54
    		 
    #[allow(clippy::needless_collect)]
    55
    		 
    fn inline_single_target_blocks(
  • mysql_async_support_model 0.3.0/src/string_values.rs
    26
    		 
        // needed as `row.unwrap()` consumes `Row`.
    27
    		 
        #[allow(clippy::needless_collect)]
    28
    		 
        fn from_row_opt(row: Row) -> Result<Self, FromRowError> {
  • mysql_async_support_model 0.3.0/src/typed_values.rs
    33
    		 
        // needed as `row.unwrap()` consumes `Row`.
    34
    		 
        #[allow(clippy::needless_collect)]
    35
    		 
        fn from_row_opt(row: Row) -> Result<Self, FromRowError> {
  • n18ui 0.1.0/src/control/_gtk3.rs
    101
    		 
    /// and provides these details (if any) to `callback`.
    102
    		 
    #[allow(clippy::needless_collect)]
    103
    		 
    pub fn select_trains<F>(
  • nameless-clap 3.0.0-beta.2.2/src/output/usage.rs
    362
    		 
        // TODO: remove the allow clippy when we update the compiler version.
    363
    		 
        #[allow(clippy::needless_collect)]
    364
    		 
        pub(crate) fn get_required_usage_from(
  • nickel-lang 0.3.1/src/eval/merge.rs
    327
    		 
                // See https://github.com/rust-lang/rust-clippy/issues/7526
    328
    		 
                #[allow(clippy::needless_collect)]
    329
    		 
                let contracts2: Vec<Contract> = contracts2
  • novasymph 0.3.1/src/blockgraph.rs
    250
    		 
        /// An lnc block tip may have children which are not notarized.
    251
    		 
        #[allow(clippy::needless_collect)]
    252
    		 
        pub fn lnc_tips(&self) -> BTreeSet<HashVal> {
  • nreplops-tool 0.0.10/src/hosts_files.rs
    35
    		 
        // XXX(soija) ConfigFiles does not implement DoubledEndedIterator
    36
    		 
        #[allow(clippy::needless_collect)]
    37
    		 
        let ps = matching_config_files("nreplops-hosts.toml")
  • nu-command 0.75.0/src/filesystem/cp.rs
    235
    		 
                        #[allow(clippy::needless_collect)]
    236
    		 
                        let comps: Vec<_> = path
  • nu-command 0.75.0/src/filesystem/glob.rs
    156
    		 
            #[allow(clippy::needless_collect)]
    157
    		 
            let glob_results: Vec<Value> = glob
  • nu-command 0.75.0/src/filters/lines.rs
    45
    		 
            match input {
    46
    		 
                #[allow(clippy::needless_collect)]
    47
    		 
                // Collect is needed because the string may not live long enough for
  • nu-command 0.75.0/src/filters/reverse.rs
    74
    		 
            #[allow(clippy::needless_collect)]
    75
    		 
            let v: Vec<_> = input.into_iter_strict(call.head)?.collect();
  • nu-command 0.75.0/src/strings/detect_columns.rs
    98
    		 
        #[allow(clippy::needless_collect)]
    99
    		 
        let input: Vec<_> = input
  • oxigraph 0.3.11/src/sparql/dataset.rs
    46
    		 
        #[allow(clippy::needless_collect)]
    47
    		 
        pub fn encoded_quads_for_pattern(
  • oxrdf 0.1.2/src/dataset.rs
    734
    		 
        #[allow(clippy::needless_collect)]
    735
    		 
        fn label(
  • palloc 0.1.3/src/test/global.rs
    47
    		 
        #[allow(clippy::needless_collect)]
    48
    		 
        let threads: Vec<JoinHandle<_>> = (0..10)
  • panrelease 0.6.0/src/args.rs
    90
    		 
            let inner_parser = clap::builder::EnumValueParser::<BumpLevel>::new();
    91
    		 
            #[allow(clippy::needless_collect)] // Erasing a lifetime
    92
    		 
            inner_parser.possible_values().map(|ps| {
  • partopo 0.1.0/src/lib.rs
    121
    		 
        // False positive: need to give up immutable borrow of graph before removing node from graph
    122
    		 
        #[allow(clippy::needless_collect)]
    123
    		 
        let dependents: Vec<NodeIndex> = graph
  • pathfinding 4.2.1/src/directed/mod.rs
    19
    		 
    #[allow(clippy::needless_collect)]
    20
    		 
    fn reverse_path<N, V, F>(parents: &FxIndexMap<N, V>, mut parent: F, start: usize) -> Vec<N>
  • plonky2 0.1.1/src/iop/ext_target.rs
    39
    		 
            let z0 = F::Extension::W.exp_biguint(&(k * count as u64));
    40
    		 
            #[allow(clippy::needless_collect)]
    41
    		 
            let zs = z0
  • plotters 0.3.4/src/drawing/area.rs
    92
    		 
            // into a iterator.
    93
    		 
            #[allow(clippy::needless_collect)]
    94
    		 
            let ysegs: Vec<_> = ys
  • polars-core 0.26.1/src/chunked_array/ops/unique/mod.rs
    133
    		 
    #[cfg(feature = "mode")]
    134
    		 
    #[allow(clippy::needless_collect)]
    135
    		 
    fn mode<T: PolarsDataType>(ca: &ChunkedArray<T>) -> ChunkedArray<T>
  • polars-lazy 0.26.1/src/frame/mod.rs
    315
    		 
                    //      b -> a
    316
    		 
                    #[allow(clippy::needless_collect)]
    317
    		 
                    let existing_idx = existing
  • pooled-writer 0.3.0/src/lib.rs
    540
    		 
        /// - `shutdown_rx` - Sentinel channel to tell the pool management thread to shutdown.
    541
    		 
        #[allow(clippy::unnecessary_wraps, clippy::needless_collect, clippy::needless_pass_by_value)]
    542
    		 
        fn pool_main<W, C>(
  • ppar 0.3.1/src/bin/perf.rs
    110
    		 
        #[allow(clippy::needless_collect)]
    111
    		 
        fn load(&mut self, n: usize, rng: &mut SmallRng) -> (time::Duration, usize) {
    229
    		 
        #[allow(clippy::needless_collect)]
    230
    		 
        fn op_insert(&mut self, n_ops: usize, rng: &mut SmallRng) {
    249
    		 
        #[allow(clippy::needless_collect)]
    250
    		 
        fn op_insert_mut(&mut self, n_ops: usize, rng: &mut SmallRng) {
    269
    		 
        #[allow(clippy::needless_collect)]
    270
    		 
        fn op_remove(&mut self, n_ops: usize, rng: &mut SmallRng) {
    301
    		 
        #[allow(clippy::needless_collect)]
    302
    		 
        fn op_remove_mut(&mut self, n_ops: usize, rng: &mut SmallRng) {
  • prompter 0.1.2/src/lib.rs
    66
    		 
        #[allow(clippy::needless_collect)]
    67
    		 
        /// Returns true if the given `word` complies to all the constraints in the set.
  • pueue-lib 0.21.0/src/log.rs
    117
    		 
    // The iterators cannot be chained, as RevBufReader.lines doesn't implement the necessary traits.
    118
    		 
    #[allow(clippy::needless_collect)]
    119
    		 
    pub fn read_last_lines(file: &mut File, amount: usize) -> String {
  • punktf-lib 2.0.0/src/profile/transform.rs
    74
    		 
    				// collect is necessary.
    75
    		 
    				#[allow(clippy::needless_collect)]
    76
    		 
    				let lf_idxs = lf_idxs
  • qiniu-download 2.0.2/src/async_api/sync.rs
    507
    		 
        #[tokio::test]
    508
    		 
        #[allow(clippy::needless_collect)]
    509
    		 
        async fn test_synced_read_at() -> anyhow::Result<()> {
  • qiniu-upload-manager 0.2.2/src/multi_parts_uploader/v1.rs
    1278
    		 
            #[allow(clippy::needless_collect)]
    1279
    		 
            let threads = (0..BLOCK_COUNT)
    1569
    		 
                    let initialized_parts = Arc::new(uploader.initialize_parts(file_source, params)?);
    1570
    		 
                    #[allow(clippy::needless_collect)]
    1571
    		 
                    let threads = (0..BLOCK_COUNT)
  • qiniu-upload-manager 0.2.2/src/multi_parts_uploader/v2.rs
    1575
    		 
            #[allow(clippy::needless_collect)]
    1576
    		 
            let threads = (0..BLOCK_COUNT)
    1901
    		 
                    let initialized_parts = Arc::new(uploader.initialize_parts(file_source, params)?);
    1902
    		 
                    #[allow(clippy::needless_collect)]
    1903
    		 
                    let threads = (0..BLOCK_COUNT)
  • rash_core 1.8.6/src/docopt/mod.rs
    282
    		 
                        None => {
    283
    		 
                            #[allow(clippy::needless_collect)]
    284
    		 
                            let splitted: Vec<String> = cap[1]
  • retry-error 0.3.0/src/lib.rs
    185
    		 
        type IntoIter = std::vec::IntoIter<E>;
    186
    		 
        #[allow(clippy::needless_collect)]
    187
    		 
        // TODO We have to use collect/into_iter here for now, since
  • reverie-zk 0.3.2/src/proof/mod.rs
    116
    		 
    // The collects are necessary in release mode
    117
    		 
    #[allow(clippy::needless_collect)]
    118
    		 
    impl Proof {
  • rick 0.2.0/src/todo/todo_db.rs
    93
    		 
            // We don't care about the ID here.
    94
    		 
            #[allow(clippy::needless_collect)]
    95
    		 
            let t: Vec<Self::Item> = self.inner.into_iter().map(|item| item.1).collect();
  • rnr 0.4.1/src/solver.rs
    137
    		 
            // Create a vector with all sources from existing targets using absolute paths
    138
    		 
            #[allow(clippy::needless_collect)] // Benchmark shows no diff, code is clearer this way.
    139
    		 
            let sources: PathList = existing_targets
  • rosomaxa 0.2.6/src/algorithms/gsom/network.rs
    286
    		 
        #[allow(clippy::needless_collect)]
    287
    		 
        fn grow_nodes(&self, node: &NodeLink<I, S>) -> Vec<(Coordinate, Vec<f64>)> {
  • rtx-cli 1.3.0/src/file.rs
    127
    		 
            let filenames = vec![".rtxrc", ".rtxrc.toml", ".tool-versions"];
    128
    		 
            #[allow(clippy::needless_collect)]
    129
    		 
            let find_up = FindUp::new(path, &filenames).collect::<Vec<_>>();
  • rtx-cli-test 1.2.6/src/file.rs
    127
    		 
            let filenames = vec![".rtxrc", ".rtxrc.toml", ".tool-versions"];
    128
    		 
            #[allow(clippy::needless_collect)]
    129
    		 
            let find_up = FindUp::new(path, &filenames).collect::<Vec<_>>();
  • rush-analyzer 0.1.1/src/analyzer.rs
    167
    		 
            // `self.global(node)` has side effects that have to happen here
    168
    		 
            #[allow(clippy::needless_collect)]
    169
    		 
            let globals: Vec<AnalyzedLetStmt> = program
  • safecoin-perf 1.14.3/src/recycler.rs
    80
    		 
    impl<T: Default + Reset + Sized> Recycler<T> {
    81
    		 
        #[allow(clippy::needless_collect)]
    82
    		 
        pub fn warmed(num: usize, size_hint: usize) -> Self {
  • safecoin-runtime 1.14.3/src/accounts.rs
    1137
    		 
        #[must_use]
    1138
    		 
        #[allow(clippy::needless_collect)]
    1139
    		 
        pub fn lock_accounts<'a>(
    1150
    		 
        #[must_use]
    1151
    		 
        #[allow(clippy::needless_collect)]
    1152
    		 
        pub fn lock_accounts_with_results<'a>(
    1187
    		 
        /// Once accounts are unlocked, new transactions that modify that state can enter the pipeline
    1188
    		 
        #[allow(clippy::needless_collect)]
    1189
    		 
        pub fn unlock_accounts<'a>(
  • safecoin-runtime 1.14.3/src/accounts_db.rs
    5325
    		 
        #[allow(clippy::needless_collect)]
    5326
    		 
        fn purge_slots<'a>(&self, slots: impl Iterator<Item = &'a Slot> + Clone) {
    8441
    		 
        #[allow(clippy::needless_collect)]
    8442
    		 
        pub fn generate_index(
  • safecoin-runtime 1.14.3/src/accounts_index.rs
    1541
    		 
        // This is designed to be called at startup time.
    1542
    		 
        #[allow(clippy::needless_collect)]
    1543
    		 
        pub(crate) fn insert_new_if_missing_into_primary_index(
  • safecoin-runtime 1.14.3/src/bank.rs
    5115
    		 
        // Ref: collect_fees
    5116
    		 
        #[allow(clippy::needless_collect)]
    5117
    		 
        fn distribute_rent_to_validators(
  • shuttle 0.6.0/tests/basic/lazy_static.rs
    205
    		 
        for _ in 0..50 {
    206
    		 
            #[allow(clippy::needless_collect)] // https://github.com/rust-lang/rust-clippy/issues/7207
    207
    		 
            let threads = (0..3)
  • shuttle 0.6.0/tests/basic/once.rs
    181
    		 
        for _ in 0..50 {
    182
    		 
            #[allow(clippy::needless_collect)] // https://github.com/rust-lang/rust-clippy/issues/7207
    183
    		 
            let threads = (0..3)
  • snarkvm-algorithms 0.9.11/src/snark/marlin/ahp/prover/oracles.rs
    33
    		 
        /// Intended for use when committing.
    34
    		 
        #[allow(clippy::needless_collect)]
    35
    		 
        pub fn iter_for_commit(&mut self) -> impl Iterator<Item = LabeledPolynomialWithBasis<'static, F>> {
  • snowchains_core 0.13.2/src/web/mod.rs
    974
    		 
    // https://github.com/rust-lang/rust-clippy/issues/5991
    975
    		 
    #[allow(clippy::needless_collect)]
    976
    		 
    fn download_with_progress(
  • solana-core 1.14.13/src/unprocessed_packet_batches.rs
    424
    		 
    // with their packet indexes.
    425
    		 
    #[allow(clippy::needless_collect)]
    426
    		 
    pub fn transaction_from_deserialized_packet(
  • solana-gossip 1.14.13/src/cluster_info.rs
    2242
    		 
        #[allow(clippy::needless_collect)]
    2243
    		 
        fn handle_batch_push_messages(
    3364
    		 
        #[test]
    3365
    		 
        #[allow(clippy::needless_collect)]
    3366
    		 
        fn test_handle_ping_messages() {
    4122
    		 
        #[test]
    4123
    		 
        #[allow(clippy::needless_collect)]
    4124
    		 
        fn test_split_messages_packet_size() {
  • solana-gossip 1.14.13/src/crds.rs
    1249
    		 
        #[test]
    1250
    		 
        #[allow(clippy::needless_collect)]
    1251
    		 
        fn test_drop() {
  • solana-ledger 1.14.13/src/blockstore_processor.rs
    330
    		 
        // The collection is a pair of (full cost, cost without estimated-bpf-code-costs).
    331
    		 
        #[allow(clippy::needless_collect)]
    332
    		 
        let tx_costs = sanitized_txs
  • solana-perf 1.14.13/src/recycler.rs
    80
    		 
    impl<T: Default + Reset + Sized> Recycler<T> {
    81
    		 
        #[allow(clippy::needless_collect)]
    82
    		 
        pub fn warmed(num: usize, size_hint: usize) -> Self {
  • solana-runtime 1.14.13/src/accounts.rs
    1139
    		 
        #[must_use]
    1140
    		 
        #[allow(clippy::needless_collect)]
    1141
    		 
        pub fn lock_accounts<'a>(
    1152
    		 
        #[must_use]
    1153
    		 
        #[allow(clippy::needless_collect)]
    1154
    		 
        pub fn lock_accounts_with_results<'a>(
    1189
    		 
        /// Once accounts are unlocked, new transactions that modify that state can enter the pipeline
    1190
    		 
        #[allow(clippy::needless_collect)]
    1191
    		 
        pub fn unlock_accounts<'a>(
  • solana-runtime 1.14.13/src/accounts_db.rs
    5316
    		 
        #[allow(clippy::needless_collect)]
    5317
    		 
        fn purge_slots<'a>(&self, slots: impl Iterator<Item = &'a Slot> + Clone) {
    8427
    		 
        #[allow(clippy::needless_collect)]
    8428
    		 
        pub fn generate_index(
  • solana-runtime 1.14.13/src/accounts_index.rs
    1541
    		 
        // This is designed to be called at startup time.
    1542
    		 
        #[allow(clippy::needless_collect)]
    1543
    		 
        pub(crate) fn insert_new_if_missing_into_primary_index(
  • solana-runtime 1.14.13/src/bank.rs
    4898
    		 
        // Ref: collect_fees
    4899
    		 
        #[allow(clippy::needless_collect)]
    4900
    		 
        fn distribute_rent_to_validators(
  • solana-tokens 1.14.13/src/commands.rs
    465
    		 
    #[allow(clippy::needless_collect)]
    466
    		 
    fn read_allocations(
  • specta 0.0.6/src/datatype/enum.rs
    17
    		 
        /// An enum may contain variants which are invalid and will cause a runtime errors during serialize/deserialization. This function will filter them out so types can be exported for valid variants.
    18
    		 
        #[allow(clippy::needless_collect)]
    19
    		 
        pub fn make_flattenable(&mut self) {
  • spr 1.3.4/src/commands/diff.rs
    79
    		 
        #[allow(clippy::needless_collect)]
    80
    		 
        let pull_request_tasks: Vec<_> = prepared_commits
  • ssstar 0.4.0/src/create.rs
    675
    		 
            // download for the large objects), which we will then evaluate in parallel.
    676
    		 
            #[allow(clippy::needless_collect)] // collect is needed to avoid lifetime issues with `self`
    677
    		 
            let parts = self
  • stack-queue 0.2.0/src/queue.rs
    708
    		 
      async fn it_process_background_tasks() {
    709
    		 
        #[allow(clippy::needless_collect)]
    710
    		 
        let receivers: Vec<_> = (0..100_usize)
  • stratisd 3.5.0/src/engine/strat_engine/thinpool/thinpool.rs
    690
    		 
                // iteration.
    691
    		 
                #[allow(clippy::needless_collect)]
    692
    		 
                let handles = self.filesystems.iter_mut()
    747
    		 
                // iteration.
    748
    		 
                #[allow(clippy::needless_collect)]
    749
    		 
                let handles = needs_save.into_iter()
  • stratisd 3.5.0/src/engine/structures/lock.rs
    849
    		 
        // different closures in the same iterator.
    850
    		 
        #[allow(clippy::needless_collect)]
    851
    		 
        fn into(self) -> Vec<SomeLockReadGuard<U, T>> {
    957
    		 
        // different closures in the same iterator.
    958
    		 
        #[allow(clippy::needless_collect)]
    959
    		 
        fn into(self) -> Vec<SomeLockWriteGuard<U, T>> {
  • sway-ir 0.33.1/src/block.rs
    393
    		 
                // Move the block arguments to the new block. We collect because we want to mutate next.
    394
    		 
                #[allow(clippy::needless_collect)]
    395
    		 
                let args: Vec<_> = self.arg_iter(context).copied().collect();
  • sway-ir 0.33.1/tests/tests.rs
    115
    		 
    // if we try that then we have borrowing issues with `ir` which is used within the closure.
    116
    		 
    #[allow(clippy::needless_collect)]
    117
    		 
    #[test]
    132
    		 
    #[allow(clippy::needless_collect)]
    133
    		 
    #[test]
    148
    		 
    #[allow(clippy::needless_collect)]
    149
    		 
    #[test]
    164
    		 
    #[allow(clippy::needless_collect)]
    165
    		 
    #[test]
  • syntaxdot-encoders 0.5.0-beta.2/src/depseq/post_processing.rs
    23
    		 
        // Collect to avoid immutable + mutable reference.
    24
    		 
        #[allow(clippy::needless_collect)]
    25
    		 
        let token_indices: Vec<_> = (0..sentence.len())
  • syntaxdot-encoders 0.5.0-beta.2/src/depseq/relative_pos.rs
    259
    		 
            // Collect to avoid immutable + mutable reference.
    260
    		 
            #[allow(clippy::needless_collect)]
    261
    		 
            let token_indices: Vec<_> = (0..sentence.len())
  • syntaxdot-encoders 0.5.0-beta.2/src/depseq/relative_position.rs
    99
    		 
            // Collect to avoid immutable + mutable reference.
    100
    		 
            #[allow(clippy::needless_collect)]
    101
    		 
            let token_indices: Vec<_> = (0..sentence.len())
  • sysinfo 0.27.7/tests/process.rs
    278
    		 
        // We need `collect` otherwise we can't have mutable access to `system`.
    279
    		 
        #[allow(clippy::needless_collect)]
    280
    		 
        let first_pids = system
  • taxonomy 0.9.0/src/formats/json.rs
    130
    		 
        // but since the links refer to their position, we need to first record them
    131
    		 
        #[allow(clippy::needless_collect)]
    132
    		 
        let initial_positions: Vec<_> = tax_nodes.iter().map(|n| n.id.clone()).collect();
  • tendermint-light-client 0.28.0/src/store/memory.rs
    83
    		 
        #[allow(clippy::needless_collect)]
    84
    		 
        fn all(&self, status: Status) -> Box<dyn Iterator<Item = LightBlock>> {
  • tentacle 0.4.2/src/service.rs
    1100
    		 
        /// Handling various tasks sent externally
    1101
    		 
        #[allow(clippy::needless_collect)]
    1102
    		 
        async fn handle_service_task(&mut self, event: ServiceTask, priority: Priority) {
    1188
    		 
                        // Borrowed check attack
    1189
    		 
                        #[allow(clippy::needless_collect)]
    1190
    		 
                        {
  • thuja 0.2.1/src/components/input.rs
    244
    		 
            // `Chars` is not a double-ended iterator
    245
    		 
            #[allow(clippy::needless_collect)]
    246
    		 
            let iter: Vec<_> = self.text.chars().take(self.cur_pos).collect();
  • tlpt 0.7.0/src/lib.rs
    421
    		 
                let remote_id = remote.id.clone();
    422
    		 
                #[allow(clippy::needless_collect)]
    423
    		 
                let all_state_infoes = (*self.0)
  • tplinker 0.4.4/src/discovery.rs
    83
    		 
    /// a problem decoding the response.
    84
    		 
    #[allow(clippy::needless_collect)] // needed for achieving parallelism
    85
    		 
    pub fn with_timeout(timeout: Option<Duration>) -> Result<Vec<(SocketAddr, DeviceData)>> {
  • tracing-log 0.1.3/benches/logging.rs
    16
    		 
        let barrier = Arc::new(AtomicBool::new(false));
    17
    		 
        #[allow(clippy::needless_collect)]
    18
    		 
        let threads: Vec<_> = (0..thread_count)
  • tracing-tunnel 0.1.0/tests/integration/main.rs
    294
    		 
    #[test]
    295
    		 
    #[allow(clippy::needless_collect)] // necessary for threads to be concurrent
    296
    		 
    fn concurrent_senders() {
  • tract-core 0.19.2/src/plan.rs
    447
    		 
            let values = {
    448
    		 
                #[allow(clippy::needless_collect)] // clippy bug ?
    449
    		 
                let precs: Vec<usize> =
  • trybuild 1.0.77/src/run.rs
    544
    		 
    // filter string will be run.
    545
    		 
    #[allow(clippy::needless_collect)] // false positive https://github.com/rust-lang/rust-clippy/issues/5991
    546
    		 
    fn filter(tests: &mut Vec<ExpandedTest>) {
  • trybuild2 1.0.0/src/run.rs
    522
    		 
    // filter string will be run.
    523
    		 
    #[allow(clippy::needless_collect)] // false positive https://github.com/rust-lang/rust-clippy/issues/5991
    524
    		 
    fn filter(tests: &mut Vec<ExpandedTest>) {
  • trycmd 0.14.11/src/cases.rs
    188
    		 
    // filter string will be run.
    189
    		 
    #[allow(clippy::needless_collect)] // false positive https://github.com/rust-lang/rust-clippy/issues/5991
    190
    		 
    fn parse_include(args: impl IntoIterator<Item = std::ffi::OsString>) -> Option<Vec<String>> {
  • tuifeed 0.3.2/src/ui/mod.rs
    122
    		 
        /// Fetch all sources and update Ui
    123
    		 
        #[allow(clippy::needless_collect)]
    124
    		 
        fn fetch_all_sources(&mut self) {
  • tuirealm 1.8.0/src/listener/worker.rs
    117
    		 
        /// Returns only the messages, while the None returned by poll are discarded
    118
    		 
        #[allow(clippy::needless_collect)]
    119
    		 
        fn poll(&mut self) -> Result<(), mpsc::SendError<ListenerMsg<U>>> {
  • tusk_parser 0.1.2/src/parser.rs
    27
    		 
        #[allow(clippy::needless_collect)]
    28
    		 
        fn match_token(&mut self, token: Token<'p>) -> Result<Statement, ParserError<'p>> {
  • uid 0.1.7/src/lib.rs
    257
    		 
      fn thread_safety() {
    258
    		 
        #[allow(clippy::needless_collect)]
    259
    		 
        fn test<T>()
  • vfs 0.9.0/src/impls/memory.rs
    127
    		 
            let mut found_directory = false;
    128
    		 
            #[allow(clippy::needless_collect)] // need collect to satisfy lifetime requirements
    129
    		 
            let entries: Vec<_> = handle
  • virtio-driver 0.4.1/src/devices/virtio_blk.rs
    271
    		 
                // Not actually needless: must drop the borrow on the transport before alloc_queue_mem()
    272
    		 
                #[allow(clippy::needless_collect)]
    273
    		 
                let iova_translators: Vec<_> = iter::repeat_with(|| transport.iova_translator())
  • vrp-core 1.19.1/src/construction/probing/repair_solution.rs
    15
    		 
    /// Repairs a feasible solution from another, potentially infeasible.
    16
    		 
    #[allow(clippy::needless_collect)]
    17
    		 
    pub fn repair_solution_from_unknown(
  • vrp-core 1.19.1/src/solver/processing/vicinity_clustering.rs
    104
    		 
            insertion_ctx.solution.routes.iter_mut().for_each(|route_ctx| {
    105
    		 
                #[allow(clippy::needless_collect)]
    106
    		 
                let clusters = route_ctx
  • vrp-core 1.19.1/src/solver/search/local/exchange_swap_star.rs
    100
    		 
    /// Creates route pairs to exchange jobs.
    101
    		 
    #[allow(clippy::needless_collect)] // NOTE enforce size hint to be non-zero
    102
    		 
    fn create_route_pairs(insertion_ctx: &InsertionContext, route_pairs_threshold: usize) -> Vec<(usize, usize)> {
  • vrp-core 1.19.1/src/solver/search/redistribute_search.rs
    111
    		 
            .flat_map(|route_ctx| {
    112
    		 
                #[allow(clippy::needless_collect)]
    113
    		 
                let all_jobs = route_ctx.route.tour.jobs().filter(|job| !locked.contains(job)).collect::<Vec<_>>();
  • vrp-core 1.19.1/src/solver/search/ruin/route_removal.rs
    76
    		 
                #[allow(clippy::needless_collect)]
    77
    		 
                let routes = route_groups_distances[route_index]
    123
    		 
            #[allow(clippy::needless_collect)]
    124
    		 
            let routes = route_sizes
  • waffles-solana-perf 1.15.0/src/recycler.rs
    80
    		 
    impl<T: Default + Reset + Sized> Recycler<T> {
    81
    		 
        #[allow(clippy::needless_collect)]
    82
    		 
        pub fn warmed(num: usize, size_hint: usize) -> Self {
  • waffles-solana-runtime 1.15.0/src/accounts.rs
    1222
    		 
        #[must_use]
    1223
    		 
        #[allow(clippy::needless_collect)]
    1224
    		 
        pub fn lock_accounts<'a>(
    1235
    		 
        #[must_use]
    1236
    		 
        #[allow(clippy::needless_collect)]
    1237
    		 
        pub fn lock_accounts_with_results<'a>(
    1272
    		 
        /// Once accounts are unlocked, new transactions that modify that state can enter the pipeline
    1273
    		 
        #[allow(clippy::needless_collect)]
    1274
    		 
        pub fn unlock_accounts<'a>(
  • waffles-solana-runtime 1.15.0/src/accounts_db.rs
    5843
    		 
        #[allow(clippy::needless_collect)]
    5844
    		 
        fn purge_slots<'a>(&self, slots: impl Iterator<Item = &'a Slot> + Clone) {
    8832
    		 
        #[allow(clippy::needless_collect)]
    8833
    		 
        pub fn generate_index(
  • waffles-solana-runtime 1.15.0/src/accounts_index.rs
    1567
    		 
        // This is designed to be called at startup time.
    1568
    		 
        #[allow(clippy::needless_collect)]
    1569
    		 
        pub(crate) fn insert_new_if_missing_into_primary_index(
  • waffles-solana-runtime 1.15.0/src/bank.rs
    5040
    		 
        // Ref: collect_fees
    5041
    		 
        #[allow(clippy::needless_collect)]
    5042
    		 
        fn distribute_rent_to_validators(
  • waffles-solana-runtime 1.15.0/src/snapshot_utils.rs
    1325
    		 
        // All shared buffer readers need to be created before the threads are spawned
    1326
    		 
        #[allow(clippy::needless_collect)]
    1327
    		 
        let archives: Vec<_> = (0..num_threads)
  • web-audio-api 0.28.0/src/context/online.rs
    236
    		 
        /// is currently not implemented.
    237
    		 
        #[allow(clippy::needless_collect, clippy::missing_panics_doc)]
    238
    		 
        pub fn set_sink_id_sync(&self, sink_id: String) -> Result<(), Box<dyn Error>> {
  • which 4.4.0/src/finder.rs
    100
    		 
            // change the API to borrow on `paths`.
    101
    		 
            #[allow(clippy::needless_collect)]
    102
    		 
            let paths: Vec<_> = env::split_paths(&p).collect();
  • worker-kv 0.5.1/tests/integration.rs
    13
    		 
    #[tokio::test]
    14
    		 
    #[allow(clippy::needless_collect)]
    15
    		 
    async fn integration_test() {
  • wyrcan 2.1.2/src/commands/unpacker.rs
    67
    		 
            // We collect here to start all the threads.
    68
    		 
            #[allow(clippy::needless_collect)]
    69
    		 
            let threads = self
  • x11rb 0.11.1/examples/tutorial.rs
    203
    		 
    #[allow(clippy::needless_collect)]
    204
    		 
    fn example1() -> Result<(), Box<dyn Error>> {
  • xq 0.2.42/src/compile/compiler.rs
    546
    		 
        fn compile_function_inner(&mut self, args: &[FuncArg], body: &Query) -> Result<Address> {
    547
    		 
            #[allow(clippy::needless_collect)] // This collect is needed to unborrow `self`
    548
    		 
            let slots: Vec<_> = args
  • yap 0.8.1/src/tokens.rs
    966
    		 
        #[test]
    967
    		 
        #[allow(clippy::needless_collect)]
    968
    		 
        fn test_many() {
    1002
    		 
        #[test]
    1003
    		 
        #[allow(clippy::needless_collect)]
    1004
    		 
        fn test_many_err() {
  • yubikey 0.7.0/src/reader.rs
    47
    		 
            #[allow(clippy::needless_collect)]
    48
    		 
            let readers: Vec<_> = reader_cstrs
  • yuml-rs 0.1.6/src/parser/activity.rs
    78
    		 
        // we must collect to ensure the incoming connections are all processed, before creating the dot file
    79
    		 
        #[allow(clippy::needless_collect)]
    80
    		 
        let arrow_details: Vec<ElementDetails<Element>> = elements
  • yuml-rs 0.1.6/src/parser/class.rs
    96
    		 
        // we must collect to ensure the incoming connections are all processed, before creating the dot file
    97
    		 
        #[allow(clippy::needless_collect)]
    98
    		 
        let arrow_details: Vec<ElementDetails<Element>> = elements
  • zenoh 0.7.0-rc/src/net/routing/network.rs
    342
    		 
            // register psid<->zid mappings & apply mapping to nodes
    343
    		 
            #[allow(clippy::needless_collect)] // need to release borrow on self
    344
    		 
            let link_states = link_states
  • building_blocks_mesh 0.7.1/src/lib.rs
    2
    		 
        clippy::type_complexity,
    3
    		 
        clippy::needless_collect,
    4
    		 
        clippy::too_many_arguments
  • building_blocks_search 0.7.1/src/lib.rs
    2
    		 
        clippy::type_complexity,
    3
    		 
        clippy::needless_collect,
    4
    		 
        clippy::too_many_arguments
  • building_blocks_storage 0.7.1/src/lib.rs
    2
    		 
        clippy::type_complexity,
    3
    		 
        clippy::needless_collect,
    4
    		 
        clippy::too_many_arguments
  • cargo-cache 0.8.3/src/clean_unref.rs
    12
    		 
    //https://github.com/rust-lang/rust-clippy/issues/7202
    13
    		 
    #![allow(clippy::needless_collect)]
  • dbcrossbarlib 0.5.2/src/lib.rs
    21
    		 
    // This has false positives on trivial code.
    22
    		 
    #![allow(clippy::needless_collect)]
    23
    		 
    // Honestly the `..Default::default()` notation is more verbose, it requires
  • encode_unicode 1.0.0/tests/iterators.rs
    13
    		 
    #![allow(
    14
    		 
        clippy::needless_collect,// test oee thing at a time
    15
    		 
    )]
  • enum-derive-2018 2.0.1/tests/iter.rs
    10
    		 
    #![deny(warnings)]
    11
    		 
    #![allow(clippy::needless_collect)]
  • exocore-store 0.1.24/src/local/entity_index/mod.rs
    510
    		 
        {
    511
    		 
            #![allow(clippy::needless_collect)] // see https://github.com/rust-lang/rust-clippy/issues/6066
    512
    		 
            let mutations = operations_id
  • flo_curves 0.6.1/src/bezier/path/path.rs
    1
    		 
    #![allow(clippy::needless_collect)]     // Required for lifetime and type inference reasons, I think. At least, clippy's suggestion does not compile here.
  • frankenstein 0.22.0/src/lib.rs
    7
    		 
        clippy::must_use_candidate,
    8
    		 
        clippy::needless_collect,
    9
    		 
        clippy::new_without_default,
  • rosrust 0.9.10/tests/benchmarks.rs
    194
    		 
    fn call_service(criterion: &mut Criterion) {
    195
    		 
        #![allow(clippy::needless_collect)]
  • safecoin-runtime 1.14.3/src/bank_forks.rs
    496
    		 
            // a unique borrow to self which is already borrowed by self.banks
    497
    		 
            #![allow(clippy::needless_collect)]
    498
    		 
            let mut prune_slots_time = Measure::start("prune_slots");
  • sha1dir 1.0.7/src/main.rs
    8
    		 
        clippy::cast_possible_truncation,
    9
    		 
        clippy::needless_collect,
    10
    		 
        clippy::needless_pass_by_value,
  • shumai 0.2.11/src/runner.rs
    1
    		 
    #![allow(clippy::needless_collect, clippy::type_complexity)]
  • solana-runtime 1.14.13/src/bank_forks.rs
    496
    		 
            // a unique borrow to self which is already borrowed by self.banks
    497
    		 
            #![allow(clippy::needless_collect)]
    498
    		 
            let mut prune_slots_time = Measure::start("prune_slots");
  • sonatina-codegen 0.0.3-alpha/src/lib.rs
    2
    		 
    // See <https://github.com/rust-lang/rust-clippy/issues/7512> and <https://github.com/rust-lang/rust-clippy/issues/7336>
    3
    		 
    #![allow(clippy::needless_collect)]
  • systeminfo 0.1.1/src/nix/hwinfo.rs
    1
    		 
    #![allow(clippy::needless_collect)]
    2
    		 
    use crate::{
  • waffles-solana-runtime 1.15.0/src/bank_forks.rs
    570
    		 
            // a unique borrow to self which is already borrowed by self.banks
    571
    		 
            #![allow(clippy::needless_collect)]
    572
    		 
            let mut prune_slots_time = Measure::start("prune_slots");