tests/ui/needless_lifetimes.rs

   1 #![warn(clippy::needless_lifetimes)]
   2 #![allow(dead_code, clippy::needless_pass_by_value, clippy::unnecessary_wraps)]
   3
   4 fn distinct_lifetimes<'a, 'b>(_x: &'a u8, _y: &'b u8, _z: u8) {}
   5
   6 fn distinct_and_static<'a, 'b>(_x: &'a u8, _y: &'b u8, _z: &'static u8) {}
   7
   8 // No error; same lifetime on two params.
   9 fn same_lifetime_on_input<'a>(_x: &'a u8, _y: &'a u8) {}
  10
  11 // No error; static involved.
  12 fn only_static_on_input(_x: &u8, _y: &u8, _z: &'static u8) {}
  13
  14 fn mut_and_static_input(_x: &mut u8, _y: &'static str) {}
  15
  16 fn in_and_out<'a>(x: &'a u8, _y: u8) -> &'a u8 {
  17     x
  18 }
  19
  20 // No error; multiple input refs.
  21 fn multiple_in_and_out_1<'a>(x: &'a u8, _y: &'a u8) -> &'a u8 {
  22     x
  23 }
  24
  25 // No error; multiple input refs.
  26 fn multiple_in_and_out_2<'a, 'b>(x: &'a u8, _y: &'b u8) -> &'a u8 {
  27     x
  28 }
  29
  30 // No error; static involved.
  31 fn in_static_and_out<'a>(x: &'a u8, _y: &'static u8) -> &'a u8 {
  32     x
  33 }
  34
  35 // No error.
  36 fn deep_reference_1<'a, 'b>(x: &'a u8, _y: &'b u8) -> Result<&'a u8, ()> {
  37     Ok(x)
  38 }
  39
  40 // No error; two input refs.
  41 fn deep_reference_2<'a>(x: Result<&'a u8, &'a u8>) -> &'a u8 {
  42     x.unwrap()
  43 }
  44
  45 fn deep_reference_3<'a>(x: &'a u8, _y: u8) -> Result<&'a u8, ()> {
  46     Ok(x)
  47 }
  48
  49 // Where-clause, but without lifetimes.
  50 fn where_clause_without_lt<'a, T>(x: &'a u8, _y: u8) -> Result<&'a u8, ()>
  51 where
  52     T: Copy,
  53 {
  54     Ok(x)
  55 }
  56
  57 type Ref<'r> = &'r u8;
  58
  59 // No error; same lifetime on two params.
  60 fn lifetime_param_1<'a>(_x: Ref<'a>, _y: &'a u8) {}
  61
  62 fn lifetime_param_2<'a, 'b>(_x: Ref<'a>, _y: &'b u8) {}
  63
  64 // No error; bounded lifetime.
  65 fn lifetime_param_3<'a, 'b: 'a>(_x: Ref<'a>, _y: &'b u8) {}
  66
  67 // No error; bounded lifetime.
  68 fn lifetime_param_4<'a, 'b>(_x: Ref<'a>, _y: &'b u8)
  69 where
  70     'b: 'a,
  71 {
  72 }
  73
  74 struct Lt<'a, I: 'static> {
  75     x: &'a I,
  76 }
  77
  78 // No error; fn bound references `'a`.
  79 fn fn_bound<'a, F, I>(_m: Lt<'a, I>, _f: F) -> Lt<'a, I>
  80 where
  81     F: Fn(Lt<'a, I>) -> Lt<'a, I>,
  82 {
  83     unreachable!()
  84 }
  85
  86 fn fn_bound_2<'a, F, I>(_m: Lt<'a, I>, _f: F) -> Lt<'a, I>
  87 where
  88     for<'x> F: Fn(Lt<'x, I>) -> Lt<'x, I>,
  89 {
  90     unreachable!()
  91 }
  92
  93 // No error; see below.
  94 fn fn_bound_3<'a, F: FnOnce(&'a i32)>(x: &'a i32, f: F) {
  95     f(x);
  96 }
  97
  98 fn fn_bound_3_cannot_elide() {
  99     let x = 42;
 100     let p = &x;
 101     let mut q = &x;
 102     // This will fail if we elide lifetimes of `fn_bound_3`.
 103     fn_bound_3(p, |y| q = y);
 104 }
 105
 106 // No error; multiple input refs.
 107 fn fn_bound_4<'a, F: FnOnce() -> &'a ()>(cond: bool, x: &'a (), f: F) -> &'a () {
 108     if cond { x } else { f() }
 109 }
 110
 111 struct X {
 112     x: u8,
 113 }
 114
 115 impl X {
 116     fn self_and_out<'s>(&'s self) -> &'s u8 {
 117         &self.x
 118     }
 119
 120     // No error; multiple input refs.
 121     fn self_and_in_out<'s, 't>(&'s self, _x: &'t u8) -> &'s u8 {
 122         &self.x
 123     }
 124
 125     fn distinct_self_and_in<'s, 't>(&'s self, _x: &'t u8) {}
 126
 127     // No error; same lifetimes on two params.
 128     fn self_and_same_in<'s>(&'s self, _x: &'s u8) {}
 129 }
 130
 131 struct Foo<'a>(&'a u8);
 132
 133 impl<'a> Foo<'a> {
 134     // No error; lifetime `'a` not defined in method.
 135     fn self_shared_lifetime(&self, _: &'a u8) {}
 136     // No error; bounds exist.
 137     fn self_bound_lifetime<'b: 'a>(&self, _: &'b u8) {}
 138 }
 139
 140 fn already_elided<'a>(_: &u8, _: &'a u8) -> &'a u8 {
 141     unimplemented!()
 142 }
 143
 144 fn struct_with_lt<'a>(_foo: Foo<'a>) -> &'a str {
 145     unimplemented!()
 146 }
 147
 148 // No warning; two input lifetimes (named on the reference, anonymous on `Foo`).
 149 fn struct_with_lt2<'a>(_foo: &'a Foo) -> &'a str {
 150     unimplemented!()
 151 }
 152
 153 // No warning; two input lifetimes (anonymous on the reference, named on `Foo`).
 154 fn struct_with_lt3<'a>(_foo: &Foo<'a>) -> &'a str {
 155     unimplemented!()
 156 }
 157
 158 // No warning; two input lifetimes.
 159 fn struct_with_lt4<'a, 'b>(_foo: &'a Foo<'b>) -> &'a str {
 160     unimplemented!()
 161 }
 162
 163 trait WithLifetime<'a> {}
 164
 165 type WithLifetimeAlias<'a> = dyn WithLifetime<'a>;
 166
 167 // Should not warn because it won't build without the lifetime.
 168 fn trait_obj_elided<'a>(_arg: &'a dyn WithLifetime) -> &'a str {
 169     unimplemented!()
 170 }
 171
 172 // Should warn because there is no lifetime on `Drop`, so this would be
 173 // unambiguous if we elided the lifetime.
 174 fn trait_obj_elided2<'a>(_arg: &'a dyn Drop) -> &'a str {
 175     unimplemented!()
 176 }
 177
 178 type FooAlias<'a> = Foo<'a>;
 179
 180 fn alias_with_lt<'a>(_foo: FooAlias<'a>) -> &'a str {
 181     unimplemented!()
 182 }
 183
 184 // No warning; two input lifetimes (named on the reference, anonymous on `FooAlias`).
 185 fn alias_with_lt2<'a>(_foo: &'a FooAlias) -> &'a str {
 186     unimplemented!()
 187 }
 188
 189 // No warning; two input lifetimes (anonymous on the reference, named on `FooAlias`).
 190 fn alias_with_lt3<'a>(_foo: &FooAlias<'a>) -> &'a str {
 191     unimplemented!()
 192 }
 193
 194 // No warning; two input lifetimes.
 195 fn alias_with_lt4<'a, 'b>(_foo: &'a FooAlias<'b>) -> &'a str {
 196     unimplemented!()
 197 }
 198
 199 fn named_input_elided_output<'a>(_arg: &'a str) -> &str {
 200     unimplemented!()
 201 }
 202
 203 fn elided_input_named_output<'a>(_arg: &str) -> &'a str {
 204     unimplemented!()
 205 }
 206
 207 fn trait_bound_ok<'a, T: WithLifetime<'static>>(_: &'a u8, _: T) {
 208     unimplemented!()
 209 }
 210 fn trait_bound<'a, T: WithLifetime<'a>>(_: &'a u8, _: T) {
 211     unimplemented!()
 212 }
 213
 214 // Don't warn on these; see issue #292.
 215 fn trait_bound_bug<'a, T: WithLifetime<'a>>() {
 216     unimplemented!()
 217 }
 218
 219 // See issue #740.
 220 struct Test {
 221     vec: Vec<usize>,
 222 }
 223
 224 impl Test {
 225     fn iter<'a>(&'a self) -> Box<dyn Iterator<Item = usize> + 'a> {
 226         unimplemented!()
 227     }
 228 }
 229
 230 trait LintContext<'a> {}
 231
 232 fn f<'a, T: LintContext<'a>>(_: &T) {}
 233
 234 fn test<'a>(x: &'a [u8]) -> u8 {
 235     let y: &'a u8 = &x[5];
 236     *y
 237 }
 238
 239 // Issue #3284: give hint regarding lifetime in return type.
 240 struct Cow<'a> {
 241     x: &'a str,
 242 }
 243 fn out_return_type_lts<'a>(e: &'a str) -> Cow<'a> {
 244     unimplemented!()
 245 }
 246
 247 // Make sure we still warn on implementations
 248 mod issue4291 {
 249     trait BadTrait {
 250         fn needless_lt<'a>(x: &'a u8) {}
 251     }
 252
 253     impl BadTrait for () {
 254         fn needless_lt<'a>(_x: &'a u8) {}
 255     }
 256 }
 257
 258 mod issue2944 {
 259     trait Foo {}
 260     struct Bar {}
 261     struct Baz<'a> {
 262         bar: &'a Bar,
 263     }
 264
 265     impl<'a> Foo for Baz<'a> {}
 266     impl Bar {
 267         fn baz<'a>(&'a self) -> impl Foo + 'a {
 268             Baz { bar: self }
 269         }
 270     }
 271 }
 272
 273 mod nested_elision_sites {
 274     // issue #issue2944
 275
 276     // closure trait bounds subject to nested elision
 277     // don't lint because they refer to outer lifetimes
 278     fn trait_fn<'a>(i: &'a i32) -> impl Fn() -> &'a i32 {
 279         move || i
 280     }
 281     fn trait_fn_mut<'a>(i: &'a i32) -> impl FnMut() -> &'a i32 {
 282         move || i
 283     }
 284     fn trait_fn_once<'a>(i: &'a i32) -> impl FnOnce() -> &'a i32 {
 285         move || i
 286     }
 287
 288     // don't lint
 289     fn impl_trait_in_input_position<'a>(f: impl Fn() -> &'a i32) -> &'a i32 {
 290         f()
 291     }
 292     fn impl_trait_in_output_position<'a>(i: &'a i32) -> impl Fn() -> &'a i32 {
 293         move || i
 294     }
 295     // lint
 296     fn impl_trait_elidable_nested_named_lifetimes<'a>(i: &'a i32, f: impl for<'b> Fn(&'b i32) -> &'b i32) -> &'a i32 {
 297         f(i)
 298     }
 299     fn impl_trait_elidable_nested_anonymous_lifetimes<'a>(i: &'a i32, f: impl Fn(&i32) -> &i32) -> &'a i32 {
 300         f(i)
 301     }
 302
 303     // don't lint
 304     fn generics_not_elidable<'a, T: Fn() -> &'a i32>(f: T) -> &'a i32 {
 305         f()
 306     }
 307     // lint
 308     fn generics_elidable<'a, T: Fn(&i32) -> &i32>(i: &'a i32, f: T) -> &'a i32 {
 309         f(i)
 310     }
 311
 312     // don't lint
 313     fn where_clause_not_elidable<'a, T>(f: T) -> &'a i32
 314     where
 315         T: Fn() -> &'a i32,
 316     {
 317         f()
 318     }
 319     // lint
 320     fn where_clause_elidadable<'a, T>(i: &'a i32, f: T) -> &'a i32
 321     where
 322         T: Fn(&i32) -> &i32,
 323     {
 324         f(i)
 325     }
 326
 327     // don't lint
 328     fn pointer_fn_in_input_position<'a>(f: fn(&'a i32) -> &'a i32, i: &'a i32) -> &'a i32 {
 329         f(i)
 330     }
 331     fn pointer_fn_in_output_position<'a>(_: &'a i32) -> fn(&'a i32) -> &'a i32 {
 332         |i| i
 333     }
 334     // lint
 335     fn pointer_fn_elidable<'a>(i: &'a i32, f: fn(&i32) -> &i32) -> &'a i32 {
 336         f(i)
 337     }
 338
 339     // don't lint
 340     fn nested_fn_pointer_1<'a>(_: &'a i32) -> fn(fn(&'a i32) -> &'a i32) -> i32 {
 341         |f| 42
 342     }
 343     fn nested_fn_pointer_2<'a>(_: &'a i32) -> impl Fn(fn(&'a i32)) {
 344         |f| ()
 345     }
 346
 347     // lint
 348     fn nested_fn_pointer_3<'a>(_: &'a i32) -> fn(fn(&i32) -> &i32) -> i32 {
 349         |f| 42
 350     }
 351     fn nested_fn_pointer_4<'a>(_: &'a i32) -> impl Fn(fn(&i32)) {
 352         |f| ()
 353     }
 354 }
 355
 356 mod issue6159 {
 357     use std::ops::Deref;
 358     pub fn apply_deref<'a, T, F, R>(x: &'a T, f: F) -> R
 359     where
 360         T: Deref,
 361         F: FnOnce(&'a T::Target) -> R,
 362     {
 363         f(x.deref())
 364     }
 365 }
 366
 367 fn main() {}