Print regions in type_name.

Currently they are skipped, which is a bit weird, and it sometimes
causes malformed output like `Foo<>` and `dyn Bar<, A = u32>`.

Most regions are erased by the time `type_name` does its work. Erased
regions are now printed as `'_` in non-optional places. Bound regions
can also occur, and they are now printed as `'0`, `'1`, etc.

The commit also renames `should_print_region` as
`should_print_optional_region`, which makes it clearer that it only
applies to some regions.

Fixes #145168.

Author: nnethercote

compiler/rustc_const_eval/src/util/type_name.rs

@@ -5,7 +5,7 @@ use rustc_hir::def_id::CrateNum;
 use rustc_hir::definitions::DisambiguatedDefPathData;
 use rustc_middle::bug;
 use rustc_middle::ty::print::{PrettyPrinter, PrintError, Printer};
-use rustc_middle::ty::{self, GenericArg, GenericArgKind, Ty, TyCtxt};
+use rustc_middle::ty::{self, GenericArg, Ty, TyCtxt};
 
 struct AbsolutePathPrinter<'tcx> {
     tcx: TyCtxt<'tcx>,
@@ -17,10 +17,17 @@ impl<'tcx> Printer<'tcx> for AbsolutePathPrinter<'tcx> {
         self.tcx
     }
 
-    fn print_region(&mut self, _region: ty::Region<'_>) -> Result<(), PrintError> {
-        // This is reachable (via `pretty_print_dyn_existential`) even though
-        // `<Self As PrettyPrinter>::should_print_region` returns false. See #144994.
-        Ok(())
+    fn print_region(&mut self, region: ty::Region<'_>) -> Result<(), PrintError> {
+        match region.kind() {
+            ty::ReErased => write!(self, "'_"),
+
+            // Because of this, `type_name::<dyn for<'a> Fn(&'a u32)>` will
+            // produce "dyn core::ops::function::Fn(&'0 u32)", which isn't
+            // great but probably better than omitting the lifetime.
+            ty::ReBound(_, b) => write!(self, "'{}", b.var.as_u32()),
+
+            _ => unreachable!(),
+        }
     }
 
     fn print_type(&mut self, ty: Ty<'tcx>) -> Result<(), PrintError> {
@@ -125,8 +132,7 @@ impl<'tcx> Printer<'tcx> for AbsolutePathPrinter<'tcx> {
         args: &[GenericArg<'tcx>],
     ) -> Result<(), PrintError> {
         print_prefix(self)?;
-        let args =
-            args.iter().cloned().filter(|arg| !matches!(arg.kind(), GenericArgKind::Lifetime(_)));
+        let args = args.iter().cloned();
         if args.clone().next().is_some() {
             self.generic_delimiters(|cx| cx.comma_sep(args))
         } else {
@@ -136,8 +142,12 @@ impl<'tcx> Printer<'tcx> for AbsolutePathPrinter<'tcx> {
 }
 
 impl<'tcx> PrettyPrinter<'tcx> for AbsolutePathPrinter<'tcx> {
-    fn should_print_region(&self, _region: ty::Region<'_>) -> bool {
-        false
+    fn should_print_optional_region(&self, _region: ty::Region<'_>) -> bool {
+        match _region.kind() {
+            ty::ReErased => false,
+            ty::ReBound(..) => true,
+            _ => unreachable!(),
+        }
     }
 
     fn generic_delimiters(

compiler/rustc_middle/src/ty/print/pretty.rs

@@ -333,10 +333,10 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
         f: impl FnOnce(&mut Self) -> Result<(), PrintError>,
     ) -> Result<(), PrintError>;
 
-    /// Returns `true` if the region should be printed in
-    /// optional positions, e.g., `&'a T` or `dyn Tr + 'b`.
-    /// This is typically the case for all non-`'_` regions.
-    fn should_print_region(&self, region: ty::Region<'tcx>) -> bool;
+    /// Returns `true` if the region should be printed in optional positions,
+    /// e.g., `&'a T` or `dyn Tr + 'b`. (Regions like the one in `Cow<'static, T>`
+    /// will always be printed.)
+    fn should_print_optional_region(&self, region: ty::Region<'tcx>) -> bool;
 
     fn reset_type_limit(&mut self) {}
 
@@ -710,7 +710,7 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
             }
             ty::Ref(r, ty, mutbl) => {
                 write!(self, "&")?;
-                if self.should_print_region(r) {
+                if self.should_print_optional_region(r) {
                     r.print(self)?;
                     write!(self, " ")?;
                 }
@@ -778,7 +778,7 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
             },
             ty::Adt(def, args) => self.print_def_path(def.did(), args)?,
             ty::Dynamic(data, r, repr) => {
-                let print_r = self.should_print_region(r);
+                let print_r = self.should_print_optional_region(r);
                 if print_r {
                     write!(self, "(")?;
                 }
@@ -2487,7 +2487,7 @@ impl<'tcx> PrettyPrinter<'tcx> for FmtPrinter<'_, 'tcx> {
         Ok(())
     }
 
-    fn should_print_region(&self, region: ty::Region<'tcx>) -> bool {
+    fn should_print_optional_region(&self, region: ty::Region<'tcx>) -> bool {
         let highlight = self.region_highlight_mode;
         if highlight.region_highlighted(region).is_some() {
             return true;

compiler/rustc_symbol_mangling/src/legacy.rs

@@ -235,7 +235,8 @@ impl<'tcx> Printer<'tcx> for SymbolPrinter<'tcx> {
 
     fn print_region(&mut self, _region: ty::Region<'_>) -> Result<(), PrintError> {
         // This might be reachable (via `pretty_print_dyn_existential`) even though
-        // `<Self As PrettyPrinter>::should_print_region` returns false. See #144994.
+        // `<Self As PrettyPrinter>::should_print_optional_region` returns false and
+        // `path_generic_args` filters out lifetimes. See #144994.
         Ok(())
     }
 
@@ -386,7 +387,6 @@ impl<'tcx> Printer<'tcx> for SymbolPrinter<'tcx> {
 
         let args =
             args.iter().cloned().filter(|arg| !matches!(arg.kind(), GenericArgKind::Lifetime(_)));
-
         if args.clone().next().is_some() {
             self.generic_delimiters(|cx| cx.comma_sep(args))
         } else {
@@ -456,7 +456,7 @@ impl<'tcx> Printer<'tcx> for SymbolPrinter<'tcx> {
 }
 
 impl<'tcx> PrettyPrinter<'tcx> for SymbolPrinter<'tcx> {
-    fn should_print_region(&self, _region: ty::Region<'_>) -> bool {
+    fn should_print_optional_region(&self, _region: ty::Region<'_>) -> bool {
         false
     }
 

library/core/src/any.rs

@@ -835,9 +835,9 @@ impl fmt::Debug for TypeId {
 ///
 /// The returned string must not be considered to be a unique identifier of a
 /// type as multiple types may map to the same type name. Similarly, there is no
-/// guarantee that all parts of a type will appear in the returned string: for
-/// example, lifetime specifiers are currently not included. In addition, the
-/// output may change between versions of the compiler.
+/// guarantee that all parts of a type will appear in the returned string. In
+/// addition, the output may change between versions of the compiler. For
+/// example, lifetime specifiers were omitted in some earlier versions.
 ///
 /// The current implementation uses the same infrastructure as compiler
 /// diagnostics and debuginfo, but this is not guaranteed.

tests/ui/type/type-name-basic.rs

@@ -62,28 +62,31 @@ pub fn main() {
 
     t!(Vec<Vec<u32>>, "alloc::vec::Vec<alloc::vec::Vec<u32>>");
     t!(Foo<usize>, "type_name_basic::Foo<usize>");
-    t!(Bar<'static>, "type_name_basic::Bar");
-    t!(Baz<'static, u32>, "type_name_basic::Baz<u32>");
+    t!(Bar<'static>, "type_name_basic::Bar<'_>");
+    t!(Baz<'static, u32>, "type_name_basic::Baz<'_, u32>");
 
-    // FIXME: lifetime omission means these all print badly.
-    t!(dyn TrL<'static>, "dyn type_name_basic::TrL<>");
-    t!(dyn TrLA<'static, A = u32>, "dyn type_name_basic::TrLA<, A = u32>");
+    t!(dyn TrL<'static>, "dyn type_name_basic::TrL<'_>");
+    t!(dyn TrLA<'static, A = u32>, "dyn type_name_basic::TrLA<'_, A = u32>");
     t!(
         dyn TrLT<'static, Cow<'static, ()>>,
-        "dyn type_name_basic::TrLT<, alloc::borrow::Cow<()>>"
+        "dyn type_name_basic::TrLT<'_, alloc::borrow::Cow<'_, ()>>"
     );
     t!(
         dyn TrLTA<'static, u32, A = Cow<'static, ()>>,
-        "dyn type_name_basic::TrLTA<, u32, A = alloc::borrow::Cow<()>>"
+        "dyn type_name_basic::TrLTA<'_, u32, A = alloc::borrow::Cow<'_, ()>>"
     );
 
     t!(fn(i32) -> i32, "fn(i32) -> i32");
-    t!(dyn for<'a> Fn(&'a u32), "dyn core::ops::function::Fn(&u32)");
+
+    // FIXME: these are sub-optimal, ideally the `for<...>` would be printed.
+    t!(dyn Fn(&'static u32), "dyn core::ops::function::Fn(&u32)");
+    t!(dyn for<'a> Fn(&'a u32), "dyn core::ops::function::Fn(&'0 u32)");
+    t!(dyn for<'a, 'b> Fn(&'a u32, &'b u32), "dyn core::ops::function::Fn(&'0 u32, &'1 u32)");
 
     struct S<'a, T>(&'a T);
     impl<'a, T: Clone> S<'a, T> {
         fn test() {
-            t!(Cow<'a, T>, "alloc::borrow::Cow<u32>");
+            t!(Cow<'a, T>, "alloc::borrow::Cow<'_, u32>");
         }
     }
     S::<u32>::test();