rustc: fix ty::print for symbol mangling.

Author: eddyb

src/librustc/hir/map/definitions.rs

@@ -660,13 +660,13 @@ impl DefPathData {
                 return name
             }
             // note that this does not show up in user printouts
-            CrateRoot => "{{root}}",
+            CrateRoot => "{{crate}}",
             Impl => "{{impl}}",
-            Misc => "{{?}}",
+            Misc => "{{misc}}",
             ClosureExpr => "{{closure}}",
             StructCtor => "{{constructor}}",
             AnonConst => "{{constant}}",
-            ImplTrait => "{{impl-Trait}}",
+            ImplTrait => "{{opaque}}",
         };
 
         Symbol::intern(s).as_interned_str()

src/librustc/infer/error_reporting/mod.rs

@@ -446,6 +446,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
         sp: Span,
     ) {
         use hir::def_id::CrateNum;
+        use hir::map::DisambiguatedDefPathData;
         use ty::print::Printer;
         use ty::subst::Kind;
 
@@ -505,6 +506,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
             fn path_append_impl(
                 self,
                 _print_prefix: impl FnOnce(Self) -> Result<Self::Path, Self::Error>,
+                _disambiguated_data: &DisambiguatedDefPathData,
                 _self_ty: Ty<'tcx>,
                 _trait_ref: Option<ty::TraitRef<'tcx>>,
             ) -> Result<Self::Path, Self::Error> {
@@ -513,10 +515,10 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
             fn path_append(
                 self,
                 print_prefix: impl FnOnce(Self) -> Result<Self::Path, Self::Error>,
-                text: &str,
+                disambiguated_data: &DisambiguatedDefPathData,
             ) -> Result<Self::Path, Self::Error> {
                 let mut path = print_prefix(self)?;
-                path.push(text.to_string());
+                path.push(disambiguated_data.data.as_interned_str().to_string());
                 Ok(path)
             }
             fn path_generic_args(
@@ -534,7 +536,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
             if !(did1.is_local() || did2.is_local()) && did1.krate != did2.krate {
                 let abs_path = |def_id| {
                     AbsolutePathPrinter { tcx: self.tcx }
-                        .print_def_path(def_id, None)
+                        .print_def_path(def_id, &[])
                 };
 
                 // We compare strings because DefPath can be different

src/librustc/mir/mod.rs

@@ -2382,7 +2382,7 @@ impl<'tcx> Debug for Rvalue<'tcx> {
                         ty::tls::with(|tcx| {
                             let substs = tcx.lift(&substs).expect("could not lift for printing");
                             FmtPrinter::new(tcx, f, Namespace::ValueNS)
-                                .print_def_path(variant_def.did, Some(substs))?;
+                                .print_def_path(variant_def.did, substs)?;
                             Ok(())
                         })?;
 

src/librustc/ty/instance.rs

@@ -178,7 +178,7 @@ impl<'tcx> fmt::Display for Instance<'tcx> {
         ty::tls::with(|tcx| {
             let substs = tcx.lift(&self.substs).expect("could not lift for printing");
             FmtPrinter::new(tcx, &mut *f, Namespace::ValueNS)
-                .print_def_path(self.def_id(), Some(substs))?;
+                .print_def_path(self.def_id(), substs)?;
             Ok(())
         })?;
 

src/librustc/ty/print/mod.rs

@@ -1,7 +1,7 @@
-use hir::map::DefPathData;
+use hir::map::{DefPathData, DisambiguatedDefPathData};
 use hir::def_id::{CrateNum, DefId};
 use ty::{self, DefIdTree, Ty, TyCtxt};
-use ty::subst::{Kind, Subst, Substs};
+use ty::subst::{Kind, Subst};
 
 use rustc_data_structures::fx::FxHashSet;
 
@@ -29,14 +29,14 @@ pub trait Printer<'gcx: 'tcx, 'tcx>: Sized {
     fn print_def_path(
         self,
         def_id: DefId,
-        substs: Option<&'tcx Substs<'tcx>>,
+        substs: &'tcx [Kind<'tcx>],
     ) -> Result<Self::Path, Self::Error> {
         self.default_print_def_path(def_id, substs)
     }
     fn print_impl_path(
         self,
         impl_def_id: DefId,
-        substs: Option<&'tcx Substs<'tcx>>,
+        substs: &'tcx [Kind<'tcx>],
         self_ty: Ty<'tcx>,
         trait_ref: Option<ty::TraitRef<'tcx>>,
     ) -> Result<Self::Path, Self::Error> {
@@ -71,13 +71,14 @@ pub trait Printer<'gcx: 'tcx, 'tcx>: Sized {
     fn path_append_impl(
         self,
         print_prefix: impl FnOnce(Self) -> Result<Self::Path, Self::Error>,
+        disambiguated_data: &DisambiguatedDefPathData,
         self_ty: Ty<'tcx>,
         trait_ref: Option<ty::TraitRef<'tcx>>,
     ) -> Result<Self::Path, Self::Error>;
     fn path_append(
         self,
         print_prefix: impl FnOnce(Self) -> Result<Self::Path, Self::Error>,
-        text: &str,
+        disambiguated_data: &DisambiguatedDefPathData,
     ) -> Result<Self::Path, Self::Error>;
     fn path_generic_args(
         self,
@@ -90,7 +91,7 @@ pub trait Printer<'gcx: 'tcx, 'tcx>: Sized {
     fn default_print_def_path(
         self,
         def_id: DefId,
-        substs: Option<&'tcx Substs<'tcx>>,
+        substs: &'tcx [Kind<'tcx>],
     ) -> Result<Self::Path, Self::Error> {
         debug!("default_print_def_path: def_id={:?}, substs={:?}", def_id, substs);
         let key = self.tcx().def_key(def_id);
@@ -103,69 +104,69 @@ pub trait Printer<'gcx: 'tcx, 'tcx>: Sized {
             }
 
             DefPathData::Impl => {
+                let generics = self.tcx().generics_of(def_id);
                 let mut self_ty = self.tcx().type_of(def_id);
-                if let Some(substs) = substs {
-                    self_ty = self_ty.subst(self.tcx(), substs);
-                }
-
                 let mut impl_trait_ref = self.tcx().impl_trait_ref(def_id);
-                if let Some(substs) = substs {
+                if substs.len() >= generics.count() {
+                    self_ty = self_ty.subst(self.tcx(), substs);
                     impl_trait_ref = impl_trait_ref.subst(self.tcx(), substs);
                 }
                 self.print_impl_path(def_id, substs, self_ty, impl_trait_ref)
             }
 
             _ => {
-                let generics = substs.map(|_| self.tcx().generics_of(def_id));
-                let generics_parent = generics.as_ref().and_then(|g| g.parent);
                 let parent_def_id = DefId { index: key.parent.unwrap(), ..def_id };
-                let print_parent_path = |cx: Self| {
-                    if let Some(generics_parent_def_id) = generics_parent {
-                        assert_eq!(parent_def_id, generics_parent_def_id);
-
-                        // FIXME(eddyb) try to move this into the parent's printing
-                        // logic, instead of doing it when printing the child.
-                        let parent_generics = cx.tcx().generics_of(parent_def_id);
-                        let parent_has_own_self =
-                            parent_generics.has_self && parent_generics.parent_count == 0;
-                        if let (Some(substs), true) = (substs, parent_has_own_self) {
-                            let trait_ref = ty::TraitRef::new(parent_def_id, substs);
-                            cx.path_qualified(trait_ref.self_ty(), Some(trait_ref))
-                        } else {
-                            cx.print_def_path(parent_def_id, substs)
-                        }
-                    } else {
-                        cx.print_def_path(parent_def_id, None)
-                    }
-                };
-                let print_path = |cx: Self| {
+
+                let mut parent_substs = substs;
+                let mut trait_qualify_parent = false;
+                if !substs.is_empty() {
+                    let generics = self.tcx().generics_of(def_id);
+                    parent_substs = &substs[..generics.parent_count.min(substs.len())];
+
                     match key.disambiguated_data.data {
-                        // Skip `::{{constructor}}` on tuple/unit structs.
-                        DefPathData::StructCtor => print_parent_path(cx),
-
-                        _ => {
-                            cx.path_append(
-                                print_parent_path,
-                                &key.disambiguated_data.data.as_interned_str().as_str(),
-                            )
+                        // Closures' own generics are only captures, don't print them.
+                        DefPathData::ClosureExpr => {}
+
+                        // If we have any generic arguments to print, we do that
+                        // on top of the same path, but without its own generics.
+                        _ => if !generics.params.is_empty() && substs.len() >= generics.count() {
+                            let args = self.generic_args_to_print(generics, substs);
+                            return self.path_generic_args(
+                                |cx| cx.print_def_path(def_id, parent_substs),
+                                args,
+                            );
                         }
                     }
-                };
 
-                if let (Some(generics), Some(substs)) = (generics, substs) {
-                    let args = self.generic_args_to_print(generics, substs);
-                    self.path_generic_args(print_path, args)
-                } else {
-                    print_path(self)
+                    // FIXME(eddyb) try to move this into the parent's printing
+                    // logic, instead of doing it when printing the child.
+                    trait_qualify_parent =
+                        generics.has_self &&
+                        generics.parent == Some(parent_def_id) &&
+                        parent_substs.len() == generics.parent_count &&
+                        self.tcx().generics_of(parent_def_id).parent_count == 0;
                 }
+
+                self.path_append(
+                    |cx: Self| if trait_qualify_parent {
+                        let trait_ref = ty::TraitRef::new(
+                            parent_def_id,
+                            cx.tcx().intern_substs(parent_substs),
+                        );
+                        cx.path_qualified(trait_ref.self_ty(), Some(trait_ref))
+                    } else {
+                        cx.print_def_path(parent_def_id, parent_substs)
+                    },
+                    &key.disambiguated_data,
+                )
             }
         }
     }
 
     fn generic_args_to_print(
         &self,
         generics: &'tcx ty::Generics,
-        substs: &'tcx Substs<'tcx>,
+        substs: &'tcx [Kind<'tcx>],
     ) -> &'tcx [Kind<'tcx>] {
         let mut own_params = generics.parent_count..generics.count();
 
@@ -192,19 +193,21 @@ pub trait Printer<'gcx: 'tcx, 'tcx>: Sized {
     fn default_print_impl_path(
         self,
         impl_def_id: DefId,
-        _substs: Option<&'tcx Substs<'tcx>>,
+        _substs: &'tcx [Kind<'tcx>],
         self_ty: Ty<'tcx>,
         impl_trait_ref: Option<ty::TraitRef<'tcx>>,
     ) -> Result<Self::Path, Self::Error> {
         debug!("default_print_impl_path: impl_def_id={:?}, self_ty={}, impl_trait_ref={:?}",
                impl_def_id, self_ty, impl_trait_ref);
 
+        let key = self.tcx().def_key(impl_def_id);
+        let parent_def_id = DefId { index: key.parent.unwrap(), ..impl_def_id };
+
         // Decide whether to print the parent path for the impl.
         // Logically, since impls are global, it's never needed, but
         // users may find it useful. Currently, we omit the parent if
         // the impl is either in the same module as the self-type or
         // as the trait.
-        let parent_def_id = self.tcx().parent(impl_def_id).unwrap();
         let in_self_mod = match characteristic_def_id_of_type(self_ty) {
             None => false,
             Some(ty_def_id) => self.tcx().parent(ty_def_id) == Some(parent_def_id),
@@ -219,7 +222,8 @@ pub trait Printer<'gcx: 'tcx, 'tcx>: Sized {
             // trait-type, then fallback to a format that identifies
             // the module more clearly.
             self.path_append_impl(
-                |cx| cx.print_def_path(parent_def_id, None),
+                |cx| cx.print_def_path(parent_def_id, &[]),
+                &key.disambiguated_data,
                 self_ty,
                 impl_trait_ref,
             )