From 765eaac000849932a22af2058d345ff2b7b750b8 Mon Sep 17 00:00:00 2001 From: Srinivas Reddy Thatiparthy Date: Mon, 26 Sep 2016 08:44:41 +0530 Subject: [PATCH] run rustfmt on librustc_typeck/variance folder --- src/librustc_typeck/variance/constraints.rs | 148 +++++++++----------- src/librustc_typeck/variance/mod.rs | 1 - src/librustc_typeck/variance/solve.rs | 56 ++++---- src/librustc_typeck/variance/terms.rs | 86 ++++++------ src/librustc_typeck/variance/xform.rs | 6 +- 5 files changed, 145 insertions(+), 152 deletions(-) diff --git a/src/librustc_typeck/variance/constraints.rs b/src/librustc_typeck/variance/constraints.rs index b18792d894287..c9e93a1a46d62 100644 --- a/src/librustc_typeck/variance/constraints.rs +++ b/src/librustc_typeck/variance/constraints.rs @@ -37,7 +37,7 @@ pub struct ConstraintContext<'a, 'tcx: 'a> { invariant: VarianceTermPtr<'a>, bivariant: VarianceTermPtr<'a>, - pub constraints: Vec> , + pub constraints: Vec>, } /// Declares that the variable `decl_id` appears in a location with @@ -49,8 +49,7 @@ pub struct Constraint<'a> { } pub fn add_constraints_from_crate<'a, 'tcx>(terms_cx: TermsContext<'a, 'tcx>) - -> ConstraintContext<'a, 'tcx> -{ + -> ConstraintContext<'a, 'tcx> { let tcx = terms_cx.tcx; let covariant = terms_cx.arena.alloc(ConstantTerm(ty::Covariant)); let contravariant = terms_cx.arena.alloc(ConstantTerm(ty::Contravariant)); @@ -80,7 +79,9 @@ impl<'a, 'tcx, 'v> Visitor<'v> for ConstraintContext<'a, 'tcx> { debug!("visit_item item={}", tcx.map.node_to_string(item.id)); match item.node { - hir::ItemEnum(..) | hir::ItemStruct(..) | hir::ItemUnion(..) => { + hir::ItemEnum(..) | + hir::ItemStruct(..) | + hir::ItemUnion(..) => { let scheme = tcx.lookup_item_type(did); // Not entirely obvious: constraints on structs/enums do not @@ -111,8 +112,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for ConstraintContext<'a, 'tcx> { hir::ItemForeignMod(..) | hir::ItemTy(..) | hir::ItemImpl(..) | - hir::ItemDefaultImpl(..) => { - } + hir::ItemDefaultImpl(..) => {} } } } @@ -120,7 +120,8 @@ impl<'a, 'tcx, 'v> Visitor<'v> for ConstraintContext<'a, 'tcx> { /// Is `param_id` a lifetime according to `map`? fn is_lifetime(map: &hir_map::Map, param_id: ast::NodeId) -> bool { match map.find(param_id) { - Some(hir_map::NodeLifetime(..)) => true, _ => false + Some(hir_map::NodeLifetime(..)) => true, + _ => false, } } @@ -143,13 +144,12 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { let tcx = self.terms_cx.tcx; assert!(is_lifetime(&tcx.map, param_id)); match tcx.named_region_map.defs.get(¶m_id) { - Some(&rl::DefEarlyBoundRegion(_, lifetime_decl_id)) - => lifetime_decl_id, + Some(&rl::DefEarlyBoundRegion(_, lifetime_decl_id)) => lifetime_decl_id, Some(_) => bug!("should not encounter non early-bound cases"), // The lookup should only fail when `param_id` is // itself a lifetime binding: use it as the decl_id. - None => param_id, + None => param_id, } } @@ -163,14 +163,15 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { // parameter (by inspecting parent of its binding declaration // to see if it is introduced by a type or by a fn/impl). - let check_result = |this:&ConstraintContext| -> bool { + let check_result = |this: &ConstraintContext| -> bool { let tcx = this.terms_cx.tcx; let decl_id = this.find_binding_for_lifetime(param_id); // Currently only called on lifetimes; double-checking that. assert!(is_lifetime(&tcx.map, param_id)); let parent_id = tcx.map.get_parent(decl_id); - let parent = tcx.map.find(parent_id).unwrap_or_else( - || bug!("tcx.map missing entry for id: {}", parent_id)); + let parent = tcx.map + .find(parent_id) + .unwrap_or_else(|| bug!("tcx.map missing entry for id: {}", parent_id)); let is_inferred; macro_rules! cannot_happen { () => { { @@ -186,14 +187,14 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { hir::ItemEnum(..) | hir::ItemStruct(..) | hir::ItemUnion(..) | - hir::ItemTrait(..) => is_inferred = true, - hir::ItemFn(..) => is_inferred = false, - _ => cannot_happen!(), + hir::ItemTrait(..) => is_inferred = true, + hir::ItemFn(..) => is_inferred = false, + _ => cannot_happen!(), } } - hir_map::NodeTraitItem(..) => is_inferred = false, - hir_map::NodeImplItem(..) => is_inferred = false, - _ => cannot_happen!(), + hir_map::NodeTraitItem(..) => is_inferred = false, + hir_map::NodeImplItem(..) => is_inferred = false, + _ => cannot_happen!(), } return is_inferred; @@ -230,21 +231,18 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { fn add_constraint(&mut self, InferredIndex(index): InferredIndex, variance: VarianceTermPtr<'a>) { - debug!("add_constraint(index={}, variance={:?})", - index, variance); - self.constraints.push(Constraint { inferred: InferredIndex(index), - variance: variance }); + debug!("add_constraint(index={}, variance={:?})", index, variance); + self.constraints.push(Constraint { + inferred: InferredIndex(index), + variance: variance, + }); } - fn contravariant(&mut self, - variance: VarianceTermPtr<'a>) - -> VarianceTermPtr<'a> { + fn contravariant(&mut self, variance: VarianceTermPtr<'a>) -> VarianceTermPtr<'a> { self.xform(variance, self.contravariant) } - fn invariant(&mut self, - variance: VarianceTermPtr<'a>) - -> VarianceTermPtr<'a> { + fn invariant(&mut self, variance: VarianceTermPtr<'a>) -> VarianceTermPtr<'a> { self.xform(variance, self.invariant) } @@ -257,23 +255,16 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { } } - fn xform(&mut self, - v1: VarianceTermPtr<'a>, - v2: VarianceTermPtr<'a>) - -> VarianceTermPtr<'a> { + fn xform(&mut self, v1: VarianceTermPtr<'a>, v2: VarianceTermPtr<'a>) -> VarianceTermPtr<'a> { match (*v1, *v2) { (_, ConstantTerm(ty::Covariant)) => { // Applying a "covariant" transform is always a no-op v1 } - (ConstantTerm(c1), ConstantTerm(c2)) => { - self.constant_term(c1.xform(c2)) - } + (ConstantTerm(c1), ConstantTerm(c2)) => self.constant_term(c1.xform(c2)), - _ => { - &*self.terms_cx.arena.alloc(TransformTerm(v1, v2)) - } + _ => &*self.terms_cx.arena.alloc(TransformTerm(v1, v2)), } } @@ -292,13 +283,12 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { // README.md for a discussion on dep-graph management. self.tcx().dep_graph.read(ItemVariances::to_dep_node(&trait_ref.def_id)); - self.add_constraints_from_substs( - generics, - trait_ref.def_id, - &trait_def.generics.types, - &trait_def.generics.regions, - trait_ref.substs, - variance); + self.add_constraints_from_substs(generics, + trait_ref.def_id, + &trait_def.generics.types, + &trait_def.generics.regions, + trait_ref.substs, + variance); } /// Adds constraints appropriate for an instance of `ty` appearing @@ -313,13 +303,13 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { variance); match ty.sty { - ty::TyBool | - ty::TyChar | ty::TyInt(_) | ty::TyUint(_) | - ty::TyFloat(_) | ty::TyStr | ty::TyNever => { - /* leaf type -- noop */ + ty::TyBool | ty::TyChar | ty::TyInt(_) | ty::TyUint(_) | ty::TyFloat(_) | + ty::TyStr | ty::TyNever => { + // leaf type -- noop } - ty::TyClosure(..) | ty::TyAnon(..) => { + ty::TyClosure(..) | + ty::TyAnon(..) => { bug!("Unexpected closure type in variance computation"); } @@ -329,11 +319,12 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { self.add_constraints_from_mt(generics, mt, variance); } - ty::TyBox(typ) | ty::TyArray(typ, _) | ty::TySlice(typ) => { + ty::TyBox(typ) | + ty::TyArray(typ, _) | + ty::TySlice(typ) => { self.add_constraints_from_ty(generics, typ, variance); } - ty::TyRawPtr(ref mt) => { self.add_constraints_from_mt(generics, mt, variance); } @@ -352,13 +343,12 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { // README.md for a discussion on dep-graph management. self.tcx().dep_graph.read(ItemVariances::to_dep_node(&def.did)); - self.add_constraints_from_substs( - generics, - def.did, - &item_type.generics.types, - &item_type.generics.regions, - substs, - variance); + self.add_constraints_from_substs(generics, + def.did, + &item_type.generics.types, + &item_type.generics.regions, + substs, + variance); } ty::TyProjection(ref data) => { @@ -370,13 +360,12 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { // README.md for a discussion on dep-graph management. self.tcx().dep_graph.read(ItemVariances::to_dep_node(&trait_ref.def_id)); - self.add_constraints_from_substs( - generics, - trait_ref.def_id, - &trait_def.generics.types, - &trait_def.generics.regions, - trait_ref.substs, - variance); + self.add_constraints_from_substs(generics, + trait_ref.def_id, + &trait_def.generics.types, + &trait_def.generics.regions, + trait_ref.substs, + variance); } ty::TyTrait(ref data) => { @@ -384,8 +373,7 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { let contra = self.contravariant(variance); self.add_constraints_from_region(generics, data.region_bound, contra); - let poly_trait_ref = - data.principal.with_self_ty(self.tcx(), self.tcx().types.err); + let poly_trait_ref = data.principal.with_self_ty(self.tcx(), self.tcx().types.err); self.add_constraints_from_trait_ref(generics, poly_trait_ref.0, variance); for projection in &data.projection_bounds { @@ -425,7 +413,8 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { ty::TyInfer(..) => { bug!("unexpected type encountered in \ - variance inference: {}", ty); + variance inference: {}", + ty); } } } @@ -445,18 +434,17 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { variance); for p in type_param_defs { - let variance_decl = - self.declared_variance(p.def_id, def_id, p.index as usize); + let variance_decl = self.declared_variance(p.def_id, def_id, p.index as usize); let variance_i = self.xform(variance, variance_decl); let substs_ty = substs.type_for_def(p); debug!("add_constraints_from_substs: variance_decl={:?} variance_i={:?}", - variance_decl, variance_i); + variance_decl, + variance_i); self.add_constraints_from_ty(generics, substs_ty, variance_i); } for p in region_param_defs { - let variance_decl = - self.declared_variance(p.def_id, def_id, p.index as usize); + let variance_decl = self.declared_variance(p.def_id, def_id, p.index as usize); let variance_i = self.xform(variance, variance_decl); let substs_r = substs.region_for_def(p); self.add_constraints_from_region(generics, substs_r, variance_i); @@ -494,15 +482,19 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { } } - ty::ReStatic => { } + ty::ReStatic => {} ty::ReLateBound(..) => { // We do not infer variance for region parameters on // methods or in fn types. } - ty::ReFree(..) | ty::ReScope(..) | ty::ReVar(..) | - ty::ReSkolemized(..) | ty::ReEmpty | ty::ReErased => { + ty::ReFree(..) | + ty::ReScope(..) | + ty::ReVar(..) | + ty::ReSkolemized(..) | + ty::ReEmpty | + ty::ReErased => { // We don't expect to see anything but 'static or bound // regions when visiting member types or method types. bug!("unexpected region encountered in variance \ diff --git a/src/librustc_typeck/variance/mod.rs b/src/librustc_typeck/variance/mod.rs index 13ed6cf764140..cd0ab1cbb9543 100644 --- a/src/librustc_typeck/variance/mod.rs +++ b/src/librustc_typeck/variance/mod.rs @@ -34,4 +34,3 @@ pub fn infer_variance<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) { solve::solve_constraints(constraints_cx); tcx.variance_computed.set(true); } - diff --git a/src/librustc_typeck/variance/solve.rs b/src/librustc_typeck/variance/solve.rs index 82b63d0cc0937..a5c53b4c6291c 100644 --- a/src/librustc_typeck/variance/solve.rs +++ b/src/librustc_typeck/variance/solve.rs @@ -25,24 +25,24 @@ use super::xform::*; struct SolveContext<'a, 'tcx: 'a> { terms_cx: TermsContext<'a, 'tcx>, - constraints: Vec> , + constraints: Vec>, // Maps from an InferredIndex to the inferred value for that variable. - solutions: Vec + solutions: Vec, } pub fn solve_constraints(constraints_cx: ConstraintContext) { let ConstraintContext { terms_cx, constraints, .. } = constraints_cx; - let solutions = - terms_cx.inferred_infos.iter() - .map(|ii| ii.initial_variance) - .collect(); + let solutions = terms_cx.inferred_infos + .iter() + .map(|ii| ii.initial_variance) + .collect(); let mut solutions_cx = SolveContext { terms_cx: terms_cx, constraints: constraints, - solutions: solutions + solutions: solutions, }; solutions_cx.solve(); solutions_cx.write(); @@ -68,13 +68,13 @@ impl<'a, 'tcx> SolveContext<'a, 'tcx> { if old_value != new_value { debug!("Updating inferred {} (node {}) \ from {:?} to {:?} due to {:?}", - inferred, - self.terms_cx - .inferred_infos[inferred] - .param_id, - old_value, - new_value, - term); + inferred, + self.terms_cx + .inferred_infos[inferred] + .param_id, + old_value, + new_value, + term); self.solutions[inferred] = new_value; changed = true; @@ -114,36 +114,40 @@ impl<'a, 'tcx> SolveContext<'a, 'tcx> { let info = &inferred_infos[index]; let variance = solutions[index]; debug!("Index {} Info {} Variance {:?}", - index, info.index, variance); + index, + info.index, + variance); assert_eq!(item_variances.len(), info.index); item_variances.push(variance); index += 1; } - debug!("item_id={} item_variances={:?}", - item_id, - item_variances); + debug!("item_id={} item_variances={:?}", item_id, item_variances); let item_def_id = tcx.map.local_def_id(item_id); // For unit testing: check for a special "rustc_variance" // attribute and report an error with various results if found. if tcx.has_attr(item_def_id, "rustc_variance") { - span_err!(tcx.sess, tcx.map.span(item_id), E0208, "{:?}", item_variances); + span_err!(tcx.sess, + tcx.map.span(item_id), + E0208, + "{:?}", + item_variances); } - let newly_added = tcx.item_variance_map.borrow_mut() - .insert(item_def_id, Rc::new(item_variances)).is_none(); + let newly_added = tcx.item_variance_map + .borrow_mut() + .insert(item_def_id, Rc::new(item_variances)) + .is_none(); assert!(newly_added); } } fn evaluate(&self, term: VarianceTermPtr<'a>) -> ty::Variance { match *term { - ConstantTerm(v) => { - v - } + ConstantTerm(v) => v, TransformTerm(t1, t2) => { let v1 = self.evaluate(t1); @@ -151,9 +155,7 @@ impl<'a, 'tcx> SolveContext<'a, 'tcx> { v1.xform(v2) } - InferredTerm(InferredIndex(index)) => { - self.solutions[index] - } + InferredTerm(InferredIndex(index)) => self.solutions[index], } } } diff --git a/src/librustc_typeck/variance/terms.rs b/src/librustc_typeck/variance/terms.rs index 577a47a35e125..f6732f36e355a 100644 --- a/src/librustc_typeck/variance/terms.rs +++ b/src/librustc_typeck/variance/terms.rs @@ -49,7 +49,12 @@ impl<'a> fmt::Debug for VarianceTerm<'a> { match *self { ConstantTerm(c1) => write!(f, "{:?}", c1), TransformTerm(v1, v2) => write!(f, "({:?} \u{00D7} {:?})", v1, v2), - InferredTerm(id) => write!(f, "[{}]", { let InferredIndex(i) = id; i }) + InferredTerm(id) => { + write!(f, "[{}]", { + let InferredIndex(i) = id; + i + }) + } } } } @@ -72,7 +77,7 @@ pub struct TermsContext<'a, 'tcx: 'a> { pub inferred_map: NodeMap, // Maps from an InferredIndex to the info for that variable. - pub inferred_infos: Vec> , + pub inferred_infos: Vec>, } pub struct InferredInfo<'a> { @@ -87,11 +92,9 @@ pub struct InferredInfo<'a> { pub initial_variance: ty::Variance, } -pub fn determine_parameters_to_be_inferred<'a, 'tcx>( - tcx: TyCtxt<'a, 'tcx, 'tcx>, - arena: &'a mut TypedArena>) - -> TermsContext<'a, 'tcx> -{ +pub fn determine_parameters_to_be_inferred<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, + arena: &'a mut TypedArena>) + -> TermsContext<'a, 'tcx> { let mut terms_cx = TermsContext { tcx: tcx, arena: arena, @@ -102,17 +105,16 @@ pub fn determine_parameters_to_be_inferred<'a, 'tcx>( // cache and share the variance struct used for items with // no type/region parameters - empty_variances: Rc::new(vec![]) + empty_variances: Rc::new(vec![]), }; // See README.md for a discussion on dep-graph management. - tcx.visit_all_items_in_krate(|def_id| ItemVariances::to_dep_node(&def_id), - &mut terms_cx); + tcx.visit_all_items_in_krate(|def_id| ItemVariances::to_dep_node(&def_id), &mut terms_cx); terms_cx } -fn lang_items(tcx: TyCtxt) -> Vec<(ast::NodeId,Vec)> { +fn lang_items(tcx: TyCtxt) -> Vec<(ast::NodeId, Vec)> { let all = vec![ (tcx.lang_items.phantom_data(), vec![ty::Covariant]), (tcx.lang_items.unsafe_cell_type(), vec![ty::Invariant]), @@ -138,15 +140,13 @@ impl<'a, 'tcx> TermsContext<'a, 'tcx> { fn add_inferreds_for_item(&mut self, item_id: ast::NodeId, has_self: bool, - generics: &hir::Generics) - { - /*! - * Add "inferreds" for the generic parameters declared on this - * item. This has a lot of annoying parameters because we are - * trying to drive this from the AST, rather than the - * ty::Generics, so that we can get span info -- but this - * means we must accommodate syntactic distinctions. - */ + generics: &hir::Generics) { + //! Add "inferreds" for the generic parameters declared on this + //! item. This has a lot of annoying parameters because we are + //! trying to drive this from the AST, rather than the + //! ty::Generics, so that we can get span info -- but this + //! means we must accommodate syntactic distinctions. + //! // NB: In the code below for writing the results back into the // tcx, we rely on the fact that all inferreds for a particular @@ -178,26 +178,26 @@ impl<'a, 'tcx> TermsContext<'a, 'tcx> { // parameters". if self.num_inferred() == inferreds_on_entry { let item_def_id = self.tcx.map.local_def_id(item_id); - let newly_added = - self.tcx.item_variance_map.borrow_mut().insert( - item_def_id, - self.empty_variances.clone()).is_none(); + let newly_added = self.tcx + .item_variance_map + .borrow_mut() + .insert(item_def_id, self.empty_variances.clone()) + .is_none(); assert!(newly_added); } } - fn add_inferred(&mut self, - item_id: ast::NodeId, - index: usize, - param_id: ast::NodeId) { + fn add_inferred(&mut self, item_id: ast::NodeId, index: usize, param_id: ast::NodeId) { let inf_index = InferredIndex(self.inferred_infos.len()); let term = self.arena.alloc(InferredTerm(inf_index)); let initial_variance = self.pick_initial_variance(item_id, index); - self.inferred_infos.push(InferredInfo { item_id: item_id, - index: index, - param_id: param_id, - term: term, - initial_variance: initial_variance }); + self.inferred_infos.push(InferredInfo { + item_id: item_id, + index: index, + param_id: param_id, + term: term, + initial_variance: initial_variance, + }); let newly_added = self.inferred_map.insert(param_id, inf_index).is_none(); assert!(newly_added); @@ -208,18 +208,17 @@ impl<'a, 'tcx> TermsContext<'a, 'tcx> { inf_index={:?}, \ initial_variance={:?})", self.tcx.item_path_str(self.tcx.map.local_def_id(item_id)), - item_id, index, param_id, inf_index, + item_id, + index, + param_id, + inf_index, initial_variance); } - fn pick_initial_variance(&self, - item_id: ast::NodeId, - index: usize) - -> ty::Variance - { + fn pick_initial_variance(&self, item_id: ast::NodeId, index: usize) -> ty::Variance { match self.lang_items.iter().find(|&&(n, _)| n == item_id) { Some(&(_, ref variances)) => variances[index], - None => ty::Bivariant + None => ty::Bivariant, } } @@ -230,7 +229,8 @@ impl<'a, 'tcx> TermsContext<'a, 'tcx> { impl<'a, 'tcx, 'v> Visitor<'v> for TermsContext<'a, 'tcx> { fn visit_item(&mut self, item: &hir::Item) { - debug!("add_inferreds for item {}", self.tcx.map.node_to_string(item.id)); + debug!("add_inferreds for item {}", + self.tcx.map.node_to_string(item.id)); match item.node { hir::ItemEnum(_, ref generics) | @@ -254,9 +254,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for TermsContext<'a, 'tcx> { hir::ItemFn(..) | hir::ItemMod(..) | hir::ItemForeignMod(..) | - hir::ItemTy(..) => { - } + hir::ItemTy(..) => {} } } } - diff --git a/src/librustc_typeck/variance/xform.rs b/src/librustc_typeck/variance/xform.rs index 02a2ceb360d7f..507734ce35e44 100644 --- a/src/librustc_typeck/variance/xform.rs +++ b/src/librustc_typeck/variance/xform.rs @@ -47,7 +47,8 @@ pub fn glb(v1: ty::Variance, v2: ty::Variance) -> ty::Variance { // - + // o match (v1, v2) { - (ty::Invariant, _) | (_, ty::Invariant) => ty::Invariant, + (ty::Invariant, _) | + (_, ty::Invariant) => ty::Invariant, (ty::Covariant, ty::Contravariant) => ty::Invariant, (ty::Contravariant, ty::Covariant) => ty::Invariant, @@ -56,6 +57,7 @@ pub fn glb(v1: ty::Variance, v2: ty::Variance) -> ty::Variance { (ty::Contravariant, ty::Contravariant) => ty::Contravariant, - (x, ty::Bivariant) | (ty::Bivariant, x) => x, + (x, ty::Bivariant) | + (ty::Bivariant, x) => x, } }