From 9200bdee2699b5d846c6d0e19ee6369007f06e2e Mon Sep 17 00:00:00 2001 From: varkor Date: Thu, 10 May 2018 23:02:41 +0100 Subject: [PATCH] Refactor generic params loops --- src/librustc/hir/lowering.rs | 16 +++--- src/librustc/hir/print.rs | 5 +- src/librustc/infer/anon_types/mod.rs | 13 ++--- src/librustc/traits/auto_trait.rs | 9 +++- src/librustc/traits/error_reporting.rs | 18 +++---- src/librustc/traits/on_unimplemented.rs | 7 +-- src/librustc/ty/context.rs | 26 +++++---- src/librustc/ty/mod.rs | 60 +++------------------ src/librustc/ty/sty.rs | 2 +- src/librustc/util/ppaux.rs | 8 +-- src/librustc_privacy/lib.rs | 4 +- src/librustc_typeck/astconv.rs | 10 ++-- src/librustc_typeck/check/method/confirm.rs | 3 +- src/librustc_typeck/check/mod.rs | 19 ++++--- src/librustc_typeck/check/wfcheck.rs | 33 ++++++------ src/librustc_typeck/collect.rs | 6 +-- src/librustdoc/clean/mod.rs | 2 +- src/libsyntax/visit.rs | 4 +- src/libsyntax_ext/deriving/generic/mod.rs | 6 +-- src/libsyntax_ext/deriving/generic/ty.rs | 9 +--- 20 files changed, 95 insertions(+), 165 deletions(-) diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs index 77c2dd219c4..628b871ed51 100644 --- a/src/librustc/hir/lowering.rs +++ b/src/librustc/hir/lowering.rs @@ -374,8 +374,8 @@ fn visit_item(&mut self, item: &'lcx Item) { if item_lowered { let item_lifetimes = match self.lctx.items.get(&item.id).unwrap().node { - hir::Item_::ItemImpl(_, _, _, ref generics, .. ) | - hir::Item_::ItemTrait(_, _, ref generics, .. ) => { + hir::Item_::ItemImpl(_, _, _, ref generics, ..) + | hir::Item_::ItemTrait(_, _, ref generics, ..) => { generics.lifetimes().cloned().collect::>() } _ => Vec::new(), @@ -1895,13 +1895,11 @@ fn lower_generic_params( GenericParam::Lifetime(ref lifetime_def) => { hir::GenericParam::Lifetime(self.lower_lifetime_def(lifetime_def)) } - GenericParam::Type(ref ty_param) => { - hir::GenericParam::Type(self.lower_ty_param( - ty_param, - add_bounds.get(&ty_param.id).map_or(&[][..], |x| &x), - itctx, - )) - } + GenericParam::Type(ref ty_param) => hir::GenericParam::Type(self.lower_ty_param( + ty_param, + add_bounds.get(&ty_param.id).map_or(&[][..], |x| &x), + itctx, + )), }) .collect() } diff --git a/src/librustc/hir/print.rs b/src/librustc/hir/print.rs index 2dc46f5f69d..3943c30127d 100644 --- a/src/librustc/hir/print.rs +++ b/src/librustc/hir/print.rs @@ -2043,10 +2043,7 @@ pub fn print_lifetime_def(&mut self, lifetime: &hir::LifetimeDef) -> io::Result< Ok(()) } - pub fn print_generic_params(&mut self, - generic_params: &[hir::GenericParam]) - -> io::Result<()> - { + pub fn print_generic_params(&mut self, generic_params: &[hir::GenericParam]) -> io::Result<()> { if !generic_params.is_empty() { self.s.word("<")?; diff --git a/src/librustc/infer/anon_types/mod.rs b/src/librustc/infer/anon_types/mod.rs index 0af95a74686..95727d10b18 100644 --- a/src/librustc/infer/anon_types/mod.rs +++ b/src/librustc/infer/anon_types/mod.rs @@ -313,16 +313,13 @@ fn constrain_anon_type>( // `['a]` for the first impl trait and `'b` for the // second. let mut least_region = None; - for index in abstract_type_generics.params.iter().filter_map(|param| { - if let GenericParamDefKind::Lifetime(_) = param.kind { - // Find the index of this region in the list of substitutions. - Some(param.index as usize) - } else { - None + for param in &abstract_type_generics.params { + match param.kind { + GenericParamDefKind::Lifetime(_) => {} + _ => continue } - }) { // Get the value supplied for this region from the substs. - let subst_arg = anon_defn.substs.region_at(index); + let subst_arg = anon_defn.substs.region_at(param.index as usize); // Compute the least upper bound of it with the other regions. debug!("constrain_anon_types: least_region={:?}", least_region); diff --git a/src/librustc/traits/auto_trait.rs b/src/librustc/traits/auto_trait.rs index 5d708f60604..4bb5387efb3 100644 --- a/src/librustc/traits/auto_trait.rs +++ b/src/librustc/traits/auto_trait.rs @@ -222,9 +222,14 @@ pub fn find_auto_trait_generics( }); let names_map: FxHashSet = generics - .regions + .params .iter() - .map(|l| l.name.to_string()) + .filter_map(|param| { + match param.kind { + ty::GenericParamDefKind::Lifetime(_) => Some(param.name.to_string()), + _ => None + } + }) .collect(); let body_ids: FxHashSet<_> = infcx diff --git a/src/librustc/traits/error_reporting.rs b/src/librustc/traits/error_reporting.rs index 2f0691d241e..9d71fe6f2d7 100644 --- a/src/librustc/traits/error_reporting.rs +++ b/src/librustc/traits/error_reporting.rs @@ -379,16 +379,16 @@ fn on_unimplemented_note( flags.push(("_Self".to_string(), Some(self.tcx.type_of(def.did).to_string()))); } - for param in generics.params.iter().filter(|param| { - match param.kind { - GenericParamDefKind::Type(_) => true, - GenericParamDefKind::Lifetime(_) => false, - } - }) { + for param in generics.params.iter() { let name = param.name.to_string(); - let ty = trait_ref.substs.type_for_def(¶m); - let ty_str = ty.to_string(); - flags.push((name.clone(), Some(ty_str.clone()))); + let value = match param.kind { + GenericParamDefKind::Type(_) => { + let ty = trait_ref.substs.type_for_def(¶m); + ty.to_string() + }, + GenericParamDefKind::Lifetime(_) => continue, + }; + flags.push((name.clone(), Some(value.clone()))); } if let Some(true) = self_ty.ty_to_def_id().map(|def_id| def_id.is_local()) { diff --git a/src/librustc/traits/on_unimplemented.rs b/src/librustc/traits/on_unimplemented.rs index e15542cb2c0..1980fbbe3ed 100644 --- a/src/librustc/traits/on_unimplemented.rs +++ b/src/librustc/traits/on_unimplemented.rs @@ -254,15 +254,12 @@ fn verify(&self, Position::ArgumentNamed(s) if s == name => (), // So is `{A}` if A is a type parameter Position::ArgumentNamed(s) => match generics.params.iter().find(|param| { - match param.kind { - GenericParamDefKind::Type(_) => param.name == s, - GenericParamDefKind::Lifetime(_) => false, - } + param.name == s }) { Some(_) => (), None => { span_err!(tcx.sess, span, E0230, - "there is no type parameter \ + "there is no parameter \ {} on trait {}", s, name); result = Err(ErrorReported); diff --git a/src/librustc/ty/context.rs b/src/librustc/ty/context.rs index ff4afdd8b7e..995d6c55767 100644 --- a/src/librustc/ty/context.rs +++ b/src/librustc/ty/context.rs @@ -35,7 +35,6 @@ use ty::subst::{Kind, Substs, Subst}; use ty::ReprOptions; use ty::Instance; -use ty::GenericParamDefKind; use traits; use traits::{Clause, Clauses, Goal, Goals}; use ty::{self, Ty, TypeAndMut}; @@ -2326,20 +2325,19 @@ pub fn mk_foreign(self, def_id: DefId) -> Ty<'tcx> { pub fn mk_box(self, ty: Ty<'tcx>) -> Ty<'tcx> { let def_id = self.require_lang_item(lang_items::OwnedBoxLangItem); let adt_def = self.adt_def(def_id); - let generics = self.generics_of(def_id); - let mut substs = vec![Kind::from(ty)]; - // Add defaults for other generic params if there are some. - for (def_id, has_default) in generics.params.iter().filter_map(|param| { - match param.kind { - GenericParamDefKind::Type(ty) => Some((param.def_id, ty.has_default)), - GenericParamDefKind::Lifetime(_) => None + let substs = Substs::for_item(self, def_id, |_, _| bug!(), |def, substs| { + if def.index == 0 { + ty + } else { + match def.kind { + ty::GenericParamDefKind::Type(ty_param) => { + assert!(ty_param.has_default); + self.type_of(def.def_id).subst(self, substs) + } + _ => unreachable!() + } } - }).skip(1) { - assert!(has_default); - let ty = self.type_of(def_id).subst(self, &substs); - substs.push(ty.into()); - } - let substs = self.mk_substs(substs.into_iter()); + }); self.mk_ty(TyAdt(adt_def, substs)) } diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs index 025e0794265..c3e9ffec9a0 100644 --- a/src/librustc/ty/mod.rs +++ b/src/librustc/ty/mod.rs @@ -804,7 +804,7 @@ pub struct Generics { pub parent_count: usize, pub params: Vec, - /// Reverse map to the `index` field of each `GenericParamDef`'s inner type + /// Reverse map to the `index` field of each `GenericParamDef` pub param_def_id_to_index: FxHashMap, pub has_self: bool, @@ -836,13 +836,11 @@ pub fn param_counts(&self) -> GenericParamCount { } pub fn requires_monomorphization(&self, tcx: TyCtxt<'a, 'gcx, 'tcx>) -> bool { - if self.params.iter().any(|param| { + for param in self.params.iter() { match param.kind { - GenericParamDefKind::Type(_) => true, - GenericParamDefKind::Lifetime(_) => false + GenericParamDefKind::Type(_) => return true, + GenericParamDefKind::Lifetime(_) => {} } - }) { - return true; } if let Some(parent_def_id) = self.parent { let parent = tcx.generics_of(parent_def_id); @@ -858,7 +856,7 @@ pub fn region_param(&'tcx self, -> &'tcx GenericParamDef { if let Some(index) = param.index.checked_sub(self.parent_count as u32) { - let ref param = self.params[index as usize]; + let param = &self.params[index as usize]; match param.kind { ty::GenericParamDefKind::Lifetime(_) => param, _ => bug!("expected region parameter, but found another generic parameter") @@ -875,53 +873,7 @@ pub fn type_param(&'tcx self, tcx: TyCtxt<'a, 'gcx, 'tcx>) -> &'tcx GenericParamDef { if let Some(index) = param.idx.checked_sub(self.parent_count as u32) { - // non-Self type parameters are always offset by exactly - // `self.regions.len()`. In the absence of a Self, this is obvious, - // but even in the presence of a `Self` we just have to "compensate" - // for the regions: - // - // Without a `Self` (or in a nested generics that doesn't have - // a `Self` in itself, even through it parent does), for example - // for `fn foo<'a, T1, T2>()`, the situation is: - // Substs: - // 0 1 2 - // 'a T1 T2 - // generics.types: - // 0 1 - // T1 T2 - // - // And with a `Self`, for example for `trait Foo<'a, 'b, T1, T2>`, the - // situation is: - // Substs: - // 0 1 2 3 4 - // Self 'a 'b T1 T2 - // generics.types: - // 0 1 2 - // Self T1 T2 - // - // And it can be seen that in both cases, to move from a substs - // offset to a generics offset you just have to offset by the - // number of regions. - let type_param_offset = self.param_counts().lifetimes; - - let has_self = self.has_self && self.parent.is_none(); - let is_separated_self = type_param_offset != 0 && index == 0 && has_self; - - if let Some(_) = (index as usize).checked_sub(type_param_offset) { - assert!(!is_separated_self, "found a Self after type_param_offset"); - let ref param = self.params[index as usize]; - match param.kind { - ty::GenericParamDefKind::Type(_) => param, - _ => bug!("expected type parameter, but found another generic parameter") - } - } else { - assert!(is_separated_self, "non-Self param before type_param_offset"); - let ref param = self.params[type_param_offset]; - match param.kind { - ty::GenericParamDefKind::Type(_) => param, - _ => bug!("expected type parameter, but found another generic parameter") - } - } + &self.params[index as usize] } else { tcx.generics_of(self.parent.expect("parent_count>0 but no parent?")) .type_param(param, tcx) diff --git a/src/librustc/ty/sty.rs b/src/librustc/ty/sty.rs index 792a6bfaedf..acc225ddf56 100644 --- a/src/librustc/ty/sty.rs +++ b/src/librustc/ty/sty.rs @@ -366,7 +366,7 @@ struct SplitGeneratorSubsts<'tcx> { impl<'tcx> GeneratorSubsts<'tcx> { fn split(self, def_id: DefId, tcx: TyCtxt<'_, '_, '_>) -> SplitGeneratorSubsts<'tcx> { let generics = tcx.generics_of(def_id); - let parent_len = generics.parent_count(); + let parent_len = generics.parent_count; SplitGeneratorSubsts { yield_ty: self.substs.type_at(parent_len), return_ty: self.substs.type_at(parent_len + 1), diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs index 47315c7243f..ca939b161d2 100644 --- a/src/librustc/util/ppaux.rs +++ b/src/librustc/util/ppaux.rs @@ -351,8 +351,10 @@ fn parameterized(&mut self, let zipped = iter::once((last_ty, types.next().unwrap())) .chain(type_params.zip(types)); for ((def_id, has_default), actual) in zipped { - if !has_default || - tcx.type_of(def_id).subst(tcx, substs) != actual { + if !has_default { + break; + } + if tcx.type_of(def_id).subst(tcx, substs) != actual { break; } num_supplied_defaults += 1; @@ -604,7 +606,7 @@ fn print(&self, f: &mut F, cx: &mut PrintContext) -> fmt::Result impl fmt::Debug for ty::GenericParamDef { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let type_name = match self.kind { - ty::GenericParamDefKind::Lifetime(_) => "Region", + ty::GenericParamDefKind::Lifetime(_) => "Lifetime", ty::GenericParamDefKind::Type(_) => "Type", }; write!(f, "{}({}, {:?}, {})", diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs index 1b2ec481a1c..929030e832e 100644 --- a/src/librustc_privacy/lib.rs +++ b/src/librustc_privacy/lib.rs @@ -399,7 +399,7 @@ fn visit_ty(&mut self, ty: &'tcx hir::Ty) { impl<'b, 'a, 'tcx> ReachEverythingInTheInterfaceVisitor<'b, 'a, 'tcx> { fn generics(&mut self) -> &mut Self { - for param in self.ev.tcx.generics_of(self.item_def_id).params.iter() { + for param in &self.ev.tcx.generics_of(self.item_def_id).params { match param.kind { GenericParamDefKind::Type(ty) => { if ty.has_default { @@ -1340,7 +1340,7 @@ struct SearchInterfaceForPrivateItemsVisitor<'a, 'tcx: 'a> { impl<'a, 'tcx: 'a> SearchInterfaceForPrivateItemsVisitor<'a, 'tcx> { fn generics(&mut self) -> &mut Self { - for param in self.tcx.generics_of(self.item_def_id).params.iter() { + for param in &self.tcx.generics_of(self.item_def_id).params { match param.kind { GenericParamDefKind::Type(ty) => { if ty.has_default { diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs index 3d77c9d39a5..e4d5ce05457 100644 --- a/src/librustc_typeck/astconv.rs +++ b/src/librustc_typeck/astconv.rs @@ -222,8 +222,8 @@ fn create_substs_for_ast_path(&self, assert_eq!(decl_generics.has_self, self_ty.is_some()); // Check the number of type parameters supplied by the user. - let type_params_offset = self_ty.is_some() as usize; - let ty_param_defs = param_counts.types - type_params_offset; + let own_self = self_ty.is_some() as usize; + let ty_param_defs = param_counts.types - own_self; if !infer_types || num_types_provided > ty_param_defs { let type_params_without_defaults = { let mut count = 0; @@ -241,7 +241,7 @@ fn create_substs_for_ast_path(&self, span, num_types_provided, ty_param_defs, - type_params_without_defaults - type_params_offset); + type_params_without_defaults - own_self); } let is_object = self_ty.map_or(false, |ty| ty.sty == TRAIT_OBJECT_DUMMY_SELF); @@ -258,7 +258,7 @@ fn create_substs_for_ast_path(&self, }; let substs = Substs::for_item(tcx, def_id, |def, _| { - let i = def.index as usize - type_params_offset; + let i = def.index as usize - own_self; if let Some(lifetime) = parameters.lifetimes.get(i) { self.ast_region_to_region(lifetime, Some(def)) } else { @@ -272,7 +272,7 @@ fn create_substs_for_ast_path(&self, return ty; } - let i = i - (param_counts.lifetimes + type_params_offset); + let i = i - (param_counts.lifetimes + own_self); if i < num_types_provided { // A provided type parameter. self.ast_ty_to_ty(¶meters.types[i]) diff --git a/src/librustc_typeck/check/method/confirm.rs b/src/librustc_typeck/check/method/confirm.rs index eab26046147..cfb84412317 100644 --- a/src/librustc_typeck/check/method/confirm.rs +++ b/src/librustc_typeck/check/method/confirm.rs @@ -316,6 +316,7 @@ fn instantiate_method_substs(&mut self, // parameters from the type and those from the method. assert_eq!(method_generics.parent_count, parent_substs.len()); let provided = &segment.parameters; + let param_counts = method_generics.param_counts(); Substs::for_item(self.tcx, pick.item.def_id, |def, _| { let i = def.index as usize; if i < parent_substs.len() { @@ -333,7 +334,7 @@ fn instantiate_method_substs(&mut self, } else if let Some(ast_ty) = provided.as_ref().and_then(|p| { let idx = - i - parent_substs.len() - method_generics.param_counts().lifetimes; + i - parent_substs.len() - param_counts.lifetimes; p.types.get(idx) }) { diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index e5dffeed560..256e44a2d6b 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -4918,13 +4918,12 @@ fn check_path_parameter_count(&self, }; // Check provided parameters. - let (ty_non_def_req_len, ty_req_len, lt_req_len) = + let (ty_req_len, accepted, lt_req_len) = segment.map_or((0, 0, 0), |(_, generics)| { let param_counts = generics.param_counts(); - let type_params_offset - = (generics.parent.is_none() && generics.has_self) as usize; - let type_params = param_counts.types - type_params_offset; + let own_self = (generics.parent.is_none() && generics.has_self) as usize; + let type_params = param_counts.types - own_self; let type_params_without_defaults = { let mut count = 0; for param in generics.params.iter() { @@ -4937,14 +4936,14 @@ fn check_path_parameter_count(&self, count }; let type_params_barring_defaults = - type_params_without_defaults - type_params_offset; + type_params_without_defaults - own_self; (type_params_barring_defaults, type_params, param_counts.lifetimes) }); - if types.len() > ty_req_len { - let span = types[ty_req_len].span; - let expected_text = count_type_params(ty_req_len); + if types.len() > accepted { + let span = types[accepted].span; + let expected_text = count_type_params(accepted); let actual_text = count_type_params(types.len()); struct_span_err!(self.tcx.sess, span, E0087, "too many type parameters provided: \ @@ -4957,8 +4956,8 @@ fn check_path_parameter_count(&self, // type parameters, we force instantiate_value_path to // use inference variables instead of the provided types. *segment = None; - } else if types.len() < ty_non_def_req_len && !infer_types && !supress_mismatch_error { - let expected_text = count_type_params(ty_non_def_req_len); + } else if types.len() < ty_req_len && !infer_types && !supress_mismatch_error { + let expected_text = count_type_params(ty_req_len); let actual_text = count_type_params(types.len()); struct_span_err!(self.tcx.sess, span, E0089, "too few type parameters provided: \ diff --git a/src/librustc_typeck/check/wfcheck.rs b/src/librustc_typeck/check/wfcheck.rs index 00a75a7d870..740a3dfcac9 100644 --- a/src/librustc_typeck/check/wfcheck.rs +++ b/src/librustc_typeck/check/wfcheck.rs @@ -378,22 +378,19 @@ fn check_where_clauses<'a, 'gcx, 'fcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'gcx>, // For example this forbids the declaration: // struct Foo> { .. } // Here the default `Vec<[u32]>` is not WF because `[u32]: Sized` does not hold. - for d in generics.params.iter().filter_map(|param| { + for param in &generics.params { if let GenericParamDefKind::Type(_) = param.kind { if is_our_default(¶m) { - return Some(param.def_id); + let ty = fcx.tcx.type_of(param.def_id); + // ignore dependent defaults -- that is, where the default of one type + // parameter includes another (e.g., ). In those cases, we can't + // be sure if it will error or not as user might always specify the other. + if !ty.needs_subst() { + fcx.register_wf_obligation(ty, fcx.tcx.def_span(param.def_id), + ObligationCauseCode::MiscObligation); + } } } - None - }) { - let ty = fcx.tcx.type_of(d); - // ignore dependent defaults -- that is, where the default of one type - // parameter includes another (e.g., ). In those cases, we can't - // be sure if it will error or not as user might always specify the other. - if !ty.needs_subst() { - fcx.register_wf_obligation(ty, fcx.tcx.def_span(d), - ObligationCauseCode::MiscObligation); - } } // Check that trait predicates are WF when params are substituted by their defaults. @@ -662,20 +659,20 @@ fn reject_shadowing_parameters(tcx: TyCtxt, def_id: DefId) { .collect(); for method_param in generics.params.iter() { - let (name, def_id) = match method_param.kind { + match method_param.kind { // Shadowing is checked in resolve_lifetime. GenericParamDefKind::Lifetime(_) => continue, - GenericParamDefKind::Type(_) => (method_param.name, method_param.def_id), + _ => {}, }; - if impl_params.contains_key(&name) { + 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(def_id); + 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[&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, &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 index 6945f8f3c07..3be702189fb 100644 --- a/src/librustc_typeck/collect.rs +++ b/src/librustc_typeck/collect.rs @@ -903,7 +903,7 @@ fn generics_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, // Now create the real type parameters. let type_start = own_start + lifetimes.len() as u32; - let types = ast_generics.ty_params().enumerate().map(|(i, p)| { + let mut types: Vec<_> = ast_generics.ty_params().enumerate().map(|(i, p)| { if p.name == keywords::SelfType.name() { span_bug!(p.span, "`Self` should not be the name of a regular parameter"); } @@ -931,9 +931,7 @@ fn generics_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, synthetic: p.synthetic, }), } - }); - - let mut types: Vec<_> = types.into_iter().collect(); + }).collect(); // provide junk type parameter defs - the only place that // cares about anything but the length is instantiation, diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 35a7b27670a..69999eb69b0 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -1753,7 +1753,7 @@ fn clean(&self, cx: &DocContext) -> Generics { let mut params = Vec::with_capacity(self.params.len()); for p in &self.params { let p = p.clean(cx); - if let GenericParam::Type(ref tp) = p { + if let GenericParamDef::Type(ref tp) = p { if tp.synthetic == Some(hir::SyntheticTyParamKind::ImplTrait) { cx.impl_trait_bounds.borrow_mut().insert(tp.did, tp.bounds.clone()); } diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs index 3f9e0b9fbb5..40d59d3ff8b 100644 --- a/src/libsyntax/visit.rs +++ b/src/libsyntax/visit.rs @@ -72,9 +72,7 @@ fn visit_pat(&mut self, p: &'ast Pat) { walk_pat(self, p) } fn visit_expr(&mut self, ex: &'ast Expr) { walk_expr(self, ex) } fn visit_expr_post(&mut self, _ex: &'ast Expr) { } fn visit_ty(&mut self, t: &'ast Ty) { walk_ty(self, t) } - fn visit_generic_param(&mut self, param: &'ast GenericParam) { - walk_generic_param(self, param) - } + fn visit_generic_param(&mut self, param: &'ast GenericParam) { walk_generic_param(self, param) } fn visit_generics(&mut self, g: &'ast Generics) { walk_generics(self, g) } fn visit_where_predicate(&mut self, p: &'ast WherePredicate) { walk_where_predicate(self, p) diff --git a/src/libsyntax_ext/deriving/generic/mod.rs b/src/libsyntax_ext/deriving/generic/mod.rs index ddf3ae41faa..80f65957c39 100644 --- a/src/libsyntax_ext/deriving/generic/mod.rs +++ b/src/libsyntax_ext/deriving/generic/mod.rs @@ -570,11 +570,7 @@ fn create_derived_impl(&self, bounds.push((*declared_bound).clone()); } - GenericParam::Type(cx.typaram(self.span, - ty_param.ident, - vec![], - bounds, - None)) + GenericParam::Type(cx.typaram(self.span, ty_param.ident, vec![], bounds, None)) } } })); diff --git a/src/libsyntax_ext/deriving/generic/ty.rs b/src/libsyntax_ext/deriving/generic/ty.rs index 76950a546cf..25a29694488 100644 --- a/src/libsyntax_ext/deriving/generic/ty.rs +++ b/src/libsyntax_ext/deriving/generic/ty.rs @@ -187,9 +187,7 @@ pub fn to_path(&self, let self_params = self_generics.params .iter() .filter_map(|param| match *param { - GenericParam::Type(ref ty_param) => { - Some(cx.ty_ident(span, ty_param.ident)) - } + GenericParam::Type(ref ty_param) => Some(cx.ty_ident(span, ty_param.ident)), _ => None, }) .collect(); @@ -272,10 +270,7 @@ pub fn to_generics(&self, let bounds = bounds.iter() .map(|b| cx.lifetime(span, Ident::from_str(b))) .collect(); - GenericParam::Lifetime(cx.lifetime_def(span, - Ident::from_str(lt), - vec![], - bounds)) + GenericParam::Lifetime(cx.lifetime_def(span, Ident::from_str(lt), vec![], bounds)) }) .chain(self.bounds .iter() -- GitLab