• activitypub_federation 0.3.4/examples/federation/activities/follow.rs
    58
    		 
        // Ignore clippy false positive: https://github.com/rust-lang/rust-clippy/issues/6446
    59
    		 
        #[allow(clippy::await_holding_lock)]
    60
    		 
        async fn receive(
  • adborc 0.1.0/src/market/consumer.rs
    63
    		 
        // the lock on the state variable before calling await on the future.
    64
    		 
        #[allow(clippy::await_holding_lock)]
    65
    		 
        #[inline(always)]
    83
    		 
        // the lock on the state variable before calling await on the future.
    84
    		 
        #[allow(clippy::await_holding_lock)]
    85
    		 
        #[inline(always)]
    98
    		 
        // the lock on the state variable before calling await on the future.
    99
    		 
        #[allow(clippy::await_holding_lock)]
    100
    		 
        #[inline(always)]
    202
    		 
        // the lock on the state variable before calling await on the future.
    203
    		 
        #[allow(clippy::await_holding_lock)]
    204
    		 
        #[inline(always)]
    216
    		 
        // the lock on the state variable before calling await on the future.
    217
    		 
        #[allow(clippy::await_holding_lock)]
    218
    		 
        #[inline(always)]
  • adborc 0.1.0/src/market/supplier.rs
    28
    		 
        // the lock on the state variable before calling await on the future.
    29
    		 
        #[allow(clippy::await_holding_lock)]
    30
    		 
        #[inline(always)]
    48
    		 
        // the lock on the state variable before calling await on the future.
    49
    		 
        #[allow(clippy::await_holding_lock)]
    50
    		 
        #[inline(always)]
    63
    		 
        // the lock on the state variable before calling await on the future.
    64
    		 
        #[allow(clippy::await_holding_lock)]
    65
    		 
        #[inline(always)]
    316
    		 
        #[allow(clippy::await_holding_lock)]
    317
    		 
        #[inline(always)]
    328
    		 
        #[allow(clippy::await_holding_lock)]
    329
    		 
        #[inline(always)]
  • bbjwt 0.2.1/src/keystore.rs
    837
    		 
      ///
    838
    		 
      #[allow(clippy::await_holding_lock)]
    839
    		 
      pub async fn load_keys(&mut self) -> BBResult<()> {
  • canyon_observer 0.1.0/src/migrations/processor.rs
    522
    		 
        /// Make the detected migrations for the next Canyon-SQL run
    523
    		 
        #[allow(clippy::await_holding_lock)]
    524
    		 
        pub async fn from_query_register(queries_to_execute: &HashMap<&str, Vec<&str>>) {
  • deduplicate 0.3.5/src/deduplicate.rs
    93
    		 
        // Disable clippy false positive. We are explicitly dropping our lock, so clippy is wrong.
    94
    		 
        #[allow(clippy::await_holding_lock)]
    95
    		 
        pub async fn get(&self, key: K) -> Result<Option<V>, DeduplicateError> {
  • dtn7 0.18.2/src/dtnd/daemon.rs
    55
    		 
    // therefore it should be safe to hold the lock
    56
    		 
    #[allow(clippy::await_holding_lock)]
    57
    		 
    async fn start_convergencylayers() {
  • futuresdr 0.0.27/src/blocks/wasm_sdr.rs
    25
    		 
    // if the lock is held by someone else
    26
    		 
    #[allow(clippy::await_holding_lock)]
    27
    		 
    #[wasm_bindgen]
  • httpc-test 0.0.1/src/client.rs
    42
    		 
    	#[allow(clippy::await_holding_lock)] // ok for testing lib
    43
    		 
    	async fn capture_response(
  • ipfs-embed-net 0.11.0/src/lib.rs
    81
    		 
        #[allow(clippy::await_holding_lock)]
    82
    		 
        pub async fn listen_on(&self, addr: Multiaddr) -> Result<Multiaddr> {
  • kludgine-app 0.4.0/src/runtime/smol.rs
    30
    		 
                .each(0..4, |_| {
    31
    		 
                    #[allow(clippy::await_holding_lock)] // this is an rwlock, not a mutex.
    32
    		 
                    futures::executor::block_on(async {
  • meio 0.97.0/src/thread.rs
    78
    		 
    // TODO: Consider to deny and refactor
    79
    		 
    #[allow(clippy::await_holding_lock)]
    80
    		 
    async fn entrypoint<T>(actor: T, term_rx: term::Receiver) -> Result<(), Error>
  • searchlight 0.3.0/src/broadcast.rs
    163
    		 
    	#[allow(clippy::await_holding_lock)]
    164
    		 
    	// It's fine to hold the lock in this case because we're using the current-thread runtime.
  • singleflight-async 0.1.1/src/lib.rs
    167
    		 
        #[allow(clippy::await_holding_lock)]
    168
    		 
        #[inline]
  • deno_flash 0.22.0/lib.rs
    4
    		 
    // https://github.com/rust-lang/rust-clippy/issues/6446
    5
    		 
    #![allow(clippy::await_holding_lock)]
    6
    		 
    // https://github.com/rust-lang/rust-clippy/issues/6353
  • nats 0.23.1/src/lib.rs
    184
    		 
        clippy::match_like_matches_macro,
    185
    		 
        clippy::await_holding_lock,
    186
    		 
        clippy::shadow_reuse,
  • nats-aflowt 0.16.105/src/lib.rs
    186
    		 
        clippy::match_like_matches_macro,
    187
    		 
        clippy::await_holding_lock,
    188
    		 
        clippy::shadow_reuse,
  • serial_test 1.0.0/src/parallel_code_lock.rs
    1
    		 
    #![allow(clippy::await_holding_lock)]
  • serial_test 1.0.0/src/serial_code_lock.rs
    1
    		 
    #![allow(clippy::await_holding_lock)]
  • thespis_impl 0.2.1/benches/multi_thread/contention.rs
    145
    		 
    		//
    146
    		 
    		#![ allow( clippy::await_holding_lock) ]
  • thespis_impl 0.2.1/examples/perf/common.rs
    165
    		 
    		//
    166
    		 
    		#![ allow( clippy::await_holding_lock) ]