• abi_stable 0.11.1/src/erased_types/dyn_trait.rs
    1557
    		 
            // I'm using the lifetime in the where clause, clippy <_<
    1558
    		 
            #[allow(clippy::needless_lifetimes)]
    1559
    		 
            pub fn serialize_into_proxy<'a>(&'a self) -> Result<I::ProxyType, RBoxError>
  • abi_stable 0.11.1/src/sabi_types/rmut.rs
    598
    		 
        #[inline(always)]
    599
    		 
        #[allow(clippy::needless_lifetimes)]
    600
    		 
        pub const fn as_rref<'r>(&'r self) -> RRef<'r, T> {
  • abi_stable 0.11.1/src/std_types/slice_mut.rs
    294
    		 
        /// ```
    295
    		 
        #[allow(clippy::needless_lifetimes)]
    296
    		 
        pub fn slice<'b, I>(&'b self, i: I) -> RSlice<'b, T>
    324
    		 
        /// ```
    325
    		 
        #[allow(clippy::needless_lifetimes)]
    326
    		 
        pub fn slice_mut<'b, I>(&'b mut self, i: I) -> RSliceMut<'b, T>
  • abi_stable 0.11.1/src/std_types/string.rs
    111
    		 
        #[inline]
    112
    		 
        #[allow(clippy::needless_lifetimes)]
    113
    		 
        pub fn slice<'a, I>(&'a self, i: I) -> RStr<'a>
  • abi_stable 0.11.1/src/std_types/vec.rs
    250
    		 
        #[inline]
    251
    		 
        #[allow(clippy::needless_lifetimes)]
    252
    		 
        pub fn slice<'a, R>(&'a self, range: R) -> RSlice<'a, T>
    297
    		 
        #[inline]
    298
    		 
        #[allow(clippy::needless_lifetimes)]
    299
    		 
        pub fn slice_mut<'a, R>(&'a mut self, range: R) -> RSliceMut<'a, T>
  • abi_stable 0.11.1/src/utils.rs
    190
    		 
    #[inline]
    191
    		 
    #[allow(clippy::needless_lifetimes)]
    192
    		 
    pub const unsafe fn transmute_reference<T, U>(ref_: &T) -> &U {
    203
    		 
    #[inline]
    204
    		 
    #[allow(clippy::needless_lifetimes)]
    205
    		 
    pub unsafe fn transmute_mut_reference<'a, T, U>(ref_: &'a mut T) -> &'a mut U {
  • actyxos_sdk 0.6.0/src/event/offsets.rs
    554
    		 
        /// An iterator over all sources that contribute events to this OffsetMap\
    555
    		 
        #[allow(clippy::needless_lifetimes)]
    556
    		 
        pub fn sources<'a>(&'a self) -> impl Iterator<Item = SourceId> + 'a {
    560
    		 
        /// An iterator over all streams that contribute events to this OffsetMap
    561
    		 
        #[allow(clippy::needless_lifetimes)]
    562
    		 
        pub fn streams<'a>(&'a self) -> impl Iterator<Item = StreamId> + 'a {
    566
    		 
        /// An iterator over all sources that contribute events to this OffsetMap including their offset
    567
    		 
        #[allow(clippy::needless_lifetimes)]
    568
    		 
        pub fn source_iter<'a>(&'a self) -> impl Iterator<Item = (SourceId, Offset)> + 'a {
    574
    		 
        /// An iterator over all streams that contribute events to this OffsetMap including their offset
    575
    		 
        #[allow(clippy::needless_lifetimes)]
    576
    		 
        pub fn stream_iter<'a>(&'a self) -> impl Iterator<Item = (StreamId, Offset)> + 'a {
  • actyxos_sdk 0.6.0/src/tagged/tags.rs
    199
    		 
        #[allow(clippy::needless_lifetimes)]
    200
    		 
        pub fn iter<'a>(&'a self) -> impl Iterator<Item = Tag> + 'a {
  • age 0.9.0/src/ssh.rs
    188
    		 
        /// Recognizes an SSH `string` matching a tag.
    189
    		 
        #[allow(clippy::needless_lifetimes)] // false positive
    190
    		 
        pub fn string_tag<'a>(value: &'a str) -> impl Fn(&'a [u8]) -> IResult<&'a [u8], &'a [u8]> {
    354
    		 
        /// We only support a single key, like OpenSSH.
    355
    		 
        #[allow(clippy::needless_lifetimes)]
    356
    		 
        pub(super) fn openssh_unencrypted_privkey<'a>(
  • arrow-ipc 32.0.0/src/lib.rs
    28
    		 
    #[allow(clippy::redundant_closure)]
    29
    		 
    #[allow(clippy::needless_lifetimes)]
    30
    		 
    #[allow(clippy::extra_unused_lifetimes)]
  • artem 1.1.5/src/options.rs
    228
    		 
        /// ```
    229
    		 
        #[allow(clippy::needless_lifetimes)] //disable this, as the life is needed for the builder
    230
    		 
        pub fn characters<'a>(&'a mut self, characters: String) -> &'a Self {
  • assembly-data 0.3.0/src/fdb/mem/mod.rs
    166
    		 
    #[allow(clippy::needless_lifetimes)] // <- clippy gets this wrong, presumably because of impl trait?
    167
    		 
    fn map_column_header<'a>(buf: &'a [u8]) -> impl Fn(&'a FDBColumnHeaderC) -> Column<'a> + Copy + Clone {
    186
    		 
    #[allow(clippy::needless_lifetimes)] // <- clippy gets this wrong
    187
    		 
    fn map_bucket_header<'a>(buf: &'a [u8]) -> impl Fn(&'a FDBBucketHeaderC) -> Bucket<'a> {
  • assembly-fdb 0.1.0/src/mem/mod.rs
    164
    		 
    #[allow(clippy::needless_lifetimes)] // <- clippy gets this wrong, presumably because of impl trait?
    165
    		 
    fn map_column_header<'a>(
  • async-local 0.11.1/src/lib.rs
    444
    		 
        trait Countable {
    445
    		 
          #[allow(clippy::needless_lifetimes)]
    446
    		 
          async fn add_one(ref_guard: RefGuard<'async_trait, AtomicUsize>) -> usize;
  • async-std 1.12.0/src/sync/condvar.rs
    120
    		 
        /// ```
    121
    		 
        #[allow(clippy::needless_lifetimes)]
    122
    		 
        pub async fn wait<'a, T>(&self, guard: MutexGuard<'a, T>) -> MutexGuard<'a, T> {
    169
    		 
        /// ```
    170
    		 
        #[allow(clippy::needless_lifetimes)]
    171
    		 
        pub async fn wait_until<'a, T, F>(
    224
    		 
        /// ```
    225
    		 
        #[allow(clippy::needless_lifetimes)]
    226
    		 
        pub async fn wait_timeout<'a, T>(
    273
    		 
        /// ```
    274
    		 
        #[allow(clippy::needless_lifetimes)]
    275
    		 
        pub async fn wait_timeout_until<'a, T, F>(
  • async-trait-ext 0.2.1/tests/basic.rs
    13
    		 
        #[allow(clippy::needless_lifetimes)]
    14
    		 
        async fn method5<'a, A: Clone>(self, a: &'a A)
    18
    		 
        async fn method7<'a, A: Clone>(&mut self, a: &'a A);
    19
    		 
        #[allow(clippy::needless_lifetimes)]
    20
    		 
        async fn method8<'a, A: Clone>(a: &'a A);
  • aurpc 0.3.1/src/lib.rs
    160
    		 
        /// socket.
    161
    		 
        #[allow(clippy::needless_lifetimes)]
    162
    		 
        pub async fn send_to<'a, A: ToSocketAddrs>(
  • azure_sdk_storage_account 0.41.3/src/lib.rs
    13
    		 
    {
    14
    		 
        #[allow(clippy::needless_lifetimes)]
    15
    		 
        fn get_account_information<'a>(
    23
    		 
    {
    24
    		 
        #[allow(clippy::needless_lifetimes)]
    25
    		 
        fn get_account_information<'a>(
  • b2-client 0.1.3/src/file.rs
    2366
    		 
    /// delimiter for working with virtual folders.
    2367
    		 
    #[allow(clippy::needless_lifetimes)] // False positive.
    2368
    		 
    pub async fn list_file_names<'a, C, E>(
    2541
    		 
    /// information.
    2542
    		 
    #[allow(clippy::needless_lifetimes)] // False positive.
    2543
    		 
    pub async fn list_file_versions<'a, C, E>(
    2649
    		 
    /// List the parts of a large file that has not yet been completed.
    2650
    		 
    #[allow(clippy::needless_lifetimes)] // False positive.
    2651
    		 
    pub async fn list_file_parts<'a, C, E>(
    2769
    		 
    /// for further information.
    2770
    		 
    #[allow(clippy::needless_lifetimes)] // False positive.
    2771
    		 
    pub async fn list_unfinished_large_files<'a, C, E>(
  • barter-integration 0.5.1/src/protocol/http/private/mod.rs
    10
    		 
    /// API specific signing logic used by a [`RequestSigner`].
    11
    		 
    #[allow(clippy::needless_lifetimes)]
    12
    		 
    pub trait Signer {
  • bigml 1.0.0/src/client.rs
    166
    		 
        /// memory at once.
    167
    		 
        #[allow(clippy::needless_lifetimes, deprecated)]
    168
    		 
        #[deprecated = "This won't work until BigML fixes Transfer-Encoding: chunked"]
    186
    		 
        /// memory.
    187
    		 
        #[allow(clippy::needless_lifetimes, deprecated)]
    188
    		 
        #[deprecated = "This won't work until BigML fixes Transfer-Encoding: chunked"]
  • bigml 1.0.0/src/wait.rs
    176
    		 
    /// some number of seconds, and then try again.
    177
    		 
    #[allow(clippy::needless_lifetimes)]
    178
    		 
    #[instrument(level = "trace", skip(f))]
  • blown-fuse 0.3.1/src/session.rs
    98
    		 
        // Does not seem like 'a can be elided here
    99
    		 
        #[allow(clippy::needless_lifetimes)]
    100
    		 
        pub fn endpoint<'a>(self: &'a Arc<Self>) -> Endpoint<'a> {
  • bluer 0.15.7/src/l2cap.rs
    640
    		 
        /// to read and write the stream concurrently.
    641
    		 
        #[allow(clippy::needless_lifetimes)]
    642
    		 
        pub fn split<'a>(&'a mut self) -> (stream::ReadHalf<'a>, stream::WriteHalf<'a>) {
  • bluer 0.15.7/src/rfcomm/mod.rs
    495
    		 
        /// to read and write the stream concurrently.
    496
    		 
        #[allow(clippy::needless_lifetimes)]
    497
    		 
        pub fn split<'a>(&'a mut self) -> (stream::ReadHalf<'a>, stream::WriteHalf<'a>) {
  • bones_ecs 0.1.0/src/system.rs
    129
    		 
        /// intermediate parameter state.
    130
    		 
        #[allow(clippy::needless_lifetimes)] // Explicit lifetimes help clarity in this case
    131
    		 
        fn borrow<'s>(state: &'s mut Self::State) -> Self::Param<'s>;
  • breadx 3.1.0/src/lib.rs
    165
    		 
        clippy::let_and_return,
    166
    		 
        clippy::needless_lifetimes,
    167
    		 
        clippy::too_many_arguments
  • cacache 11.0.0/src/content/write.rs
    148
    		 
        #[allow(clippy::new_ret_no_self)]
    149
    		 
        #[allow(clippy::needless_lifetimes)]
    150
    		 
        pub async fn new(cache: &Path, algo: Algorithm, size: Option<usize>) -> Result<AsyncWriter> {
  • cafebabe 0.6.1/src/lib.rs
    350
    		 
    #[allow(clippy::needless_lifetimes)]
    351
    		 
    pub fn parse_class<'a>(raw_bytes: &'a [u8]) -> Result<ClassFile<'a>, ParseError> {
  • casper-node 1.4.8/src/components/small_network/outgoing.rs
    423
    		 
        /// Iterates over all connected peer IDs.
    424
    		 
        #[allow(clippy::needless_lifetimes)]
    425
    		 
        pub(crate) fn connected_peers<'a>(&'a self) -> impl Iterator<Item = NodeId> + 'a {
  • castaway 0.2.2/src/lib.rs
    316
    		 
            #[allow(clippy::needless_lifetimes)]
    317
    		 
            fn inner3<'a>(value: &'a mut [u8]) {
  • cbor-diag 0.1.11/src/parse/diag.rs
    48
    		 
    #[allow(clippy::needless_lifetimes)]
    49
    		 
    fn opt_comma_tag<'a>(t: &'a str) -> impl Fn(&'a str) -> IResult<&'a str, &'a str> {
  • cdbc 0.1.23/src/pool/inner.rs
    161
    		 
        #[allow(clippy::needless_lifetimes)]
    162
    		 
        pub(super) fn acquire<'s>(&'s self) -> Result<Floating<'s, Live<DB>>, Error> {
  • cdbc-mysql 0.1.22/src/connection/executor.rs
    82
    		 
        #[allow(clippy::needless_lifetimes)]
    83
    		 
        fn run<'e, 'c: 'e, 'q: 'e>(
  • cdbc-pg 0.1.22/src/copy.rs
    51
    		 
        /// https://www.postgresql.org/docs/current/sql-copy.html
    52
    		 
        #[allow(clippy::needless_lifetimes)]
    53
    		 
        pub fn copy_out_raw<'c>(
  • clouddns-nat-helper 0.2.10/src/registry.rs
    52
    		 
        /// Returns a result containing [`Ok`] if the domain is claimed or a [`RegistryError`] if the domain could not be claimed.
    53
    		 
        #[allow(clippy::needless_lifetimes)] // needed for mockall
    54
    		 
        fn claim(&mut self, name: &str) -> Result<(), RegistryError>;
    56
    		 
        /// Returns a result containing [`Ok`] if the domain is released or a [`RegistryError`] if the domain could not be released.
    57
    		 
        #[allow(clippy::needless_lifetimes)] // needed for mockall
    58
    		 
        fn release(&mut self, name: &str) -> Result<(), RegistryError>;
  • colorgrad 0.6.2/src/builder.rs
    136
    		 
        /// Set the color blending mode
    137
    		 
        #[allow(clippy::needless_lifetimes)]
    138
    		 
        pub fn mode<'a>(&'a mut self, mode: BlendMode) -> &'a mut Self {
    143
    		 
        /// Set the interpolation mode
    144
    		 
        #[allow(clippy::needless_lifetimes)]
    145
    		 
        pub fn interpolation<'a>(&'a mut self, mode: Interpolation) -> &'a mut Self {
  • complate 0.10.1/src/render/mod.rs
    57
    		 
    #[allow(clippy::needless_lifetimes)]
    58
    		 
    pub async fn select_template<'a>(
  • concread 0.4.1/src/internals/bptree/cursor.rs
    216
    		 
        #[allow(clippy::needless_lifetimes)]
    217
    		 
        fn contains_key<'a, 'b, Q: ?Sized>(&'a self, k: &'b Q) -> bool
  • concread 0.4.1/src/internals/hashmap/cursor.rs
    229
    		 
        #[allow(clippy::needless_lifetimes)]
    230
    		 
        fn contains_key<'a, 'b, Q: ?Sized>(&'a self, h: u64, k: &'b Q) -> bool
  • coreutils 0.0.17/tests/by-util/test_relpath.rs
    64
    		 
    #[allow(clippy::needless_lifetimes)]
    65
    		 
    fn convert_path<'a>(path: &'a str) -> Cow<'a, str> {
  • cosmic-text 0.6.0/src/font/system/no_std.rs
    49
    		 
        // Clippy false positive
    50
    		 
        #[allow(clippy::needless_lifetimes)]
    51
    		 
        pub fn get_font<'a>(&'a self, id: fontdb::ID) -> Option<Arc<Font<'a>>> {
  • cosmic-text 0.6.0/src/font/system/redox.rs
    73
    		 
        // Clippy false positive
    74
    		 
        #[allow(clippy::needless_lifetimes)]
    75
    		 
        pub fn get_font<'a>(&'a self, id: fontdb::ID) -> Option<Arc<Font<'a>>> {
  • cosmic-text 0.6.0/src/font/system/std.rs
    83
    		 
        // Clippy false positive
    84
    		 
        #[allow(clippy::needless_lifetimes)]
    85
    		 
        pub fn get_font<'a>(&'a self, id: fontdb::ID) -> Option<Arc<Font<'a>>> {
  • cosync 0.2.1/src/futures/waker_ref.rs
    44
    		 
    #[allow(clippy::needless_lifetimes)] // clippy is wrong with ArcSelf here
    45
    		 
    pub fn waker_ref<T: ArcWake>(this: &Arc<T>) -> WakerRef<'_> {
  • crate2nix 0.10.0/src/metadata.rs
    153
    		 
        /// the returned map.
    154
    		 
        #[allow(clippy::needless_lifetimes)]
    155
    		 
        fn new<'a>(all_packages: impl Iterator<Item = &'a Package>) -> PackageIdShortener {
  • cretonne-frontend 0.13.2/src/frontend.rs
    568
    		 
        // Clippy thinks the lifetime that follows is needless, but rustc needs it
    569
    		 
        #[cfg_attr(feature = "cargo-clippy", allow(needless_lifetimes))]
    570
    		 
        pub fn display<'b, I: Into<Option<&'b TargetIsa>>>(&'b self, isa: I) -> DisplayFunction {
  • crossbeam-epoch 0.9.13/src/atomic.rs
    1173
    		 
        /// ```
    1174
    		 
        #[allow(clippy::needless_lifetimes)]
    1175
    		 
        pub fn into_shared<'g>(self, _: &'g Guard) -> Shared<'g, T> {
  • crossbeam-skiplist 0.1.1/src/base.rs
    534
    		 
        /// Returns an iterator over a subset of entries in the skip list.
    535
    		 
        #[allow(clippy::needless_lifetimes)]
    536
    		 
        pub fn ref_range<'a, Q, R>(&'a self, range: R) -> RefRange<'a, Q, R, K, V>
  • crossbeam-skiplist_piedb 0.8.11/src/base.rs
    555
    		 
        /// Returns an iterator over a subset of entries in the skip list.
    556
    		 
        #[allow(clippy::needless_lifetimes)]
    557
    		 
        pub fn ref_range<'a, Q, R>(&'a self, range: R) -> RefRange<'a, Q, R, K, V>
  • cses-cli 0.1.3/src/api/mod.rs
    49
    		 
    #[allow(clippy::needless_lifetimes)]
    50
    		 
    #[cfg_attr(test, automock)]
  • daml-grpc 0.2.2/src/executor.rs
    209
    		 
    #[async_trait]
    210
    		 
    #[allow(clippy::needless_lifetimes)]
    211
    		 
    impl CommandExecutor for DamlSimpleExecutor<'_> {
  • dangerous 0.10.0/src/reader/input.rs
    668
    		 
        #[must_use = "peek result must be used"]
    669
    		 
        #[allow(clippy::needless_lifetimes)]
    670
    		 
        pub fn peek_opt<'p>(&'p self, len: usize) -> Option<Peek<'p, I>> {
  • deadpool-postgres 0.10.5/src/generic_client.rs
    181
    		 
    #[async_trait]
    182
    		 
    #[allow(clippy::needless_lifetimes)]
    183
    		 
    impl GenericClient for Transaction<'_> {
    260
    		 
        #[allow(clippy::needless_lifetimes)]
    261
    		 
        async fn transaction<'a>(&'a mut self) -> Result<Transaction<'a>, Error> {
  • deno_core 0.168.0/resources.rs
    189
    		 
      #[inline(always)]
    190
    		 
      #[allow(clippy::needless_lifetimes)]
    191
    		 
      pub fn downcast_rc<'a, T: Resource>(self: &'a Rc<Self>) -> Option<&'a Rc<T>> {
  • dev-mmio 0.1.0/src/lib.rs
    46
    		 
        #[inline]
    47
    		 
        #[allow(clippy::needless_lifetimes)]
    48
    		 
        ///Access raw pointer
  • dezoomify-rs 2.9.4/tests/local_dezoomifying.rs
    29
    		 
    #[allow(clippy::needless_lifetimes)]
    30
    		 
    #[allow(clippy::field_reassign_with_default)]
  • diffy 0.3.0/src/diff/cleanup.rs
    4
    		 
    // edits which can be merged
    5
    		 
    #[allow(clippy::needless_lifetimes)]
    6
    		 
    pub fn compact<'a, 'b, T: ?Sized + SliceLike>(diffs: &mut Vec<DiffRange<'a, 'b, T>>) {
    29
    		 
    // Attempts to shift the Insertion or Deletion at location `pointer` as far upwards as possible.
    30
    		 
    #[allow(clippy::needless_lifetimes)]
    31
    		 
    fn shift_diff_up<'a, 'b, T: ?Sized + SliceLike>(
    131
    		 
    // Attempts to shift the Insertion or Deletion at location `pointer` as far downwards as possible.
    132
    		 
    #[allow(clippy::needless_lifetimes)]
    133
    		 
    fn shift_diff_down<'a, 'b, T: ?Sized + SliceLike>(
  • diffy 0.3.0/src/merge/mod.rs
    463
    		 
    #[allow(clippy::needless_lifetimes)]
    464
    		 
    fn cleanup_conflicts<'ancestor, 'ours, 'theirs, T: ?Sized + SliceLike + PartialEq>(
  • dlpackrs 0.2.0/src/tensor.rs
    271
    		 
    #[allow(clippy::needless_lifetimes)]
    272
    		 
    #[pinned_drop]
  • dns-firewall 1.2.1/src/proxy_server.rs
    321
    		 
        #[allow(clippy::needless_lifetimes)] // false positive
    322
    		 
        async fn connect_upstream_tcp_socket<'a>(
  • doh-client 3.1.2/src/handler.rs
    31
    		 
    #[allow(clippy::needless_lifetimes)]
    32
    		 
    async fn get_response_from_cache<'a>(
    131
    		 
    #[allow(clippy::needless_lifetimes)]
    132
    		 
    async fn get_response_from_cache_fallback<'a>(
  • easy-ml 1.8.2/src/matrices/mod.rs
    779
    		 
        #[track_caller]
    780
    		 
        #[allow(clippy::needless_lifetimes)] // false positive?
    781
    		 
        pub fn partition_quadrants<'a>(
  • eightfold 0.1.0/src/vec.rs
    499
    		 
        #[must_use]
    500
    		 
        #[allow(clippy::uninit_assumed_init, clippy::needless_lifetimes)]
    501
    		 
        pub unsafe fn prepare_raw_array<'s, const LEN: usize>(
  • endbasic-std 0.10.0/src/arrays.rs
    32
    		 
    /// either `LBOUND` or `UBOUND`.
    33
    		 
    #[allow(clippy::needless_lifetimes)]
    34
    		 
    async fn parse_bound_args<'a>(
  • epics-ca 0.1.0/src/channel/get.rs
    132
    		 
    impl<'a, F: Callback> PinnedDrop for Get<'a, F> {
    133
    		 
        #[allow(clippy::needless_lifetimes)]
    134
    		 
        fn drop(self: Pin<&mut Self>) {
  • epics-ca 0.1.0/src/channel/subscribe.rs
    142
    		 
    impl<'a, F: Queue> PinnedDrop for Subscription<'a, F> {
    143
    		 
        #[allow(clippy::needless_lifetimes)]
    144
    		 
        fn drop(self: Pin<&mut Self>) {
  • erl_dist 0.5.1/src/io.rs
    30
    		 
        #[allow(clippy::needless_lifetimes)]
    31
    		 
        pub async fn handshake_message_reader<'a>(
  • esp-idf-sys 0.32.1/build/common.rs
    119
    		 
        #[allow(clippy::needless_lifetimes)]
    120
    		 
        pub fn clang_args<'a>(&'a self) -> impl Iterator<Item = String> + 'a {
    129
    		 
        #[allow(clippy::needless_lifetimes)]
    130
    		 
        pub fn cfg_args<'a>(&'a self) -> impl Iterator<Item = String> + 'a {
  • fizyr-rpc 0.5.1/src/transport/mod.rs
    50
    		 
    	/// Split the transport into a read half and a write half.
    51
    		 
    	#[allow(clippy::needless_lifetimes)]
    52
    		 
    	fn split<'a>(&'a mut self) -> (<Self::ReadHalf as ReadHalfType<'a>>::ReadHalf, <Self::WriteHalf as WriteHalfType<'a>>::WriteHalf);
  • flume 0.10.14/src/async.rs
    184
    		 
    #[allow(clippy::needless_lifetimes)] // False positive, see https://github.com/rust-lang/rust-clippy/issues/5787
    185
    		 
    #[pinned_drop]
  • fmtor 0.1.2/src/lib.rs
    129
    		 
    ///
    130
    		 
    #[allow(clippy::needless_lifetimes)] // They're nice to see in docs
    131
    		 
    pub trait FmtOr<T> {
  • foundationdb 0.7.0/src/database.rs
    228
    		 
    #[allow(clippy::needless_lifetimes)]
    229
    		 
    #[allow(clippy::type_complexity)]
    281
    		 
    #[allow(clippy::needless_lifetimes)]
    282
    		 
    #[allow(clippy::type_complexity)]
  • freedesktop_entry_parser 1.3.0/src/internal.rs
    139
    		 
        // Clippy is wrong here
    140
    		 
        #[allow(clippy::needless_lifetimes)]
    141
    		 
        pub(crate) fn section_names_iter<'a>(
  • futures-scopes 0.1.5/src/relay/relay_future.rs
    190
    		 
    impl<'sc, Sp> PinnedDrop for RelayFuture<'sc, Sp> {
    191
    		 
        #[allow(clippy::needless_lifetimes)]
    192
    		 
        fn drop(self: Pin<&mut Self>) {
  • fvm 3.0.0-alpha.21/src/syscalls/context.rs
    39
    		 
    impl Memory {
    40
    		 
        #[allow(clippy::needless_lifetimes)]
    41
    		 
        pub fn new<'a>(m: &'a mut [u8]) -> &'a mut Memory {
  • genemichaels 0.1.17/src/sg_expr.rs
    61
    		 
    #[allow(clippy::needless_lifetimes)]
    62
    		 
    fn get_dotted<'a>(e: &'a Expr) -> DottedRes<'a> {
  • generic-tests 0.1.2/tests/tests.rs
    342
    		 
    #[generic_tests::define(attrs(allow))]
    343
    		 
    #[allow(clippy::needless_lifetimes)]
    344
    		 
    mod lifetimes_in_signature {
  • geos 8.1.0/src/geometry.rs
    1353
    		 
        /// ```
    1354
    		 
        #[allow(clippy::needless_lifetimes)]
    1355
    		 
        fn to_prepared_geom<'c>(&'c self) -> GResult<PreparedGeometry<'c>>;
  • git-packetline 0.14.1/src/read/async_io.rs
    17
    		 
    {
    18
    		 
        #[allow(clippy::needless_lifetimes)] // TODO: remove once this is clippy false positive is fixed
    19
    		 
        async fn read_line_inner<'a>(
  • globmatch 0.2.3/src/utils.rs
    11
    		 
    /// If the provided `prefix` is not a valid path this function returns an `io::Error`.
    12
    		 
    #[allow(clippy::needless_lifetimes)]
    13
    		 
    pub fn resolve_root<'a, P>(
  • handle 1.0.2/src/lib.rs
    168
    		 
        #[allow(clippy::needless_lifetimes)]
    169
    		 
        fn b<'a>(cx: &'a mut Context) -> BoxFuture<'a, Result> {
    215
    		 
        #[allow(clippy::needless_lifetimes)]
    216
    		 
        fn d<'a>(cx: &'a mut Context) -> impl Future<Output = Result> + 'a {
  • holochain 0.1.0/src/test_utils/consistency.rs
    578
    		 
    // Seems these lifetimes are actually needed.
    579
    		 
    #[allow(clippy::needless_lifetimes)]
    580
    		 
    async fn check_agents<'iter>(
  • holochain_core 0.0.52-alpha2/src/instance.rs
    508
    		 
        #[allow(clippy::needless_lifetimes)]
    509
    		 
        #[no_autotrace]
  • hostsmod 0.2.2/src/parse/mod.rs
    217
    		 
    /// Parses hosts file and returns `Vec` of resulting parts.
    218
    		 
    #[allow(clippy::needless_lifetimes)]
    219
    		 
    pub fn try_parse_hosts<'a>(read: &'a str) -> Result<Vec<HostsPart<'a>>, String> {
  • hotdrink-rs 0.1.3/src/planner/experimental/new_planners.rs
    235
    		 
    #[allow(clippy::needless_lifetimes)]
    236
    		 
    pub fn new_new_simple_planner<'a, M, C, Comp>(component: &'a Comp) -> Option<Vec<&'a M>>
  • hotdrink-rs 0.1.3/src/planner/simple.rs
    129
    		 
    /// ```
    130
    		 
    #[allow(clippy::needless_lifetimes)]
    131
    		 
    pub fn simple_planner<'a, M, C, Comp>(component: &'a Comp) -> Option<Plan<'a, M>>
    202
    		 
    /// If successful, this plan can then be run to enforce all the constraints in the input-component.
    203
    		 
    #[allow(clippy::needless_lifetimes)]
    204
    		 
    pub fn simple_planner_toposort<'a, M, C, Comp>(
  • icu_provider 1.1.0/src/hello_world.rs
    241
    		 
        /// Formats a hello world message, returning a [`FormattedHelloWorld`].
    242
    		 
        #[allow(clippy::needless_lifetimes)] // documentary example
    243
    		 
        pub fn format<'l>(&'l self) -> FormattedHelloWorld<'l> {
  • icu_provider 1.1.0/src/response.rs
    266
    		 
        #[inline]
    267
    		 
        #[allow(clippy::needless_lifetimes)]
    268
    		 
        pub fn get<'a>(&'a self) -> &'a <M::Yokeable as Yokeable<'a>>::Output {
  • implicit-trait 0.3.0/tests/pass/basic.rs
    14
    		 
        #[allow(clippy::needless_lifetimes)]
    15
    		 
        fn baz<'a>(&'a self) -> &str {
  • iroh-api 0.2.0/src/api.rs
    61
    		 
        // The lifetime is needed for mocking.
    62
    		 
        #[allow(clippy::needless_lifetimes)]
    63
    		 
        pub async fn from_env<'a>(
  • jsonpath_lib 0.3.0/src/lib.rs
    220
    		 
    /// ```
    221
    		 
    #[allow(clippy::needless_lifetimes)]
    222
    		 
    pub fn selector<'a>(json: &'a Value) -> impl FnMut(&str) -> Result<Vec<&'a Value>, JsonPathError> {
  • jsonpath_lib-fl 0.3.7/src/lib.rs
    217
    		 
    /// ```
    218
    		 
    #[allow(clippy::needless_lifetimes)]
    219
    		 
    pub fn selector<'a>(json: &'a Value) -> impl FnMut(&str) -> Result<Vec<&'a Value>, JsonPathError> {
  • klickhouse 0.8.5/src/internal_client_out.rs
    135
    		 
        #[allow(clippy::needless_lifetimes)]
    136
    		 
        pub async fn send_query<'a>(&mut self, params: Query<'a>) -> Result<()> {
    225
    		 
        #[allow(clippy::needless_lifetimes)]
    226
    		 
        pub async fn send_hello<'a>(&mut self, params: ClientHello<'a>) -> Result<()> {
  • kparse 1.0.1/src/test.rs
    636
    		 
        /// To be used with Test::ok().
    637
    		 
        #[allow(clippy::needless_lifetimes)]
    638
    		 
        pub fn span<'a, 's, T, C>(span: &'a TrackSpan<'s, C, T>, value: (usize, T)) -> bool
    647
    		 
        /// Compares only the first tuple element. Fails if it is None.
    648
    		 
        #[allow(clippy::needless_lifetimes)]
    649
    		 
        pub fn span_0<'a, 's, T, C>(
    664
    		 
        /// Check that the first element of a tuple (Option<Span<'s>>, Span<'s>) is None.
    665
    		 
        #[allow(clippy::needless_lifetimes)]
    666
    		 
        pub fn span_0_isnone<'a, 's, T, C>(
    678
    		 
        /// Compares the second element.
    679
    		 
        #[allow(clippy::needless_lifetimes)]
    680
    		 
        pub fn span_1<'a, 's, T, C>(
  • krill 0.12.1/src/daemon/auth/providers/openid_connect/provider.rs
    924
    		 
        #[allow(clippy::needless_lifetimes)] // clippy says it can be elided, but.. it seems like it's a false positive.
    925
    		 
        async fn get_token_id_claims<'a>(
  • kul 0.1.2/tests/stream_char_source.rs
    35
    		 
    #[allow(clippy::needless_lifetimes)] // Note: Clippy is wrong: 'f is needed
    36
    		 
    fn ciss_maker<'f, F, R>(converter: &'f F)
  • lair_keystore_api 0.2.3/src/lair_server/priv_api.rs
    629
    		 
    #[allow(clippy::needless_lifetimes)] // this helps me define the future bounds
    630
    		 
    pub(crate) fn priv_get_full_entry_by_tag<'a>(
    654
    		 
    #[allow(clippy::needless_lifetimes)] // this helps me define the future bounds
    655
    		 
    pub(crate) fn priv_get_full_entry_by_ed_pub_key<'a>(
    679
    		 
    #[allow(clippy::needless_lifetimes)] // this helps me define the future bounds
    680
    		 
    pub(crate) fn priv_get_full_entry_by_x_pub_key<'a>(
  • lavish 0.4.0/src/system.rs
    120
    		 
        #[allow(clippy::needless_lifetimes)]
    121
    		 
        pub fn call<D, RR>(&self, params: P, downgrade: D) -> Result<RR, Error>
  • lazy_futuristic 1.0.2/src/lib.rs
    89
    		 
        /// Get the value or setter will be returned if value is not available.
    90
    		 
        #[allow(clippy::needless_lifetimes)]
    91
    		 
        pub async fn get_or_set<'l>(&'l self) -> ValueOrSetter<'l, T> {
  • lifelink 0.1.1/src/lib.rs
    59
    		 
        /// ```
    60
    		 
        #[allow(clippy::needless_lifetimes)] // False positive
    61
    		 
        pub fn new<'a>(thing: C::Ty<'a>) -> (Lifelink<C>, Deathtouch<'a, C>) {
  • locutus-node 0.0.1/src/http_gateway.rs
    327
    		 
    #[allow(clippy::needless_lifetimes)]
    328
    		 
    impl ClientEventsProxy for HttpGateway {
  • madsim-tokio-postgres 0.2.0/src/generic_client.rs
    159
    		 
    #[async_trait]
    160
    		 
    #[allow(clippy::needless_lifetimes)]
    161
    		 
    impl GenericClient for Transaction<'_> {
    230
    		 
        #[allow(clippy::needless_lifetimes)]
    231
    		 
        async fn transaction<'a>(&'a mut self) -> Result<Transaction<'a>, Error> {
  • magnesia 0.9.2/src/linalg/dmatrix.rs
    885
    		 
        /// Returns the transposed matrix as a matrix expression.
    886
    		 
        #[allow(clippy::needless_lifetimes)] // false positive
    887
    		 
        pub fn t<'a>(&'a self) -> MatrixExprWrapper<impl MatrixExpr<Entry = T> + 'a> {
    903
    		 
        /// Returns the transposed matrix as a matrix expression.
    904
    		 
        #[allow(clippy::needless_lifetimes)] // false positive
    905
    		 
        pub fn h<'a>(&'a self) -> MatrixExprWrapper<impl MatrixExpr<Entry = T> + 'a> {
    943
    		 
        /// ```
    944
    		 
        #[allow(clippy::needless_lifetimes)] // False positive warning
    945
    		 
        pub fn diag<'a>(&'a self) -> VectorExprWrapper<impl VectorExpr<Entry = T> + 'a> {
  • magnesia 0.9.2/src/linalg/dvector.rs
    743
    		 
        /// Returns the conjugated vector as a vector expression.
    744
    		 
        #[allow(clippy::needless_lifetimes)] // false positive
    745
    		 
        pub fn conj<'a>(&'a self) -> VectorExprWrapper<impl VectorExpr<Entry = T> + 'a> {
    783
    		 
        /// ```
    784
    		 
        #[allow(clippy::needless_lifetimes)] // False positive warning
    785
    		 
        pub fn diag<'a>(&'a self) -> MatrixExprWrapper<impl MatrixExpr<Entry = T> + 'a> {
  • metrics_printer 0.1.0/src/lib.rs
    644
    		 
    #[allow(clippy::needless_lifetimes)]
    645
    		 
    fn ignore<'a, T: 'static>(_t: &'a T) {
  • millennium-core 1.0.0-beta.3/src/platform_impl/macos/util/mod.rs
    86
    		 
    	type Target = id;
    87
    		 
    	#[allow(clippy::needless_lifetimes)]
    88
    		 
    	fn deref<'a>(&'a self) -> &'a id {
  • monch 0.4.0/src/lib.rs
    93
    		 
    /// Gets the next character.
    94
    		 
    #[allow(clippy::needless_lifetimes)]
    95
    		 
    pub fn next_char<'a>(input: &'a str) -> ParseResult<'a, char> {
  • mpl-auction-house 1.3.5/src/cancel/mod.rs
    186
    		 
    #[allow(clippy::needless_lifetimes)]
    187
    		 
    fn cancel_logic<'info>(
  • mpl-auction-house 1.3.5/src/deposit/mod.rs
    233
    		 
    #[allow(clippy::needless_lifetimes)]
    234
    		 
    /// Deposit `amount` into the escrow payment account for your specific wallet.
  • mpl-auction-house 1.3.5/src/withdraw/mod.rs
    230
    		 
    #[allow(clippy::needless_lifetimes)]
    231
    		 
    fn withdraw_logic<'info>(
  • mundane 0.5.0/src/boringssl/mod.rs
    275
    		 
        #[must_use]
    276
    		 
        #[allow(clippy::needless_lifetimes)] // to be more explicit
    277
    		 
        pub fn ec_key_get0_group<'a>(&'a self) -> Result<CRef<'a, EC_GROUP>, BoringError> {
    681
    		 
        #[must_use]
    682
    		 
        #[allow(clippy::needless_lifetimes)] // to be more explicit
    683
    		 
        pub fn rsa_get0_e<'a>(&'a self) -> Result<CRef<'a, BIGNUM>, BoringError> {
    689
    		 
        /// Returns a constant reference to the key public modulus.
    690
    		 
        #[allow(clippy::needless_lifetimes)] // to be more explicit
    691
    		 
        pub fn rsa_get0_n<'a>(&'a self) -> Result<CRef<'a, BIGNUM>, BoringError> {
  • mv-vm-types 0.3.2/src/values/values_impl.rs
    2686
    		 
    impl Struct {
    2687
    		 
        #[allow(clippy::needless_lifetimes)]
    2688
    		 
        pub fn field_views<'a>(&'a self) -> impl ExactSizeIterator<Item = impl ValueView + 'a> {
    2699
    		 
    impl GlobalValue {
    2700
    		 
        #[allow(clippy::needless_lifetimes)]
    2701
    		 
        pub fn view<'a>(&'a self) -> Option<impl ValueView + 'a> {
  • nalgebra-numpy 0.3.0/src/from_numpy.rs
    58
    		 
    /// The user must ensure that the data is not modified through other pointers or references.
    59
    		 
    #[allow(clippy::needless_lifetimes)]
    60
    		 
    pub unsafe fn matrix_slice_from_numpy<'a, N, R, C>(
    80
    		 
    /// The user must ensure that no other Rust references to the same data exist.
    81
    		 
    #[allow(clippy::needless_lifetimes)]
    82
    		 
    pub unsafe fn matrix_slice_mut_from_numpy<'a, N, R, C>(
  • nalgebra-py 0.3.1/src/from_numpy.rs
    59
    		 
    /// The user must ensure that the data is not modified through other pointers or references.
    60
    		 
    #[allow(clippy::needless_lifetimes)]
    61
    		 
    pub unsafe fn matrix_slice_from_numpy<'a, N, R, C>(
    81
    		 
    /// The user must ensure that no other Rust references to the same data exist.
    82
    		 
    #[allow(clippy::needless_lifetimes)]
    83
    		 
    pub unsafe fn matrix_slice_mut_from_numpy<'a, N, R, C>(
  • oasis-amqp 0.3.0/src/proto.rs
    187
    		 
    impl BytesFrame {
    188
    		 
        #[allow(clippy::needless_lifetimes)]
    189
    		 
        pub fn frame<'a>(&'a self) -> &'a Frame<'a> {
    193
    		 
        #[allow(clippy::needless_lifetimes)]
    194
    		 
        pub fn body<'a>(&'a self) -> Option<&'a [u8]> {
  • oauth1-request 0.6.0/src/signature_method/rsa_sha1_06.rs
    55
    		 
        fn as_ref(&self) -> &RsaSha1 {
    56
    		 
            #[allow(clippy::needless_lifetimes)] // Adding the lifetime annotations just to be sure.
    57
    		 
            fn inner<'a>(key: &'a RsaPrivateKey) -> &'a RsaSha1 {
  • objc2 0.3.0-beta.4/src/rc/autorelease.rs
    86
    		 
        #[inline]
    87
    		 
        #[allow(clippy::needless_lifetimes)]
    88
    		 
        pub unsafe fn ptr_as_ref<'p, T: ?Sized>(&'p self, ptr: *const T) -> &'p T {
    106
    		 
        #[inline]
    107
    		 
        #[allow(clippy::needless_lifetimes)]
    108
    		 
        #[allow(clippy::mut_from_ref)]
  • objc2 0.3.0-beta.4/src/rc/id.rs
    543
    		 
        #[inline]
    544
    		 
        #[allow(clippy::needless_lifetimes)]
    545
    		 
        #[allow(clippy::mut_from_ref)]
    596
    		 
        #[inline]
    597
    		 
        #[allow(clippy::needless_lifetimes)]
    598
    		 
        pub fn autorelease<'p>(self, pool: &'p AutoreleasePool) -> &'p T {
  • ouroboros_examples 0.15.5/src/fail_tests/borrowchk_external_lifetime.rs
    13
    		 
    fn main() {
    14
    		 
        #[allow(clippy::needless_lifetimes)]
    15
    		 
        fn bar<'a>(x: &'a ()) -> &'a str {
  • owned_ttf_parser 0.18.1/src/owned.rs
    141
    		 
        #[inline]
    142
    		 
        #[allow(clippy::needless_lifetimes)] // explicit is nice as it's important 'static isn't leaked
    143
    		 
        fn inner_ref<'a>(self: &'a Pin<Box<Self>>) -> &'a ttf_parser::Face<'a> {
  • parallel_vec 0.2.4/src/param.rs
    136
    		 
        /// Creates a set of iterators from slices.
    137
    		 
        #[allow(clippy::needless_lifetimes)]
    138
    		 
        fn iters<'a>(slices: Self::Slices<'a>) -> Self::Iters<'a>;
    140
    		 
        /// Creates a set of iterators of mutable references from slices.
    141
    		 
        #[allow(clippy::needless_lifetimes)]
    142
    		 
        fn iters_mut<'a>(slices: Self::SlicesMut<'a>) -> Self::ItersMut<'a>;
  • partiql-parser 0.2.0/src/parse/mod.rs
    22
    		 
    #[allow(clippy::type_complexity)]
    23
    		 
    #[allow(clippy::needless_lifetimes)]
    24
    		 
    #[allow(clippy::too_many_arguments)]
  • patract-wasmi 0.9.1/src/memory/mod.rs
    539
    		 
        /// [`clear`]: #method.set
    540
    		 
        #[allow(clippy::needless_lifetimes)]
    541
    		 
        pub fn direct_access<'a>(&'a self) -> impl AsRef<[u8]> + 'a {
    560
    		 
        /// [`set`]: #method.set
    561
    		 
        #[allow(clippy::needless_lifetimes)]
    562
    		 
        pub fn direct_access_mut<'a>(&'a self) -> impl AsMut<[u8]> + 'a {
  • peg-runtime 0.8.1/lib.rs
    20
    		 
    /// A type that can be used as input to a parser.
    21
    		 
    #[allow(clippy::needless_lifetimes)]
    22
    		 
    pub trait Parse {
  • pin-project 1.0.12/tests/pin_project.rs
    428
    		 
    #[allow(clippy::needless_lifetimes)]
    429
    		 
    #[test]
  • pin-project-lite 0.2.9/tests/test.rs
    325
    		 
    #[allow(clippy::needless_lifetimes)]
    326
    		 
    #[test]
  • poem-openapi-derive 2.0.23/src/utils.rs
    138
    		 
    #[allow(clippy::needless_lifetimes)]
    139
    		 
    fn handle_path<'a>(
  • poise 0.5.2/src/dispatch/common.rs
    172
    		 
    /// (A command that didn't even get past argument parsing shouldn't trigger cooldowns)
    173
    		 
    #[allow(clippy::needless_lifetimes)] // false positive (clippy issue 7271)
    174
    		 
    pub async fn check_permissions_and_cooldown<'a, U, E>(
  • polars_arrow_rvsry99dx 0.17.1/src/lib.rs
    38
    		 
    #[allow(clippy::redundant_closure)]
    39
    		 
    #[allow(clippy::needless_lifetimes)]
    40
    		 
    #[allow(clippy::extra_unused_lifetimes)]
  • polars-core 0.26.1/src/frame/groupby/aggregations/mod.rs
    300
    		 
    impl Utf8Chunked {
    301
    		 
        #[allow(clippy::needless_lifetimes)]
    302
    		 
        pub(crate) unsafe fn agg_min<'a>(&'a self, groups: &GroupsProxy) -> Series {
    362
    		 
        #[allow(clippy::needless_lifetimes)]
    363
    		 
        pub(crate) unsafe fn agg_max<'a>(&'a self, groups: &GroupsProxy) -> Series {
  • polars-core 0.26.1/src/frame/groupby/into_groups.rs
    242
    		 
    impl IntoGroupsProxy for Utf8Chunked {
    243
    		 
        #[allow(clippy::needless_lifetimes)]
    244
    		 
        fn group_tuples<'a>(&'a self, multithreaded: bool, sorted: bool) -> PolarsResult<GroupsProxy> {
    295
    		 
    impl IntoGroupsProxy for BinaryChunked {
    296
    		 
        #[allow(clippy::needless_lifetimes)]
    297
    		 
        fn group_tuples<'a>(&'a self, multithreaded: bool, sorted: bool) -> PolarsResult<GroupsProxy> {
    347
    		 
    impl IntoGroupsProxy for ListChunked {
    348
    		 
        #[allow(clippy::needless_lifetimes)]
    349
    		 
        #[allow(unused_variables)]
  • polyhedron-ops 0.2.4/src/helpers.rs
    609
    		 
    #[allow(clippy::needless_lifetimes)]
    610
    		 
    #[inline]
  • postage 0.5.0/src/channels/watch.rs
    78
    		 
    #[allow(clippy::needless_lifetimes)]
    79
    		 
    impl<T> Sender<T> {
  • pravega-client 0.3.2/src/segment/raw_client.rs
    102
    		 
    #[allow(clippy::needless_lifetimes)]
    103
    		 
    #[async_trait]
  • pravega-wire-protocol 0.3.2/src/client_connection.rs
    95
    		 
    #[async_trait]
    96
    		 
    #[allow(clippy::needless_lifetimes)] //Normally the compiler could infer lifetimes but async is throwing it for a loop.
    97
    		 
    impl ClientConnection for ClientConnectionImpl<'_> {
  • prefixset 0.1.0-rc.2/src/node/mod.rs
    295
    		 
        #[allow(clippy::needless_lifetimes, clippy::borrowed_box)]
    296
    		 
        pub fn children<'a>(self: &'a Box<Self>) -> Children<'a, P> {
  • presser 0.3.1/src/lib.rs
    441
    		 
        /// Also see the [top-level safety documentation][`crate#safety`]
    442
    		 
        #[allow(clippy::needless_lifetimes)] // Important to be explicit in this case because of unsafety
    443
    		 
        pub unsafe fn borrow_as_slab<'a>(&'a mut self) -> BorrowedRawAllocation<'a> {
  • qsv 0.87.0/src/select.rs
    440
    		 
    impl NormalSelection {
    441
    		 
        #[allow(clippy::needless_lifetimes)]
    442
    		 
        pub fn select<'a, T, I>(&'a self, row: I) -> _NormalFilterMap<'a, T, I>
  • quickwit-search 0.3.0/src/fetch_docs.rs
    35
    		 
    /// returns them as a hashmap.
    36
    		 
    #[allow(clippy::needless_lifetimes)]
    37
    		 
    async fn fetch_docs_to_map(
    146
    		 
    #[tracing::instrument(skip(global_doc_addrs, index_storage, split))]
    147
    		 
    #[allow(clippy::needless_lifetimes)]
    148
    		 
    async fn fetch_docs_in_split(
  • rbdc-mysql 0.1.19/src/connection/executor.rs
    84
    		 
        #[allow(clippy::needless_lifetimes)]
    85
    		 
        async fn run<'e, 'q: 'e>(
  • remoc 0.10.0/src/robs/list.rs
    306
    		 
        /// While the borrow is held sending of events to subscribers is paused.
    307
    		 
        #[allow(clippy::needless_lifetimes)]
    308
    		 
        pub async fn borrow<'a>(&'a self) -> ObservableListRef<'a, T> {
  • remoc-obs 0.5.0/src/list.rs
    306
    		 
        /// While the borrow is held sending of events to subscribers is paused.
    307
    		 
        #[allow(clippy::needless_lifetimes)]
    308
    		 
        pub async fn borrow<'a>(&'a self) -> ObservableListRef<'a, T> {
  • reool 0.30.0/src/redis_ops.rs
    29
    		 
        /// Send a ping command and return the roundrip time if successful
    30
    		 
        #[allow(clippy::needless_lifetimes)]
    31
    		 
        fn ping<'a>(&'a mut self) -> RedisFuture<'a, Duration> {
  • rocket_cors 0.6.0-alpha1/src/lib.rs
    629
    		 
        /// crafting your Regex expressions.
    630
    		 
        #[allow(clippy::needless_lifetimes)]
    631
    		 
        pub fn some<'a, 'b, S1: AsRef<str>, S2: AsRef<str>>(exact: &'a [S1], regex: &'b [S2]) -> Self {
  • roxmltree 0.17.0/src/parse.rs
    1015
    		 
    #[allow(clippy::needless_lifetimes)]
    1016
    		 
    fn append_text<'input, 'temp>(
  • rust-libretro 0.3.1/src/environment.rs
    283
    		 
    #[proc::context(OptionsChangedContext)]
    284
    		 
    #[allow(clippy::needless_lifetimes)]
    285
    		 
    pub unsafe fn get_variable<'a>(callback: retro_environment_t, key: &'a str) -> Option<&'a str> {
  • rxrust 1.0.0-alpha.5/src/rc.rs
    12
    		 
        Self: 'a;
    13
    		 
      #[allow(clippy::needless_lifetimes)]
    14
    		 
      fn rc_deref<'a>(&'a self) -> Self::Target<'a>;
    20
    		 
        Self: 'a;
    21
    		 
      #[allow(clippy::needless_lifetimes)]
    22
    		 
      fn try_rc_deref<'a>(&'a self) -> Self::Target<'a>;
    28
    		 
        Self: 'a;
    29
    		 
      #[allow(clippy::needless_lifetimes)]
    30
    		 
      fn rc_deref_mut<'a>(&'a self) -> Self::Target<'a>;
    36
    		 
        Self: 'a;
    37
    		 
      #[allow(clippy::needless_lifetimes)]
    38
    		 
      fn try_rc_deref_mut<'a>(&'a self) -> Self::Target<'a>;
    90
    		 
      #[inline]
    91
    		 
      #[allow(clippy::needless_lifetimes)]
    92
    		 
      fn rc_deref<'a>(&'a self) -> Self::Target<'a> {
  • ryml 0.1.5/src/inner.rs
    314
    		 
    #[allow(clippy::needless_lifetimes)] // Needed because of some weirdness at line 539
    315
    		 
    #[cxx::bridge]
  • s3handler 0.8.1/src/blocking/download_pool.rs
    22
    		 
    #[allow(clippy::needless_lifetimes)]
    23
    		 
    fn acquire<'a, T>(s: &'a Arc<Mutex<T>>) -> MutexGuard<'a, T>
  • s3handler 0.8.1/src/blocking/upload_pool.rs
    24
    		 
    #[allow(clippy::needless_lifetimes)]
    25
    		 
    fn acquire<'a, T>(s: &'a Arc<Mutex<T>>) -> MutexGuard<'a, T>
  • safety_breaker 0.1.0/src/lib.rs
    17
    		 
    #[allow(clippy::mut_from_ref)]
    18
    		 
    #[allow(clippy::needless_lifetimes)]
    19
    		 
    pub trait ForceMut {
    27
    		 
    #[allow(clippy::needless_lifetimes)]
    28
    		 
    #[allow(clippy::cast_ref_to_mut)]
  • seaslug 0.0.0/src/ebr/atomic.rs
    582
    		 
        /// Converts the owned pointer into a [`Shared`].
    583
    		 
        #[allow(clippy::needless_lifetimes)]
    584
    		 
        pub(crate) fn into_shared<'g>(self, _: &'g Guard) -> Shared<'g, T> {
  • serde_json 1.0.91/tests/test.rs
    2109
    		 
    // Clippy false positive: https://github.com/Manishearth/rust-clippy/issues/292
    2110
    		 
    #[allow(clippy::needless_lifetimes)]
    2111
    		 
    fn test_into_io_error() {
  • serenity 0.11.5/src/framework/standard/parse/mod.rs
    176
    		 
    #[allow(clippy::needless_lifetimes)] // Clippy and the compiler disagree
    177
    		 
    async fn find_prefix<'a>(
    214
    		 
    /// In all cases, whitespace after the prefix is cleared.
    215
    		 
    #[allow(clippy::needless_lifetimes)] // Clippy and the compiler disagree
    216
    		 
    pub async fn prefix<'a>(
  • shadowsocks 1.15.2/src/context.rs
    124
    		 
        /// Resolves DNS address to `SocketAddr`s
    125
    		 
        #[allow(clippy::needless_lifetimes)]
    126
    		 
        pub async fn dns_resolve<'a>(&self, addr: &'a str, port: u16) -> io::Result<impl Iterator<Item = SocketAddr> + 'a> {
  • shadowsocks 1.15.2/src/dns_resolver/resolver.rs
    264
    		 
        /// Resolve address into `SocketAddr`s
    265
    		 
        #[allow(clippy::needless_lifetimes)]
    266
    		 
        pub async fn resolve<'a>(&self, addr: &'a str, port: u16) -> io::Result<impl Iterator<Item = SocketAddr> + 'a> {
  • shaku_rocket 0.7.0-rc.1/src/lib.rs
    18
    		 
    #[allow(clippy::needless_lifetimes)] // false positive
    19
    		 
    async fn get_module_from_state<'r, M: ModuleInterface + ?Sized>(
  • show-image 0.13.1/src/features/tch.rs
    76
    		 
    /// If you also need to convert the tensor, consider doing so before displaying it.
    77
    		 
    #[allow(clippy::needless_lifetimes)]
    78
    		 
    pub trait TensorAsImage {
  • socketcan-alt 0.4.0/src/aio.rs
    39
    		 
        #[allow(clippy::needless_lifetimes)]
    40
    		 
        pub async fn recv_msg<'a>(
  • solabi 0.0.3/src/bytes.rs
    26
    		 
        /// Returns a borrowed `Bytes` from a slice of bytes.
    27
    		 
        #[allow(clippy::needless_lifetimes)]
    28
    		 
        pub fn new<'a>(bytes: &'a [u8]) -> &'a Bytes<[u8]> {
    37
    		 
        /// Returns a new `Cow::Borrowed` slice of bytes.
    38
    		 
        #[allow(clippy::needless_lifetimes)]
    39
    		 
        pub fn borrowed<'a>(bytes: &'a [u8]) -> Cow<'a, Bytes<[u8]>> {
  • sp-multihash 0.3.0/src/multihash.rs
    63
    		 
      /// ```
    64
    		 
      #[allow(clippy::needless_lifetimes)]
    65
    		 
      fn multihash_from_digest<'a, D, const DIGEST_SIZE: usize>(
  • sqlx-core 0.6.2/src/mysql/connection/executor.rs
    85
    		 
        #[allow(clippy::needless_lifetimes)]
    86
    		 
        async fn run<'e, 'c: 'e, 'q: 'e>(
  • sqlx-core 0.6.2/src/postgres/copy.rs
    51
    		 
        /// https://www.postgresql.org/docs/current/sql-copy.html
    52
    		 
        #[allow(clippy::needless_lifetimes)]
    53
    		 
        pub async fn copy_out_raw<'c>(
  • sqlx-core-guts 0.6.0/src/mysql/connection/executor.rs
    85
    		 
        #[allow(clippy::needless_lifetimes)]
    86
    		 
        async fn run<'e, 'c: 'e, 'q: 'e>(
  • sqlx-core-guts 0.6.0/src/postgres/copy.rs
    51
    		 
        /// https://www.postgresql.org/docs/current/sql-copy.html
    52
    		 
        #[allow(clippy::needless_lifetimes)]
    53
    		 
        pub async fn copy_out_raw<'c>(
  • stack-queue 0.2.0/src/queue.rs
    72
    		 
      #[allow(clippy::needless_lifetimes)]
    73
    		 
      async fn batch_process<const N: usize>(
    90
    		 
      #[allow(clippy::needless_lifetimes)]
    91
    		 
      async fn batch_process<const N: usize>(tasks: UnboundedSlice<'async_trait, Self::Task, N>);
  • stubr 0.5.1/src/server/mod.rs
    191
    		 
        #[allow(clippy::needless_lifetimes)]
    192
    		 
        fn find_all_mocks<'a>(&self, from: &Path) -> impl Iterator<Item = (JsonStub, PathBuf)> + 'a {
  • swc_ecma_minifier 0.166.10/src/compress/pure/mod.rs
    51
    		 
    #[allow(clippy::needless_lifetimes)]
    52
    		 
    pub(crate) fn pure_optimizer<'a>(
  • switchyard 0.3.0/src/threads.rs
    55
    		 
    /// `input` is the result of calling [`thread_info`].
    56
    		 
    #[allow(clippy::needless_lifetimes)]
    57
    		 
    pub fn one_to_one<'a>(
    74
    		 
    /// `input` is the result of calling [`thread_info`].
    75
    		 
    #[allow(clippy::needless_lifetimes)]
    76
    		 
    pub fn two_to_one<'a>(
  • synthizer 0.5.4/src/context.rs
    23
    		 
        /// to limit the number of events received, use `.take`.
    24
    		 
        #[allow(clippy::needless_lifetimes)] // Actually appears to be a false positive.
    25
    		 
        pub fn get_events<'a>(&'a self) -> impl Iterator<Item = Result<events::Event>> + 'a {
  • sysinfo 0.27.7/src/apple/network.rs
    158
    		 
    impl NetworksExt for Networks {
    159
    		 
        #[allow(clippy::needless_lifetimes)]
    160
    		 
        fn iter<'a>(&'a self) -> NetworksIter<'a> {
  • sysinfo 0.27.7/src/windows/network.rs
    35
    		 
    impl NetworksExt for Networks {
    36
    		 
        #[allow(clippy::needless_lifetimes)]
    37
    		 
        fn iter<'a>(&'a self) -> NetworksIter<'a> {
  • tao 0.17.0/src/platform_impl/macos/util/mod.rs
    83
    		 
      type Target = id;
    84
    		 
      #[allow(clippy::needless_lifetimes)]
    85
    		 
      fn deref<'a>(&'a self) -> &'a id {
  • tari_comms 0.8.1/src/tor/control_client/client.rs
    108
    		 
        /// The GETCONF command. Returns configuration keys matching the `conf_name`.
    109
    		 
        #[allow(clippy::needless_lifetimes)]
    110
    		 
        pub async fn get_conf<'a>(&mut self, conf_name: &'a str) -> Result<Vec<Cow<'a, str>>, TorClientError> {
    115
    		 
        /// The GETINFO command. Returns configuration keys matching the `conf_name`.
    116
    		 
        #[allow(clippy::needless_lifetimes)]
    117
    		 
        pub async fn get_info<'a>(&mut self, key_name: &'a str) -> Result<Vec<Cow<'a, str>>, TorClientError> {
  • tensorflow 0.19.1/src/eager/op.rs
    25
    		 
        clippy::derivable_impls,
    26
    		 
        clippy::needless_lifetimes
    27
    		 
    )]
  • tokio 1.25.0/src/io/async_fd.rs
    436
    		 
        /// [`AsyncFdReadyGuard`].
    437
    		 
        #[allow(clippy::needless_lifetimes)] // The lifetime improves rustdoc rendering.
    438
    		 
        pub async fn readable<'a>(&'a self) -> io::Result<AsyncFdReadyGuard<'a, T>> {
    447
    		 
        /// resource mutably when handling the [`AsyncFdReadyMutGuard`].
    448
    		 
        #[allow(clippy::needless_lifetimes)] // The lifetime improves rustdoc rendering.
    449
    		 
        pub async fn readable_mut<'a>(&'a mut self) -> io::Result<AsyncFdReadyMutGuard<'a, T>> {
    460
    		 
        /// [`AsyncFdReadyGuard`].
    461
    		 
        #[allow(clippy::needless_lifetimes)] // The lifetime improves rustdoc rendering.
    462
    		 
        pub async fn writable<'a>(&'a self) -> io::Result<AsyncFdReadyGuard<'a, T>> {
    471
    		 
        /// resource mutably when handling the [`AsyncFdReadyMutGuard`].
    472
    		 
        #[allow(clippy::needless_lifetimes)] // The lifetime improves rustdoc rendering.
    473
    		 
        pub async fn writable_mut<'a>(&'a mut self) -> io::Result<AsyncFdReadyMutGuard<'a, T>> {
  • tokio 1.25.0/src/net/tcp/stream.rs
    1212
    		 
        // it more clear that this is a *borrowed* split.
    1213
    		 
        #[allow(clippy::needless_lifetimes)]
    1214
    		 
        /// Splits a `TcpStream` into a read half and a write half, which can be used
  • tokio 1.25.0/src/net/unix/stream.rs
    877
    		 
        // it more clear that this is a *borrowed* split.
    878
    		 
        #[allow(clippy::needless_lifetimes)]
    879
    		 
        /// Splits a `UnixStream` into a read half and a write half, which can be used
  • tokio-postgres 0.7.7/src/generic_client.rs
    159
    		 
    #[async_trait]
    160
    		 
    #[allow(clippy::needless_lifetimes)]
    161
    		 
    impl GenericClient for Transaction<'_> {
    230
    		 
        #[allow(clippy::needless_lifetimes)]
    231
    		 
        async fn transaction<'a>(&'a mut self) -> Result<Transaction<'a>, Error> {
  • tokio-tcp 0.2.0-alpha.1/src/listener.rs
    88
    		 
        /// ```
    89
    		 
        #[allow(clippy::needless_lifetimes)] // false positive: https://github.com/rust-lang/rust-clippy/issues/3988
    90
    		 
        pub async fn accept(&mut self) -> io::Result<(TcpStream, SocketAddr)> {
  • tokio-uds 0.3.0-alpha.1/src/listener.rs
    54
    		 
        /// Accepts a new incoming connection to this listener.
    55
    		 
        #[allow(clippy::needless_lifetimes)] // false positive: https://github.com/rust-lang/rust-clippy/issues/3988
    56
    		 
        pub async fn accept(&mut self) -> io::Result<(UnixStream, SocketAddr)> {
  • tokio_wasi 1.23.0/src/io/async_fd.rs
    436
    		 
        /// [`AsyncFdReadyGuard`].
    437
    		 
        #[allow(clippy::needless_lifetimes)] // The lifetime improves rustdoc rendering.
    438
    		 
        pub async fn readable<'a>(&'a self) -> io::Result<AsyncFdReadyGuard<'a, T>> {
    447
    		 
        /// resource mutably when handling the [`AsyncFdReadyMutGuard`].
    448
    		 
        #[allow(clippy::needless_lifetimes)] // The lifetime improves rustdoc rendering.
    449
    		 
        pub async fn readable_mut<'a>(&'a mut self) -> io::Result<AsyncFdReadyMutGuard<'a, T>> {
    460
    		 
        /// [`AsyncFdReadyGuard`].
    461
    		 
        #[allow(clippy::needless_lifetimes)] // The lifetime improves rustdoc rendering.
    462
    		 
        pub async fn writable<'a>(&'a self) -> io::Result<AsyncFdReadyGuard<'a, T>> {
    471
    		 
        /// resource mutably when handling the [`AsyncFdReadyMutGuard`].
    472
    		 
        #[allow(clippy::needless_lifetimes)] // The lifetime improves rustdoc rendering.
    473
    		 
        pub async fn writable_mut<'a>(&'a mut self) -> io::Result<AsyncFdReadyMutGuard<'a, T>> {
  • tokio_wasi 1.23.0/src/net/tcp/stream.rs
    1209
    		 
        // it more clear that this is a *borrowed* split.
    1210
    		 
        #[allow(clippy::needless_lifetimes)]
    1211
    		 
        /// Splits a `TcpStream` into a read half and a write half, which can be used
  • tokio_wasi 1.23.0/src/net/unix/stream.rs
    855
    		 
        // it more clear that this is a *borrowed* split.
    856
    		 
        #[allow(clippy::needless_lifetimes)]
    857
    		 
        /// Splits a `UnixStream` into a read half and a write half, which can be used
  • tunneler 0.4.1/src/server/dns.rs
    89
    		 
    pub(crate) trait DnsResponseHandler {
    90
    		 
        #[allow(clippy::needless_lifetimes)]
    91
    		 
        fn send_response<'a, 'b>(&mut self, response: MessageResponse<'a, 'b>) -> io::Result<()>;
  • uapi 0.2.10/src/dir/mod.rs
    73
    		 
    #[allow(clippy::needless_lifetimes)]
    74
    		 
    impl Dir {
  • ubench 0.0.0-alpha0/src/reporters/basic.rs
    16
    		 
    #[allow(clippy::needless_lifetimes)]
    17
    		 
    impl BasicReporter<'static, Void> {
  • unstructured 0.5.1/src/core/de.rs
    55
    		 
    #[allow(clippy::needless_lifetimes)]
    56
    		 
    impl Unexpected {
  • vst 0.3.0/src/api.rs
    476
    		 
        #[inline]
    477
    		 
        #[allow(clippy::needless_lifetimes)]
    478
    		 
        pub fn events<'a>(&'a self) -> impl Iterator<Item = crate::event::Event<'a>> {
  • wax 0.5.0/src/token/parse.rs
    350
    		 
        // Explicit lifetimes prevent inference errors.
    351
    		 
        #[allow(clippy::needless_lifetimes)]
    352
    		 
        fn flags_with_state<'i>(input: Input<'i>) -> ParseResult<'i, ()> {
    365
    		 
        // Explicit lifetimes prevent inference errors.
    366
    		 
        #[allow(clippy::needless_lifetimes)]
    367
    		 
        fn flags_without_state<'i>(input: Input<'i>) -> ParseResult<'i, ()> {
  • windows-permissions 0.2.4/src/wrappers/build_trustee_with_name.rs
    6
    		 
    #[allow(non_snake_case)]
    7
    		 
    #[allow(clippy::needless_lifetimes)]
    8
    		 
    pub fn BuildTrusteeWithName<'s>(name_buf: &'s [u16]) -> Trustee<'s> {
  • windows-permissions 0.2.4/src/wrappers/build_trustee_with_sid.rs
    4
    		 
    #[allow(non_snake_case)]
    5
    		 
    #[allow(clippy::needless_lifetimes)]
    6
    		 
    pub fn BuildTrusteeWithSid<'s>(sid: &'s Sid) -> Trustee<'s> {
  • wpa-ctrl 0.2.0/src/lib.rs
    118
    		 
        #[inline]
    119
    		 
        #[allow(clippy::needless_lifetimes)]
    120
    		 
        ///Changes root folder
  • yara 0.16.2/src/internals/iterator.rs
    62
    		 
        // unsafe.
    63
    		 
        #[allow(clippy::needless_lifetimes)]
    64
    		 
        pub fn as_yara<'a>(&'a mut self) -> impl DerefMut<Target = YR_MEMORY_BLOCK_ITERATOR> + 'a {
    75
    		 
    impl<T: MemoryBlockIteratorSized> WrapperMemoryBlockIterator<T> {
    76
    		 
        #[allow(clippy::needless_lifetimes)]
    77
    		 
        pub fn as_yara_sized<'a>(
  • zephyrus 0.6.0/src/builder.rs
    36
    		 
        /// **SAFETY: The caller must ensure the type given is the same as the boxed one.**
    37
    		 
        #[allow(clippy::needless_lifetimes, clippy::borrow_deref_ref)]
    38
    		 
        pub fn cast<'a, T>(&'a self) -> Option<&'a T> {
  • zerovec 0.9.2/src/map/borrowed.rs
    277
    		 
        /// to `K::ULE` and `V::ULE`, in cases when `K` and `V` are fixed-size
    278
    		 
        #[allow(clippy::needless_lifetimes)] // Lifetime is necessary in impl Trait
    279
    		 
        pub fn iter_copied<'b: 'a>(&'b self) -> impl Iterator<Item = (K, V)> + 'b {
  • zerovec 0.9.2/src/map/map.rs
    467
    		 
        /// to `K::ULE` and `V::ULE`, in cases when `K` and `V` are fixed-size
    468
    		 
        #[allow(clippy::needless_lifetimes)] // Lifetime is necessary in impl Trait
    469
    		 
        pub fn iter_copied<'b>(&'b self) -> impl Iterator<Item = (K, V)> + 'b {
  • agilulf 0.1.0/src/lib.rs
    23
    		 
    #![feature(atomic_min_max)]
    24
    		 
    #![allow(clippy::needless_lifetimes)]
  • agilulf_driver 0.1.0/src/lib.rs
    22
    		 
    #![feature(test)]
    23
    		 
    #![allow(clippy::needless_lifetimes)]
  • agilulf_protocol 0.1.0/src/lib.rs
    13
    		 
    #![feature(test)]
    14
    		 
    #![allow(clippy::needless_lifetimes)]
    15
    		 
    #![feature(type_alias_enum_variants)]
  • amadeus-core 0.4.3/src/file/local.rs
    1
    		 
    #![allow(clippy::needless_lifetimes)]
  • assert2 0.3.8/src/lib.rs
    1
    		 
    #![cfg_attr(feature = "doc-cfg", feature(doc_cfg))]
    2
    		 
    #![allow(clippy::needless_lifetimes)]
  • async-condvar-fair 1.0.0/src/lib.rs
    5
    		 
    #![forbid(unsafe_code)]
    6
    		 
    #![allow(clippy::needless_lifetimes)] // these sometimes make things clearer
    7
    		 
    #![allow(clippy::option_map_unit_fn)] // suggestion is in poor taste
  • async-mq 1.1.0/examples/mqctl.rs
    418
    		 
            clippy::extra_unused_lifetimes,
    419
    		 
            clippy::needless_lifetimes,
    420
    		 
            clippy::redundant_closure,
  • awint_core 0.8.0/src/lib.rs
    17
    		 
    // We need to be certain in some places that lifetimes are being elided correctly
    18
    		 
    #![allow(clippy::needless_lifetimes)]
    19
    		 
    // There are many guaranteed nonzero lengths
  • awint_ext 0.8.0/src/lib.rs
    10
    		 
    // We need to be certain in some places that lifetimes are being elided correctly
    11
    		 
    #![allow(clippy::needless_lifetimes)]
    12
    		 
    // There are many guaranteed nonzero lengths
  • azure_sdk_storage_blob 0.45.3/src/lib.rs
    1
    		 
    #![recursion_limit = "128"]
    2
    		 
    #![allow(clippy::needless_lifetimes)]
  • azure_storage 0.9.0/src/lib.rs
    16
    		 
    #![recursion_limit = "256"]
    17
    		 
    #![allow(clippy::needless_lifetimes)]
    18
    		 
    #![allow(clippy::enum_variant_names)]
  • azure_storage_mirror 1.0.0/src/lib.rs
    1
    		 
    #![recursion_limit = "256"]
    2
    		 
    #![allow(clippy::needless_lifetimes)]
  • baryon-core 0.1.0/src/lib.rs
    8
    		 
        // Explicit lifetimes are often easier to reason about.
    9
    		 
        clippy::needless_lifetimes,
    10
    		 
        // No need for defaults in the internal types.
  • bevy-inspector-egui 0.17.0/src/lib.rs
    6
    		 
    #![allow(
    7
    		 
        clippy::needless_lifetimes, // can be good for clarity
    8
    		 
        clippy::needless_doctest_main, // sometimes a full copy-pasteable standalone example is better
  • blade-graphics 0.1.1/src/lib.rs
    6
    		 
        // Explicit lifetimes are often easier to reason about.
    7
    		 
        clippy::needless_lifetimes,
    8
    		 
        // No need for defaults in the internal types.
  • cargo-tally 1.0.22/src/main.rs
    9
    		 
        clippy::module_name_repetitions,
    10
    		 
        clippy::needless_lifetimes,
    11
    		 
        clippy::redundant_else,
  • coap-handler 0.1.4/src/helpers.rs
    8
    		 
        clippy::redundant_pattern_matching,
    9
    		 
        clippy::needless_lifetimes,
    10
    		 
        clippy::result_unit_err
  • coap-handler 0.1.4/src/implementations.rs
    8
    		 
    #![allow(
    9
    		 
        clippy::needless_lifetimes,
    10
    		 
        clippy::useless_conversion,
  • com_macros_support 0.6.0/src/lib.rs
    1
    		 
    #![allow(clippy::needless_lifetimes)]
    2
    		 
    #![allow(clippy::upper_case_acronyms)]
  • concread 0.4.1/src/lib.rs
    39
    		 
    #![warn(missing_docs)]
    40
    		 
    #![allow(clippy::needless_lifetimes)]
    41
    		 
    #![cfg_attr(feature = "simd_support", feature(portable_simd))]
  • content-tree 0.2.0/src/root.rs
    1
    		 
    #![allow(clippy::needless_lifetimes)] // Clippy doesn't understand the need for some lifetimes below
  • content-tree 0.2.0/src/safe_cursor.rs
    1
    		 
    #![allow(clippy::needless_lifetimes)] // Clippy doesn't understand the need for some lifetimes below
  • cretonne-codegen 0.13.2/src/lib.rs
    12
    		 
    // Produces many false positives, but did produce some valid lints, now fixed:
    13
    		 
                    needless_lifetimes,
    14
    		 
    // Generated code makes some style transgressions, but readability doesn't suffer much:
  • db-dump 0.4.1/src/lib.rs
    9
    		 
        clippy::must_use_candidate,
    10
    		 
        clippy::needless_lifetimes,
    11
    		 
        clippy::never_loop,
  • deflect 0.1.0/src/lib.rs
    75
    		 
    #![allow(clippy::len_without_is_empty, clippy::needless_lifetimes)]
    76
    		 
    #![deny(missing_docs)]
  • dhall 0.12.0/src/lib.rs
    4
    		 
        clippy::module_inception,
    5
    		 
        clippy::needless_lifetimes,
    6
    		 
        clippy::needless_question_mark,
  • diplomat_core 0.5.0/src/lib.rs
    6
    		 
    #![allow(clippy::needless_lifetimes)] // we use named lifetimes for clarity
  • distill-daemon 0.0.3/src/scope.rs
    1
    		 
    #![allow(clippy::needless_lifetimes)]
    2
    		 
    use std::{
  • ed25519-compact 2.0.4/src/lib.rs
    99
    		 
        clippy::let_and_return,
    100
    		 
        clippy::needless_lifetimes,
    101
    		 
        clippy::cast_lossless,
  • embedded-nal-async-std 0.1.1/src/tcp.rs
    1
    		 
    #![allow(clippy::needless_lifetimes)]
  • embedded-nal-async-std 0.1.1/src/udp.rs
    1
    		 
    #![allow(clippy::needless_lifetimes)]
  • fast-erasure-shake-rng 0.2.0/src/lib.rs
    227
    		 
    #![warn(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
    228
    		 
    #![allow(clippy::needless_lifetimes)]
  • field-offset 0.3.4/src/lib.rs
    5
    		 
    // which are too lax.
    6
    		 
    #![allow(clippy::needless_lifetimes)]
  • flowistry 0.5.34/src/lib.rs
    44
    		 
      clippy::single_match,
    45
    		 
      clippy::needless_lifetimes,
    46
    		 
      clippy::needless_return,
  • flowistry_ide 0.5.34/src/lib.rs
    3
    		 
      clippy::single_match,
    4
    		 
      clippy::needless_lifetimes,
    5
    		 
      clippy::needless_return,
  • fluence-fork-libp2p-kad 0.29.2/src/behaviour.rs
    23
    		 
    #![allow(clippy::needless_lifetimes)]
  • front-api 0.0.2/src/lib.rs
    58
    		 
    #![allow(missing_docs)]
    59
    		 
    #![allow(clippy::needless_lifetimes)]
    60
    		 
    #![cfg_attr(docsrs, feature(doc_cfg))]
  • futures-async-stream 0.2.6/tests/elisions.rs
    2
    		 
    #![allow(clippy::needless_pass_by_value)]
    3
    		 
    #![allow(clippy::needless_lifetimes)] // broken
    4
    		 
    #![feature(generators)]
  • futures-async-stream 0.2.6/tests/stream.rs
    2
    		 
    #![allow(clippy::unused_async)]
    3
    		 
    #![allow(clippy::needless_lifetimes, clippy::semicolon_if_nothing_returned)] // broken
    4
    		 
    #![feature(generators, proc_macro_hygiene, stmt_expr_attributes)]
  • fuzzcheck 0.12.1/src/lib.rs
    44
    		 
    #![allow(clippy::comparison_chain)]
    45
    		 
    #![allow(clippy::needless_lifetimes)]
    46
    		 
    #![allow(clippy::manual_map)]
  • golem-rpc-api 0.2.0/src/terms.rs
    1
    		 
    #![allow(clippy::needless_lifetimes)]
  • httpmock 0.6.7/src/api/mod.rs
    1
    		 
    // TODO: Remove this at some point
    2
    		 
    #![allow(clippy::needless_lifetimes)]
  • icu_capi 1.1.0/src/lib.rs
    17
    		 
    #![allow(clippy::upper_case_acronyms)]
    18
    		 
    #![allow(clippy::needless_lifetimes)]
    19
    		 
    #![allow(clippy::result_unit_err)]
  • image_hasher 1.1.2/src/alg/mod.rs
    1
    		 
    #![allow(clippy::needless_lifetimes)]
    2
    		 
    use crate::CowImage::*;
  • influxdb 0.5.2/src/lib.rs
    109
    		 
    #![allow(clippy::needless_doctest_main)]
    110
    		 
    #![allow(clippy::needless_lifetimes)] // False positive in client/mod.rs query fn
    111
    		 
    #![forbid(bare_trait_objects)]
  • inout 0.1.3/src/lib.rs
    9
    		 
    )]
    10
    		 
    #![allow(clippy::needless_lifetimes)]
    11
    		 
    #![cfg_attr(docsrs, feature(doc_cfg))]
  • jaylink 0.3.0/src/lib.rs
    78
    		 
    // We use explicit lifetimes to make APIs easier to understand (this also affects rustdoc)
    79
    		 
    #![allow(clippy::needless_lifetimes)]
  • juniper 0.15.11/src/integrations/chrono.rs
    17
    		 
    */
    18
    		 
    #![allow(clippy::needless_lifetimes)]
    19
    		 
    use chrono::prelude::*;
  • juniper 0.15.11/src/integrations/uuid.rs
    1
    		 
    #![allow(clippy::needless_lifetimes)]
  • juniper_puff 0.16.0-dev/src/integrations/uuid.rs
    3
    		 
    #![allow(clippy::needless_lifetimes)]
  • kas-text 0.6.0/src/lib.rs
    19
    		 
    #![allow(clippy::unit_arg)]
    20
    		 
    #![allow(clippy::needless_lifetimes)]
    21
    		 
    #![allow(clippy::neg_cmp_op_on_partial_ord)]
  • kittycad 0.2.2/src/lib.rs
    58
    		 
    #![allow(missing_docs)]
    59
    		 
    #![allow(clippy::needless_lifetimes)]
    60
    		 
    #![cfg_attr(docsrs, feature(doc_cfg))]
  • laundry5 0.1.0/src/main.rs
    1
    		 
    // https://github.com/rust-lang/rust-clippy/issues/7271
    2
    		 
    #![allow(clippy::needless_lifetimes)]
  • linkme 0.3.7/tests/fn_element.rs
    1
    		 
    #![cfg_attr(feature = "used_linker", feature(used_with_arg))]
    2
    		 
    #![allow(clippy::needless_lifetimes, clippy::trivially_copy_pass_by_ref)]
  • lsp-text 0.9.0/src/lib.rs
    2
    		 
    #![deny(unsafe_code)]
    3
    		 
    #![allow(clippy::needless_lifetimes)]
  • megra_rs 0.0.6/src/main.rs
    2
    		 
    #![allow(clippy::new_without_default)]
    3
    		 
    #![allow(clippy::needless_lifetimes)]
    4
    		 
    #![allow(clippy::large_enum_variant)]
  • melib 0.7.2/src/smtp.rs
    22
    		 
    #![allow(clippy::just_underscores_and_digits)]
    23
    		 
    #![allow(clippy::needless_lifetimes)]
  • millennium-core 1.0.0-beta.3/src/lib.rs
    163
    		 
    	clippy::option_map_unit_fn,
    164
    		 
    	clippy::needless_lifetimes,
    165
    		 
    	clippy::type_complexity,
  • minicbor 0.19.0/src/lib.rs
    126
    		 
    #![forbid(unused_imports, unused_variables)]
    127
    		 
    #![allow(clippy::needless_lifetimes)]
    128
    		 
    #![cfg_attr(not(feature = "std"), no_std)]
  • minisign 0.7.2/src/crypto/mod.rs
    5
    		 
        clippy::let_and_return,
    6
    		 
        clippy::needless_lifetimes,
    7
    		 
        clippy::cast_lossless,
  • msgpackin 0.0.3/src/types/producer.rs
    3
    		 
    // come on clippy... sometimes these help make more sense of things
    4
    		 
    #![allow(clippy::needless_lifetimes)]
  • multiversion 0.7.1/tests/generics.rs
    1
    		 
    #![allow(clippy::needless_lifetimes)]
  • numpy 0.18.0/src/lib.rs
    74
    		 
    // We often want to make the GIL lifetime explicit.
    75
    		 
    #![allow(clippy::needless_lifetimes)]
  • nvbit-rs 0.0.6/src/nvbit.rs
    1
    		 
    #![allow(clippy::needless_lifetimes)]
  • ockam_executor 0.41.0/src/runtime.rs
    1
    		 
    #![allow(missing_docs)]
    2
    		 
    #![allow(clippy::needless_lifetimes)]
  • pearl 0.17.0/src/benchmark/bin.rs
    1
    		 
    #![allow(clippy::needless_lifetimes)]
    2
    		 
    // #![warn(clippy::pedantic)]
  • pilka_ash 0.7.11/src/lib.rs
    9
    		 
        // Explicit lifetimes are often easier to reason about.
    10
    		 
        clippy::needless_lifetimes,
    11
    		 
        // No need for defaults in the internal types.
  • pilka_wgpu 0.7.11/src/lib.rs
    10
    		 
        // Explicit lifetimes are often easier to reason about.
    11
    		 
        clippy::needless_lifetimes,
    12
    		 
        // No need for defaults in the internal types.
  • pin-init 0.2.0/src/lib.rs
    6
    		 
    #![allow(clippy::should_implement_trait)]
    7
    		 
    #![allow(clippy::needless_lifetimes)]
  • pin-project 1.0.12/examples/enum-default-expanded.rs
    18
    		 
    #![allow(
    19
    		 
        clippy::needless_lifetimes,
    20
    		 
        clippy::just_underscores_and_digits,
  • pin-project 1.0.12/examples/not_unpin-expanded.rs
    21
    		 
    #![allow(dead_code, unused_imports, unused_parens, unknown_lints, renamed_and_removed_lints)]
    22
    		 
    #![allow(clippy::needless_lifetimes)]
  • pin-project 1.0.12/examples/pinned_drop-expanded.rs
    25
    		 
    #![allow(dead_code, unused_imports, unused_parens, unknown_lints, renamed_and_removed_lints)]
    26
    		 
    #![allow(clippy::needless_lifetimes, clippy::mut_mut)]
  • pin-project 1.0.12/examples/project_replace-expanded.rs
    18
    		 
    #![allow(dead_code, unused_imports, unused_parens, unknown_lints, renamed_and_removed_lints)]
    19
    		 
    #![allow(clippy::needless_lifetimes)]
  • pin-project 1.0.12/examples/struct-default-expanded.rs
    18
    		 
    #![allow(dead_code, unused_imports, unused_parens, unknown_lints, renamed_and_removed_lints)]
    19
    		 
    #![allow(clippy::needless_lifetimes)]
  • pin-project 1.0.12/examples/unsafe_unpin-expanded.rs
    20
    		 
    #![allow(dead_code, unused_imports, unused_parens, unknown_lints, renamed_and_removed_lints)]
    21
    		 
    #![allow(clippy::needless_lifetimes)]
  • posixmq 1.0.0/posixmq.rs
    227
    		 
    #![allow(clippy::needless_return, clippy::redundant_closure, clippy::needless_lifetimes)] // style
    228
    		 
    #![allow(clippy::range_plus_one)] // edge case: I think 1..x+1 is clearer than 1..=x
  • qvnt 0.5.0-alpha/src/qasm/int/mod.rs
    1
    		 
    #![allow(clippy::boxed_local)]
    2
    		 
    #![allow(clippy::needless_lifetimes)]
  • racc 0.0.3/src/lib.rs
    229
    		 
    #![warn(rust_2018_idioms)]
    230
    		 
    #![allow(clippy::needless_lifetimes)]
    231
    		 
    #![allow(clippy::cognitive_complexity)]
  • rink-core 0.6.2/src/lib.rs
    36
    		 
    #![allow(clippy::option_as_ref_deref)]
    37
    		 
    #![allow(clippy::needless_lifetimes)]
  • rquickjs-core 0.1.7/src/lib.rs
    6
    		 
    #![allow(clippy::needless_lifetimes)]
    7
    		 
    #![cfg_attr(feature = "doc-cfg", feature(doc_cfg))]
  • rustmq 1.0.0/examples/rustmq/main.rs
    402
    		 
            clippy::extra_unused_lifetimes,
    403
    		 
            clippy::needless_lifetimes,
    404
    		 
            clippy::redundant_closure,
  • secmem-proc 0.3.0/src/lib.rs
    5
    		 
    #![warn(clippy::must_use_candidate)]
    6
    		 
    #![allow(clippy::needless_lifetimes)]
    7
    		 
    //! `secmem-proc` is a crate designed to harden a process against
  • smt2parser 0.6.1/src/parser.rs
    6
    		 
    #![allow(clippy::upper_case_acronyms)]
    7
    		 
    #![allow(clippy::needless_lifetimes)]
  • snarkos-consensus 1.3.17/src/lib.rs
    34
    		 
    )]
    35
    		 
    #![allow(clippy::needless_lifetimes)]
    36
    		 
    #![forbid(unsafe_code)]
  • snocat 0.7.0/src/lib.rs
    18
    		 
    // GATs also present complications wherein this lint has not yet caught up to all nuance.
    19
    		 
    #![allow(clippy::needless_lifetimes)]
    20
    		 
    // Codebase policy prefers an explicit unit return when it clarifies intent,
  • spreadsheet-ods 0.15.0/src/refs_impl/mod.rs
    1
    		 
    #![allow(clippy::needless_lifetimes)]
  • starlark 0.8.0/src/lib.rs
    384
    		 
    #![allow(clippy::type_complexity)]
    385
    		 
    #![allow(clippy::needless_lifetimes)]
    386
    		 
    #![allow(clippy::comparison_to_empty)]
  • swash 0.1.6/src/lib.rs
    26
    		 
    #![allow(clippy::many_single_char_names)]
    27
    		 
    #![allow(clippy::needless_lifetimes)]
    28
    		 
    #![allow(clippy::redundant_static_lifetimes)]
  • swc_ecma_transforms_module 0.158.8/src/lib.rs
    2
    		 
    #![deny(unused)]
    3
    		 
    #![allow(clippy::needless_lifetimes)]
    4
    		 
    #![allow(clippy::vec_box)]
  • tao 0.17.0/src/lib.rs
    141
    		 
      clippy::option_map_unit_fn,
    142
    		 
      clippy::needless_lifetimes,
    143
    		 
      clippy::type_complexity,
  • thruster 1.3.0/src/lib.rs
    1
    		 
    #![allow(clippy::needless_lifetimes)]
    2
    		 
    #![allow(clippy::type_complexity)]
  • tulipv2-sdk-common 0.9.22/src/traits/mod.rs
    3
    		 
    #![allow(clippy::needless_lifetimes)]
    4
    		 
    #![allow(clippy::bool_assert_comparison)]
  • twilio-async 0.5.0/src/lib.rs
    6
    		 
        clippy::needless_doctest_main,
    7
    		 
        clippy::needless_lifetimes
    8
    		 
    )]
  • uapi 0.2.10/src/lib.rs
    4
    		 
        clippy::manual_non_exhaustive,
    5
    		 
        clippy::needless_lifetimes
    6
    		 
    )]
  • upon 0.6.0/src/filters/impls.rs
    3
    		 
    #![allow(clippy::needless_lifetimes)]
  • ux-charts 0.1.3/src/utils.rs
    2
    		 
    #![allow(unused_imports)]
    3
    		 
    #![allow(clippy::needless_lifetimes)]
  • wgpu-core 0.15.0/src/lib.rs
    16
    		 
        // Explicit lifetimes are often easier to reason about.
    17
    		 
        clippy::needless_lifetimes,
    18
    		 
        // No need for defaults in the internal types.
  • wgpu-hal 0.15.1/src/lib.rs
    27
    		 
        // Explicit lifetimes are often easier to reason about.
    28
    		 
        clippy::needless_lifetimes,
    29
    		 
        // No need for defaults in the internal types.
  • x11rb 0.11.1/src/protocol/mod.rs
    11
    		 
    // This is not easy to fix, so ignore it.
    12
    		 
    #![allow(clippy::needless_borrow, clippy::needless_lifetimes)]
    13
    		 
    pub mod xproto;
  • x11rb-protocol 0.11.1/src/protocol/mod.rs
    11
    		 
    // This is not easy to fix, so ignore it.
    12
    		 
    #![allow(clippy::needless_borrow, clippy::needless_lifetimes)]
  • yoke 0.7.0/src/lib.rs
    42
    		 
    // them out is good even when redundant
    43
    		 
    #![allow(clippy::needless_lifetimes)]
  • zerofrom 0.1.1/src/lib.rs
    24
    		 
    // them out is good even when redundant
    25
    		 
    #![allow(clippy::needless_lifetimes)]
  • zerovec 0.9.2/src/lib.rs
    211
    		 
    // is better here.
    212
    		 
    #![allow(clippy::needless_lifetimes)]