rustc: keep the DefId of type parameters in types (ParamTy).

Author: eddyb

src/librustc/ich/impls_ty.rs

@@ -940,6 +940,7 @@ for ty::FloatVid
 
 impl_stable_hash_for!(struct ty::ParamTy {
     idx,
+    def_id,
     name
 });
 

src/librustc/infer/error_reporting/mod.rs

@@ -1112,36 +1112,30 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
     {
         // Attempt to obtain the span of the parameter so we can
         // suggest adding an explicit lifetime bound to it.
-        let type_param_span = match (self.in_progress_tables, bound_kind) {
-            (Some(ref table), GenericKind::Param(ref param)) => {
-                let table = table.borrow();
-                table.local_id_root.and_then(|did| {
-                    let generics = self.tcx.generics_of(did);
-                    let type_param = generics.type_param(param, self.tcx);
-                    let hir = &self.tcx.hir;
-                    hir.as_local_node_id(type_param.def_id).and_then(|id| {
-                        // Get the `hir::Param` to verify whether it already has any bounds.
-                        // We do this to avoid suggesting code that ends up as `T: 'a'b`,
-                        // instead we suggest `T: 'a + 'b` in that case.
-                        // Also, `Self` isn't in the HIR so we rule it out here.
-                        if let hir_map::NodeGenericParam(ref hir_param) = hir.get(id) {
-                            let has_bounds = !hir_param.bounds.is_empty();
-                            let sp = hir.span(id);
-                            // `sp` only covers `T`, change it so that it covers
-                            // `T:` when appropriate
-                            let sp = if has_bounds {
-                                sp.to(self.tcx
-                                    .sess
-                                    .source_map()
-                                    .next_point(self.tcx.sess.source_map().next_point(sp)))
-                            } else {
-                                sp
-                            };
-                            Some((sp, has_bounds))
+        let type_param_span = match bound_kind {
+            GenericKind::Param(ref param) => {
+                self.tcx.hir.as_local_node_id(param.def_id).and_then(|id| {
+                    // Get the `hir::Param` to verify whether it already has any bounds.
+                    // We do this to avoid suggesting code that ends up as `T: 'a'b`,
+                    // instead we suggest `T: 'a + 'b` in that case.
+                    // Also, `Self` isn't in the HIR so we rule it out here.
+                    if let hir_map::NodeGenericParam(ref hir_param) = self.tcx.hir.get(id) {
+                        let has_bounds = !hir_param.bounds.is_empty();
+                        let sp = self.tcx.hir.span(id);
+                        // `sp` only covers `T`, change it so that it covers
+                        // `T:` when appropriate
+                        let sp = if has_bounds {
+                            sp.to(self.tcx
+                                .sess
+                                .source_map()
+                                .next_point(self.tcx.sess.source_map().next_point(sp)))
                         } else {
-                            None
-                        }
-                    })
+                            sp
+                        };
+                        Some((sp, has_bounds))
+                    } else {
+                        None
+                    }
                 })
             }
             _ => None,

src/librustc/traits/object_safety.rs

@@ -169,7 +169,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
         trait_def_id: DefId,
         supertraits_only: bool) -> bool
     {
-        let trait_self_ty = self.mk_self_type();
+        let trait_self_ty = self.mk_self_type(trait_def_id);
         let trait_ref = ty::Binder::dummy(ty::TraitRef::identity(self, trait_def_id));
         let predicates = if supertraits_only {
             self.super_predicates_of(trait_def_id)
@@ -203,11 +203,11 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
     }
 
     fn trait_has_sized_self(self, trait_def_id: DefId) -> bool {
-        self.generics_require_sized_self(trait_def_id)
+        self.generics_require_sized_self(trait_def_id, trait_def_id)
     }
 
-    fn generics_require_sized_self(self, def_id: DefId) -> bool {
-        let trait_self_ty = self.mk_self_type();
+    fn generics_require_sized_self(self, trait_def_id: DefId, def_id: DefId) -> bool {
+        let trait_self_ty = self.mk_self_type(trait_def_id);
         let sized_def_id = match self.lang_items().sized_trait() {
             Some(def_id) => def_id,
             None => { return false; /* No Sized trait, can't require it! */ }
@@ -245,7 +245,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
     {
         // Any method that has a `Self : Sized` requisite is otherwise
         // exempt from the regulations.
-        if self.generics_require_sized_self(method.def_id) {
+        if self.generics_require_sized_self(trait_def_id, method.def_id) {
             return None;
         }
 
@@ -262,7 +262,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
                                  -> bool
     {
         // Any method that has a `Self : Sized` requisite can't be called.
-        if self.generics_require_sized_self(method.def_id) {
+        if self.generics_require_sized_self(trait_def_id, method.def_id) {
             return false;
         }
 
@@ -290,7 +290,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
 
         let sig = self.fn_sig(method.def_id);
 
-        let self_ty = self.mk_self_type();
+        let self_ty = self.mk_self_type(trait_def_id);
         let self_arg_ty = sig.skip_binder().inputs()[0];
         if let ExplicitSelf::Other = ExplicitSelf::determine(self_arg_ty, |ty| ty == self_ty) {
             return Some(MethodViolationCode::NonStandardSelfType);
@@ -371,7 +371,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
         // object type, and we cannot resolve `Self as SomeOtherTrait`
         // without knowing what `Self` is.
 
-        let trait_self_ty = self.mk_self_type();
+        let trait_self_ty = self.mk_self_type(trait_def_id);
         let mut supertraits: Option<Vec<ty::PolyTraitRef<'tcx>>> = None;
         let mut error = false;
         ty.maybe_walk(|ty| {

src/librustc/traits/util.rs

@@ -213,7 +213,7 @@ impl<'cx, 'gcx, 'tcx> Elaborator<'cx, 'gcx, 'tcx> {
                            },
 
                            Component::Param(p) => {
-                               let ty = tcx.mk_ty_param(p.idx, p.name);
+                               let ty = p.to_ty(tcx);
                                Some(ty::Predicate::TypeOutlives(
                                    ty::Binder::dummy(ty::OutlivesPredicate(ty, r_min))))
                            },

src/librustc/ty/context.rs

@@ -76,7 +76,7 @@ use syntax::attr;
 use syntax::source_map::MultiSpan;
 use syntax::edition::Edition;
 use syntax::feature_gate;
-use syntax::symbol::{Symbol, keywords, InternedString};
+use syntax::symbol::Symbol;
 use syntax_pos::Span;
 
 use hir;
@@ -2556,22 +2556,20 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
         self.mk_ty(Infer(it))
     }
 
-    pub fn mk_ty_param(self,
-                    index: u32,
-                    name: InternedString) -> Ty<'tcx> {
-        self.mk_ty(Param(ParamTy { idx: index, name: name }))
+    pub fn mk_ty_param(self, def: &ty::GenericParamDef) -> Ty<'tcx> {
+        ParamTy::for_def(def).to_ty(self)
     }
 
-    pub fn mk_self_type(self) -> Ty<'tcx> {
-        self.mk_ty_param(0, keywords::SelfType.name().as_interned_str())
+    pub fn mk_self_type(self, trait_def_id: DefId) -> Ty<'tcx> {
+        ParamTy::for_self(trait_def_id).to_ty(self)
     }
 
-    pub fn mk_param_from_def(self, param: &ty::GenericParamDef) -> Kind<'tcx> {
+    pub fn mk_param(self, param: &ty::GenericParamDef) -> Kind<'tcx> {
         match param.kind {
             GenericParamDefKind::Lifetime => {
                 self.mk_region(ty::ReEarlyBound(param.to_early_bound_region_data())).into()
             }
-            GenericParamDefKind::Type {..} => self.mk_ty_param(param.index, param.name).into(),
+            GenericParamDefKind::Type {..} => self.mk_ty_param(param).into(),
         }
     }
 

src/librustc/ty/sty.rs

@@ -963,24 +963,25 @@ impl<'tcx> PolyFnSig<'tcx> {
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable)]
 pub struct ParamTy {
     pub idx: u32,
+    pub def_id: DefId,
     pub name: InternedString,
 }
 
-impl<'a, 'gcx, 'tcx> ParamTy {
-    pub fn new(index: u32, name: InternedString) -> ParamTy {
-        ParamTy { idx: index, name: name }
+impl ParamTy {
+    pub fn new(idx: u32, def_id: DefId, name: ast::Name) -> ParamTy {
+        ParamTy { idx, def_id, name: name.as_interned_str() }
     }
 
-    pub fn for_self() -> ParamTy {
-        ParamTy::new(0, keywords::SelfType.name().as_interned_str())
+    pub fn for_self(trait_def_id: DefId) -> ParamTy {
+        ParamTy::new(0, trait_def_id, keywords::SelfType.name())
     }
 
     pub fn for_def(def: &ty::GenericParamDef) -> ParamTy {
-        ParamTy::new(def.index, def.name)
+        ParamTy { idx: def.index, def_id: def.def_id, name: def.name }
     }
 
-    pub fn to_ty(self, tcx: TyCtxt<'a, 'gcx, 'tcx>) -> Ty<'tcx> {
-        tcx.mk_ty_param(self.idx, self.name)
+    pub fn to_ty(self, tcx: TyCtxt<'_, '_, 'tcx>) -> Ty<'tcx> {
+        tcx.mk_ty(ty::Param(self))
     }
 }
 

src/librustc/ty/subst.rs

@@ -185,9 +185,7 @@ impl<'a, 'gcx, 'tcx> Substs<'tcx> {
     /// Creates a Substs that maps each generic parameter to itself.
     pub fn identity_for_item(tcx: TyCtxt<'a, 'gcx, 'tcx>, def_id: DefId)
                              -> &'tcx Substs<'tcx> {
-        Substs::for_item(tcx, def_id, |param, _| {
-            tcx.mk_param_from_def(param)
-        })
+        Substs::for_item(tcx, def_id, |param, _| tcx.mk_param(param))
     }
 
     /// Creates a Substs for generic parameter definitions,

src/librustc_driver/test.rs

@@ -312,8 +312,9 @@ impl<'a, 'gcx, 'tcx> Env<'a, 'gcx, 'tcx> {
     }
 
     pub fn t_param(&self, index: u32) -> Ty<'tcx> {
+        let def_id = self.infcx.tcx.hir.local_def_id(ast::CRATE_NODE_ID);
         let name = format!("T{}", index);
-        self.infcx.tcx.mk_ty_param(index, Symbol::intern(&name).as_interned_str())
+        ty::ParamTy::new(index, def_id, Symbol::intern(&name)).to_ty(self.infcx.tcx)
     }
 
     pub fn re_early_bound(&self, index: u32, name: &'static str) -> ty::Region<'tcx> {

src/librustc_lint/builtin.rs

@@ -1076,7 +1076,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnconditionalRecursion {
                 // A trait method, from any number of possible sources.
                 // Attempt to select a concrete impl before checking.
                 ty::TraitContainer(trait_def_id) => {
-                    let trait_self_ty = tcx.mk_self_type();
+                    let trait_self_ty = tcx.mk_self_type(trait_def_id);
                     let trait_ref = ty::TraitRef::from_method(tcx, trait_def_id, callee_substs);
                     let trait_ref = ty::Binder::bind(trait_ref);
                     let span = tcx.hir.span(expr_id);

src/librustc_typeck/astconv.rs

@@ -597,7 +597,7 @@ impl<'o, 'gcx: 'tcx, 'tcx> dyn AstConv<'gcx, 'tcx>+'o {
         let default_needs_object_self = |param: &ty::GenericParamDef| {
             if let GenericParamDefKind::Type { has_default, .. } = param.kind {
                 if is_object && has_default {
-                    let trait_self_ty = tcx.mk_self_type();
+                    let trait_self_ty = tcx.mk_self_type(def_id);
                     let default = tcx.at(span).type_of(param.def_id);
                     if default.walk().any(|ty| ty == trait_self_ty) {
                         // There is no suitable inference default for a type parameter
@@ -1412,7 +1412,7 @@ impl<'o, 'gcx: 'tcx, 'tcx> dyn AstConv<'gcx, 'tcx>+'o {
                 let item_def_id = tcx.hir.local_def_id(item_id);
                 let generics = tcx.generics_of(item_def_id);
                 let index = generics.param_def_id_to_index[&tcx.hir.local_def_id(node_id)];
-                tcx.mk_ty_param(index, tcx.hir.name(node_id).as_interned_str())
+                ty::ParamTy::new(index, did, tcx.hir.name(node_id)).to_ty(tcx)
             }
             Def::SelfTy(_, Some(def_id)) => {
                 // Self in impl (we know the concrete type).
@@ -1422,11 +1422,11 @@ impl<'o, 'gcx: 'tcx, 'tcx> dyn AstConv<'gcx, 'tcx>+'o {
 
                 tcx.at(span).type_of(def_id)
             }
-            Def::SelfTy(Some(_), None) => {
+            Def::SelfTy(Some(trait_def_id), None) => {
                 // Self in trait.
                 assert_eq!(opt_self_ty, None);
                 self.prohibit_generics(&path.segments);
-                tcx.mk_self_type()
+                tcx.mk_self_type(trait_def_id)
             }
             Def::AssociatedTy(def_id) => {
                 self.prohibit_generics(&path.segments[..path.segments.len()-2]);
@@ -1572,7 +1572,7 @@ impl<'o, 'gcx: 'tcx, 'tcx> dyn AstConv<'gcx, 'tcx>+'o {
                     GenericParamDefKind::Lifetime => {
                         tcx.types.re_static.into()
                     }
-                    _ => tcx.mk_param_from_def(param)
+                    _ => tcx.mk_param(param)
                 }
             }
         });

src/librustc_typeck/check/compare_method.rs

@@ -512,7 +512,7 @@ fn compare_self_type<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
     let self_string = |method: &ty::AssociatedItem| {
         let untransformed_self_ty = match method.container {
             ty::ImplContainer(_) => impl_trait_ref.self_ty(),
-            ty::TraitContainer(_) => tcx.mk_self_type()
+            ty::TraitContainer(def_id) => tcx.mk_self_type(def_id),
         };
         let self_arg_ty = *tcx.fn_sig(method.def_id).input(0).skip_binder();
         let param_env = ty::ParamEnv::reveal_all();

src/librustc_typeck/check/intrinsic.rs

@@ -19,7 +19,6 @@ use require_same_types;
 
 use rustc_target::spec::abi::Abi;
 use syntax::ast;
-use syntax::symbol::Symbol;
 use syntax_pos::Span;
 
 use rustc::hir;
@@ -76,7 +75,9 @@ fn equate_intrinsic_type<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
 /// and in libcore/intrinsics.rs
 pub fn check_intrinsic_type<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                                       it: &hir::ForeignItem) {
-    let param = |n| tcx.mk_ty_param(n, Symbol::intern(&format!("P{}", n)).as_interned_str());
+    let def_id = tcx.hir.local_def_id(it.id);
+    let generics = tcx.generics_of(def_id);
+    let param = |n| tcx.mk_ty_param(&generics.params[n]);
     let name = it.name.as_str();
     let (n_tps, inputs, output) = if name.starts_with("atomic_") {
         let split : Vec<&str> = name.split('_').collect();
@@ -335,13 +336,11 @@ pub fn check_intrinsic_type<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
 /// Type-check `extern "platform-intrinsic" { ... }` functions.
 pub fn check_platform_intrinsic_type<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                                                it: &hir::ForeignItem) {
-    let param = |n| {
-        let name = Symbol::intern(&format!("P{}", n)).as_interned_str();
-        tcx.mk_ty_param(n, name)
-    };
-
     let def_id = tcx.hir.local_def_id(it.id);
-    let i_n_tps = tcx.generics_of(def_id).own_counts().types;
+    let generics = tcx.generics_of(def_id);
+    let param = |n| tcx.mk_ty_param(&generics.params[n]);
+
+    let i_n_tps = generics.own_counts().types;
     let name = it.name.as_str();
 
     let (n_tps, inputs, output) = match &*name {

src/librustc_typeck/check/wfcheck.rs

@@ -183,7 +183,7 @@ fn check_associated_item<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
         let item = fcx.tcx.associated_item(fcx.tcx.hir.local_def_id(item_id));
 
         let (mut implied_bounds, self_ty) = match item.container {
-            ty::TraitContainer(_) => (vec![], fcx.tcx.mk_self_type()),
+            ty::TraitContainer(def_id) => (vec![], fcx.tcx.mk_self_type(def_id)),
             ty::ImplContainer(def_id) => (fcx.impl_implied_bounds(def_id, span),
                                             fcx.tcx.type_of(def_id))
         };
@@ -431,7 +431,7 @@ fn check_where_clauses<'a, 'gcx, 'fcx, 'tcx>(
         match param.kind {
             GenericParamDefKind::Lifetime => {
                 // All regions are identity.
-                fcx.tcx.mk_param_from_def(param)
+                fcx.tcx.mk_param(param)
             }
             GenericParamDefKind::Type {..} => {
                 // If the param has a default,

src/librustc_typeck/check/writeback.rs

@@ -433,9 +433,7 @@ impl<'cx, 'gcx, 'tcx> WritebackCx<'cx, 'gcx, 'tcx> {
                                     if subst == ty {
                                         // found it in the substitution list, replace with the
                                         // parameter from the existential type
-                                        return self.tcx()
-                                            .global_tcx()
-                                            .mk_ty_param(param.index, param.name);
+                                        return self.tcx().global_tcx().mk_ty_param(param);
                                     }
                                 }
                             }

src/librustc_typeck/collect.rs

@@ -249,7 +249,7 @@ fn type_param_predicates<'a, 'tcx>(
     let param_owner_def_id = tcx.hir.local_def_id(param_owner);
     let generics = tcx.generics_of(param_owner_def_id);
     let index = generics.param_def_id_to_index[&def_id];
-    let ty = tcx.mk_ty_param(index, tcx.hir.ty_param_name(param_id).as_interned_str());
+    let ty = ty::ParamTy::new(index, def_id, tcx.hir.ty_param_name(param_id)).to_ty(tcx);
 
     // Don't look for bounds where the type parameter isn't in scope.
     let parent = if item_def_id == param_owner_def_id {
@@ -683,7 +683,7 @@ fn super_predicates_of<'a, 'tcx>(
     let icx = ItemCtxt::new(tcx, trait_def_id);
 
     // Convert the bounds that follow the colon, e.g. `Bar+Zed` in `trait Foo : Bar+Zed`.
-    let self_param_ty = tcx.mk_self_type();
+    let self_param_ty = tcx.mk_self_type(trait_def_id);
     let superbounds1 = compute_bounds(&icx, self_param_ty, bounds, SizedByDefault::No, item.span);
 
     let superbounds1 = superbounds1.predicates(tcx, self_param_ty);
@@ -1773,8 +1773,9 @@ fn explicit_predicates_of<'a, 'tcx>(
     for param in &ast_generics.params {
         match param.kind {
             GenericParamKind::Type { .. } => {
-                let name = param.name.ident().as_interned_str();
-                let param_ty = ty::ParamTy::new(index, name).to_ty(tcx);
+                let def_id = tcx.hir.local_def_id(param.id);
+                let name = param.name.ident().name;
+                let param_ty = ty::ParamTy::new(index, def_id, name).to_ty(tcx);
                 index += 1;
 
                 let sized = SizedByDefault::Yes;