From 0bea550a2a78eba05533f333cc2a0e7f9b5b44e8 Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Tue, 24 Feb 2015 09:50:36 +0100 Subject: [PATCH] style nitpicks --- src/libcollections/btree/map.rs | 8 +- src/librustc/metadata/loader.rs | 12 +- src/librustc/middle/infer/combine.rs | 332 +++++++++--------- .../middle/infer/region_inference/mod.rs | 16 +- src/librustc/middle/traits/select.rs | 160 +++------ src/librustc_trans/trans/consts.rs | 24 +- 6 files changed, 241 insertions(+), 311 deletions(-) diff --git a/src/libcollections/btree/map.rs b/src/libcollections/btree/map.rs index 1b456eec830..64d9d99d88d 100644 --- a/src/libcollections/btree/map.rs +++ b/src/libcollections/btree/map.rs @@ -347,7 +347,7 @@ impl BTreeMap { let result = stack.with(move |pusher, node| { // Same basic logic as found in `find`, but with PartialSearchStack mediating the // actual nodes for us - return match Node::search(node, &key) { + match Node::search(node, &key) { Found(mut handle) => { // Perfect match, swap the values and return the old one mem::swap(handle.val_mut(), &mut value); @@ -372,7 +372,7 @@ impl BTreeMap { } }); match result { - Finished(ret) => { return ret; }, + Finished(ret) => return ret, Continue((new_stack, renewed_key, renewed_val)) => { stack = new_stack; key = renewed_key; @@ -439,7 +439,7 @@ impl BTreeMap { let mut stack = stack::PartialSearchStack::new(self); loop { let result = stack.with(move |pusher, node| { - return match Node::search(node, key) { + match Node::search(node, key) { Found(handle) => { // Perfect match. Terminate the stack here, and remove the entry Finished(Some(pusher.seal(handle).remove())) @@ -1560,7 +1560,7 @@ impl BTreeMap { let mut stack = stack::PartialSearchStack::new(self); loop { let result = stack.with(move |pusher, node| { - return match Node::search(node, &key) { + match Node::search(node, &key) { Found(handle) => { // Perfect match Finished(Occupied(OccupiedEntry { diff --git a/src/librustc/metadata/loader.rs b/src/librustc/metadata/loader.rs index fbc3e76cf93..07082d81876 100644 --- a/src/librustc/metadata/loader.rs +++ b/src/librustc/metadata/loader.rs @@ -736,12 +736,10 @@ fn get_metadata_section_imp(is_osx: bool, filename: &Path) -> Result { - return Err((format!("failed to read rlib metadata: '{}'", - filename.display()))) - } - Some(blob) => return Ok(blob) - } + None => Err(format!("failed to read rlib metadata: '{}'", + filename.display())), + Some(blob) => Ok(blob) + }; } unsafe { let buf = CString::new(filename.as_vec()).unwrap(); @@ -791,7 +789,7 @@ fn get_metadata_section_imp(is_osx: bool, filename: &Path) -> Result : Sized { variadic: a.variadic}); - fn argvecs<'tcx, C: Combine<'tcx>>(combiner: &C, - a_args: &[Ty<'tcx>], - b_args: &[Ty<'tcx>]) - -> cres<'tcx, Vec>> - { + fn argvecs<'tcx, C>(combiner: &C, + a_args: &[Ty<'tcx>], + b_args: &[Ty<'tcx>]) + -> cres<'tcx, Vec>> + where C: Combine<'tcx> { if a_args.len() == b_args.len() { a_args.iter().zip(b_args.iter()) .map(|(a, b)| combiner.args(*a, *b)).collect() @@ -351,51 +351,51 @@ pub trait Combineable<'tcx> : Repr<'tcx> + TypeFoldable<'tcx> { impl<'tcx,T> Combineable<'tcx> for Rc where T : Combineable<'tcx> { - fn combine>(combiner: &C, - a: &Rc, - b: &Rc) - -> cres<'tcx, Rc> - { + fn combine(combiner: &C, + a: &Rc, + b: &Rc) + -> cres<'tcx, Rc> + where C: Combine<'tcx> { Ok(Rc::new(try!(Combineable::combine(combiner, &**a, &**b)))) } } impl<'tcx> Combineable<'tcx> for ty::TraitRef<'tcx> { - fn combine>(combiner: &C, - a: &ty::TraitRef<'tcx>, - b: &ty::TraitRef<'tcx>) - -> cres<'tcx, ty::TraitRef<'tcx>> - { + fn combine(combiner: &C, + a: &ty::TraitRef<'tcx>, + b: &ty::TraitRef<'tcx>) + -> cres<'tcx, ty::TraitRef<'tcx>> + where C: Combine<'tcx> { combiner.trait_refs(a, b) } } impl<'tcx> Combineable<'tcx> for Ty<'tcx> { - fn combine>(combiner: &C, - a: &Ty<'tcx>, - b: &Ty<'tcx>) - -> cres<'tcx, Ty<'tcx>> - { + fn combine(combiner: &C, + a: &Ty<'tcx>, + b: &Ty<'tcx>) + -> cres<'tcx, Ty<'tcx>> + where C: Combine<'tcx> { combiner.tys(*a, *b) } } impl<'tcx> Combineable<'tcx> for ty::ProjectionPredicate<'tcx> { - fn combine>(combiner: &C, - a: &ty::ProjectionPredicate<'tcx>, - b: &ty::ProjectionPredicate<'tcx>) - -> cres<'tcx, ty::ProjectionPredicate<'tcx>> - { + fn combine(combiner: &C, + a: &ty::ProjectionPredicate<'tcx>, + b: &ty::ProjectionPredicate<'tcx>) + -> cres<'tcx, ty::ProjectionPredicate<'tcx>> + where C: Combine<'tcx> { combiner.projection_predicates(a, b) } } impl<'tcx> Combineable<'tcx> for ty::FnSig<'tcx> { - fn combine>(combiner: &C, - a: &ty::FnSig<'tcx>, - b: &ty::FnSig<'tcx>) - -> cres<'tcx, ty::FnSig<'tcx>> - { + fn combine(combiner: &C, + a: &ty::FnSig<'tcx>, + b: &ty::FnSig<'tcx>) + -> cres<'tcx, ty::FnSig<'tcx>> + where C: Combine<'tcx> { combiner.fn_sigs(a, b) } } @@ -407,8 +407,11 @@ pub struct CombineFields<'a, 'tcx: 'a> { pub trace: TypeTrace<'tcx>, } -pub fn expected_found<'tcx, C: Combine<'tcx>, T>( - this: &C, a: T, b: T) -> ty::expected_found { +pub fn expected_found<'tcx, C, T>(this: &C, + a: T, + b: T) + -> ty::expected_found + where C: Combine<'tcx> { if this.a_is_expected() { ty::expected_found {expected: a, found: b} } else { @@ -416,29 +419,26 @@ pub fn expected_found<'tcx, C: Combine<'tcx>, T>( } } -pub fn super_tys<'tcx, C: Combine<'tcx>>(this: &C, - a: Ty<'tcx>, - b: Ty<'tcx>) - -> cres<'tcx, Ty<'tcx>> -{ +pub fn super_tys<'tcx, C>(this: &C, + a: Ty<'tcx>, + b: Ty<'tcx>) + -> cres<'tcx, Ty<'tcx>> + where C: Combine<'tcx> { let tcx = this.infcx().tcx; let a_sty = &a.sty; let b_sty = &b.sty; debug!("super_tys: a_sty={:?} b_sty={:?}", a_sty, b_sty); return match (a_sty, b_sty) { - // The "subtype" ought to be handling cases involving var: - (&ty::ty_infer(TyVar(_)), _) | - (_, &ty::ty_infer(TyVar(_))) => { - tcx.sess.bug( - &format!("{}: bot and var types should have been handled ({},{})", - this.tag(), - a.repr(this.infcx().tcx), - b.repr(this.infcx().tcx))); - } + // The "subtype" ought to be handling cases involving var: + (&ty::ty_infer(TyVar(_)), _) + | (_, &ty::ty_infer(TyVar(_))) => + tcx.sess.bug( + &format!("{}: bot and var types should have been handled ({},{})", + this.tag(), + a.repr(this.infcx().tcx), + b.repr(this.infcx().tcx))), - (&ty::ty_err, _) | (_, &ty::ty_err) => { - Ok(tcx.types.err) - } + (&ty::ty_err, _) | (_, &ty::ty_err) => Ok(tcx.types.err), // Relate integral variables to other types (&ty::ty_infer(IntVar(a_id)), &ty::ty_infer(IntVar(b_id))) => { @@ -475,68 +475,62 @@ pub fn super_tys<'tcx, C: Combine<'tcx>>(this: &C, unify_float_variable(this, !this.a_is_expected(), v_id, v) } - (&ty::ty_char, _) | - (&ty::ty_bool, _) | - (&ty::ty_int(_), _) | - (&ty::ty_uint(_), _) | - (&ty::ty_float(_), _) => { - if a == b { - Ok(a) - } else { - Err(ty::terr_sorts(expected_found(this, a, b))) + (&ty::ty_char, _) + | (&ty::ty_bool, _) + | (&ty::ty_int(_), _) + | (&ty::ty_uint(_), _) + | (&ty::ty_float(_), _) => { + if a == b { + Ok(a) + } else { + Err(ty::terr_sorts(expected_found(this, a, b))) + } } - } - (&ty::ty_param(ref a_p), &ty::ty_param(ref b_p)) if - a_p.idx == b_p.idx && a_p.space == b_p.space => { - Ok(a) - } + (&ty::ty_param(ref a_p), &ty::ty_param(ref b_p)) if + a_p.idx == b_p.idx && a_p.space == b_p.space => Ok(a), - (&ty::ty_enum(a_id, a_substs), - &ty::ty_enum(b_id, b_substs)) - if a_id == b_id => { - let substs = try!(this.substs(a_id, - a_substs, - b_substs)); - Ok(ty::mk_enum(tcx, a_id, tcx.mk_substs(substs))) - } + (&ty::ty_enum(a_id, a_substs), &ty::ty_enum(b_id, b_substs)) + if a_id == b_id => { + let substs = try!(this.substs(a_id, a_substs, b_substs)); + Ok(ty::mk_enum(tcx, a_id, tcx.mk_substs(substs))) + } - (&ty::ty_trait(ref a_), - &ty::ty_trait(ref b_)) => { - debug!("Trying to match traits {:?} and {:?}", a, b); - let principal = try!(this.binders(&a_.principal, &b_.principal)); - let bounds = try!(this.existential_bounds(&a_.bounds, &b_.bounds)); - Ok(ty::mk_trait(tcx, principal, bounds)) - } + (&ty::ty_trait(ref a_), &ty::ty_trait(ref b_)) => { + debug!("Trying to match traits {:?} and {:?}", a, b); + let principal = try!(this.binders(&a_.principal, &b_.principal)); + let bounds = try!(this.existential_bounds(&a_.bounds, &b_.bounds)); + Ok(ty::mk_trait(tcx, principal, bounds)) + } - (&ty::ty_struct(a_id, a_substs), &ty::ty_struct(b_id, b_substs)) - if a_id == b_id => { + (&ty::ty_struct(a_id, a_substs), &ty::ty_struct(b_id, b_substs)) + if a_id == b_id => { let substs = try!(this.substs(a_id, a_substs, b_substs)); Ok(ty::mk_struct(tcx, a_id, tcx.mk_substs(substs))) - } + } - (&ty::ty_closure(a_id, a_region, a_substs), - &ty::ty_closure(b_id, b_region, b_substs)) - if a_id == b_id => { - // All ty_closure types with the same id represent - // the (anonymous) type of the same closure expression. So - // all of their regions should be equated. - let region = try!(this.equate().regions(*a_region, *b_region)); - let substs = try!(this.substs_variances(None, a_substs, b_substs)); - Ok(ty::mk_closure(tcx, a_id, tcx.mk_region(region), tcx.mk_substs(substs))) - } + (&ty::ty_closure(a_id, a_region, a_substs), + &ty::ty_closure(b_id, b_region, b_substs)) + if a_id == b_id => { + // All ty_closure types with the same id represent + // the (anonymous) type of the same closure expression. So + // all of their regions should be equated. + let region = try!(this.equate().regions(*a_region, *b_region)); + let substs = try!(this.substs_variances(None, a_substs, b_substs)); + Ok(ty::mk_closure(tcx, a_id, tcx.mk_region(region), tcx.mk_substs(substs))) + } - (&ty::ty_uniq(a_inner), &ty::ty_uniq(b_inner)) => { - let typ = try!(this.tys(a_inner, b_inner)); - Ok(ty::mk_uniq(tcx, typ)) - } + (&ty::ty_uniq(a_inner), &ty::ty_uniq(b_inner)) => { + let typ = try!(this.tys(a_inner, b_inner)); + Ok(ty::mk_uniq(tcx, typ)) + } - (&ty::ty_ptr(ref a_mt), &ty::ty_ptr(ref b_mt)) => { - let mt = try!(this.mts(a_mt, b_mt)); - Ok(ty::mk_ptr(tcx, mt)) - } + (&ty::ty_ptr(ref a_mt), &ty::ty_ptr(ref b_mt)) => { + let mt = try!(this.mts(a_mt, b_mt)); + Ok(ty::mk_ptr(tcx, mt)) + } - (&ty::ty_rptr(a_r, ref a_mt), &ty::ty_rptr(b_r, ref b_mt)) => { + (&ty::ty_rptr(a_r, ref a_mt), &ty::ty_rptr(b_r, ref b_mt)) => { let r = try!(this.regions_with_variance(ty::Contravariant, *a_r, *b_r)); // FIXME(14985) If we have mutable references to trait objects, we @@ -551,45 +545,43 @@ pub fn super_tys<'tcx, C: Combine<'tcx>>(this: &C, _ => try!(this.mts(a_mt, b_mt)) }; Ok(ty::mk_rptr(tcx, tcx.mk_region(r), mt)) - } + } - (&ty::ty_vec(a_t, Some(sz_a)), &ty::ty_vec(b_t, Some(sz_b))) => { - this.tys(a_t, b_t).and_then(|t| { - if sz_a == sz_b { - Ok(ty::mk_vec(tcx, t, Some(sz_a))) - } else { - Err(ty::terr_fixed_array_size(expected_found(this, sz_a, sz_b))) - } - }) - } + (&ty::ty_vec(a_t, Some(sz_a)), &ty::ty_vec(b_t, Some(sz_b))) => { + this.tys(a_t, b_t).and_then(|t| { + if sz_a == sz_b { + Ok(ty::mk_vec(tcx, t, Some(sz_a))) + } else { + Err(ty::terr_fixed_array_size(expected_found(this, sz_a, sz_b))) + } + }) + } - (&ty::ty_vec(a_t, sz_a), &ty::ty_vec(b_t, sz_b)) => { - this.tys(a_t, b_t).and_then(|t| { - if sz_a == sz_b { - Ok(ty::mk_vec(tcx, t, sz_a)) + (&ty::ty_vec(a_t, sz_a), &ty::ty_vec(b_t, sz_b)) => { + this.tys(a_t, b_t).and_then(|t| { + if sz_a == sz_b { + Ok(ty::mk_vec(tcx, t, sz_a)) + } else { + Err(ty::terr_sorts(expected_found(this, a, b))) + } + }) + } + + (&ty::ty_str, &ty::ty_str) => Ok(ty::mk_str(tcx)), + + (&ty::ty_tup(ref as_), &ty::ty_tup(ref bs)) => { + if as_.len() == bs.len() { + as_.iter().zip(bs.iter()) + .map(|(a, b)| this.tys(*a, *b)) + .collect::>() + .map(|ts| ty::mk_tup(tcx, ts)) + } else if as_.len() != 0 && bs.len() != 0 { + Err(ty::terr_tuple_size( + expected_found(this, as_.len(), bs.len()))) } else { Err(ty::terr_sorts(expected_found(this, a, b))) } - }) - } - - (&ty::ty_str, &ty::ty_str) => { - Ok(ty::mk_str(tcx)) - } - - (&ty::ty_tup(ref as_), &ty::ty_tup(ref bs)) => { - if as_.len() == bs.len() { - as_.iter().zip(bs.iter()) - .map(|(a, b)| this.tys(*a, *b)) - .collect::>() - .map(|ts| ty::mk_tup(tcx, ts)) - } else if as_.len() != 0 && bs.len() != 0 { - Err(ty::terr_tuple_size( - expected_found(this, as_.len(), bs.len()))) - } else { - Err(ty::terr_sorts(expected_found(this, a, b))) } - } (&ty::ty_bare_fn(a_opt_def_id, a_fty), &ty::ty_bare_fn(b_opt_def_id, b_fty)) if a_opt_def_id == b_opt_def_id => @@ -598,33 +590,33 @@ pub fn super_tys<'tcx, C: Combine<'tcx>>(this: &C, Ok(ty::mk_bare_fn(tcx, a_opt_def_id, tcx.mk_bare_fn(fty))) } - (&ty::ty_projection(ref a_data), &ty::ty_projection(ref b_data)) => { - let projection_ty = try!(this.projection_tys(a_data, b_data)); - Ok(ty::mk_projection(tcx, projection_ty.trait_ref, projection_ty.item_name)) - } + (&ty::ty_projection(ref a_data), &ty::ty_projection(ref b_data)) => { + let projection_ty = try!(this.projection_tys(a_data, b_data)); + Ok(ty::mk_projection(tcx, projection_ty.trait_ref, projection_ty.item_name)) + } - _ => Err(ty::terr_sorts(expected_found(this, a, b))) + _ => Err(ty::terr_sorts(expected_found(this, a, b))), }; - fn unify_integral_variable<'tcx, C: Combine<'tcx>>( - this: &C, - vid_is_expected: bool, - vid: ty::IntVid, - val: ty::IntVarValue) -> cres<'tcx, Ty<'tcx>> - { + fn unify_integral_variable<'tcx, C>(this: &C, + vid_is_expected: bool, + vid: ty::IntVid, + val: ty::IntVarValue) + -> cres<'tcx, Ty<'tcx>> + where C: Combine<'tcx> { try!(this.infcx().simple_var_t(vid_is_expected, vid, val)); match val { IntType(v) => Ok(ty::mk_mach_int(this.tcx(), v)), - UintType(v) => Ok(ty::mk_mach_uint(this.tcx(), v)) + UintType(v) => Ok(ty::mk_mach_uint(this.tcx(), v)), } } - fn unify_float_variable<'tcx, C: Combine<'tcx>>( - this: &C, - vid_is_expected: bool, - vid: ty::FloatVid, - val: ast::FloatTy) -> cres<'tcx, Ty<'tcx>> - { + fn unify_float_variable<'tcx, C>(this: &C, + vid_is_expected: bool, + vid: ty::FloatVid, + val: ast::FloatTy) + -> cres<'tcx, Ty<'tcx>> + where C: Combine<'tcx> { try!(this.infcx().simple_var_t(vid_is_expected, vid, val)); Ok(ty::mk_mach_float(this.tcx(), val)) } @@ -696,12 +688,8 @@ impl<'f, 'tcx> CombineFields<'f, 'tcx> { None => { // ...not yet instantiated: // Generalize type if necessary. let generalized_ty = try!(match dir { - EqTo => { - self.generalize(a_ty, b_vid, false) - } - BiTo | SupertypeOf | SubtypeOf => { - self.generalize(a_ty, b_vid, true) - } + EqTo => self.generalize(a_ty, b_vid, false), + BiTo | SupertypeOf | SubtypeOf => self.generalize(a_ty, b_vid, true), }); debug!("instantiate(a_ty={}, dir={:?}, \ b_vid={}, generalized_ty={})", @@ -723,22 +711,14 @@ impl<'f, 'tcx> CombineFields<'f, 'tcx> { // to associate causes/spans with each of the relations in // the stack to get this right. match dir { - BiTo => { - try!(self.bivariate().tys(a_ty, b_ty)); - } + BiTo => try!(self.bivariate().tys(a_ty, b_ty)), - EqTo => { - try!(self.equate().tys(a_ty, b_ty)); - } + EqTo => try!(self.equate().tys(a_ty, b_ty)), - SubtypeOf => { - try!(self.sub().tys(a_ty, b_ty)); - } + SubtypeOf => try!(self.sub().tys(a_ty, b_ty)), - SupertypeOf => { - try!(self.sub().tys_with_variance(ty::Contravariant, a_ty, b_ty)); - } - } + SupertypeOf => try!(self.sub().tys_with_variance(ty::Contravariant, a_ty, b_ty)), + }; } Ok(()) @@ -754,11 +734,13 @@ impl<'f, 'tcx> CombineFields<'f, 'tcx> { make_region_vars: bool) -> cres<'tcx, Ty<'tcx>> { - let mut generalize = Generalizer { infcx: self.infcx, - span: self.trace.origin.span(), - for_vid: for_vid, - make_region_vars: make_region_vars, - cycle_detected: false }; + let mut generalize = Generalizer { + infcx: self.infcx, + span: self.trace.origin.span(), + for_vid: for_vid, + make_region_vars: make_region_vars, + cycle_detected: false + }; let u = ty.fold_with(&mut generalize); if generalize.cycle_detected { Err(ty::terr_cyclic_ty) diff --git a/src/librustc/middle/infer/region_inference/mod.rs b/src/librustc/middle/infer/region_inference/mod.rs index 7800d99f8ed..759d7357df1 100644 --- a/src/librustc/middle/infer/region_inference/mod.rs +++ b/src/librustc/middle/infer/region_inference/mod.rs @@ -1133,18 +1133,12 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { true // changed } - ErrorValue => { - false // no change - } + ErrorValue => false, // no change Value(a_region) => { match a_data.classification { - Expanding => { - check_node(self, a_vid, a_data, a_region, b_region) - } - Contracting => { - adjust_node(self, a_vid, a_data, a_region, b_region) - } + Expanding => check_node(self, a_vid, a_data, a_region, b_region), + Contracting => adjust_node(self, a_vid, a_data, a_region, b_region), } } }; @@ -1154,7 +1148,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { a_data: &mut VarData, a_region: Region, b_region: Region) - -> bool { + -> bool { if !this.is_subregion_of(a_region, b_region) { debug!("Setting {:?} to ErrorValue: {} not subregion of {}", a_vid, @@ -1170,7 +1164,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { a_data: &mut VarData, a_region: Region, b_region: Region) - -> bool { + -> bool { match this.glb_concrete_regions(a_region, b_region) { Ok(glb) => { if glb == a_region { diff --git a/src/librustc/middle/traits/select.rs b/src/librustc/middle/traits/select.rs index 8086ca71e01..9ec89f55b8f 100644 --- a/src/librustc/middle/traits/select.rs +++ b/src/librustc/middle/traits/select.rs @@ -1409,27 +1409,23 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { let self_ty = self.infcx.shallow_resolve(obligation.predicate.0.self_ty()); return match self_ty.sty { - ty::ty_infer(ty::IntVar(_)) | - ty::ty_infer(ty::FloatVar(_)) | - ty::ty_uint(_) | - ty::ty_int(_) | - ty::ty_bool | - ty::ty_float(_) | - ty::ty_bare_fn(..) | - ty::ty_char => { + ty::ty_infer(ty::IntVar(_)) + | ty::ty_infer(ty::FloatVar(_)) + | ty::ty_uint(_) + | ty::ty_int(_) + | ty::ty_bool + | ty::ty_float(_) + | ty::ty_bare_fn(..) + | ty::ty_char => { // safe for everything Ok(If(Vec::new())) } ty::ty_uniq(_) => { // Box match bound { - ty::BoundCopy => { - Err(Unimplemented) - } + ty::BoundCopy => Err(Unimplemented), - ty::BoundSized => { - Ok(If(Vec::new())) - } + ty::BoundSized => Ok(If(Vec::new())), ty::BoundSync | ty::BoundSend => { self.tcx().sess.bug("Send/Sync shouldn't occur in builtin_bounds()"); @@ -1439,9 +1435,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { ty::ty_ptr(..) => { // *const T, *mut T match bound { - ty::BoundCopy | ty::BoundSized => { - Ok(If(Vec::new())) - } + ty::BoundCopy | ty::BoundSized => Ok(If(Vec::new())), ty::BoundSync | ty::BoundSend => { self.tcx().sess.bug("Send/Sync shouldn't occur in builtin_bounds()"); @@ -1451,9 +1445,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { ty::ty_trait(ref data) => { match bound { - ty::BoundSized => { - Err(Unimplemented) - } + ty::BoundSized => Err(Unimplemented), ty::BoundCopy => { if data.bounds.builtin_bounds.contains(&bound) { Ok(If(Vec::new())) @@ -1485,20 +1477,14 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { ty::BoundCopy => { match mutbl { // &mut T is affine and hence never `Copy` - ast::MutMutable => { - Err(Unimplemented) - } + ast::MutMutable => Err(Unimplemented), // &T is always copyable - ast::MutImmutable => { - Ok(If(Vec::new())) - } + ast::MutImmutable => Ok(If(Vec::new())), } } - ty::BoundSized => { - Ok(If(Vec::new())) - } + ty::BoundSized => Ok(If(Vec::new())), ty::BoundSync | ty::BoundSend => { self.tcx().sess.bug("Send/Sync shouldn't occur in builtin_bounds()"); @@ -1511,14 +1497,11 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { match bound { ty::BoundCopy => { match *len { - Some(_) => { - // [T, ..n] is copy iff T is copy - Ok(If(vec![element_ty])) - } - None => { - // [T] is unsized and hence affine - Err(Unimplemented) - } + // [T, ..n] is copy iff T is copy + Some(_) => Ok(If(vec![element_ty])), + + // [T] is unsized and hence affine + None => Err(Unimplemented), } } @@ -1543,16 +1526,12 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { self.tcx().sess.bug("Send/Sync shouldn't occur in builtin_bounds()"); } - ty::BoundCopy | ty::BoundSized => { - Err(Unimplemented) - } + ty::BoundCopy | ty::BoundSized => Err(Unimplemented), } } - ty::ty_tup(ref tys) => { - // (T1, ..., Tn) -- meets any bound that all of T1...Tn meet - Ok(If(tys.clone())) - } + // (T1, ..., Tn) -- meets any bound that all of T1...Tn meet + ty::ty_tup(ref tys) => Ok(If(tys.clone())), ty::ty_closure(def_id, _, substs) => { // FIXME -- This case is tricky. In the case of by-ref @@ -1581,9 +1560,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { } match self.closure_typer.closure_upvars(def_id, substs) { - Some(upvars) => { - Ok(If(upvars.iter().map(|c| c.ty).collect())) - } + Some(upvars) => Ok(If(upvars.iter().map(|c| c.ty).collect())), None => { debug!("assemble_builtin_bound_candidates: no upvar types available yet"); Ok(AmbiguousBuiltin) @@ -1609,8 +1586,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { nominal(bound, types) } - ty::ty_projection(_) | - ty::ty_param(_) => { + ty::ty_projection(_) | ty::ty_param(_) => { // Note: A type parameter is only considered to meet a // particular bound if there is a where clause telling // us that it does, and that case is handled by @@ -1626,12 +1602,10 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { Ok(AmbiguousBuiltin) } - ty::ty_err => { - Ok(If(Vec::new())) - } + ty::ty_err => Ok(If(Vec::new())), - ty::ty_infer(ty::FreshTy(_)) | - ty::ty_infer(ty::FreshIntTy(_)) => { + ty::ty_infer(ty::FreshTy(_)) + | ty::ty_infer(ty::FreshIntTy(_)) => { self.tcx().sess.bug( &format!( "asked to assemble builtin bounds of unexpected type: {}", @@ -1641,7 +1615,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { fn nominal<'cx, 'tcx>(bound: ty::BuiltinBound, types: Vec>) - -> Result,SelectionError<'tcx>> + -> Result, SelectionError<'tcx>> { // First check for markers and other nonsense. match bound { @@ -1692,7 +1666,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { self.tcx().sess.bug( &format!( "asked to assemble constituent types of unexpected type: {}", - t.repr(self.tcx()))[]); + t.repr(self.tcx()))); } ty::ty_uniq(referent_ty) => { // Box @@ -1909,7 +1883,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { }).collect::>(); let obligations = match obligations { Ok(o) => o, - Err(ErrorReported) => Vec::new() + Err(ErrorReported) => Vec::new(), }; let obligations = VecPerParamSpace::new(obligations, Vec::new(), Vec::new()); @@ -1937,14 +1911,12 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { let self_ty = self.infcx.shallow_resolve(obligation.predicate.0.self_ty()); match self.constituent_types_for_ty(self_ty) { - Some(types) => { - Ok(self.vtable_default_impl(obligation, impl_def_id, types)) - } + Some(types) => Ok(self.vtable_default_impl(obligation, impl_def_id, types)), None => { self.tcx().sess.bug( &format!( "asked to confirm default implementation for ambiguous type: {}", - self_ty.repr(self.tcx()))[]); + self_ty.repr(self.tcx()))); } } } @@ -2223,9 +2195,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { { match self.match_impl(impl_def_id, obligation, snapshot, skol_map, skol_obligation_trait_ref) { - Ok(substs) => { - substs - } + Ok(substs) => substs, Err(()) => { self.tcx().sess.bug( &format!("Impl {} was matchable against {} but now is not", @@ -2273,30 +2243,26 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { skol_obligation_trait_ref.repr(self.tcx())); let origin = infer::RelateOutputImplTypes(obligation.cause.span); - match self.infcx.sub_trait_refs(false, - origin, - impl_trait_ref.value.clone(), - skol_obligation_trait_ref) { - Ok(()) => { } - Err(e) => { - debug!("match_impl: failed sub_trait_refs due to `{}`", - ty::type_err_to_str(self.tcx(), &e)); - return Err(()); - } + if let Err(e) = self.infcx.sub_trait_refs(false, + origin, + impl_trait_ref.value.clone(), + skol_obligation_trait_ref) { + debug!("match_impl: failed sub_trait_refs due to `{}`", + ty::type_err_to_str(self.tcx(), &e)); + return Err(()); } - match self.infcx.leak_check(skol_map, snapshot) { - Ok(()) => { } - Err(e) => { - debug!("match_impl: failed leak check due to `{}`", - ty::type_err_to_str(self.tcx(), &e)); - return Err(()); - } + if let Err(e) = self.infcx.leak_check(skol_map, snapshot) { + debug!("match_impl: failed leak check due to `{}`", + ty::type_err_to_str(self.tcx(), &e)); + return Err(()); } debug!("match_impl: success impl_substs={}", impl_substs.repr(self.tcx())); - Ok(Normalized { value: impl_substs, - obligations: impl_trait_ref.obligations }) + Ok(Normalized { + value: impl_substs, + obligations: impl_trait_ref.obligations + }) } fn fast_reject_trait_refs(&mut self, @@ -2332,9 +2298,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { where_clause_trait_ref: ty::PolyTraitRef<'tcx>) -> Result>,()> { - let () = - try!(self.match_poly_trait_ref(obligation, where_clause_trait_ref)); - + try!(self.match_poly_trait_ref(obligation, where_clause_trait_ref)); Ok(Vec::new()) } @@ -2451,7 +2415,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { match self.tcx().trait_impls.borrow().get(&trait_def_id) { None => Vec::new(), - Some(impls) => impls.borrow().clone() + Some(impls) => impls.borrow().clone(), } } @@ -2549,9 +2513,7 @@ impl<'tcx> Repr<'tcx> for SelectionCandidate<'tcx> { DefaultImplCandidate(t) => format!("DefaultImplCandidate({:?})", t), ProjectionCandidate => format!("ProjectionCandidate"), FnPointerCandidate => format!("FnPointerCandidate"), - ObjectCandidate => { - format!("ObjectCandidate") - } + ObjectCandidate => format!("ObjectCandidate"), ClosureCandidate(c, ref s) => { format!("ClosureCandidate({:?},{})", c, s.repr(tcx)) } @@ -2582,9 +2544,7 @@ impl<'o, 'tcx> Iterator for Option<&'o TraitObligationStack<'o, 'tcx>> { *self = o.previous; Some(o) } - None => { - None - } + None => None } } } @@ -2599,15 +2559,11 @@ impl<'o, 'tcx> Repr<'tcx> for TraitObligationStack<'o, 'tcx> { impl<'tcx> EvaluationResult<'tcx> { fn may_apply(&self) -> bool { match *self { - EvaluatedToOk | - EvaluatedToAmbig | - EvaluatedToErr(Overflow) | - EvaluatedToErr(OutputTypeParameterMismatch(..)) => { - true - } - EvaluatedToErr(Unimplemented) => { - false - } + EvaluatedToOk + | EvaluatedToAmbig + | EvaluatedToErr(Overflow) + | EvaluatedToErr(OutputTypeParameterMismatch(..)) => true, + EvaluatedToErr(Unimplemented) => false, } } } diff --git a/src/librustc_trans/trans/consts.rs b/src/librustc_trans/trans/consts.rs index 19046d84d69..5cbe9dd71fb 100644 --- a/src/librustc_trans/trans/consts.rs +++ b/src/librustc_trans/trans/consts.rs @@ -359,7 +359,7 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, }; unsafe { let _icx = push_ctxt("const_expr"); - return match e.node { + match e.node { ast::ExprLit(ref lit) => { const_lit(cx, e, &**lit) } @@ -379,7 +379,7 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, let (te2, _) = const_expr(cx, &**e2, param_substs); let te2 = base::cast_shift_const_rhs(b, te1, te2); - return match b.node { + match b.node { ast::BiAdd => { if is_float { llvm::LLVMConstFAdd(te1, te2) } else { llvm::LLVMConstAdd(te1, te2) } @@ -433,7 +433,7 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, ast::ExprUnary(u, ref e) => { let (te, ty) = const_expr(cx, &**e, param_substs); let is_float = ty::type_is_fp(ty); - return match u { + match u { ast::UnUniq | ast::UnDeref => { const_deref(cx, te, ty).0 } @@ -514,8 +514,8 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, if expr::cast_is_noop(basety, ety) { return v; } - return match (expr::cast_type_kind(cx.tcx(), basety), - expr::cast_type_kind(cx.tcx(), ety)) { + match (expr::cast_type_kind(cx.tcx(), basety), + expr::cast_type_kind(cx.tcx(), ety)) { (expr::cast_integral, expr::cast_integral) => { let s = ty::type_is_signed(basety) as Bool; @@ -584,13 +584,13 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, } let opt_def = cx.tcx().def_map.borrow().get(&cur.id).cloned(); if let Some(def::DefStatic(def_id, _)) = opt_def { - return get_static_val(cx, def_id, ety); + get_static_val(cx, def_id, ety) + } else { + // If this isn't the address of a static, then keep going through + // normal constant evaluation. + let (v, _) = const_expr(cx, &**sub, param_substs); + addr_of(cx, v, "ref", e.id) } - - // If this isn't the address of a static, then keep going through - // normal constant evaluation. - let (v, _) = const_expr(cx, &**sub, param_substs); - addr_of(cx, v, "ref", e.id) } ast::ExprAddrOf(ast::MutMutable, ref sub) => { let (v, _) = const_expr(cx, &**sub, param_substs); @@ -740,7 +740,7 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, } _ => cx.sess().span_bug(e.span, "bad constant expression type in consts::const_expr") - }; + } } }