• aces 0.0.13/src/firing.rs
    69
    		 
        #[allow(clippy::map_entry)]
    70
    		 
        fn try_from(sol: Solution) -> Result<Self, Self::Error> {
  • agreed 1.1.0/src/core/admin.rs
    117
    		 
        #[tracing::instrument(level = "trace", skip(self, tx))]
    118
    		 
        #[allow(clippy::map_entry)]
    119
    		 
        pub(super) async fn add_voter(&mut self, id: NodeId, tx: ChangeMembershipTx) {
  • amethyst_network 0.15.3/src/simulation/transport/tcp.rs
    111
    		 
        // there is a `return;` statement for early exit, which is not allowed within the closure.
    112
    		 
        #[allow(clippy::map_entry)]
    113
    		 
        fn run(&mut self, (mut net, transport, mut event_channel): Self::SystemData) {
  • asuran 0.1.6/src/repository/backend/sftp/index.rs
    118
    		 
        }
    119
    		 
        #[allow(clippy::map_entry)]
    120
    		 
        fn set_chunk(&mut self, id: ChunkID, location: SegmentDescriptor) -> Result<()> {
  • aw-transform 0.1.0/src/merge.rs
    41
    		 
    /// ```
    42
    		 
    #[allow(clippy::map_entry)]
    43
    		 
    pub fn merge_events_by_keys(events: Vec<Event>, keys: Vec<String>) -> Vec<Event> {
  • buildkit-llb 0.2.0/src/serialization/mod.rs
    18
    		 
    impl Context {
    19
    		 
        #[allow(clippy::map_entry)]
    20
    		 
        pub(crate) fn register<'a>(&'a mut self, op: &dyn Operation) -> Result<&'a Node> {
  • casperlabs-engine-shared 0.7.1/src/account/associated_keys.rs
    21
    		 
        /// Returns true if added successfully, false otherwise.
    22
    		 
        #[allow(clippy::map_entry)]
    23
    		 
        pub fn add_key(&mut self, key: AccountHash, weight: Weight) -> Result<(), AddKeyFailure> {
    45
    		 
        /// Returns true if added successfully, false otherwise.
    46
    		 
        #[allow(clippy::map_entry)]
    47
    		 
        pub fn update_key(&mut self, key: AccountHash, weight: Weight) -> Result<(), UpdateKeyFailure> {
  • cli_lib 1.25.2/lsp/registries.rs
    564
    		 
        let origin = base_url(&origin_url);
    565
    		 
        #[allow(clippy::map_entry)]
    566
    		 
        // we can't use entry().or_insert_with() because we can't use async closures
    592
    		 
        let origin = base_url(&specifier);
    593
    		 
        #[allow(clippy::map_entry)]
    594
    		 
        if !self.origins.contains_key(&origin) {
  • cmdparse-derive 0.1.1/src/attributes.rs
    264
    		 
    impl<'a> FieldNamesAttributes<'a> {
    265
    		 
        #[allow(clippy::map_entry)]
    266
    		 
        fn push(
  • cogsy 0.2.2/src/screens/history.rs
    87
    		 
        //? What is its Big O / space-time complexity?
    88
    		 
        #[allow(clippy::map_entry)]
    89
    		 
        pub fn build_sparkview_btreemap(&self) -> BTreeMap<String, String> {
  • compacts-bits 0.2.1/src/vec32/pairwise.rs
    82
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(map_entry))]
    83
    		 
    impl<'r> ::ops::UnionWith<&'r super::Vec32> for super::Vec32 {
    110
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(map_entry))]
    111
    		 
    impl<'r> ::ops::SymmetricDifferenceWith<&'r super::Vec32> for super::Vec32 {
  • compacts-bits 0.2.1/src/vec64/pairwise.rs
    68
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(map_entry))]
    69
    		 
    impl<'r> UnionWith<&'r super::Vec64> for super::Vec64 {
    96
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(map_entry))]
    97
    		 
    impl<'r> SymmetricDifferenceWith<&'r super::Vec64> for super::Vec64 {
  • crazyflie-lib 0.1.1/src/crtp_utils.rs
    46
    		 
        #[allow(clippy::map_entry)]
    47
    		 
        pub fn get_port_receiver(&mut self, port: u8) -> Option<Receiver<Packet>> {
  • databend-thrift 0.17.0/src/server/multiplexed.rs
    74
    		 
        /// * You attempt to register a processor as default, and an existing default exists
    75
    		 
        #[allow(clippy::map_entry)]
    76
    		 
        pub fn register<S: Into<String>>(
  • dcc-tiler 0.1.2/src/cli/tiler.rs
    172
    		 
        #[allow(dead_code, clippy::map_entry)]
    173
    		 
        fn generate_graph(&mut self) {
  • deno 1.30.0/lsp/registries.rs
    550
    		 
        let origin = base_url(&origin_url);
    551
    		 
        #[allow(clippy::map_entry)]
    552
    		 
        // we can't use entry().or_insert_with() because we can't use async closures
    578
    		 
        let origin = base_url(&specifier);
    579
    		 
        #[allow(clippy::map_entry)]
    580
    		 
        if !self.origins.contains_key(&origin) {
  • deno_3p_lib 1.25.2/lsp/registries.rs
    563
    		 
        let origin = base_url(&origin_url);
    564
    		 
        #[allow(clippy::map_entry)]
    565
    		 
        // we can't use entry().or_insert_with() because we can't use async closures
    591
    		 
        let origin = base_url(&specifier);
    592
    		 
        #[allow(clippy::map_entry)]
    593
    		 
        if !self.origins.contains_key(&origin) {
  • denox 0.2.1/lsp/registries.rs
    550
    		 
        let origin = base_url(&origin_url);
    551
    		 
        #[allow(clippy::map_entry)]
    552
    		 
        // we can't use entry().or_insert_with() because we can't use async closures
    578
    		 
        let origin = base_url(&specifier);
    579
    		 
        #[allow(clippy::map_entry)]
    580
    		 
        if !self.origins.contains_key(&origin) {
  • dipstick 0.9.1/src/lru_cache.rs
    37
    		 
        /// If there is no room in the cache the oldest item will be removed.
    38
    		 
        #[allow(clippy::map_entry)]
    39
    		 
        pub fn insert(&mut self, key: K, value: V) -> Option<V> {
  • dotter 0.12.14/src/config.rs
    244
    		 
    #[allow(clippy::map_entry)]
    245
    		 
    fn merge_configuration_files(
  • dtn7 0.18.2/src/cla/mtcp.rs
    229
    		 
        #[allow(clippy::map_entry)]
    230
    		 
        if !MTCP_CONNECTIONS.lock().contains_key(&addr) {
    367
    		 
            #[allow(clippy::map_entry)]
    368
    		 
            if !MTCP_CONNECTIONS.lock().contains_key(&addr) {
  • dw-transform 0.1.0/src/merge.rs
    41
    		 
    /// ```
    42
    		 
    #[allow(clippy::map_entry)]
    43
    		 
    pub fn merge_events_by_keys(events: Vec<Event>, keys: Vec<String>) -> Vec<Event> {
  • easyops_deno 1.13.0/lsp/registries.rs
    363
    		 
        let origin = base_url(&Url::parse(origin)?);
    364
    		 
        #[allow(clippy::map_entry)]
    365
    		 
        // we can't use entry().or_insert_with() because we can't use async closures
  • evm 0.37.0/src/executor/stack/memory.rs
    281
    		 
    	#[allow(clippy::map_entry)]
    282
    		 
    	fn account_mut<B: Backend>(&mut self, address: H160, backend: &B) -> &mut MemoryStackAccount {
  • evm-nogas 0.1.0/src/executor/stack/memory.rs
    281
    		 
        #[allow(clippy::map_entry)]
    282
    		 
        fn account_mut<B: Backend>(&mut self, address: H160, backend: &B) -> &mut MemoryStackAccount {
  • fibers_rpc 0.3.4/src/message_stream.rs
    152
    		 
        #[allow(clippy::map_entry)]
    153
    		 
        fn handle_incoming_messages(
  • finch 0.5.0/src/sketch_schemes/mash.rs
    35
    		 
        #[allow(clippy::map_entry)]
    36
    		 
        pub fn push(&mut self, kmer: &[u8], extra_count: u8) {
  • finch 0.5.0/src/sketch_schemes/scaled.rs
    38
    		 
        #[allow(clippy::map_entry)]
    39
    		 
        pub fn push(&mut self, kmer: &[u8], extra_count: u8) {
  • finch_lib 0.4.0/src/sketch_schemes/mash.rs
    35
    		 
        #[allow(clippy::map_entry)]
    36
    		 
        pub fn push(&mut self, kmer: &[u8], extra_count: u8) {
  • finch_lib 0.4.0/src/sketch_schemes/scaled.rs
    38
    		 
        #[allow(clippy::map_entry)]
    39
    		 
        pub fn push(&mut self, kmer: &[u8], extra_count: u8) {
  • fluvio-spu 0.4.0/src/controllers/leader_replica/replica_state.rs
    122
    		 
        /// if replica id's doesn't exists, then add, otherwise ignore it
    123
    		 
        #[allow(clippy::map_entry)]
    124
    		 
        fn add_follower_replica(&mut self, follower_ids: Vec<SpuId>) {
  • geese 0.1.14/src/lib.rs
    266
    		 
                // systems map while a new system is being created (during which it may reference the system map).
    267
    		 
                #[allow(clippy::map_entry)]
    268
    		 
                if !self.inner.systems_mut().contains_key(&system.system_id()) {
  • glyph_brush 0.7.5/src/glyph_brush.rs
    235
    		 
        /// Returns the calculate_glyph_cache key for this sections glyphs
    236
    		 
        #[allow(clippy::map_entry)] // further borrows are required after the contains_key check
    237
    		 
        fn cache_glyphs<L>(&mut self, section: &Section<'_, X>, layout: &L) -> SectionHash
  • graphannis-core 2.4.2/src/graph/serialization/graphml.rs
    70
    		 
                    for key in gs.get_anno_storage().annotation_keys()? {
    71
    		 
                        #[allow(clippy::map_entry)]
    72
    		 
                        if !key_id_mapping.contains_key(&key) {
  • guido_rbx_binary 0.6.7/src/serializer/state.rs
    259
    		 
        // clone canonical_name in a cold branch. We don't want to do that.
    260
    		 
        #[allow(clippy::map_entry)]
    261
    		 
        #[profiling::function]
  • here_be_dragons 0.2.1/src/filter/maze.rs
    42
    		 
        #[allow(clippy::map_entry)]
    43
    		 
        fn build(&self, rng: &mut StdRng, map: &Map<D>) -> Map<D> {
  • kbs2 0.6.0/src/kbs2/agent.rs
    285
    		 
                        // pubkey, return early with a success.
    286
    		 
                        #[allow(clippy::map_entry)]
    287
    		 
                        if self.unwrapped_keys.contains_key(&pubkey) {
  • key-node-list 0.0.5/src/map.rs
    136
    		 
      #[inline]
    137
    		 
      #[allow(clippy::map_entry)]
    138
    		 
      fn insert<T: Into<V>>(&mut self, k: K, v: T) -> Result<(), (K, T)>
  • kludgine-core 0.4.0/src/frame_renderer/frame.rs
    166
    		 
                            // Load the texture if needed
    167
    		 
                            #[allow(clippy::map_entry)]
    168
    		 
                            if !self.textures.contains_key(&texture.id()) {
  • kompact-component-derive 0.11.0/src/lib.rs
    34
    		 
    #[allow(clippy::map_entry)]
    35
    		 
    fn impl_component_definition(ast: &syn::DeriveInput) -> TokenStream2 {
  • kurobako 0.2.10/src/runner.rs
    350
    		 
        #[allow(clippy::map_entry)]
    351
    		 
        fn init_evaluator(&mut self, trial: &NextTrial) -> Result<()> {
  • kurobako_solvers 0.2.2/src/asha.rs
    193
    		 
        #[allow(clippy::map_entry)]
    194
    		 
        fn ask<R: Rng, G: yamakan::IdGen>(
  • lancelot 0.8.6/src/analysis/flirt.rs
    161
    		 
                                // can't use entry API because of mutable cache used to create cache entry.
    162
    		 
                                #[allow(clippy::map_entry)]
    163
    		 
                                if !cache.contains_key(&target) {
  • liquid-ml 0.1.0/src/network/client.rs
    391
    		 
        /// [`Connection`]: struct.Connection.html
    392
    		 
        #[allow(clippy::map_entry)] // clippy is being dumb
    393
    		 
        async fn connect(
  • locustdb 0.3.4/src/engine/execution/scratchpad.rs
    140
    		 
        // TODO: return struct
    141
    		 
        #[allow(clippy::type_complexity, clippy::map_entry)]
    142
    		 
        pub fn collect_aliased(&mut self,
  • mapgen 0.6.0/src/filter/maze.rs
    37
    		 
        #[allow(clippy::map_entry)]
    38
    		 
        fn build(&self, rng: &mut StdRng, map: &MapBuffer) -> MapBuffer {
  • medea 0.2.0/src/signalling/peers/metrics/connection_failure_detector.rs
    117
    		 
        /// exist, then nothing will be done.
    118
    		 
        #[allow(clippy::map_entry)]
    119
    		 
        fn register_peer(&mut self, peer: &PeerStateMachine) {
  • minsc 0.2.0/src/scope.rs
    30
    		 
            #[allow(clippy::map_entry)]
    31
    		 
            if self.local.contains_key(&key) {
  • mun_codegen 0.4.0/src/ir/dispatch_table.rs
    275
    		 
        /// Collects function call expression from the given expression.
    276
    		 
        #[allow(clippy::map_entry)]
    277
    		 
        pub fn collect_fn_def(&mut self, function: mun_hir::Function) {
  • mycelium_core 0.1.1/src/ephemeral/history.rs
    60
    		 
        /// Original node is appended to history after removed from primary.
    61
    		 
        #[allow(clippy::map_entry)]
    62
    		 
        pub(crate) fn append_history(&mut self, node: Node) -> Result<(), Box<dyn std::error::Error>> {
  • onefetch-image 2.15.1/src/sixel.rs
    80
    		 
    impl super::ImageBackend for SixelBackend {
    81
    		 
        #[allow(clippy::map_entry)]
    82
    		 
        fn add_image(&self, lines: Vec<String>, image: &DynamicImage, colors: usize) -> Result<String> {
  • opentelemetry-otlp 0.11.0/src/transform/metrics.rs
    120
    		 
        // then instrumentation libraries.
    121
    		 
        #[allow(clippy::map_entry)] // caused by https://github.com/rust-lang/rust-clippy/issues/4674
    122
    		 
        pub(crate) fn sink(metrics: Vec<CheckpointedMetrics>) -> ExportMetricsServiceRequest {
  • pinus 0.0.4/src/sync.rs
    476
    		 
    		} = &mut *contents;
    477
    		 
    		#[allow(clippy::map_entry)]
    478
    		 
    		if let Some(existing_value) = addresses.get(&key) {
    506
    		 
    		} = self.contents.get_mut();
    507
    		 
    		#[allow(clippy::map_entry)]
    508
    		 
    		if let Some(existing_value) = addresses.get(&key) {
    535
    		 
    		let PressedCambium { addresses, memory } = &mut *contents;
    536
    		 
    		#[allow(clippy::map_entry)]
    537
    		 
    		if let Some(existing_value) = addresses.get(&key) {
    555
    		 
    		let PressedCambium { addresses, memory } = self.contents.get_mut(/* poisoned */);
    556
    		 
    		#[allow(clippy::map_entry)]
    557
    		 
    		if let Some(existing_value) = addresses.get(&key) {
  • pliantdb-local 0.1.0-dev-2/src/open_trees.rs
    14
    		 
        pub fn open_tree(&mut self, sled: &sled::Db, name: &str) -> Result<(), sled::Error> {
    15
    		 
            #[allow(clippy::map_entry)] // unwrapping errors is much uglier using entry()
    16
    		 
            if !self.trees_index_by_name.contains_key(name) {
  • plumtree 0.1.1/src/node.rs
    270
    		 
        #[cfg_attr(feature = "cargo-clippy", allow(map_entry))]
    271
    		 
        fn handle_gossip(&mut self, gossip: GossipMessage<T>) {
  • pmd_flow 1.0.2/src/flowdata.rs
    408
    		 
        #[allow(clippy::map_entry)]
    409
    		 
        #[allow(clippy::cognitive_complexity)]
  • pravega-client 0.3.2/src/segment/selector.rs
    139
    		 
        /// Creates any missing segment writers and sets up connections for them.
    140
    		 
        #[allow(clippy::map_entry)] // clippy warns about using entry, but async closure is not stable
    141
    		 
        pub(crate) async fn create_missing_writers(&mut self) {
  • prexel 0.1.9/src/context.rs
    105
    		 
    #[allow(clippy::map_entry)]
    106
    		 
    impl<'a, N> DefaultContext<'a, N> {
  • rbx_binary 0.6.6/src/serializer/state.rs
    259
    		 
        // clone canonical_name in a cold branch. We don't want to do that.
    260
    		 
        #[allow(clippy::map_entry)]
    261
    		 
        #[profiling::function]
  • reunion 0.1.14/src/union_find.rs
    67
    		 
    {
    68
    		 
        #[allow(clippy::map_entry)]
    69
    		 
        fn find(&mut self, node: T) -> T {
    86
    		 
            #[allow(clippy::map_entry)]
    87
    		 
            if !self.rank.contains_key(&x_root) {
    91
    		 
            #[allow(clippy::map_entry)]
    92
    		 
            if !self.rank.contains_key(&y_root) {
    119
    		 
                #[allow(clippy::map_entry)]
    120
    		 
                if !result.contains_key(&root) {
  • rthrift 0.11.0/src/server/multiplexed.rs
    73
    		 
        /// * You attempt to register a processor as default, and an existing default exists
    74
    		 
        #[cfg_attr(feature = "cargo-clippy", allow(map_entry))]
    75
    		 
        pub fn register<S: Into<String>>(
  • rucene 0.1.1/src/core/search/cache/lru_cache.rs
    88
    		 
        /// ```
    89
    		 
        #[allow(clippy::map_entry)]
    90
    		 
        pub fn insert(&mut self, key: K, value: V) -> Option<V> {
  • rustos 0.4.3/src/task/executor.rs
    63
    		 
                let task_id = task.id;
    64
    		 
                #[allow(clippy::map_entry)]
    65
    		 
                if !self.waker_cache.contains_key(&task_id) {
  • rustun 0.4.0/src/channel.rs
    109
    		 
        /// returns a future that waits the corresponding response.
    110
    		 
        #[allow(clippy::map_entry)]
    111
    		 
        pub fn call(
  • rustun 0.4.0/src/transport/udp.rs
    240
    		 
        #[allow(clippy::map_entry)]
    241
    		 
        fn start_transaction(
  • serde-sarif 0.3.4/src/converters/shellcheck.rs
    148
    		 
        .try_for_each(|result| -> Result<()> {
    149
    		 
          #[allow(clippy::map_entry)]
    150
    		 
          if !map.contains_key(&result.code.to_string()) {
  • skim 0.10.2/src/selection.rs
    220
    		 
        #[allow(clippy::map_entry)]
    221
    		 
        pub fn act_toggle(&mut self) {
    239
    		 
        #[allow(clippy::map_entry)]
    240
    		 
        pub fn act_toggle_all(&mut self) {
  • skim-qkzk 0.9.9/src/selection.rs
    219
    		 
        #[allow(clippy::map_entry)]
    220
    		 
        pub fn act_toggle(&mut self) {
    238
    		 
        #[allow(clippy::map_entry)]
    239
    		 
        pub fn act_toggle_all(&mut self) {
  • solana-core 1.14.13/src/heaviest_subtree_fork_choice.rs
    541
    		 
        #[allow(clippy::map_entry)]
    542
    		 
        fn do_insert_aggregate_operations_across_ancestors(
    562
    		 
        #[allow(clippy::map_entry)]
    563
    		 
        fn do_insert_aggregate_operation(
  • solang 0.2.1/src/codegen/dead_storage.rs
    86
    		 
    /// analysis which is used for further optimizations
    87
    		 
    #[allow(clippy::map_entry)]
    88
    		 
    fn reaching_definitions(cfg: &mut ControlFlowGraph) -> (Vec<Vec<Vec<Transfer>>>, BlockVars) {
  • stackdump-trace 0.2.3/src/variables/type_value_tree_building/pointer.rs
    69
    		 
        // Insert the pointee into the type cache
    70
    		 
        #[allow(clippy::map_entry)] // Can't use the entry api because of the type_cache borrow later
    71
    		 
        if !type_cache.contains_key(&pointee_type_die_offset) {
  • stronghold-communication 0.4.1/src/actor/swarm_task.rs
    290
    		 
        #[allow(clippy::map_entry)]
    291
    		 
        // Add a relay for listening if it is not already known.
  • structdump 0.2.0/src/lib.rs
    42
    		 
    		let code_str = code.to_string();
    43
    		 
    		#[allow(clippy::map_entry)]
    44
    		 
    		let var_name = if !self.codes.contains_key(&code_str) {
  • subshell 1.23.1/lsp/registries.rs
    554
    		 
        let origin = base_url(&origin_url);
    555
    		 
        #[allow(clippy::map_entry)]
    556
    		 
        // we can't use entry().or_insert_with() because we can't use async closures
    582
    		 
        let origin = base_url(&specifier);
    583
    		 
        #[allow(clippy::map_entry)]
    584
    		 
        if !self.origins.contains_key(&origin) {
  • sway-core 0.33.1/src/decl_engine/engine.rs
    67
    		 
        /// found, we do not find them again.
    68
    		 
        #[allow(clippy::map_entry)]
    69
    		 
        pub(crate) fn find_all_parents(&self, engines: Engines<'_>, index: DeclId) -> Vec<DeclId> {
  • sway-ir 0.33.1/src/irtype.rs
    32
    		 
            // Trying to avoiding cloning t unless we're creating a new type.
    33
    		 
            #[allow(clippy::map_entry)]
    34
    		 
            if !context.type_map.contains_key(&t) {
  • sysinfo 0.27.7/src/windows/system.rs
    200
    		 
        #[allow(clippy::map_entry)]
    201
    		 
        fn refresh_process_specifics(&mut self, pid: Pid, refresh_kind: ProcessRefreshKind) -> bool {
  • tari_core 0.8.1/src/mempool/unconfirmed_pool/unconfirmed_pool.rs
    99
    		 
        /// reached and the new transaction has a higher priority than the currently stored lowest priority transaction.
    100
    		 
        #[allow(clippy::map_entry)]
    101
    		 
        pub fn insert(&mut self, tx: Arc<Transaction>) -> Result<(), UnconfirmedPoolError> {
  • tari_wallet 0.8.1/src/transaction_service/service.rs
    840
    		 
        #[allow(clippy::map_entry)]
    841
    		 
        async fn restart_all_send_transaction_protocols(
  • thrift 0.17.0/src/server/multiplexed.rs
    74
    		 
        /// * You attempt to register a processor as default, and an existing default exists
    75
    		 
        #[allow(clippy::map_entry)]
    76
    		 
        pub fn register<S: Into<String>>(
  • tracing-tunnel 0.1.0/src/receiver/mod.rs
    419
    		 
        /// [`TracingEventSender`]: crate::TracingEventSender
    420
    		 
        #[allow(clippy::missing_panics_doc, clippy::map_entry)] // false positive
    421
    		 
        pub fn try_receive(&mut self, event: TracingEvent) -> Result<(), ReceiveError> {
  • treebender 0.1.1/src/featurestructure.rs
    337
    		 
      #[allow(clippy::map_entry)]
    338
    		 
      fn push_edge(&mut self, label: String, target: NodeRef) -> Result<(), Err> {
  • trustfall_core 0.1.1/src/util.rs
    46
    		 
                //       https://github.com/rust-lang/rust/issues/56167#issuecomment-910742027
    47
    		 
                #[allow(clippy::map_entry)]
    48
    		 
                if map.contains_key(&key) {
  • twenty-first 0.15.0/src/shared_math/mpolynomial.rs
    745
    		 
        // Substitute the variables in a multivariate polynomial with univariate polynomials, fast
    746
    		 
        #[allow(clippy::map_entry)]
    747
    		 
        #[allow(clippy::type_complexity)]
  • uninode 0.4.2/src/value/tree.rs
    103
    		 
                        if let UniNode::Object(src) = src {
    104
    		 
                            #[allow(clippy::map_entry)]
    105
    		 
                            for (key, node) in src {
  • valico 3.6.1/src/json_schema/scope.rs
    190
    		 
        #[allow(clippy::map_entry)] // allowing for the return values
    191
    		 
        fn add(&mut self, id: &url::Url, schema: schema::Schema) -> Result<(), schema::SchemaError> {
    206
    		 
        #[allow(clippy::map_entry)] // allowing for the return values
    207
    		 
        fn add_and_return<'a>(
  • versio 0.7.1/src/github.rs
    22
    		 
    /// this way, the original type and size information from the PR is preserved.
    23
    		 
    #[allow(clippy::map_entry)]
    24
    		 
    pub async fn changes(auth: &Auth, repo: &Repo, baseref: FromTagBuf, headref: String) -> Result<Changes> {
  • xbasic 0.3.2/src/compiler.rs
    121
    		 
    	#[allow(clippy::map_entry)]
    122
    		 
    	fn get_variable(&mut self, name: Token) -> u8 {
  • zamm_yin 0.2.1/src/tao/form/form_trait.rs
    67
    		 
                    let parent_tao = parent.as_form();
    68
    		 
                    #[allow(clippy::map_entry)]
    69
    		 
                    if !backpointers.contains_key(&parent_tao) {
  • zkp-stark 0.2.1/src/solidity_verifier.rs
    708
    		 
            // TODO - Clean this pattern
    709
    		 
            #[allow(clippy::map_entry)]
    710
    		 
            let flag = !memory_lookups.contains_key(&implied_expression);
  • cl-aux 2.0.0/src/traits/insert.rs
    2
    		 
      // `_manage_hash` is also used by BTreeMap
    3
    		 
      clippy::map_entry
    4
    		 
    )]
  • cl-traits 7.0.0/src/traits/insert.rs
    2
    		 
      // `_manage_hash` is also used by BTreeMap
    3
    		 
      clippy::map_entry
    4
    		 
    )]
  • high_mem_utils 0.2.7/src/lib.rs
    2
    		 
    #![feature(vec_leak, untagged_unions, const_fn, const_fn_union)]
    3
    		 
    #![allow(unused_unsafe, clippy::wrong_self_convention, clippy::map_entry)]
  • kaiju-core 0.1.4/src/assembly.rs
    1
    		 
    #![allow(clippy::unused_io_amount)]
    2
    		 
    #![allow(clippy::map_entry)]
  • mako 0.3.0/src/tokenization/hf_tokenizers/models/bpe/trainer.rs
    1
    		 
    #![allow(clippy::map_entry)]
  • rgch 0.1.33/src/git/ls_files.rs
    1
    		 
    #![allow(clippy::type_complexity)]
    2
    		 
    #![allow(clippy::map_entry)]
    3
    		 
    #![allow(unused_imports)]
  • tokenizers 0.13.2/src/models/bpe/trainer.rs
    1
    		 
    #![allow(clippy::map_entry)]
  • ux-components 0.1.3/src/lib.rs
    12
    		 
        clippy::let_unit_value,
    13
    		 
        clippy::map_entry,
    14
    		 
    )]
  • ux-dx 0.2.1/src/lib.rs
    52
    		 
        clippy::or_fun_call,
    53
    		 
        clippy::map_entry,
    54
    		 
        clippy::while_let_loop,
  • ux-vg 0.2.9/src/lib.rs
    12
    		 
        clippy::manual_map,
    13
    		 
        clippy::map_entry
    14
    		 
    )]
  • xi-core-lib 0.3.0/src/lib.rs
    21
    		 
        clippy::let_and_return,
    22
    		 
        clippy::map_entry,
    23
    		 
        clippy::match_as_ref,
  • ya-sb-router 0.6.1/src/connection.rs
    1
    		 
    #![allow(clippy::map_entry)]