rustc: support cross-crate DefId's in ty_param_{name,owner}.

eddyb · eddyb · commit 0d5122acacf0 · 2018-08-25T07:52:50.000+03:00
diff --git a/src/librustc/hir/map/mod.rs b/src/librustc/hir/map/mod.rs
@@ -602,27 +602,6 @@ impl<'hir> Map<'hir> {
         }
     }
 
-    pub fn ty_param_owner(&self, id: NodeId) -> NodeId {
-        match self.get(id) {
-            NodeItem(&Item { node: ItemKind::Trait(..), .. }) => id,
-            NodeGenericParam(_) => self.get_parent_node(id),
-            _ => {
-                bug!("ty_param_owner: {} not a type parameter",
-                    self.node_to_string(id))
-            }
-        }
-    }
-
-    pub fn ty_param_name(&self, id: NodeId) -> Name {
-        match self.get(id) {
-            NodeItem(&Item { node: ItemKind::Trait(..), .. }) => {
-                keywords::SelfType.name()
-            }
-            NodeGenericParam(param) => param.name.ident().name,
-            _ => bug!("ty_param_name: {} not a type parameter", self.node_to_string(id)),
-        }
-    }
-
     pub fn trait_impls(&self, trait_did: DefId) -> &'hir [NodeId] {
         self.dep_graph.read(DepNode::new_no_params(DepKind::AllLocalTraitImpls));
 
diff --git a/src/librustc/infer/region_constraints/mod.rs b/src/librustc/infer/region_constraints/mod.rs
@@ -875,8 +875,8 @@ impl<'tcx> fmt::Display for GenericKind<'tcx> {
 impl<'a, 'gcx, 'tcx> GenericKind<'tcx> {
     pub fn to_ty(&self, tcx: TyCtxt<'a, 'gcx, 'tcx>) -> Ty<'tcx> {
         match *self {
-            GenericKind::Param(ref p) => p.to_ty(tcx),
-            GenericKind::Projection(ref p) => tcx.mk_projection(p.item_def_id, p.substs),
+            GenericKind::Param(p) => tcx.mk_ty(ty::Param(p)),
+            GenericKind::Projection(p) => tcx.mk_projection(p.item_def_id, p.substs),
         }
     }
 }
diff --git a/src/librustc/traits/util.rs b/src/librustc/traits/util.rs
@@ -213,7 +213,7 @@ impl<'cx, 'gcx, 'tcx> Elaborator<'cx, 'gcx, 'tcx> {
                            },
 
                            Component::Param(p) => {
-                               let ty = p.to_ty(tcx);
+                               let ty = tcx.mk_ty(ty::Param(p));
                                Some(ty::Predicate::TypeOutlives(
                                    ty::Binder::dummy(ty::OutlivesPredicate(ty, r_min))))
                            },
diff --git a/src/librustc/ty/context.rs b/src/librustc/ty/context.rs
@@ -40,7 +40,7 @@ use traits::{Clause, Clauses, Goal, Goals};
 use ty::{self, Ty, TypeAndMut};
 use ty::{TyS, TyKind, List};
 use ty::{AdtKind, AdtDef, ClosureSubsts, GeneratorSubsts, Region, Const};
-use ty::{PolyFnSig, InferTy, ParamTy, ProjectionTy, ExistentialPredicate, Predicate};
+use ty::{PolyFnSig, InferTy, ProjectionTy, ExistentialPredicate, Predicate};
 use ty::RegionKind;
 use ty::{TyVar, TyVid, IntVar, IntVid, FloatVar, FloatVid};
 use ty::TyKind::*;
@@ -76,7 +76,7 @@ use syntax::attr;
 use syntax::source_map::MultiSpan;
 use syntax::edition::Edition;
 use syntax::feature_gate;
-use syntax::symbol::Symbol;
+use syntax::symbol::{keywords, Symbol};
 use syntax_pos::Span;
 
 use hir;
@@ -2557,11 +2557,19 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
     }
 
     pub fn mk_ty_param(self, def: &ty::GenericParamDef) -> Ty<'tcx> {
-        ParamTy::for_def(def).to_ty(self)
+        self.mk_ty(ty::Param(ty::ParamTy {
+            idx: def.index,
+            def_id: def.def_id,
+            name: def.name,
+        }))
     }
 
     pub fn mk_self_type(self, trait_def_id: DefId) -> Ty<'tcx> {
-        ParamTy::for_self(trait_def_id).to_ty(self)
+        self.mk_ty(ty::Param(ty::ParamTy {
+            idx: 0,
+            def_id: trait_def_id,
+            name: keywords::SelfType.name().as_interned_str(),
+        }))
     }
 
     pub fn mk_param(self, param: &ty::GenericParamDef) -> Kind<'tcx> {
diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs
@@ -2637,6 +2637,29 @@ 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::Trait(_) => {
+                keywords::SelfType.name().as_interned_str()
+            }
+            DefPathData::TypeParam(name) => name,
+            _ => bug!("ty_param_name: {:?} not a type parameter", id),
+        }
+    }
+
+    pub fn ty_param_owner(&self, id: DefId) -> DefId {
+        let def_key = self.def_key(id);
+        match def_key.disambiguated_data.data {
+            DefPathData::Trait(_) => id,
+            DefPathData::TypeParam(_) => DefId {
+                krate: id.krate,
+                index: def_key.parent.unwrap()
+            },
+            _ => bug!("ty_param_owner: {:?} not a type parameter", id),
+        }
+    }
+
     /// Return the possibly-auto-generated MIR of a (DefId, Subst) pair.
     pub fn instance_mir(self, instance: ty::InstanceDef<'gcx>)
                         -> &'gcx Mir<'gcx>
diff --git a/src/librustc/ty/query/config.rs b/src/librustc/ty/query/config.rs
@@ -212,9 +212,8 @@ impl<'tcx> QueryDescription<'tcx> for queries::erase_regions_ty<'tcx> {
 
 impl<'tcx> QueryDescription<'tcx> for queries::type_param_predicates<'tcx> {
     fn describe(tcx: TyCtxt, (_, def_id): (DefId, DefId)) -> String {
-        let id = tcx.hir.as_local_node_id(def_id).unwrap();
         format!("computing the bounds for type parameter `{}`",
-                tcx.hir.ty_param_name(id))
+                tcx.ty_param_name(def_id))
     }
 }
 
diff --git a/src/librustc/ty/sty.rs b/src/librustc/ty/sty.rs
@@ -26,7 +26,7 @@ use std::iter;
 use std::cmp::Ordering;
 use rustc_target::spec::abi;
 use syntax::ast::{self, Ident};
-use syntax::symbol::{keywords, InternedString};
+use syntax::symbol::InternedString;
 
 use serialize;
 
@@ -967,24 +967,6 @@ pub struct ParamTy {
     pub name: InternedString,
 }
 
-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(trait_def_id: DefId) -> ParamTy {
-        ParamTy::new(0, trait_def_id, keywords::SelfType.name())
-    }
-
-    pub fn for_def(def: &ty::GenericParamDef) -> ParamTy {
-        ParamTy { idx: def.index, def_id: def.def_id, name: def.name }
-    }
-
-    pub fn to_ty(self, tcx: TyCtxt<'_, '_, 'tcx>) -> Ty<'tcx> {
-        tcx.mk_ty(ty::Param(self))
-    }
-}
-
 /// A [De Bruijn index][dbi] is a standard means of representing
 /// regions (and perhaps later types) in a higher-ranked setting. In
 /// particular, imagine a type like this:
diff --git a/src/librustc_driver/test.rs b/src/librustc_driver/test.rs
@@ -314,7 +314,11 @@ 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);
-        ty::ParamTy::new(index, def_id, Symbol::intern(&name)).to_ty(self.infcx.tcx)
+        self.infcx.tcx.mk_ty(ty::TyParam(ty::ParamTy {
+            idx: index,
+            def_id,
+            name: Symbol::intern(&name).as_interned_str()
+        }))
     }
 
     pub fn re_early_bound(&self, index: u32, name: &'static str) -> ty::Region<'tcx> {
diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs
@@ -1132,8 +1132,7 @@ impl<'o, 'gcx: 'tcx, 'tcx> dyn AstConv<'gcx, 'tcx>+'o {
             traits::transitive_bounds(tcx, &bounds)
             .filter(|b| self.trait_defines_associated_type_named(b.def_id(), assoc_name));
 
-        let param_node_id = tcx.hir.as_local_node_id(ty_param_def_id).unwrap();
-        let param_name = tcx.hir.ty_param_name(param_node_id);
+        let param_name = tcx.ty_param_name(ty_param_def_id);
         self.one_bound_for_assoc_type(suitable_bounds,
                                       &param_name.as_str(),
                                       assoc_name,
@@ -1412,7 +1411,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)];
-                ty::ParamTy::new(index, did, tcx.hir.name(node_id)).to_ty(tcx)
+                tcx.mk_ty_param(generics.param_at(index, tcx))
             }
             Def::SelfTy(_, Some(def_id)) => {
                 // Self in impl (we know the concrete type).
diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs
@@ -1825,9 +1825,7 @@ impl<'a, 'gcx, 'tcx> AstConv<'gcx, 'tcx> for FnCtxt<'a, 'gcx, 'tcx> {
                                  -> ty::GenericPredicates<'tcx>
     {
         let tcx = self.tcx;
-        let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
-        let item_id = tcx.hir.ty_param_owner(node_id);
-        let item_def_id = tcx.hir.local_def_id(item_id);
+        let item_def_id = tcx.ty_param_owner(def_id);
         let generics = tcx.generics_of(item_def_id);
         let index = generics.param_def_id_to_index[&def_id];
         ty::GenericPredicates {
diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs
@@ -244,12 +244,10 @@ fn type_param_predicates<'a, 'tcx>(
     // written inline like `<T:Foo>` or in a where clause like
     // `where T:Foo`.
 
-    let param_id = tcx.hir.as_local_node_id(def_id).unwrap();
-    let param_owner = tcx.hir.ty_param_owner(param_id);
-    let param_owner_def_id = tcx.hir.local_def_id(param_owner);
+    let param_owner_def_id = tcx.ty_param_owner(def_id);
     let generics = tcx.generics_of(param_owner_def_id);
     let index = generics.param_def_id_to_index[&def_id];
-    let ty = ty::ParamTy::new(index, def_id, tcx.hir.ty_param_name(param_id)).to_ty(tcx);
+    let ty = tcx.mk_ty_param(generics.param_at(index, tcx));
 
     // Don't look for bounds where the type parameter isn't in scope.
     let parent = if item_def_id == param_owner_def_id {
@@ -290,7 +288,7 @@ fn type_param_predicates<'a, 'tcx>(
                 | ItemKind::Union(_, ref generics) => generics,
                 ItemKind::Trait(_, _, ref generics, ..) => {
                     // Implied `Self: Trait` and supertrait bounds.
-                    if param_id == item_node_id {
+                    if def_id == item_def_id {
                         result
                             .predicates
                             .push(ty::TraitRef::identity(tcx, item_def_id).to_predicate());
@@ -310,6 +308,7 @@ fn type_param_predicates<'a, 'tcx>(
     };
 
     let icx = ItemCtxt::new(tcx, item_def_id);
+    let param_id = tcx.hir.as_local_node_id(def_id).unwrap();
     result
         .predicates
         .extend(icx.type_parameter_bounds_in_generics(ast_generics, param_id, ty));
@@ -1773,9 +1772,7 @@ fn explicit_predicates_of<'a, 'tcx>(
     for param in &ast_generics.params {
         match param.kind {
             GenericParamKind::Type { .. } => {
-                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);
+                let param_ty = tcx.mk_ty_param(generics.param_at(index, tcx));
                 index += 1;
 
                 let sized = SizedByDefault::Yes;
diff --git a/src/librustc_typeck/impl_wf_check.rs b/src/librustc_typeck/impl_wf_check.rs
@@ -26,8 +26,6 @@ use rustc::ty::{self, TyCtxt};
 use rustc::util::nodemap::{FxHashMap, FxHashSet};
 use std::collections::hash_map::Entry::{Occupied, Vacant};
 
-use syntax_pos::Span;
-
 /// Checks that all the type/lifetime parameters on an impl also
 /// appear in the trait ref or self-type (or are constrained by a
 /// where-clause). These rules are needed to ensure that, given a
@@ -114,28 +112,28 @@ fn enforce_impl_params_are_constrained<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
         }).collect();
 
     for param in &impl_generics.params {
-        match param.kind {
+        let ctp_param = ctp::Parameter(param.index);
+        if input_parameters.contains(&ctp_param) {
+            continue;
+        }
+        let kind = match param.kind {
             // Disallow ANY unconstrained type parameters.
-            ty::GenericParamDefKind::Type {..} => {
-                let param_ty = ty::ParamTy::for_def(param);
-                if !input_parameters.contains(&ctp::Parameter::from(param_ty)) {
-                    report_unused_parameter(tcx,
-                                            tcx.def_span(param.def_id),
-                                            "type",
-                                            &param_ty.to_string());
-                }
-            }
+            ty::GenericParamDefKind::Type {..} => "type",
             ty::GenericParamDefKind::Lifetime => {
-                let param_lt = ctp::Parameter::from(param.to_early_bound_region_data());
-                if lifetimes_in_associated_types.contains(&param_lt) && // (*)
-                    !input_parameters.contains(&param_lt) {
-                    report_unused_parameter(tcx,
-                                            tcx.def_span(param.def_id),
-                                            "lifetime",
-                                            &param.name.to_string());
+                if !lifetimes_in_associated_types.contains(&ctp_param) { // (*)
+                    continue;
                 }
+                "lifetime"
             }
-        }
+        };
+        let span = tcx.def_span(param.def_id);
+        struct_span_err!(
+            tcx.sess, span, E0207,
+            "the {} parameter `{}` is not constrained by the \
+            impl trait, self type, or predicates",
+            kind, param.name)
+            .span_label(span, format!("unconstrained {} parameter", kind))
+            .emit();
     }
 
     // (*) This is a horrible concession to reality. I think it'd be
@@ -158,20 +156,6 @@ fn enforce_impl_params_are_constrained<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
     // used elsewhere are not projected back out.
 }
 
-fn report_unused_parameter(tcx: TyCtxt,
-                           span: Span,
-                           kind: &str,
-                           name: &str)
-{
-    struct_span_err!(
-        tcx.sess, span, E0207,
-        "the {} parameter `{}` is not constrained by the \
-        impl trait, self type, or predicates",
-        kind, name)
-        .span_label(span, format!("unconstrained {} parameter", kind))
-        .emit();
-}
-
 /// Enforce that we do not have two items in an impl with the same name.
 fn enforce_impl_items_are_distinct<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                                              impl_item_refs: &[hir::ImplItemRef])
diff --git a/src/librustc_typeck/outlives/utils.rs b/src/librustc_typeck/outlives/utils.rs
@@ -77,7 +77,7 @@ pub fn insert_outlives_predicate<'tcx>(
                         // Vec<U>`.  Decomposing `Vec<U>` into
                         // components would yield `U`, and we add the
                         // where clause that `U: 'a`.
-                        let ty: Ty<'tcx> = param_ty.to_ty(tcx);
+                        let ty = tcx.mk_ty(ty::Param(param_ty));
                         required_predicates
                             .insert(ty::OutlivesPredicate(ty.into(), outlived_region));
                     }

Original file line number	Diff line number	Diff line change
`@@ -875,8 +875,8 @@ impl<'tcx> fmt::Display for GenericKind<'tcx> {`
`875`	`875`	`impl<'a, 'gcx, 'tcx> GenericKind<'tcx> {`
`876`	`876`	`pub fn to_ty(&self, tcx: TyCtxt<'a, 'gcx, 'tcx>) -> Ty<'tcx> {`
`877`	`877`	`match *self {`
`878`		`- GenericKind::Param(ref p) => p.to_ty(tcx),`
`879`		`- GenericKind::Projection(ref p) => tcx.mk_projection(p.item_def_id, p.substs),`
	`878`	`+ GenericKind::Param(p) => tcx.mk_ty(ty::Param(p)),`
	`879`	`+ GenericKind::Projection(p) => tcx.mk_projection(p.item_def_id, p.substs),`
`880`	`880`	`}`
`881`	`881`	`}`
`882`	`882`	`}`
Original file line number	Diff line number	Diff line change
`@@ -212,9 +212,8 @@ impl<'tcx> QueryDescription<'tcx> for queries::erase_regions_ty<'tcx> {`
`212`	`212`
`213`	`213`	`impl<'tcx> QueryDescription<'tcx> for queries::type_param_predicates<'tcx> {`
`214`	`214`	`fn describe(tcx: TyCtxt, (_, def_id): (DefId, DefId)) -> String {`
`215`		`- let id = tcx.hir.as_local_node_id(def_id).unwrap();`
`216`	`215`	format!("computing the bounds for type parameter `{}`",
`217`		`- tcx.hir.ty_param_name(id))`
	`216`	`+ tcx.ty_param_name(def_id))`
`218`	`217`	`}`
`219`	`218`	`}`
`220`	`219`