pretty: trim paths of unique symbols

If a symbol name can only be imported from one place for a type, and
as long as it was not glob-imported anywhere in the current crate, we
can trim its printed path and print only the name.

This has wide implications on error messages with types, for example,
shortening `std::vec::Vec` to just `Vec`, as long as there is no other
`Vec` importable anywhere.

This adds a new '-Z trim-diagnostic-paths=false' option to control this
feature.

On the good path, with no diagnosis printed, we should try to avoid
issuing this query, so we need to prevent trimmed_def_paths query on
several cases.

This change also relies on a previous commit that differentiates
between `Debug` and `Display` on various rustc types, where the latter
is trimmed and presented to the user and the former is not.

1 files changed, 28 insertions, 28 deletions

diff --git a/src/test/pretty/issue-4264.pp b/src/test/pretty/issue-4264.pp
index 0e45b6f04a8..7b0a00282fb 100644
--- a/src/test/pretty/issue-4264.pp
+++ b/src/test/pretty/issue-4264.pp
@@ -32,34 +32,34 @@ pub fn bar() ({
                   ({
                        let res =
                            ((::alloc::fmt::format as
-                                for<'r> fn(std::fmt::Arguments<'r>) -> std::string::String {std::fmt::format})(((::core::fmt::Arguments::new_v1
-                                                                                                                    as
-                                                                                                                    fn(&[&'static str], &[std::fmt::ArgumentV1]) -> std::fmt::Arguments {std::fmt::Arguments::new_v1})((&([("test"
-                                                                                                                                                                                                                               as
-                                                                                                                                                                                                                               &str)]
-                                                                                                                                                                                                                             as
-                                                                                                                                                                                                                             [&str; 1])
-                                                                                                                                                                                                                           as
-                                                                                                                                                                                                                           &[&str; 1]),
-                                                                                                                                                                                                                       (&(match (()
-                                                                                                                                                                                                                                    as
-                                                                                                                                                                                                                                    ())
-                                                                                                                                                                                                                              {
-                                                                                                                                                                                                                              ()
-                                                                                                                                                                                                                              =>
-                                                                                                                                                                                                                              ([]
-                                                                                                                                                                                                                                  as
-                                                                                                                                                                                                                                  [std::fmt::ArgumentV1; 0]),
-                                                                                                                                                                                                                          }
-                                                                                                                                                                                                                             as
-                                                                                                                                                                                                                             [std::fmt::ArgumentV1; 0])
-                                                                                                                                                                                                                           as
-                                                                                                                                                                                                                           &[std::fmt::ArgumentV1; 0]))
-                                                                                                                   as
-                                                                                                                   std::fmt::Arguments))
-                               as std::string::String);
-                       (res as std::string::String)
-                   } as std::string::String);
+                                for<'r> fn(Arguments<'r>) -> String {format})(((::core::fmt::Arguments::new_v1
+                                                                                   as
+                                                                                   fn(&[&'static str], &[ArgumentV1]) -> Arguments {Arguments::new_v1})((&([("test"
+                                                                                                                                                                as
+                                                                                                                                                                &str)]
+                                                                                                                                                              as
+                                                                                                                                                              [&str; 1])
+                                                                                                                                                            as
+                                                                                                                                                            &[&str; 1]),
+                                                                                                                                                        (&(match (()
+                                                                                                                                                                     as
+                                                                                                                                                                     ())
+                                                                                                                                                               {
+                                                                                                                                                               ()
+                                                                                                                                                               =>
+                                                                                                                                                               ([]
+                                                                                                                                                                   as
+                                                                                                                                                                   [ArgumentV1; 0]),
+                                                                                                                                                           }
+                                                                                                                                                              as
+                                                                                                                                                              [ArgumentV1; 0])
+                                                                                                                                                            as
+                                                                                                                                                            &[ArgumentV1; 0]))
+                                                                                  as
+                                                                                  Arguments))
+                               as String);
+                       (res as String)
+                   } as String);
               } as ())
 pub type Foo = [i32; (3 as usize)];
 pub struct Bar {