rustc: pretty-print impl Trait on-demand in ty_param_name.

Author: eddyb

src/librustc/ty/mod.rs

@@ -42,7 +42,7 @@ use session::DataTypeKind;
 use serialize::{self, Encodable, Encoder};
 use std::cell::RefCell;
 use std::cmp::{self, Ordering};
-use std::fmt;
+use std::fmt::{self, Write};
 use std::hash::{Hash, Hasher};
 use std::ops::Deref;
 use rustc_data_structures::sync::{self, Lrc, ParallelIterator, par_iter};
@@ -2640,37 +2640,63 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
     pub fn ty_param_name(self, id: DefId) -> InternedString {
         let def_key = self.def_key(id);
         match def_key.disambiguated_data.data {
-            DefPathData::TypeParam(name) => name,
             DefPathData::ImplTrait => {
-                let param_owner_def_id = DefId {
+                // HACK(eddyb) on-demand pretty-printing of `impl Trait`
+                // parameters - hopefully this is not used too often.
+
+                // Grab the "TraitA + TraitB" from `impl TraitA + TraitB`, by
+                // looking up the predicates associated with the owner's def_id.
+                let predicates_of_owner = self.predicates_of(DefId {
                     krate: id.krate,
                     index: def_key.parent.unwrap()
-                };
-                let generics = self.generics_of(param_owner_def_id);
-                let index = generics.param_def_id_to_index[&id];
-                generics.param_at(index, self).name
+                });
+
+                let mut first = true;
+                let mut is_sized = false;
+                let mut s = String::from("impl");
+                for predicate in predicates_of_owner.predicates {
+                    if let Some(trait_ref) = predicate.to_opt_poly_trait_ref() {
+                        // Ignore bounds other than those on this parameter.
+                        match trait_ref.self_ty().sty {
+                            ty::TyParam(p) if p.def_id == id => {}
+                            _ => continue,
+                        }
+
+                        // Don't print +Sized, but rather +?Sized if absent.
+                        if Some(trait_ref.def_id()) == self.lang_items().sized_trait() {
+                            is_sized = true;
+                            continue;
+                        }
+
+                        let _ = write!(s, "{}{}", if first { " " } else { "+" }, trait_ref);
+                        first = false;
+                    }
+                }
+                if !is_sized {
+                    let _ = write!(s, "{}?Sized", if first { " " } else { "+" });
+                }
+
+                Symbol::intern(&s).as_interned_str()
             }
             DefPathData::Trait(_) => {
                 keywords::SelfType.name().as_interned_str()
             }
             DefPathData::ClosureExpr => {
                 Symbol::intern("<synthetic closure param>").as_interned_str()
             }
-            _ => bug!("ty_param_name: {:?} not a type parameter", id),
+            data => data.as_interned_str()
         }
     }
 
     pub fn ty_param_owner(self, id: DefId) -> DefId {
         let def_key = self.def_key(id);
         match def_key.disambiguated_data.data {
-            DefPathData::ImplTrait |
-            DefPathData::TypeParam(_) => DefId {
+            DefPathData::Trait(_) |
+            DefPathData::ClosureExpr => id,
+            _ => DefId {
                 krate: id.krate,
                 index: def_key.parent.unwrap()
             },
-            DefPathData::Trait(_) |
-            DefPathData::ClosureExpr => id,
-            _ => bug!("ty_param_owner: {:?} not a type parameter", id),
         }
     }
 

src/librustc/util/ppaux.rs

@@ -1124,7 +1124,7 @@ define_print! {
                             return Ok(());
                         }
                         // Grab the "TraitA + TraitB" from `impl TraitA + TraitB`,
-                        // by looking up the projections associated with the def_id.
+                        // by looking up the predicates associated with the def_id.
                         let predicates_of = tcx.predicates_of(def_id);
                         let substs = tcx.lift(&substs).unwrap_or_else(|| {
                             tcx.intern_substs(&[])

src/test/ui/impl-trait/impl-generic-mismatch-ab.stderr

@@ -5,10 +5,10 @@ LL |     fn foo<A: Debug>(&self, a: &A, b: &impl Debug);
    |                                -- type in trait
 ...
 LL |     fn foo<B: Debug>(&self, a: &impl Debug, b: &B) { }
-   |                                ^^^^^^^^^^^ expected `B` parameter, found `impl Debug` parameter
+   |                                ^^^^^^^^^^^ expected `B` parameter, found `impl std::fmt::Debug` parameter
    |
-   = note: expected type `fn(&(), &B, &impl Debug)`
-              found type `fn(&(), &impl Debug, &B)`
+   = note: expected type `fn(&(), &B, &impl std::fmt::Debug)`
+              found type `fn(&(), &impl std::fmt::Debug, &B)`
 
 error: aborting due to previous error
 

src/test/ui/impl-trait/universal-mismatched-type.stderr

@@ -4,10 +4,10 @@ error[E0308]: mismatched types
 LL | fn foo(x: impl Debug) -> String {
    |                          ------ expected `std::string::String` because of return type
 LL |     x //~ ERROR mismatched types
-   |     ^ expected struct `std::string::String`, found `impl Debug` parameter
+   |     ^ expected struct `std::string::String`, found `impl std::fmt::Debug` parameter
    |
    = note: expected type `std::string::String`
-              found type `impl Debug`
+              found type `impl std::fmt::Debug`
 
 error: aborting due to previous error
 

src/test/ui/impl-trait/universal-two-impl-traits.stderr

@@ -2,10 +2,10 @@ error[E0308]: mismatched types
   --> $DIR/universal-two-impl-traits.rs:15:9
    |
 LL |     a = y; //~ ERROR mismatched
-   |         ^ expected `impl Debug` parameter, found a different `impl Debug` parameter
+   |         ^ expected `impl std::fmt::Debug` parameter, found a different `impl std::fmt::Debug` parameter
    |
-   = note: expected type `impl Debug` (`impl Debug` parameter)
-              found type `impl Debug` (`impl Debug` parameter)
+   = note: expected type `impl std::fmt::Debug` (`impl std::fmt::Debug` parameter)
+              found type `impl std::fmt::Debug` (`impl std::fmt::Debug` parameter)
 
 error: aborting due to previous error