Distinguish hidden and anonymous lifetimes in references in HIR

An upcoming lint will want to be able to know if a reference has a
hidden lifetime (`&u8`) or an anonymous lifetime (`&'_ u8`). The code
previously treated hidden lifetimes as anonymous.

To preserve diagnostic quality, lifetime suggestions now need to know
if they are in the context of a reference or a path, as there is
different syntax for each. For example, a reference changes from `&u8`
to `&'a u8` (add a space with no comma), while a path changes from `T`
to `T<'a>` (add angle brackets) or `T<X>` to `T<'a, X>` (add a comma
and a space).

There's a minor ugliness introduced to -Zunpretty=hir output, as
there's a non-idiomatic space character introduced after the
ampersand, but it's called unpretty for a reason!

Author: shepmaster

compiler/rustc_ast_lowering/src/lib.rs

@@ -1206,7 +1206,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                         self.next_node_id()
                     };
                     let span = self.tcx.sess.source_map().start_point(t.span).shrink_to_hi();
-                    Lifetime { ident: Ident::new(kw::UnderscoreLifetime, span), id }
+                    Lifetime { ident: Ident::new(kw::Empty, span), id }
                 });
                 let lifetime = self.lower_lifetime(&region);
                 hir::TyKind::Ref(lifetime, self.lower_mt(mt, itctx))
@@ -1222,7 +1222,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                         self.next_node_id()
                     };
                     let span = self.tcx.sess.source_map().start_point(t.span).shrink_to_hi();
-                    Lifetime { ident: Ident::new(kw::UnderscoreLifetime, span), id }
+                    Lifetime { ident: Ident::new(kw::Empty, span), id }
                 });
                 let lifetime = self.lower_lifetime(&region);
                 let kind = hir::TyKind::Ref(lifetime, self.lower_mt(mt, itctx));

compiler/rustc_hir/src/hir.rs

@@ -161,9 +161,11 @@ impl Lifetime {
         self.ident.name == kw::Empty || self.ident.name == kw::UnderscoreLifetime
     }
 
-    pub fn suggestion_position(&self) -> (LifetimeSuggestionPosition, Span) {
+    pub fn suggestion_position(&self, is_ref: bool) -> (LifetimeSuggestionPosition, Span) {
         if self.ident.name == kw::Empty {
-            if self.ident.span.is_empty() {
+            if is_ref {
+                (LifetimeSuggestionPosition::Ampersand, self.ident.span)
+            } else if self.ident.span.is_empty() {
                 (LifetimeSuggestionPosition::ElidedPathArgument, self.ident.span)
             } else {
                 (LifetimeSuggestionPosition::ElidedPath, self.ident.span.shrink_to_hi())
@@ -177,9 +179,9 @@ impl Lifetime {
         }
     }
 
-    pub fn suggestion(&self, new_lifetime: &str) -> (Span, String) {
+    pub fn suggestion(&self, new_lifetime: &str, is_ref: bool) -> (Span, String) {
         debug_assert!(new_lifetime.starts_with('\''));
-        let (pos, span) = self.suggestion_position();
+        let (pos, span) = self.suggestion_position(is_ref);
         let code = match pos {
             LifetimeSuggestionPosition::Normal => format!("{new_lifetime}"),
             LifetimeSuggestionPosition::Ampersand => format!("{new_lifetime} "),

compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs

@@ -64,6 +64,7 @@ struct BoundVarContext<'a, 'tcx> {
     tcx: TyCtxt<'tcx>,
     rbv: &'a mut ResolveBoundVars,
     scope: ScopeRef<'a>,
+    is_ref: bool,
 }
 
 #[derive(Debug)]
@@ -245,8 +246,12 @@ pub(crate) fn provide(providers: &mut Providers) {
 #[instrument(level = "debug", skip(tcx))]
 fn resolve_bound_vars(tcx: TyCtxt<'_>, local_def_id: hir::OwnerId) -> ResolveBoundVars {
     let mut rbv = ResolveBoundVars::default();
-    let mut visitor =
-        BoundVarContext { tcx, rbv: &mut rbv, scope: &Scope::Root { opt_parent_item: None } };
+    let mut visitor = BoundVarContext {
+        tcx,
+        rbv: &mut rbv,
+        scope: &Scope::Root { opt_parent_item: None },
+        is_ref: false,
+    };
     match tcx.hir_owner_node(local_def_id) {
         hir::OwnerNode::Item(item) => visitor.visit_item(item),
         hir::OwnerNode::ForeignItem(item) => visitor.visit_foreign_item(item),
@@ -648,7 +653,7 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {
         match *arg {
             hir::PreciseCapturingArg::Lifetime(lt) => match lt.res {
                 LifetimeName::Param(def_id) => {
-                    self.resolve_lifetime_ref(def_id, lt);
+                    self.resolve_lifetime_ref(def_id, lt, false);
                 }
                 LifetimeName::Error => {}
                 LifetimeName::ImplicitObjectLifetimeDefault
@@ -701,6 +706,8 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {
 
     #[instrument(level = "debug", skip(self))]
     fn visit_ty(&mut self, ty: &'tcx hir::Ty<'tcx, AmbigArg>) {
+        let old_is_ref = self.is_ref;
+
         match ty.kind {
             hir::TyKind::BareFn(c) => {
                 let (mut bound_vars, binders): (FxIndexMap<LocalDefId, ResolvedArg>, Vec<_>) = c
@@ -797,6 +804,7 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {
                 }
             }
             hir::TyKind::Ref(lifetime_ref, ref mt) => {
+                self.is_ref = true;
                 self.visit_lifetime(lifetime_ref);
                 let scope = Scope::ObjectLifetimeDefault {
                     lifetime: self.rbv.defs.get(&lifetime_ref.hir_id.local_id).cloned(),
@@ -821,6 +829,8 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {
             }
             _ => intravisit::walk_ty(self, ty),
         }
+
+        self.is_ref = old_is_ref;
     }
 
     #[instrument(level = "debug", skip(self))]
@@ -878,7 +888,7 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {
                 self.insert_lifetime(lifetime_ref, ResolvedArg::StaticLifetime)
             }
             hir::LifetimeName::Param(param_def_id) => {
-                self.resolve_lifetime_ref(param_def_id, lifetime_ref)
+                self.resolve_lifetime_ref(param_def_id, lifetime_ref, self.is_ref)
             }
             // If we've already reported an error, just ignore `lifetime_ref`.
             hir::LifetimeName::Error => {}
@@ -888,6 +898,9 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {
     }
 
     fn visit_path(&mut self, path: &hir::Path<'tcx>, hir_id: HirId) {
+        let old_is_ref = self.is_ref;
+        self.is_ref = false;
+
         for (i, segment) in path.segments.iter().enumerate() {
             let depth = path.segments.len() - i - 1;
             if let Some(args) = segment.args {
@@ -897,6 +910,8 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {
         if let Res::Def(DefKind::TyParam | DefKind::ConstParam, param_def_id) = path.res {
             self.resolve_type_ref(param_def_id.expect_local(), hir_id);
         }
+
+        self.is_ref = old_is_ref;
     }
 
     fn visit_fn(
@@ -1092,7 +1107,7 @@ impl<'a, 'tcx> BoundVarContext<'a, 'tcx> {
         F: for<'b> FnOnce(&mut BoundVarContext<'b, 'tcx>),
     {
         let BoundVarContext { tcx, rbv, .. } = self;
-        let mut this = BoundVarContext { tcx: *tcx, rbv, scope: &wrap_scope };
+        let mut this = BoundVarContext { tcx: *tcx, rbv, scope: &wrap_scope, is_ref: false };
         let span = debug_span!("scope", scope = ?this.scope.debug_truncated());
         {
             let _enter = span.enter();
@@ -1201,6 +1216,7 @@ impl<'a, 'tcx> BoundVarContext<'a, 'tcx> {
         &mut self,
         region_def_id: LocalDefId,
         lifetime_ref: &'tcx hir::Lifetime,
+        is_ref: bool,
     ) {
         // Walk up the scope chain, tracking the number of fn scopes
         // that we pass through, until we find a lifetime with the
@@ -1266,7 +1282,7 @@ impl<'a, 'tcx> BoundVarContext<'a, 'tcx> {
                                     (generics.span, "<'a>".to_owned())
                                 };
 
-                            let lifetime_sugg = lifetime_ref.suggestion("'a");
+                            let lifetime_sugg = lifetime_ref.suggestion("'a", is_ref);
                             let suggestions = vec![lifetime_sugg, new_param_sugg];
 
                             diag.span_label(

compiler/rustc_trait_selection/src/error_reporting/infer/region.rs

@@ -853,14 +853,42 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
             needle: hir::LifetimeName,
             new_lt: &'a str,
             add_lt_suggs: &'a mut Vec<(Span, String)>,
+            is_ref: bool,
         }
 
         impl<'hir> hir::intravisit::Visitor<'hir> for LifetimeReplaceVisitor<'_> {
             fn visit_lifetime(&mut self, lt: &'hir hir::Lifetime) {
                 if lt.res == self.needle {
-                    self.add_lt_suggs.push(lt.suggestion(self.new_lt));
+                    self.add_lt_suggs.push(lt.suggestion(self.new_lt, self.is_ref));
                 }
             }
+
+            fn visit_ty(
+                &mut self,
+                ty: &'hir rustc_hir::Ty<'hir, rustc_hir::AmbigArg>,
+            ) -> Self::Result {
+                use rustc_hir::TyKind::*;
+
+                let old_is_ref = self.is_ref;
+
+                match ty.kind {
+                    Ref(..) => {
+                        self.is_ref = true;
+                    }
+
+                    Path(..) => {
+                        self.is_ref = false;
+                    }
+
+                    InferDelegation(..) | Slice(..) | Array(..) | Ptr(..) | BareFn(..)
+                    | UnsafeBinder(..) | Never | Tup(..) | OpaqueDef(..) | TraitAscription(..)
+                    | TraitObject(..) | Typeof(..) | Err(..) | Pat(..) | Infer(..) => {}
+                }
+
+                rustc_hir::intravisit::walk_ty(self, ty);
+
+                self.is_ref = old_is_ref;
+            }
         }
 
         let (lifetime_def_id, lifetime_scope) = match self
@@ -897,6 +925,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
             needle: hir::LifetimeName::Param(lifetime_def_id),
             add_lt_suggs,
             new_lt: &new_lt,
+            is_ref: false,
         };
         match self.tcx.expect_hir_owner_node(lifetime_scope) {
             hir::OwnerNode::Item(i) => visitor.visit_item(i),

compiler/rustc_trait_selection/src/errors.rs

@@ -551,15 +551,6 @@ impl Subdiagnostic for AddLifetimeParamsSuggestion<'_> {
 
             impl<'v> Visitor<'v> for ImplicitLifetimeFinder {
                 fn visit_ty(&mut self, ty: &'v hir::Ty<'v, AmbigArg>) {
-                    let make_suggestion = |ident: Ident| {
-                        if ident.name == kw::Empty && ident.span.is_empty() {
-                            format!("{}, ", self.suggestion_param_name)
-                        } else if ident.name == kw::UnderscoreLifetime && ident.span.is_empty() {
-                            format!("{} ", self.suggestion_param_name)
-                        } else {
-                            self.suggestion_param_name.clone()
-                        }
-                    };
                     match ty.kind {
                         hir::TyKind::Path(hir::QPath::Resolved(_, path)) => {
                             for segment in path.segments {
@@ -587,9 +578,9 @@ impl Subdiagnostic for AddLifetimeParamsSuggestion<'_> {
                                             if let hir::GenericArg::Lifetime(lifetime) = arg
                                                 && lifetime.is_anonymous()
                                             {
-                                                self.suggestions.push((
-                                                    lifetime.ident.span,
-                                                    make_suggestion(lifetime.ident),
+                                                self.suggestions.push(lifetime.suggestion(
+                                                    &self.suggestion_param_name,
+                                                    false,
                                                 ));
                                             }
                                         }
@@ -599,7 +590,7 @@ impl Subdiagnostic for AddLifetimeParamsSuggestion<'_> {
                         }
                         hir::TyKind::Ref(lifetime, ..) if lifetime.is_anonymous() => {
                             self.suggestions
-                                .push((lifetime.ident.span, make_suggestion(lifetime.ident)));
+                                .push(lifetime.suggestion(&self.suggestion_param_name, true));
                         }
                         _ => {}
                     }

tests/ui/unpretty/debug-fmt-hir.stdout

@@ -13,13 +13,13 @@ struct Bar {
 }
 
 impl fmt::Debug for Bar {
-    fn fmt(&self, f: &'_ mut fmt::Formatter<'_>)
+    fn fmt(&self, f: & mut fmt::Formatter<'_>)
         ->
             fmt::Result {
         debug_struct_field2_finish(f, "Bar", "a", &self.a, "b", &&self.b)
     }
 }
 
-fn debug_struct_field2_finish<'a>(name: &'_ str, name1: &'_ str,
-    value1: &'a dyn fmt::Debug, name2: &'_ str, value2: &'a dyn fmt::Debug)
+fn debug_struct_field2_finish<'a>(name: & str, name1: & str,
+    value1: &'a dyn fmt::Debug, name2: & str, value2: &'a dyn fmt::Debug)
     -> fmt::Result { loop { } }