rustc: remove the name field from ty::GenericParamDef.

eddyb · eddyb · commit d337a3b8891f · 2018-08-25T07:53:44.000+03:00
diff --git a/src/librustc/ich/impls_ty.rs b/src/librustc/ich/impls_ty.rs
@@ -690,7 +690,6 @@ impl_stable_hash_for!(struct ty::Generics {
 });
 
 impl_stable_hash_for!(struct ty::GenericParamDef {
-    name,
     def_id,
     index,
     pure_wrt_drop,
diff --git a/src/librustc/infer/error_reporting/mod.rs b/src/librustc/infer/error_reporting/mod.rs
@@ -1338,7 +1338,10 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
                 br_string(br),
                 self.tcx.associated_item(def_id).ident
             ),
-            infer::EarlyBoundRegion(_, name) => format!(" for lifetime parameter `{}`", name),
+            infer::EarlyBoundRegion(_, def_id) => format!(
+                " for lifetime parameter `{}`",
+                self.tcx.generic_param_name(def_id),
+            ),
             infer::BoundRegionInCoherence(name) => {
                 format!(" for lifetime parameter `{}` in coherence check", name)
             }
diff --git a/src/librustc/infer/mod.rs b/src/librustc/infer/mod.rs
@@ -35,7 +35,6 @@ use std::fmt;
 use syntax::ast;
 use errors::DiagnosticBuilder;
 use syntax_pos::{self, Span};
-use syntax_pos::symbol::InternedString;
 use util::nodemap::FxHashMap;
 use arena::SyncDroplessArena;
 
@@ -355,7 +354,7 @@ pub enum RegionVariableOrigin {
     Coercion(Span),
 
     // Region variables created as the values for early-bound regions
-    EarlyBoundRegion(Span, InternedString),
+    EarlyBoundRegion(Span, DefId),
 
     // Region variables created for bound regions
     // in a function or method that is called
@@ -931,7 +930,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
             GenericParamDefKind::Lifetime => {
                 // Create a region inference variable for the given
                 // region parameter definition.
-                self.next_region_var(EarlyBoundRegion(span, param.name)).into()
+                self.next_region_var(EarlyBoundRegion(span, param.def_id)).into()
             }
             GenericParamDefKind::Type {..} => {
                 // Create a type inference variable for the given
diff --git a/src/librustc/traits/auto_trait.rs b/src/librustc/traits/auto_trait.rs
@@ -225,7 +225,9 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> {
                 .params
                 .iter()
                 .filter_map(|param| match param.kind {
-                    ty::GenericParamDefKind::Lifetime => Some(param.name.to_string()),
+                    ty::GenericParamDefKind::Lifetime => {
+                        Some(tcx.generic_param_name(param.def_id).to_string())
+                    }
                     _ => None
                 })
                 .collect();
diff --git a/src/librustc/traits/error_reporting.rs b/src/librustc/traits/error_reporting.rs
@@ -387,7 +387,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
                 },
                 GenericParamDefKind::Lifetime => continue,
             };
-            let name = param.name.to_string();
+            let name = self.tcx.generic_param_name(param.def_id).to_string();
             flags.push((name, Some(value)));
         }
 
diff --git a/src/librustc/traits/on_unimplemented.rs b/src/librustc/traits/on_unimplemented.rs
@@ -260,7 +260,7 @@ impl<'a, 'gcx, 'tcx> OnUnimplementedFormatString {
                     Position::ArgumentNamed(s) if s == "from_desugaring" => (),
                     // So is `{A}` if A is a type parameter
                     Position::ArgumentNamed(s) => match generics.params.iter().find(|param| {
-                        param.name == s
+                        tcx.generic_param_name(param.def_id) == s
                     }) {
                         Some(_) => (),
                         None => {
@@ -298,7 +298,7 @@ impl<'a, 'gcx, 'tcx> OnUnimplementedFormatString {
                 },
                 GenericParamDefKind::Lifetime => return None
             };
-            let name = param.name.to_string();
+            let name = tcx.generic_param_name(param.def_id).to_string();
             Some((name, value))
         }).collect::<FxHashMap<String, String>>();
         let empty_string = String::new();
diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs
@@ -844,7 +844,6 @@ pub enum GenericParamDefKind {
 
 #[derive(Clone, RustcEncodable, RustcDecodable)]
 pub struct GenericParamDef {
-    pub name: InternedString,
     pub def_id: DefId,
     pub index: u32,
 
diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs
@@ -637,7 +637,7 @@ impl fmt::Debug for ty::GenericParamDef {
         };
         write!(f, "{}({}, {:?}, {})",
                type_name,
-               self.name,
+               ty::tls::with(|tcx| tcx.generic_param_name(self.def_id)),
                self.def_id,
                self.index)
     }
diff --git a/src/librustc_codegen_llvm/debuginfo/mod.rs b/src/librustc_codegen_llvm/debuginfo/mod.rs
@@ -437,7 +437,9 @@ pub fn create_function_debug_context(
         let mut names = generics.parent.map_or(vec![], |def_id| {
             get_parameter_names(cx, cx.tcx.generics_of(def_id))
         });
-        names.extend(generics.params.iter().map(|param| param.name));
+        names.extend(generics.params.iter().map(|param| {
+            cx.tcx.generic_param_name(param.def_id)
+        }));
         names
     }
 
diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs
@@ -636,12 +636,13 @@ impl<'o, 'gcx: 'tcx, 'tcx> dyn AstConv<'gcx, 'tcx>+'o {
                             // defaults. This will lead to an ICE if we are not
                             // careful!
                             if default_needs_object_self(param) {
+                                let param_name = tcx.generic_param_name(param.def_id);
                                 struct_span_err!(tcx.sess, span, E0393,
                                                     "the type parameter `{}` must be explicitly \
                                                     specified",
-                                                    param.name)
+                                                    param_name)
                                     .span_label(span,
-                                                format!("missing reference to `{}`", param.name))
+                                                format!("missing reference to `{}`", param_name))
                                     .note(&format!("because of the default `Self` reference, \
                                                     type parameters must be specified on object \
                                                     types"))
diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs
@@ -1844,7 +1844,7 @@ impl<'a, 'gcx, 'tcx> AstConv<'gcx, 'tcx> for FnCtxt<'a, 'gcx, 'tcx> {
     fn re_infer(&self, span: Span, def: Option<&ty::GenericParamDef>)
                 -> Option<ty::Region<'tcx>> {
         let v = match def {
-            Some(def) => infer::EarlyBoundRegion(span, def.name),
+            Some(def) => infer::EarlyBoundRegion(span, def.def_id),
             None => infer::MiscVariable(span)
         };
         Some(self.next_region_var(v))
@@ -5259,9 +5259,9 @@ pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
     });
     for (&used, param) in types_used.iter().zip(types) {
         if !used {
-            let id = tcx.hir.as_local_node_id(param.def_id).unwrap();
-            let span = tcx.hir.span(id);
-            struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param.name)
+            let span = tcx.def_span(param.def_id);
+            let param_name = tcx.generic_param_name(param.def_id);
+            struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param_name)
                 .span_label(span, "unused type parameter")
                 .emit();
         }
diff --git a/src/librustc_typeck/check/wfcheck.rs b/src/librustc_typeck/check/wfcheck.rs
@@ -838,7 +838,9 @@ fn reject_shadowing_parameters(tcx: TyCtxt, def_id: DefId) {
     let parent = tcx.generics_of(generics.parent.unwrap());
     let impl_params: FxHashMap<_, _> = parent.params.iter().flat_map(|param| match param.kind {
         GenericParamDefKind::Lifetime => None,
-        GenericParamDefKind::Type {..} => Some((param.name, param.def_id)),
+        GenericParamDefKind::Type {..} => {
+            Some((tcx.generic_param_name(param.def_id), param.def_id))
+        }
     }).collect();
 
     for method_param in &generics.params {
@@ -847,15 +849,16 @@ fn reject_shadowing_parameters(tcx: TyCtxt, def_id: DefId) {
             GenericParamDefKind::Lifetime => continue,
             _ => {},
         };
-        if impl_params.contains_key(&method_param.name) {
+        let method_param_name = tcx.generic_param_name(method_param.def_id);
+        if impl_params.contains_key(&method_param_name) {
             // Tighten up the span to focus on only the shadowing type
             let type_span = tcx.def_span(method_param.def_id);
 
             // The expectation here is that the original trait declaration is
             // local so it should be okay to just unwrap everything.
-            let trait_def_id = impl_params[&method_param.name];
+            let trait_def_id = impl_params[&method_param_name];
             let trait_decl_span = tcx.def_span(trait_def_id);
-            error_194(tcx, type_span, trait_decl_span, &method_param.name.as_str()[..]);
+            error_194(tcx, type_span, trait_decl_span, &method_param_name.as_str()[..]);
         }
     }
 }
diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs
@@ -45,7 +45,7 @@ use syntax::ast::MetaItemKind;
 use syntax::attr::{InlineAttr, list_contains_name, mark_used};
 use syntax::source_map::Spanned;
 use syntax::feature_gate;
-use syntax::symbol::{keywords, Symbol};
+use syntax::symbol::Symbol;
 use syntax_pos::{Span, DUMMY_SP};
 
 use rustc::hir::def::{CtorKind, Def};
@@ -909,7 +909,6 @@ fn generics_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> &'tcx ty
 
                     opt_self = Some(ty::GenericParamDef {
                         index: 0,
-                        name: keywords::SelfType.name().as_interned_str(),
                         def_id: tcx.hir.local_def_id(param_id),
                         pure_wrt_drop: false,
                         kind: ty::GenericParamDefKind::Type {
@@ -954,7 +953,6 @@ fn generics_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> &'tcx ty
         early_lifetimes
             .enumerate()
             .map(|(i, param)| ty::GenericParamDef {
-                name: param.name.ident().as_interned_str(),
                 index: own_start + i as u32,
                 def_id: tcx.hir.local_def_id(param.id),
                 pure_wrt_drop: param.pure_wrt_drop,
@@ -994,7 +992,6 @@ fn generics_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> &'tcx ty
 
                     let ty_param = ty::GenericParamDef {
                         index: type_start + i as u32,
-                        name: param.name.ident().as_interned_str(),
                         def_id: tcx.hir.local_def_id(param.id),
                         pure_wrt_drop: param.pure_wrt_drop,
                         kind: ty::GenericParamDefKind::Type {
@@ -1030,9 +1027,8 @@ fn generics_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> &'tcx ty
             dummy_args
                 .iter()
                 .enumerate()
-                .map(|(i, &arg)| ty::GenericParamDef {
+                .map(|(i, &_arg)| ty::GenericParamDef {
                     index: type_start + i as u32,
-                    name: Symbol::intern(arg).as_interned_str(),
                     def_id,
                     pure_wrt_drop: false,
                     kind: ty::GenericParamDefKind::Type {
@@ -1047,7 +1043,6 @@ fn generics_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> &'tcx ty
             params.extend(fv.iter().zip((dummy_args.len() as u32)..).map(|(_, i)| {
                 ty::GenericParamDef {
                     index: type_start + i,
-                    name: Symbol::intern("<upvar>").as_interned_str(),
                     def_id,
                     pure_wrt_drop: false,
                     kind: ty::GenericParamDefKind::Type {
diff --git a/src/librustc_typeck/impl_wf_check.rs b/src/librustc_typeck/impl_wf_check.rs
@@ -131,7 +131,7 @@ fn enforce_impl_params_are_constrained<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
             tcx.sess, span, E0207,
             "the {} parameter `{}` is not constrained by the \
             impl trait, self type, or predicates",
-            kind, param.name)
+            kind, tcx.generic_param_name(param.def_id))
             .span_label(span, format!("unconstrained {} parameter", kind))
             .emit();
     }
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
@@ -1243,8 +1243,8 @@ impl Clean<Lifetime> for hir::GenericParam {
 }
 
 impl<'tcx> Clean<Lifetime> for ty::GenericParamDef {
-    fn clean(&self, _cx: &DocContext) -> Lifetime {
-        Lifetime(self.name.to_string())
+    fn clean(&self, cx: &DocContext) -> Lifetime {
+        Lifetime(cx.tcx.generic_param_name(self.def_id).to_string())
     }
 }
 
@@ -1409,19 +1409,20 @@ impl GenericParamDef {
 
 impl<'tcx> Clean<GenericParamDef> for ty::GenericParamDef {
     fn clean(&self, cx: &DocContext) -> GenericParamDef {
+        let name = cx.tcx.generic_param_name(self.def_id);
         let (name, kind) = match self.kind {
             ty::GenericParamDefKind::Lifetime => {
-                (self.name.to_string(), GenericParamDefKind::Lifetime)
+                (name.to_string(), GenericParamDefKind::Lifetime)
             }
             ty::GenericParamDefKind::Type { has_default, .. } => {
                 cx.renderinfo.borrow_mut().external_typarams
-                             .insert(self.def_id, self.name.clean(cx));
+                             .insert(self.def_id, name.clean(cx));
                 let default = if has_default {
                     Some(cx.tcx.type_of(self.def_id).clean(cx))
                 } else {
                     None
                 };
-                (self.name.clean(cx), GenericParamDefKind::Type {
+                (name.clean(cx), GenericParamDefKind::Type {
                     did: self.def_id,
                     bounds: vec![], // These are filled in from the where-clauses.
                     default,
@@ -1561,8 +1562,7 @@ impl<'a, 'tcx> Clean<Generics> for (&'a ty::Generics,
         let stripped_typarams = gens.params.iter().filter_map(|param| match param.kind {
             ty::GenericParamDefKind::Lifetime => None,
             ty::GenericParamDefKind::Type { .. } => {
-                if param.name == keywords::SelfType.name().as_str() {
-                    assert_eq!(param.index, 0);
+                if gens.has_self && param.index == 0 {
                     return None;
                 }
                 Some(param.clean(cx))
diff --git a/src/librustdoc/core.rs b/src/librustdoc/core.rs
@@ -201,10 +201,11 @@ impl<'a, 'tcx, 'rcx, 'cstore> DocContext<'a, 'tcx, 'rcx, 'cstore> {
         for param in generics.params.iter() {
             match param.kind {
                 ty::GenericParamDefKind::Lifetime => {
-                    let name = if param.name == "" {
+                    let param_name = self.tcx.generic_param_name(param.def_id);
+                    let name = if param_name == "" {
                         hir::ParamName::Plain(keywords::StaticLifetime.ident())
                     } else {
-                        hir::ParamName::Plain(ast::Ident::from_interned_str(param.name))
+                        hir::ParamName::Plain(ast::Ident::from_interned_str(param_name))
                     };
 
                     args.push(hir::GenericArg::Lifetime(hir::Lifetime {
@@ -228,6 +229,7 @@ impl<'a, 'tcx, 'rcx, 'cstore> DocContext<'a, 'tcx, 'rcx, 'cstore> {
 
     pub fn ty_param_to_ty(&self, param: ty::GenericParamDef) -> hir::Ty {
         debug!("ty_param_to_ty({:?}) {:?}", param, param.def_id);
+        let param_name = self.tcx.generic_param_name(param.def_id);
         hir::Ty {
             id: ast::DUMMY_NODE_ID,
             node: hir::TyKind::Path(hir::QPath::Resolved(
@@ -236,7 +238,7 @@ impl<'a, 'tcx, 'rcx, 'cstore> DocContext<'a, 'tcx, 'rcx, 'cstore> {
                     span: DUMMY_SP,
                     def: Def::TyParam(param.def_id),
                     segments: HirVec::from_vec(vec![
-                        hir::PathSegment::from_ident(Ident::from_interned_str(param.name))
+                        hir::PathSegment::from_ident(Ident::from_interned_str(param_name))
                     ]),
                 }),
             )),

Original file line number	Diff line number	Diff line change
`@@ -387,7 +387,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {`
`387`	`387`	`},`
`388`	`388`	`GenericParamDefKind::Lifetime => continue,`
`389`	`389`	`};`
`390`		`- let name = param.name.to_string();`
	`390`	`+ let name = self.tcx.generic_param_name(param.def_id).to_string();`
`391`	`391`	`flags.push((name, Some(value)));`
`392`	`392`	`}`
`393`	`393`
Original file line number	Diff line number	Diff line change
`@@ -637,7 +637,7 @@ impl fmt::Debug for ty::GenericParamDef {`
`637`	`637`	`};`
`638`	`638`	`write!(f, "{}({}, {:?}, {})",`
`639`	`639`	`type_name,`
`640`		`- self.name,`
	`640`	`+ ty::tls::with(\|tcx\| tcx.generic_param_name(self.def_id)),`
`641`	`641`	`self.def_id,`
`642`	`642`	`self.index)`
`643`	`643`	`}`