In-band lifetimes: Lint against single-use lifetime names

[nikomatsakis]

Once support for '_ lands in #44691, the next step for #44524 is to implement a lint that warns against "single use" lifetime names.

Current status

The lint is partially implemented but needs to be completed. Here is a checklist:

• Issue warnings at the right times; this gist provides a comprehensive test case.
  • "Warning: never used at all" falls under unused_lifetimes
• For each warning, issue a suggested fix:
  • For a single-use lifetime 'a appearing in &'a T, suggest &T
  • For a single-use lifetime 'a appearing in any other place, suggest '_
  • One challenge: the binder must be removed too
    • cc @estebank -- is it possible to give suggested fixes that make changes to multiple spots at once? I guess that might just be multiple suggestions?
• [] We'll know this is really done when we can enable by default in rustc crates and apply rustfix with suggestions

Older Background

The idea is that an explicit name like 'a should only be used (at least in a function or impl) to link together two things. Otherwise, you should just use '_ to indicate that the lifetime is not linked to anything.

Until #15872 is closed, we should only lint for single-use lifetime names that are bound in functions. Once #15872 is closed, we can also lint against those found in impl headers.

We can detect cases where a lint is valid by modifying the resolve_lifetimes code:

• This code basically walks over the HIR and resolves all lifetime names.
• It maintains a stack of scopes indicating what names are valid.
• The function with() is used to push new scopes on the stack. It is also given a closure which will execute with the new name bindings in scope.
  • with() gets called for impls and other kinds of items from here; for methods and functions in particular it is called from visit_early_late).
• Once a name is in scope, resolve_lifetime_ref() is called to resolve an actual reference to a named lifetime.
  • This could be used, for example, to update some information in the Scope, e.g. counting how many times a particular lifetime was referenced.
• Then, before with() returns, we could scan the lifetimes and check for those that were only referenced 1 time (or 0 times...) and issue a lint warning.

(There are some directions for how to add a lint under the header "Issuing future compatibility warnings" in the rustc-bug-fix-procedure page on forge -- we can skip the "future compatibility" parts here.)

[cramertj]

we should only lint for single-use lifetime names that are bound in functions

Also, I believe, only for lifetime names that appear in argument position. Currently we require explicitly binding output-only lifetimes with a name:

fn bar<'a>() -> &'a u8 { &5 } // OK
fn bar() -> &'_ u8 { &5 } // ERROR: missing lifetime specifier

[nikomatsakis]

@cramertj Hmm. I would consider the proper way to declare bar() to probably be fn bar() -> &'static u8, really, though there are subtleties involved in rare cases (e.g., around invariance).

[cramertj]

@nikomatsakis Yes, 'static is the right thing to use. I wanted to point out that we shouldn't recommend '_ here, as it won't work.

[gaurikholkar-zz]

Is this up for grabs?

[cramertj]

@gaurikholkar Go for it!

[gaurikholkar-zz]

Will start working on it

[nikomatsakis]

@gaurikholkar hey, just checking in! How's it going? Any blockers?

[nikomatsakis]

Some examples:

fn foo<'x>(_: &'x u32) { }

This should lint against 'x and suggest &u32 instead.

struct Foo<'a> { x: &'a u32 }
fn foo<'x>(_: Foo<'x>) { }

This should lint against 'x and suggest Foo<'_> instead.

struct Foo<'a, 'b> { f: &'a &'b u32 }
fn foo<'x, 'y>(foo: Foo<'x, 'y>) -> &'x u32 { foo.f }

This should lint against 'y and suggest Foo<'x, '_> instead.

struct Foo<'a, 'b> { f: &'a &'b u32 }
fn foo<'x, 'y>(foo: Foo<'x, 'y>) -> &'y u32 { foo.f }

This should lint against 'x and suggest Foo<'_, 'y> instead.

fn foo<'x>() -> &'x u32 { &22 }

This should not lint, because 'x appears only in the return type.

trait Trait<'a> { }
impl<'a, T> Trait<'a> for T { }

fn foo<'x, T>(t: T)
where T: Trait<'x>
{ 
}

fn main() { 
  foo(22);
}

This should not lint, because at present '_ does not work in that position (which we should fix).