From 00a933f9ece4ef22f8651320e5f4fcfcbd37e0bf Mon Sep 17 00:00:00 2001 From: Alfie John Date: Sun, 25 Jan 2015 10:58:43 +0000 Subject: [PATCH] More deprecating of i/u suffixes in libraries --- src/liballoc/arc.rs | 12 ++--- src/liballoc/boxed_test.rs | 10 ++-- src/liballoc/rc.rs | 42 ++++++++-------- src/librustc/lint/builtin.rs | 2 +- src/librustc/lint/context.rs | 2 +- src/librustc/metadata/decoder.rs | 4 +- src/librustc/metadata/encoder.rs | 2 +- src/librustc/metadata/loader.rs | 2 +- src/librustc/metadata/tydecode.rs | 28 +++++------ src/librustc/middle/astconv_util.rs | 4 +- src/librustc/middle/astencode.rs | 20 ++++---- src/librustc/middle/check_match.rs | 24 ++++----- src/librustc/middle/dataflow.rs | 10 ++-- .../middle/infer/region_inference/mod.rs | 4 +- src/librustc/middle/liveness.rs | 18 +++---- src/librustc/middle/mem_categorization.rs | 2 +- src/librustc/middle/region.rs | 12 ++--- src/librustc/middle/ty.rs | 6 +-- src/librustc/session/mod.rs | 2 +- src/librustc/util/ppaux.rs | 4 +- src/librustc_trans/back/link.rs | 2 +- src/librustc_trans/back/lto.rs | 2 +- src/librustc_trans/save/recorder.rs | 10 ++-- src/librustc_trans/save/span_utils.rs | 8 +-- src/librustc_trans/trans/_match.rs | 24 ++++----- src/librustc_trans/trans/base.rs | 4 +- src/librustc_trans/trans/builder.rs | 12 ++--- src/librustc_trans/trans/cabi_aarch64.rs | 2 +- src/librustc_trans/trans/cabi_arm.rs | 2 +- src/librustc_trans/trans/cabi_mips.rs | 2 +- src/librustc_trans/trans/cabi_powerpc.rs | 2 +- src/librustc_trans/trans/cabi_x86_64.rs | 50 +++++++++---------- src/librustc_trans/trans/callee.rs | 2 +- src/librustc_trans/trans/cleanup.rs | 2 +- src/librustc_trans/trans/context.rs | 20 ++++---- src/librustc_trans/trans/debuginfo.rs | 6 +-- src/librustc_trans/trans/expr.rs | 8 +-- src/librustc_trans/trans/glue.rs | 6 +-- src/librustc_trans/trans/meth.rs | 12 ++--- src/librustc_trans/trans/tvec.rs | 16 +++--- 40 files changed, 201 insertions(+), 201 deletions(-) diff --git a/src/liballoc/arc.rs b/src/liballoc/arc.rs index 4818e4abaf2..21b9c060f6f 100644 --- a/src/liballoc/arc.rs +++ b/src/liballoc/arc.rs @@ -39,7 +39,7 @@ //! //! let five = Arc::new(5); //! -//! for _ in 0u..10 { +//! for _ in 0..10 { //! let five = five.clone(); //! //! Thread::spawn(move || { @@ -56,7 +56,7 @@ //! //! let five = Arc::new(Mutex::new(5)); //! -//! for _ in 0u..10 { +//! for _ in 0..10 { //! let five = five.clone(); //! //! Thread::spawn(move || { @@ -101,7 +101,7 @@ /// let numbers: Vec<_> = (0..100u32).map(|i| i as f32).collect(); /// let shared_numbers = Arc::new(numbers); /// -/// for _ in 0u..10 { +/// for _ in 0..10 { /// let child_numbers = shared_numbers.clone(); /// /// Thread::spawn(move || { @@ -661,7 +661,7 @@ fn manually_share_arc() { #[test] fn test_cowarc_clone_make_unique() { - let mut cow0 = Arc::new(75u); + let mut cow0 = Arc::new(75); let mut cow1 = cow0.clone(); let mut cow2 = cow1.clone(); @@ -685,7 +685,7 @@ fn test_cowarc_clone_make_unique() { #[test] fn test_cowarc_clone_unique2() { - let mut cow0 = Arc::new(75u); + let mut cow0 = Arc::new(75); let cow1 = cow0.clone(); let cow2 = cow1.clone(); @@ -708,7 +708,7 @@ fn test_cowarc_clone_unique2() { #[test] fn test_cowarc_clone_weak() { - let mut cow0 = Arc::new(75u); + let mut cow0 = Arc::new(75); let cow1_weak = cow0.downgrade(); assert!(75 == *cow0); diff --git a/src/liballoc/boxed_test.rs b/src/liballoc/boxed_test.rs index 4ffb94e7a61..6f6d9ab394d 100644 --- a/src/liballoc/boxed_test.rs +++ b/src/liballoc/boxed_test.rs @@ -30,11 +30,11 @@ fn test_owned_clone() { #[test] fn any_move() { - let a = Box::new(8u) as Box; + let a = Box::new(8us) as Box; let b = Box::new(Test) as Box; match a.downcast::() { - Ok(a) => { assert!(a == Box::new(8u)); } + Ok(a) => { assert!(a == Box::new(8us)); } Err(..) => panic!() } match b.downcast::() { @@ -42,7 +42,7 @@ fn any_move() { Err(..) => panic!() } - let a = Box::new(8u) as Box; + let a = Box::new(8) as Box; let b = Box::new(Test) as Box; assert!(a.downcast::>().is_err()); @@ -51,14 +51,14 @@ fn any_move() { #[test] fn test_show() { - let a = Box::new(8u) as Box; + let a = Box::new(8) as Box; let b = Box::new(Test) as Box; let a_str = format!("{:?}", a); let b_str = format!("{:?}", b); assert_eq!(a_str, "Box"); assert_eq!(b_str, "Box"); - static EIGHT: usize = 8us; + static EIGHT: usize = 8; static TEST: Test = Test; let a = &EIGHT as &Any; let b = &TEST as &Any; diff --git a/src/liballoc/rc.rs b/src/liballoc/rc.rs index 8a542e1b8cb..464f20e9cac 100644 --- a/src/liballoc/rc.rs +++ b/src/liballoc/rc.rs @@ -266,12 +266,12 @@ pub fn is_unique(rc: &Rc) -> bool { /// ``` /// use std::rc::{self, Rc}; /// -/// let x = Rc::new(3u); -/// assert_eq!(rc::try_unwrap(x), Ok(3u)); +/// let x = Rc::new(3); +/// assert_eq!(rc::try_unwrap(x), Ok(3)); /// -/// let x = Rc::new(4u); +/// let x = Rc::new(4); /// let _y = x.clone(); -/// assert_eq!(rc::try_unwrap(x), Err(Rc::new(4u))); +/// assert_eq!(rc::try_unwrap(x), Err(Rc::new(4))); /// ``` #[inline] #[unstable(feature = "alloc")] @@ -300,9 +300,9 @@ pub fn try_unwrap(rc: Rc) -> Result> { /// ``` /// use std::rc::{self, Rc}; /// -/// let mut x = Rc::new(3u); -/// *rc::get_mut(&mut x).unwrap() = 4u; -/// assert_eq!(*x, 4u); +/// let mut x = Rc::new(3); +/// *rc::get_mut(&mut x).unwrap() = 4; +/// assert_eq!(*x, 4); /// /// let _y = x.clone(); /// assert!(rc::get_mut(&mut x).is_none()); @@ -845,7 +845,7 @@ struct Cycle { #[test] fn is_unique() { - let x = Rc::new(3u); + let x = Rc::new(3); assert!(super::is_unique(&x)); let y = x.clone(); assert!(!super::is_unique(&x)); @@ -893,21 +893,21 @@ fn test_weak_count() { #[test] fn try_unwrap() { - let x = Rc::new(3u); - assert_eq!(super::try_unwrap(x), Ok(3u)); - let x = Rc::new(4u); + let x = Rc::new(3); + assert_eq!(super::try_unwrap(x), Ok(3)); + let x = Rc::new(4); let _y = x.clone(); - assert_eq!(super::try_unwrap(x), Err(Rc::new(4u))); - let x = Rc::new(5u); + assert_eq!(super::try_unwrap(x), Err(Rc::new(4))); + let x = Rc::new(5); let _w = x.downgrade(); - assert_eq!(super::try_unwrap(x), Err(Rc::new(5u))); + assert_eq!(super::try_unwrap(x), Err(Rc::new(5))); } #[test] fn get_mut() { - let mut x = Rc::new(3u); - *super::get_mut(&mut x).unwrap() = 4u; - assert_eq!(*x, 4u); + let mut x = Rc::new(3); + *super::get_mut(&mut x).unwrap() = 4; + assert_eq!(*x, 4); let y = x.clone(); assert!(super::get_mut(&mut x).is_none()); drop(y); @@ -918,7 +918,7 @@ fn get_mut() { #[test] fn test_cowrc_clone_make_unique() { - let mut cow0 = Rc::new(75u); + let mut cow0 = Rc::new(75); let mut cow1 = cow0.clone(); let mut cow2 = cow1.clone(); @@ -942,7 +942,7 @@ fn test_cowrc_clone_make_unique() { #[test] fn test_cowrc_clone_unique2() { - let mut cow0 = Rc::new(75u); + let mut cow0 = Rc::new(75); let cow1 = cow0.clone(); let cow2 = cow1.clone(); @@ -965,7 +965,7 @@ fn test_cowrc_clone_unique2() { #[test] fn test_cowrc_clone_weak() { - let mut cow0 = Rc::new(75u); + let mut cow0 = Rc::new(75); let cow1_weak = cow0.downgrade(); assert!(75 == *cow0); @@ -979,7 +979,7 @@ fn test_cowrc_clone_weak() { #[test] fn test_show() { - let foo = Rc::new(75u); + let foo = Rc::new(75); assert_eq!(format!("{:?}", foo), "75"); } diff --git a/src/librustc/lint/builtin.rs b/src/librustc/lint/builtin.rs index e8e8d35fe07..904c9c3adb5 100644 --- a/src/librustc/lint/builtin.rs +++ b/src/librustc/lint/builtin.rs @@ -493,7 +493,7 @@ fn check_foreign_fn(cx: &Context, decl: &ast::FnDecl) { impl BoxPointers { fn check_heap_type<'a, 'tcx>(&self, cx: &Context<'a, 'tcx>, span: Span, ty: Ty<'tcx>) { - let mut n_uniq = 0u; + let mut n_uniq = 0us; ty::fold_ty(cx.tcx, ty, |t| { match t.sty { ty::ty_uniq(_) => { diff --git a/src/librustc/lint/context.rs b/src/librustc/lint/context.rs index 76f874f2428..c649ff2635b 100644 --- a/src/librustc/lint/context.rs +++ b/src/librustc/lint/context.rs @@ -490,7 +490,7 @@ fn with_lint_attrs(&mut self, // current dictionary of lint information. Along the way, keep a history // of what we changed so we can roll everything back after invoking the // specified closure - let mut pushed = 0u; + let mut pushed = 0; for result in gather_attrs(attrs).into_iter() { let v = match result { diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs index 322abe79ed2..94fe99ff07d 100644 --- a/src/librustc/metadata/decoder.rs +++ b/src/librustc/metadata/decoder.rs @@ -88,7 +88,7 @@ pub fn maybe_find_item<'a>(item_id: ast::NodeId, items: rbml::Doc<'a>) -> Option> { fn eq_item(bytes: &[u8], item_id: ast::NodeId) -> bool { return u64_from_be_bytes( - &bytes[0u..4u], 0u, 4u) as ast::NodeId + &bytes[0..4], 0, 4) as ast::NodeId == item_id; } lookup_hash(items, @@ -1164,7 +1164,7 @@ fn get_attributes(md: rbml::Doc) -> Vec { let meta_items = get_meta_items(attr_doc); // Currently it's only possible to have a single meta item on // an attribute - assert_eq!(meta_items.len(), 1u); + assert_eq!(meta_items.len(), 1); let meta_item = meta_items.into_iter().nth(0).unwrap(); attrs.push( codemap::Spanned { diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs index 6767f77de84..94d13399507 100644 --- a/src/librustc/metadata/encoder.rs +++ b/src/librustc/metadata/encoder.rs @@ -1071,7 +1071,7 @@ fn add_to_index(item: &ast::Item, rbml_w: &Encoder, encode_name(rbml_w, item.ident.name); encode_path(rbml_w, path); encode_attributes(rbml_w, &item.attrs[]); - if tps_len > 0u || should_inline(&item.attrs[]) { + if tps_len > 0 || should_inline(&item.attrs[]) { encode_inlined_item(ecx, rbml_w, IIItemRef(item)); } if tps_len == 0 { diff --git a/src/librustc/metadata/loader.rs b/src/librustc/metadata/loader.rs index 3ee4017292c..09957f58bcc 100644 --- a/src/librustc/metadata/loader.rs +++ b/src/librustc/metadata/loader.rs @@ -487,7 +487,7 @@ fn find_library_crate(&mut self) -> Option { fn extract_one(&mut self, m: HashMap, flavor: &str, slot: &mut Option) -> Option<(Path, PathKind)> { let mut ret = None::<(Path, PathKind)>; - let mut error = 0u; + let mut error = 0; if slot.is_some() { // FIXME(#10786): for an optimization, we only read one of the diff --git a/src/librustc/metadata/tydecode.rs b/src/librustc/metadata/tydecode.rs index 6d19107096a..ac6d2d0174c 100644 --- a/src/librustc/metadata/tydecode.rs +++ b/src/librustc/metadata/tydecode.rs @@ -76,13 +76,13 @@ fn peek(st: &PState) -> char { fn next(st: &mut PState) -> char { let ch = st.data[st.pos] as char; - st.pos = st.pos + 1u; + st.pos = st.pos + 1; return ch; } fn next_byte(st: &mut PState) -> u8 { let b = st.data[st.pos]; - st.pos = st.pos + 1u; + st.pos = st.pos + 1; return b; } @@ -498,7 +498,7 @@ fn parse_ty_<'a, 'tcx, F>(st: &mut PState<'a, 'tcx>, conv: &mut F) -> Ty<'tcx> w assert_eq!(next(st), '['); let mut params = Vec::new(); while peek(st) != ']' { params.push(parse_ty_(st, conv)); } - st.pos = st.pos + 1u; + st.pos = st.pos + 1; return ty::mk_tup(tcx, params); } 'F' => { @@ -590,7 +590,7 @@ fn parse_uint(st: &mut PState) -> uint { loop { let cur = peek(st); if cur < '0' || cur > '9' { return n; } - st.pos = st.pos + 1u; + st.pos = st.pos + 1; n *= 10; n += (cur as uint) - ('0' as uint); }; @@ -608,15 +608,15 @@ fn parse_param_space(st: &mut PState) -> subst::ParamSpace { } fn parse_hex(st: &mut PState) -> uint { - let mut n = 0u; + let mut n = 0; loop { let cur = peek(st); if (cur < '0' || cur > '9') && (cur < 'a' || cur > 'f') { return n; } - st.pos = st.pos + 1u; - n *= 16u; + st.pos = st.pos + 1; + n *= 16; if '0' <= cur && cur <= '9' { n += (cur as uint) - ('0' as uint); - } else { n += 10u + (cur as uint) - ('a' as uint); } + } else { n += 10 + (cur as uint) - ('a' as uint); } }; } @@ -686,7 +686,7 @@ fn parse_sig_<'a, 'tcx, F>(st: &mut PState<'a, 'tcx>, conv: &mut F) -> ty::PolyF while peek(st) != ']' { inputs.push(parse_ty_(st, conv)); } - st.pos += 1u; // eat the ']' + st.pos += 1; // eat the ']' let variadic = match next(st) { 'V' => true, 'N' => false, @@ -694,7 +694,7 @@ fn parse_sig_<'a, 'tcx, F>(st: &mut PState<'a, 'tcx>, conv: &mut F) -> ty::PolyF }; let output = match peek(st) { 'z' => { - st.pos += 1u; + st.pos += 1; ty::FnDiverging } _ => ty::FnConverging(parse_ty_(st, conv)) @@ -706,16 +706,16 @@ fn parse_sig_<'a, 'tcx, F>(st: &mut PState<'a, 'tcx>, conv: &mut F) -> ty::PolyF // Rust metadata parsing pub fn parse_def_id(buf: &[u8]) -> ast::DefId { - let mut colon_idx = 0u; + let mut colon_idx = 0; let len = buf.len(); - while colon_idx < len && buf[colon_idx] != ':' as u8 { colon_idx += 1u; } + while colon_idx < len && buf[colon_idx] != ':' as u8 { colon_idx += 1; } if colon_idx == len { error!("didn't find ':' when parsing def id"); panic!(); } - let crate_part = &buf[0u..colon_idx]; - let def_part = &buf[colon_idx + 1u..len]; + let crate_part = &buf[0..colon_idx]; + let def_part = &buf[colon_idx + 1..len]; let crate_num = match str::from_utf8(crate_part).ok().and_then(|s| { s.parse::().ok() diff --git a/src/librustc/middle/astconv_util.rs b/src/librustc/middle/astconv_util.rs index 8cd3795580e..7143e3caac2 100644 --- a/src/librustc/middle/astconv_util.rs +++ b/src/librustc/middle/astconv_util.rs @@ -25,14 +25,14 @@ pub fn check_path_args(tcx: &ty::ctxt, path: &ast::Path, flags: uint) { - if (flags & NO_TPS) != 0u { + if (flags & NO_TPS) != 0 { if path.segments.iter().any(|s| s.parameters.has_types()) { span_err!(tcx.sess, path.span, E0109, "type parameters are not allowed on this type"); } } - if (flags & NO_REGIONS) != 0u { + if (flags & NO_REGIONS) != 0 { if path.segments.iter().any(|s| s.parameters.has_lifetimes()) { span_err!(tcx.sess, path.span, E0110, "region parameters are not allowed on this type"); diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index 902c029fef4..6a5c3b0fc37 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -579,16 +579,16 @@ fn encode_method_callee<'a, 'tcx>(ecx: &e::EncodeContext<'a, 'tcx>, use serialize::Encoder; rbml_w.emit_struct("MethodCallee", 4, |rbml_w| { - rbml_w.emit_struct_field("adjustment", 0u, |rbml_w| { + rbml_w.emit_struct_field("adjustment", 0, |rbml_w| { adjustment.encode(rbml_w) }); - rbml_w.emit_struct_field("origin", 1u, |rbml_w| { + rbml_w.emit_struct_field("origin", 1, |rbml_w| { Ok(rbml_w.emit_method_origin(ecx, &method.origin)) }); - rbml_w.emit_struct_field("ty", 2u, |rbml_w| { + rbml_w.emit_struct_field("ty", 2, |rbml_w| { Ok(rbml_w.emit_ty(ecx, method.ty)) }); - rbml_w.emit_struct_field("substs", 3u, |rbml_w| { + rbml_w.emit_struct_field("substs", 3, |rbml_w| { Ok(rbml_w.emit_substs(ecx, &method.substs)) }) }).unwrap(); @@ -743,30 +743,30 @@ fn read_vtable_origin(&mut self, Ok(match i { 0 => { ty::vtable_static( - this.read_enum_variant_arg(0u, |this| { + this.read_enum_variant_arg(0, |this| { Ok(this.read_def_id_nodcx(cdata)) }).unwrap(), - this.read_enum_variant_arg(1u, |this| { + this.read_enum_variant_arg(1, |this| { Ok(this.read_substs_nodcx(tcx, cdata)) }).unwrap(), - this.read_enum_variant_arg(2u, |this| { + this.read_enum_variant_arg(2, |this| { Ok(this.read_vtable_res(tcx, cdata)) }).unwrap() ) } 1 => { ty::vtable_param( - this.read_enum_variant_arg(0u, |this| { + this.read_enum_variant_arg(0, |this| { Decodable::decode(this) }).unwrap(), - this.read_enum_variant_arg(1u, |this| { + this.read_enum_variant_arg(1, |this| { this.read_uint() }).unwrap() ) } 2 => { ty::vtable_closure( - this.read_enum_variant_arg(0u, |this| { + this.read_enum_variant_arg(0, |this| { Ok(this.read_def_id_nodcx(cdata)) }).unwrap() ) diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs index aded63336dc..6de517b2906 100644 --- a/src/librustc/middle/check_match.rs +++ b/src/librustc/middle/check_match.rs @@ -68,10 +68,10 @@ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { .collect::>() }).collect(); - let column_count = m.iter().map(|row| row.len()).max().unwrap_or(0u); + let column_count = m.iter().map(|row| row.len()).max().unwrap_or(0); assert!(m.iter().all(|row| row.len() == column_count)); let column_widths: Vec = (0..column_count).map(|col| { - pretty_printed_matrix.iter().map(|row| row[col].len()).max().unwrap_or(0u) + pretty_printed_matrix.iter().map(|row| row[col].len()).max().unwrap_or(0) }).collect(); let total_width = column_widths.iter().map(|n| *n).sum() + column_count * 3 + 1; @@ -588,13 +588,13 @@ fn is_useful(cx: &MatchCheckCtxt, -> Usefulness { let &Matrix(ref rows) = matrix; debug!("{:?}", matrix); - if rows.len() == 0u { + if rows.len() == 0 { return match witness { ConstructWitness => UsefulWithWitness(vec!()), LeaveOutWitness => Useful }; } - if rows[0].len() == 0u { + if rows[0].len() == 0 { return NotUseful; } let real_pat = match rows.iter().find(|r| (*r)[0].id != DUMMY_NODE_ID) { @@ -669,9 +669,9 @@ fn is_useful_specialized(cx: &MatchCheckCtxt, &Matrix(ref m): &Matrix, witness: WitnessPreference) -> Usefulness { let arity = constructor_arity(cx, &ctor, lty); let matrix = Matrix(m.iter().filter_map(|r| { - specialize(cx, &r[], &ctor, 0u, arity) + specialize(cx, &r[], &ctor, 0, arity) }).collect()); - match specialize(cx, v, &ctor, 0u, arity) { + match specialize(cx, v, &ctor, 0, arity) { Some(v) => is_useful(cx, &matrix, &v[], witness), None => NotUseful } @@ -742,20 +742,20 @@ fn pat_constructors(cx: &MatchCheckCtxt, p: &Pat, /// This computes the arity of a constructor. The arity of a constructor /// is how many subpattern patterns of that constructor should be expanded to. /// -/// For instance, a tuple pattern (_, 42u, Some([])) has the arity of 3. +/// For instance, a tuple pattern (_, 42, Some([])) has the arity of 3. /// A struct pattern's arity is the number of fields it contains, etc. pub fn constructor_arity(cx: &MatchCheckCtxt, ctor: &Constructor, ty: Ty) -> uint { match ty.sty { ty::ty_tup(ref fs) => fs.len(), - ty::ty_uniq(_) => 1u, + ty::ty_uniq(_) => 1, ty::ty_rptr(_, ty::mt { ty, .. }) => match ty.sty { ty::ty_vec(_, None) => match *ctor { Slice(length) => length, - ConstantValue(_) => 0u, + ConstantValue(_) => 0, _ => unreachable!() }, - ty::ty_str => 0u, - _ => 1u + ty::ty_str => 0, + _ => 1 }, ty::ty_enum(eid, _) => { match *ctor { @@ -765,7 +765,7 @@ pub fn constructor_arity(cx: &MatchCheckCtxt, ctor: &Constructor, ty: Ty) -> uin } ty::ty_struct(cid, _) => ty::lookup_struct_fields(cx.tcx, cid).len(), ty::ty_vec(_, Some(n)) => n, - _ => 0u + _ => 0 } } diff --git a/src/librustc/middle/dataflow.rs b/src/librustc/middle/dataflow.rs index 01d42523f35..3e2e81077da 100644 --- a/src/librustc/middle/dataflow.rs +++ b/src/librustc/middle/dataflow.rs @@ -352,7 +352,7 @@ fn each_bit(&self, words: &[uint], mut f: F) -> bool where for (word_index, &word) in words.iter().enumerate() { if word != 0 { let base_index = word_index * uint::BITS; - for offset in 0u..uint::BITS { + for offset in 0..uint::BITS { let bit = 1 << offset; if (word & bit) != 0 { // NB: we round up the total number of bits @@ -447,7 +447,7 @@ pub fn propagate(&mut self, cfg: &cfg::CFG, blk: &ast::Block) { changed: true }; - let mut temp: Vec<_> = repeat(0u).take(words_per_id).collect(); + let mut temp: Vec<_> = repeat(0).take(words_per_id).collect(); while propcx.changed { propcx.changed = false; propcx.reset(temp.as_mut_slice()); @@ -466,7 +466,7 @@ fn pretty_print_to(&self, wr: Box, blk: &ast::Block) -> old_io::IoResult<()> { let mut ps = pprust::rust_printer_annotated(wr, self); try!(ps.cbox(pprust::indent_unit)); - try!(ps.ibox(0u)); + try!(ps.ibox(0)); try!(ps.print_block(blk)); pp::eof(&mut ps.s) } @@ -552,7 +552,7 @@ fn bits_to_string(words: &[uint]) -> String { for &word in words.iter() { let mut v = word; - for _ in 0u..uint::BYTES { + for _ in 0..uint::BYTES { result.push(sep); result.push_str(&format!("{:02x}", v & 0xFF)[]); v >>= 8; @@ -593,7 +593,7 @@ fn set_bit(words: &mut [uint], bit: uint) -> bool { fn bit_str(bit: uint) -> String { let byte = bit >> 8; - let lobits = 1u << (bit & 0xFF); + let lobits = 1 << (bit & 0xFF); format!("[{}:{}-{:02x}]", bit, byte, lobits) } diff --git a/src/librustc/middle/infer/region_inference/mod.rs b/src/librustc/middle/infer/region_inference/mod.rs index 052e7dbb3a4..8952452cb4b 100644 --- a/src/librustc/middle/infer/region_inference/mod.rs +++ b/src/librustc/middle/infer/region_inference/mod.rs @@ -1259,7 +1259,7 @@ fn extract_values_and_collect_conflicts( let mut opt_graph = None; - for idx in 0u..self.num_vars() as uint { + for idx in 0..self.num_vars() as uint { match var_data[idx].value { Value(_) => { /* Inference successful */ @@ -1548,7 +1548,7 @@ fn process_edges<'a, 'tcx>(this: &RegionVarBindings<'a, 'tcx>, fn iterate_until_fixed_point(&self, tag: &str, mut body: F) where F: FnMut(&Constraint) -> bool, { - let mut iteration = 0u; + let mut iteration = 0; let mut changed = true; while changed { changed = false; diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs index 982bc41f06a..cb0157fed87 100644 --- a/src/librustc/middle/liveness.rs +++ b/src/librustc/middle/liveness.rs @@ -540,9 +540,9 @@ struct Specials { clean_exit_var: Variable } -static ACC_READ: uint = 1u; -static ACC_WRITE: uint = 2u; -static ACC_USE: uint = 4u; +static ACC_READ: uint = 1; +static ACC_WRITE: uint = 2; +static ACC_USE: uint = 4; struct Liveness<'a, 'tcx: 'a> { ir: &'a mut IrMaps<'a, 'tcx>, @@ -672,9 +672,9 @@ fn assigned_on_exit(&self, ln: LiveNode, var: Variable) fn indices2(&mut self, ln: LiveNode, succ_ln: LiveNode, mut op: F) where F: FnMut(&mut Liveness<'a, 'tcx>, uint, uint), { - let node_base_idx = self.idx(ln, Variable(0u)); - let succ_base_idx = self.idx(succ_ln, Variable(0u)); - for var_idx in 0u..self.ir.num_vars { + let node_base_idx = self.idx(ln, Variable(0)); + let succ_base_idx = self.idx(succ_ln, Variable(0)); + for var_idx in 0..self.ir.num_vars { op(self, node_base_idx + var_idx, succ_base_idx + var_idx); } } @@ -687,7 +687,7 @@ fn write_vars(&self, F: FnMut(uint) -> LiveNode, { let node_base_idx = self.idx(ln, Variable(0)); - for var_idx in 0u..self.ir.num_vars { + for var_idx in 0..self.ir.num_vars { let idx = node_base_idx + var_idx; if test(idx).is_valid() { try!(write!(wr, " {:?}", Variable(var_idx))); @@ -847,7 +847,7 @@ fn compute(&mut self, decl: &ast::FnDecl, body: &ast::Block) -> LiveNode { // hack to skip the loop unless debug! is enabled: debug!("^^ liveness computation results for body {} (entry={:?})", { - for ln_idx in 0u..self.ir.num_live_nodes { + for ln_idx in 0..self.ir.num_live_nodes { debug!("{:?}", self.ln_str(LiveNode(ln_idx))); } body.id @@ -1303,7 +1303,7 @@ fn access_path(&mut self, expr: &Expr, succ: LiveNode, acc: uint) match self.ir.tcx.def_map.borrow()[expr.id].clone() { DefLocal(nid) => { let ln = self.live_node(expr.id, expr.span); - if acc != 0u { + if acc != 0 { self.init_from_succ(ln, succ); let var = self.variable(nid, expr.span); self.acc(ln, var, acc); diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs index 0d86dbeadf4..9363ad22187 100644 --- a/src/librustc/middle/mem_categorization.rs +++ b/src/librustc/middle/mem_categorization.rs @@ -454,7 +454,7 @@ pub fn cat_expr_autoderefd(&self, debug!("cat_expr_autoderefd: autoderefs={}, cmt={}", autoderefs, cmt.repr(self.tcx())); - for deref in 1u..autoderefs + 1 { + for deref in 1..autoderefs + 1 { cmt = try!(self.cat_deref(expr, cmt, deref)); } return Ok(cmt); diff --git a/src/librustc/middle/region.rs b/src/librustc/middle/region.rs index c70532dbb30..3f8b7e5a7b3 100644 --- a/src/librustc/middle/region.rs +++ b/src/librustc/middle/region.rs @@ -461,8 +461,8 @@ pub fn nearest_common_ancestor(&self, let a_ancestors = ancestors_of(self, scope_a); let b_ancestors = ancestors_of(self, scope_b); - let mut a_index = a_ancestors.len() - 1u; - let mut b_index = b_ancestors.len() - 1u; + let mut a_index = a_ancestors.len() - 1; + let mut b_index = b_ancestors.len() - 1; // Here, ~[ab]_ancestors is a vector going from narrow to broad. // The end of each vector will be the item where the scope is @@ -479,10 +479,10 @@ pub fn nearest_common_ancestor(&self, loop { // Loop invariant: a_ancestors[a_index] == b_ancestors[b_index] // for all indices between a_index and the end of the array - if a_index == 0u { return Some(scope_a); } - if b_index == 0u { return Some(scope_b); } - a_index -= 1u; - b_index -= 1u; + if a_index == 0 { return Some(scope_a); } + if b_index == 0 { return Some(scope_b); } + a_index -= 1; + b_index -= 1; if a_ancestors[a_index] != b_ancestors[b_index] { return Some(a_ancestors[a_index + 1]); } diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index 8e88e4338cd..cdcd02ba83a 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -4475,7 +4475,7 @@ pub fn expr_kind(tcx: &ctxt, expr: &ast::Expr) -> ExprKind { match resolve_expr(tcx, expr) { def::DefVariant(tid, vid, _) => { let variant_info = enum_variant_with_id(tcx, tid, vid); - if variant_info.args.len() > 0u { + if variant_info.args.len() > 0 { // N-ary variant. RvalueDatumExpr } else { @@ -4639,8 +4639,8 @@ pub fn stmt_node_id(s: &ast::Stmt) -> ast::NodeId { pub fn field_idx_strict(tcx: &ctxt, name: ast::Name, fields: &[field]) -> uint { - let mut i = 0u; - for f in fields.iter() { if f.name == name { return i; } i += 1u; } + let mut i = 0; + for f in fields.iter() { if f.name == name { return i; } i += 1; } tcx.sess.bug(&format!( "no field named `{}` found in the list of fields `{:?}`", token::get_name(name), diff --git a/src/librustc/session/mod.rs b/src/librustc/session/mod.rs index e62f3145e5a..54384da33fc 100644 --- a/src/librustc/session/mod.rs +++ b/src/librustc/session/mod.rs @@ -260,7 +260,7 @@ fn split_msg_into_multilines(msg: &str) -> Option { }).map(|(a, b)| (a - 1, b)); let mut new_msg = String::new(); - let mut head = 0u; + let mut head = 0; // Insert `\n` before expected and found. for (pos1, pos2) in first.zip(second) { diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs index 6c723a58380..b351f7fcef2 100644 --- a/src/librustc/util/ppaux.rs +++ b/src/librustc/util/ppaux.rs @@ -531,8 +531,8 @@ pub fn parameterized<'tcx>(cx: &ctxt<'tcx>, pub fn ty_to_short_str<'tcx>(cx: &ctxt<'tcx>, typ: Ty<'tcx>) -> String { let mut s = typ.repr(cx).to_string(); - if s.len() >= 32u { - s = (&s[0u..32u]).to_string(); + if s.len() >= 32 { + s = (&s[0u..32]).to_string(); } return s; } diff --git a/src/librustc_trans/back/link.rs b/src/librustc_trans/back/link.rs index 93a2b6eaa4f..c97d9090441 100644 --- a/src/librustc_trans/back/link.rs +++ b/src/librustc_trans/back/link.rs @@ -256,7 +256,7 @@ pub fn sanitize(s: &str) -> String { } // Underscore-qualify anything that didn't start as an ident. - if result.len() > 0u && + if result.len() > 0 && result.as_bytes()[0] != '_' as u8 && ! (result.as_bytes()[0] as char).is_xid_start() { return format!("_{}", &result[]); diff --git a/src/librustc_trans/back/lto.rs b/src/librustc_trans/back/lto.rs index a67c31bffba..5fcf0be4c67 100644 --- a/src/librustc_trans/back/lto.rs +++ b/src/librustc_trans/back/lto.rs @@ -62,7 +62,7 @@ pub fn run(sess: &session::Session, llmod: ModuleRef, let file = path.filename_str().unwrap(); let file = &file[3..file.len() - 5]; // chop off lib/.rlib debug!("reading {}", file); - for i in iter::count(0u, 1) { + for i in iter::count(0us, 1) { let bc_encoded = time(sess.time_passes(), format!("check for {}.{}.bytecode.deflate", name, i).as_slice(), (), diff --git a/src/librustc_trans/save/recorder.rs b/src/librustc_trans/save/recorder.rs index 1378d409208..f6f03887528 100644 --- a/src/librustc_trans/save/recorder.rs +++ b/src/librustc_trans/save/recorder.rs @@ -272,7 +272,7 @@ pub fn variable_str(&mut self, self.check_and_record(Variable, span, sub_span, - svec!(id, name, qualname, value, typ, 0u)); + svec!(id, name, qualname, value, typ, 0)); } // formal parameters @@ -289,7 +289,7 @@ pub fn formal_str(&mut self, self.check_and_record(Variable, span, sub_span, - svec!(id, name, qualname, "", typ, 0u)); + svec!(id, name, qualname, "", typ, 0)); } // value is the initialising expression of the static if it is not mut, otherwise "". @@ -520,7 +520,7 @@ pub fn inherit_str(&mut self, svec!(base_id.node, base_id.krate, deriv_id, - 0u)); + 0)); } pub fn fn_call_str(&mut self, @@ -562,7 +562,7 @@ pub fn sub_mod_ref_str(&mut self, self.record_with_span(ModRef, span, sub_span, - svec!(0u, 0u, qualname, parent)); + svec!(0, 0, qualname, parent)); } pub fn typedef_str(&mut self, @@ -603,7 +603,7 @@ pub fn sub_type_ref_str(&mut self, self.record_with_span(TypeRef, span, sub_span, - svec!(0u, 0u, qualname, 0u)); + svec!(0, 0, qualname, 0)); } // A slightly generic function for a reference to an item of any kind. diff --git a/src/librustc_trans/save/span_utils.rs b/src/librustc_trans/save/span_utils.rs index 419ccfa312e..beec8071a72 100644 --- a/src/librustc_trans/save/span_utils.rs +++ b/src/librustc_trans/save/span_utils.rs @@ -94,7 +94,7 @@ pub fn span_for_last_ident(&self, span: Span) -> Option { let mut result = None; let mut toks = self.retokenise_span(span); - let mut bracket_count = 0u; + let mut bracket_count = 0; loop { let ts = toks.real_token(); if ts.tok == token::Eof { @@ -117,7 +117,7 @@ pub fn span_for_last_ident(&self, span: Span) -> Option { // Return the span for the first identifier in the path. pub fn span_for_first_ident(&self, span: Span) -> Option { let mut toks = self.retokenise_span(span); - let mut bracket_count = 0u; + let mut bracket_count = 0; loop { let ts = toks.real_token(); if ts.tok == token::Eof { @@ -143,7 +143,7 @@ pub fn sub_span_for_meth_name(&self, span: Span) -> Option { let mut toks = self.retokenise_span(span); let mut prev = toks.real_token(); let mut result = None; - let mut bracket_count = 0u; + let mut bracket_count = 0; let mut last_span = None; while prev.tok != token::Eof { last_span = None; @@ -191,7 +191,7 @@ pub fn sub_span_for_type_name(&self, span: Span) -> Option { let mut toks = self.retokenise_span(span); let mut prev = toks.real_token(); let mut result = None; - let mut bracket_count = 0u; + let mut bracket_count = 0; loop { let next = toks.real_token(); diff --git a/src/librustc_trans/trans/_match.rs b/src/librustc_trans/trans/_match.rs index 50dfbff0034..b66e2770815 100644 --- a/src/librustc_trans/trans/_match.rs +++ b/src/librustc_trans/trans/_match.rs @@ -32,7 +32,7 @@ //! match foo { //! A => ..., //! B(x) => ..., -//! C(1u, 2) => ..., +//! C(1, 2) => ..., //! C(_) => ... //! } //! @@ -41,7 +41,7 @@ //! various options and then compile the code for the case where `foo` is an //! `A`, a `B`, and a `C`. When we generate the code for `C`, we would (1) //! drop the two matches that do not match a `C` and (2) expand the other two -//! into two patterns each. In the first case, the two patterns would be `1u` +//! into two patterns each. In the first case, the two patterns would be `1` //! and `2`, and the in the second case the _ pattern would be expanded into //! `_` and `_`. The two values are of course the arguments to `C`. //! @@ -638,8 +638,8 @@ fn bind_subslice_pat(bcx: Block, ty::mt {ty: vt.unit_ty, mutbl: ast::MutImmutable}); let scratch = rvalue_scratch_datum(bcx, slice_ty, ""); Store(bcx, slice_begin, - GEPi(bcx, scratch.val, &[0u, abi::FAT_PTR_ADDR])); - Store(bcx, slice_len, GEPi(bcx, scratch.val, &[0u, abi::FAT_PTR_EXTRA])); + GEPi(bcx, scratch.val, &[0, abi::FAT_PTR_ADDR])); + Store(bcx, slice_len, GEPi(bcx, scratch.val, &[0, abi::FAT_PTR_EXTRA])); scratch.val } @@ -742,8 +742,8 @@ fn pick_column_to_specialize(def_map: &DefMap, m: &[Match]) -> Option { fn pat_score(def_map: &DefMap, pat: &ast::Pat) -> uint { match pat.node { ast::PatIdent(_, _, Some(ref inner)) => pat_score(def_map, &**inner), - _ if pat_is_refutable(def_map, pat) => 1u, - _ => 0u + _ if pat_is_refutable(def_map, pat) => 1, + _ => 0 } } @@ -922,7 +922,7 @@ fn compile_submatch<'a, 'p, 'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let _indenter = indenter(); let _icx = push_ctxt("match::compile_submatch"); let mut bcx = bcx; - if m.len() == 0u { + if m.len() == 0 { if chk.is_fallible() { chk.handle_fail(bcx); } @@ -982,8 +982,8 @@ fn compile_submatch_continue<'a, 'p, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, let tcx = bcx.tcx(); let dm = &tcx.def_map; - let mut vals_left = vals[0u..col].to_vec(); - vals_left.push_all(&vals[col + 1u..]); + let mut vals_left = vals[0..col].to_vec(); + vals_left.push_all(&vals[col + 1..]); let ccx = bcx.fcx.ccx; // Find a real id (we're adding placeholder wildcard patterns, but @@ -1042,7 +1042,7 @@ fn compile_submatch_continue<'a, 'p, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, let mut kind = NoBranch; let mut test_val = val; debug!("test_val={}", bcx.val_to_string(test_val)); - if opts.len() > 0u { + if opts.len() > 0 { match opts[0] { ConstantValue(_) | ConstantRange(_, _) => { test_val = load_if_immediate(bcx, val, left_ty); @@ -1082,7 +1082,7 @@ fn compile_submatch_continue<'a, 'p, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, }; let defaults = enter_default(else_cx, dm, m, col, val); - let exhaustive = chk.is_infallible() && defaults.len() == 0u; + let exhaustive = chk.is_infallible() && defaults.len() == 0; let len = opts.len(); // Compile subtrees for each option @@ -1157,7 +1157,7 @@ fn compile_submatch_continue<'a, 'p, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, Br(bcx, else_cx.llbb, DebugLoc::None); } - let mut size = 0u; + let mut size = 0; let mut unpacked = Vec::new(); match *opt { Variant(disr_val, ref repr, _) => { diff --git a/src/librustc_trans/trans/base.rs b/src/librustc_trans/trans/base.rs index 1b212aca330..254483c226d 100644 --- a/src/librustc_trans/trans/base.rs +++ b/src/librustc_trans/trans/base.rs @@ -401,7 +401,7 @@ pub fn get_tydesc<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, _ => { } } - ccx.stats().n_static_tydescs.set(ccx.stats().n_static_tydescs.get() + 1u); + ccx.stats().n_static_tydescs.set(ccx.stats().n_static_tydescs.get() + 1); let inf = Rc::new(glue::declare_tydesc(ccx, t)); ccx.tydescs().borrow_mut().insert(t, inf.clone()); @@ -2879,7 +2879,7 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef { panic!("struct variant kind unexpected in get_item_val") } }; - assert!(args.len() != 0u); + assert!(args.len() != 0); let ty = ty::node_id_to_type(ccx.tcx(), id); let parent = ccx.tcx().map.get_parent(id); let enm = ccx.tcx().map.expect_item(parent); diff --git a/src/librustc_trans/trans/builder.rs b/src/librustc_trans/trans/builder.rs index b307f4e5a9b..32e16c7bf8d 100644 --- a/src/librustc_trans/trans/builder.rs +++ b/src/librustc_trans/trans/builder.rs @@ -61,22 +61,22 @@ pub fn count_insn(&self, category: &str) { // Pass 1: scan table mapping str -> rightmost pos. let mut mm = FnvHashMap(); let len = v.len(); - let mut i = 0u; + let mut i = 0; while i < len { mm.insert(v[i], i); - i += 1u; + i += 1; } // Pass 2: concat strings for each elt, skipping // forwards over any cycles by advancing to rightmost // occurrence of each element in path. let mut s = String::from_str("."); - i = 0u; + i = 0; while i < len { i = mm[v[i]]; s.push('/'); s.push_str(v[i]); - i += 1u; + i += 1; } s.push('/'); @@ -84,9 +84,9 @@ pub fn count_insn(&self, category: &str) { let n = match h.get(&s) { Some(&n) => n, - _ => 0u + _ => 0 }; - h.insert(s, n+1u); + h.insert(s, n+1); }) } } diff --git a/src/librustc_trans/trans/cabi_aarch64.rs b/src/librustc_trans/trans/cabi_aarch64.rs index 0d8ef9e2fc9..ce1cf54919c 100644 --- a/src/librustc_trans/trans/cabi_aarch64.rs +++ b/src/librustc_trans/trans/cabi_aarch64.rs @@ -19,7 +19,7 @@ use std::cmp; fn align_up_to(off: uint, a: uint) -> uint { - return (off + a - 1u) / a * a; + return (off + a - 1) / a * a; } fn align(off: uint, ty: Type) -> uint { diff --git a/src/librustc_trans/trans/cabi_arm.rs b/src/librustc_trans/trans/cabi_arm.rs index 7d1a8ab1452..ac32ce49511 100644 --- a/src/librustc_trans/trans/cabi_arm.rs +++ b/src/librustc_trans/trans/cabi_arm.rs @@ -26,7 +26,7 @@ pub enum Flavor { type TyAlignFn = fn(ty: Type) -> uint; fn align_up_to(off: uint, a: uint) -> uint { - return (off + a - 1u) / a * a; + return (off + a - 1) / a * a; } fn align(off: uint, ty: Type, align_fn: TyAlignFn) -> uint { diff --git a/src/librustc_trans/trans/cabi_mips.rs b/src/librustc_trans/trans/cabi_mips.rs index 776be8855cb..af7956b46be 100644 --- a/src/librustc_trans/trans/cabi_mips.rs +++ b/src/librustc_trans/trans/cabi_mips.rs @@ -20,7 +20,7 @@ use trans::type_::Type; fn align_up_to(off: uint, a: uint) -> uint { - return (off + a - 1u) / a * a; + return (off + a - 1) / a * a; } fn align(off: uint, ty: Type) -> uint { diff --git a/src/librustc_trans/trans/cabi_powerpc.rs b/src/librustc_trans/trans/cabi_powerpc.rs index 9fc67e19662..c3b0026de98 100644 --- a/src/librustc_trans/trans/cabi_powerpc.rs +++ b/src/librustc_trans/trans/cabi_powerpc.rs @@ -19,7 +19,7 @@ use std::cmp; fn align_up_to(off: uint, a: uint) -> uint { - return (off + a - 1u) / a * a; + return (off + a - 1) / a * a; } fn align(off: uint, ty: Type) -> uint { diff --git a/src/librustc_trans/trans/cabi_x86_64.rs b/src/librustc_trans/trans/cabi_x86_64.rs index 3c0530bbb9a..c0ab0d24dab 100644 --- a/src/librustc_trans/trans/cabi_x86_64.rs +++ b/src/librustc_trans/trans/cabi_x86_64.rs @@ -88,7 +88,7 @@ fn is_ret_bysret(&self) -> bool { fn classify_ty(ty: Type) -> Vec { fn align(off: uint, ty: Type) -> uint { let a = ty_align(ty); - return (off + a - 1u) / a * a; + return (off + a - 1) / a * a; } fn ty_align(ty: Type) -> uint { @@ -211,12 +211,12 @@ fn classify(ty: Type, let t_size = ty_size(ty); let misalign = off % t_align; - if misalign != 0u { - let mut i = off / 8u; - let e = (off + t_size + 7u) / 8u; + if misalign != 0 { + let mut i = off / 8; + let e = (off + t_size + 7) / 8; while i < e { unify(cls, ix + i, Memory); - i += 1u; + i += 1; } return; } @@ -224,17 +224,17 @@ fn classify(ty: Type, match ty.kind() { Integer | Pointer => { - unify(cls, ix + off / 8u, Int); + unify(cls, ix + off / 8, Int); } Float => { - if off % 8u == 4u { - unify(cls, ix + off / 8u, SSEFv); + if off % 8 == 4 { + unify(cls, ix + off / 8, SSEFv); } else { - unify(cls, ix + off / 8u, SSEFs); + unify(cls, ix + off / 8, SSEFs); } } Double => { - unify(cls, ix + off / 8u, SSEDs); + unify(cls, ix + off / 8, SSEDs); } Struct => { classify_struct(ty.field_types().as_slice(), cls, ix, off, ty.is_packed()); @@ -243,10 +243,10 @@ fn classify(ty: Type, let len = ty.array_length(); let elt = ty.element_type(); let eltsz = ty_size(elt); - let mut i = 0u; + let mut i = 0; while i < len { classify(elt, cls, ix, off + i * eltsz); - i += 1u; + i += 1; } } Vector => { @@ -260,14 +260,14 @@ fn classify(ty: Type, _ => panic!("classify: unhandled vector element type") }; - let mut i = 0u; + let mut i = 0; while i < len { unify(cls, ix + (off + i * eltsz) / 8, reg); // everything after the first one is the upper // half of a register. reg = SSEUp; - i += 1u; + i += 1; } } _ => panic!("classify: unhandled type") @@ -275,18 +275,18 @@ fn classify(ty: Type, } fn fixup(ty: Type, cls: &mut [RegClass]) { - let mut i = 0u; + let mut i = 0; let ty_kind = ty.kind(); let e = cls.len(); - if cls.len() > 2u && (ty_kind == Struct || ty_kind == Array || ty_kind == Vector) { + if cls.len() > 2 && (ty_kind == Struct || ty_kind == Array || ty_kind == Vector) { if cls[i].is_sse() { - i += 1u; + i += 1; while i < e { if cls[i] != SSEUp { all_mem(cls); return; } - i += 1u; + i += 1; } } else { all_mem(cls); @@ -308,10 +308,10 @@ fn fixup(ty: Type, cls: &mut [RegClass]) { cls[i] = SSEDv; } else if cls[i].is_sse() { i += 1; - while i != e && cls[i] == SSEUp { i += 1u; } + while i != e && cls[i] == SSEUp { i += 1; } } else if cls[i] == X87 { i += 1; - while i != e && cls[i] == X87Up { i += 1u; } + while i != e && cls[i] == X87Up { i += 1; } } else { i += 1; } @@ -332,18 +332,18 @@ fn fixup(ty: Type, cls: &mut [RegClass]) { fn llreg_ty(ccx: &CrateContext, cls: &[RegClass]) -> Type { fn llvec_len(cls: &[RegClass]) -> uint { - let mut len = 1u; + let mut len = 1; for c in cls.iter() { if *c != SSEUp { break; } - len += 1u; + len += 1; } return len; } let mut tys = Vec::new(); - let mut i = 0u; + let mut i = 0; let e = cls.len(); while i < e { match cls[i] { @@ -361,7 +361,7 @@ fn llvec_len(cls: &[RegClass]) -> uint { } _ => unreachable!(), }; - let vec_len = llvec_len(&cls[i + 1u..]); + let vec_len = llvec_len(&cls[i + 1..]); let vec_ty = Type::vector(&elt_ty, vec_len as u64 * elts_per_word); tys.push(vec_ty); i += vec_len; @@ -375,7 +375,7 @@ fn llvec_len(cls: &[RegClass]) -> uint { } _ => panic!("llregtype: unhandled class") } - i += 1u; + i += 1; } if tys.len() == 1 && tys[0].kind() == Vector { // if the type contains only a vector, pass it as that vector. diff --git a/src/librustc_trans/trans/callee.rs b/src/librustc_trans/trans/callee.rs index fc29c7071f2..5f3cb01d762 100644 --- a/src/librustc_trans/trans/callee.rs +++ b/src/librustc_trans/trans/callee.rs @@ -182,7 +182,7 @@ fn trans_def<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, bcx.fcx.param_substs); // Nullary variants are not callable - assert!(vinfo.args.len() > 0u); + assert!(vinfo.args.len() > 0); Callee { bcx: bcx, diff --git a/src/librustc_trans/trans/cleanup.rs b/src/librustc_trans/trans/cleanup.rs index 61a6f4cfe10..096ea22eaac 100644 --- a/src/librustc_trans/trans/cleanup.rs +++ b/src/librustc_trans/trans/cleanup.rs @@ -747,7 +747,7 @@ fn get_or_create_landing_pad(&'blk self) -> BasicBlockRef { }; // The only landing pad clause will be 'cleanup' - let llretval = build::LandingPad(pad_bcx, llretty, llpersonality, 1u); + let llretval = build::LandingPad(pad_bcx, llretty, llpersonality, 1); // The landing pad block is a cleanup build::SetCleanup(pad_bcx, llretval); diff --git a/src/librustc_trans/trans/context.rs b/src/librustc_trans/trans/context.rs index 12e79c407ec..3a2a1d15864 100644 --- a/src/librustc_trans/trans/context.rs +++ b/src/librustc_trans/trans/context.rs @@ -258,15 +258,15 @@ pub fn new(crate_name: &str, symbol_hasher: RefCell::new(symbol_hasher), tcx: tcx, stats: Stats { - n_static_tydescs: Cell::new(0u), - n_glues_created: Cell::new(0u), - n_null_glues: Cell::new(0u), - n_real_glues: Cell::new(0u), - n_fns: Cell::new(0u), - n_monos: Cell::new(0u), - n_inlines: Cell::new(0u), - n_closures: Cell::new(0u), - n_llvm_insns: Cell::new(0u), + n_static_tydescs: Cell::new(0), + n_glues_created: Cell::new(0), + n_null_glues: Cell::new(0), + n_real_glues: Cell::new(0), + n_fns: Cell::new(0), + n_monos: Cell::new(0), + n_inlines: Cell::new(0), + n_closures: Cell::new(0), + n_llvm_insns: Cell::new(0), llvm_insns: RefCell::new(FnvHashMap()), fn_stats: RefCell::new(Vec::new()), }, @@ -418,7 +418,7 @@ fn new(shared: &SharedCrateContext<'tcx>, dbg_cx: dbg_cx, eh_personality: RefCell::new(None), intrinsics: RefCell::new(FnvHashMap()), - n_llvm_insns: Cell::new(0u), + n_llvm_insns: Cell::new(0), trait_cache: RefCell::new(FnvHashMap()), }; diff --git a/src/librustc_trans/trans/debuginfo.rs b/src/librustc_trans/trans/debuginfo.rs index 4f9c97795e1..258a6fb958d 100644 --- a/src/librustc_trans/trans/debuginfo.rs +++ b/src/librustc_trans/trans/debuginfo.rs @@ -1730,7 +1730,7 @@ fn file_metadata(cx: &CrateContext, full_path: &str) -> DIFile { let work_dir = cx.sess().working_dir.as_str().unwrap(); let file_name = if full_path.starts_with(work_dir) { - &full_path[work_dir.len() + 1u..full_path.len()] + &full_path[work_dir.len() + 1..full_path.len()] } else { full_path }; @@ -2268,7 +2268,7 @@ fn create_member_descriptions<'a>(&self, cx: &CrateContext<'a, 'tcx>) let null_variant_index = (1 - non_null_variant_index) as uint; let null_variant_name = token::get_name((*self.variants)[null_variant_index].name); let union_member_name = format!("RUST$ENCODED$ENUM${}${}", - 0u, + 0, null_variant_name); // Finally create the (singleton) list of descriptions of union @@ -3855,7 +3855,7 @@ fn push_item_name(cx: &CrateContext, output.push_str("::"); } - let mut path_element_count = 0u; + let mut path_element_count = 0; for path_element in path { let name = token::get_name(path_element.name()); output.push_str(name.get()); diff --git a/src/librustc_trans/trans/expr.rs b/src/librustc_trans/trans/expr.rs index 46726f78d04..cf85389cd5b 100644 --- a/src/librustc_trans/trans/expr.rs +++ b/src/librustc_trans/trans/expr.rs @@ -153,11 +153,11 @@ pub fn trans<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, } pub fn get_len(bcx: Block, fat_ptr: ValueRef) -> ValueRef { - GEPi(bcx, fat_ptr, &[0u, abi::FAT_PTR_EXTRA]) + GEPi(bcx, fat_ptr, &[0, abi::FAT_PTR_EXTRA]) } pub fn get_dataptr(bcx: Block, fat_ptr: ValueRef) -> ValueRef { - GEPi(bcx, fat_ptr, &[0u, abi::FAT_PTR_ADDR]) + GEPi(bcx, fat_ptr, &[0, abi::FAT_PTR_ADDR]) } /// Helper for trans that apply adjustments from `expr` to `datum`, which should be the unadjusted @@ -366,7 +366,7 @@ fn unsize_expr<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, }, info), ty::UnsizeLength(..) => into_fat_ptr(bcx, expr, datum, dest_ty, |bcx, val| { - GEPi(bcx, val, &[0u, 0u]) + GEPi(bcx, val, &[0, 0]) }, info), ty::UnsizeVtable(..) => into_fat_ptr(bcx, expr, datum, dest_ty, |_bcx, val| { @@ -1185,7 +1185,7 @@ fn trans_def_dps_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, match def { def::DefVariant(tid, vid, _) => { let variant_info = ty::enum_variant_with_id(bcx.tcx(), tid, vid); - if variant_info.args.len() > 0u { + if variant_info.args.len() > 0 { // N-ary variant. let llfn = callee::trans_fn_ref(bcx.ccx(), vid, ExprId(ref_expr.id), diff --git a/src/librustc_trans/trans/glue.rs b/src/librustc_trans/trans/glue.rs index 69d1922ab9a..497237da38c 100644 --- a/src/librustc_trans/trans/glue.rs +++ b/src/librustc_trans/trans/glue.rs @@ -337,8 +337,8 @@ fn size_and_align_of_dst<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, t: Ty<'tcx>, info: // info points to the vtable and the second entry in the vtable is the // dynamic size of the object. let info = PointerCast(bcx, info, Type::int(bcx.ccx()).ptr_to()); - let size_ptr = GEPi(bcx, info, &[1u]); - let align_ptr = GEPi(bcx, info, &[2u]); + let size_ptr = GEPi(bcx, info, &[1]); + let align_ptr = GEPi(bcx, info, &[2]); (Load(bcx, size_ptr), Load(bcx, align_ptr)) } ty::ty_vec(_, None) | ty::ty_str => { @@ -551,7 +551,7 @@ fn make_generic_glue<'a, 'tcx, F>(ccx: &CrateContext<'a, 'tcx>, update_linkage(ccx, llfn, None, OriginalTranslation); - ccx.stats().n_glues_created.set(ccx.stats().n_glues_created.get() + 1u); + ccx.stats().n_glues_created.set(ccx.stats().n_glues_created.get() + 1); // All glue functions take values passed *by alias*; this is a // requirement since in many contexts glue is invoked indirectly and // the caller has no idea if it's dealing with something that can be diff --git a/src/librustc_trans/trans/meth.rs b/src/librustc_trans/trans/meth.rs index c4240fa9eba..335c639df90 100644 --- a/src/librustc_trans/trans/meth.rs +++ b/src/librustc_trans/trans/meth.rs @@ -78,7 +78,7 @@ pub fn trans_impl(ccx: &CrateContext, for impl_item in impl_items.iter() { match *impl_item { ast::MethodImplItem(ref method) => { - if method.pe_generics().ty_params.len() == 0u { + if method.pe_generics().ty_params.len() == 0 { let trans_everywhere = attr::requests_inline(&method.attrs[]); for (ref ccx, is_origin) in ccx.maybe_iter(trans_everywhere) { let llfn = get_item_val(ccx, method.id); @@ -488,7 +488,7 @@ pub fn trans_trait_callee_from_llval<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, callee_ty.repr(ccx.tcx()), vtable_index, bcx.val_to_string(llpair)); - let llboxptr = GEPi(bcx, llpair, &[0u, abi::FAT_PTR_ADDR]); + let llboxptr = GEPi(bcx, llpair, &[0, abi::FAT_PTR_ADDR]); let llbox = Load(bcx, llboxptr); let llself = PointerCast(bcx, llbox, Type::i8p(ccx)); @@ -510,9 +510,9 @@ pub fn trans_trait_callee_from_llval<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let llvtable = Load(bcx, PointerCast(bcx, GEPi(bcx, llpair, - &[0u, abi::FAT_PTR_EXTRA]), + &[0, abi::FAT_PTR_EXTRA]), Type::vtable(ccx).ptr_to().ptr_to())); - let mptr = Load(bcx, GEPi(bcx, llvtable, &[0u, vtable_index + VTABLE_OFFSET])); + let mptr = Load(bcx, GEPi(bcx, llvtable, &[0, vtable_index + VTABLE_OFFSET])); let mptr = PointerCast(bcx, mptr, llcallee_ty.ptr_to()); return Callee { @@ -877,13 +877,13 @@ pub fn trans_trait_cast<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let llbox_ty = type_of(bcx.ccx(), datum_ty); // Store the pointer into the first half of pair. - let llboxdest = GEPi(bcx, lldest, &[0u, abi::FAT_PTR_ADDR]); + let llboxdest = GEPi(bcx, lldest, &[0, abi::FAT_PTR_ADDR]); let llboxdest = PointerCast(bcx, llboxdest, llbox_ty.ptr_to()); bcx = datum.store_to(bcx, llboxdest); // Store the vtable into the second half of pair. let vtable = get_vtable(bcx, datum_ty, trait_ref); - let llvtabledest = GEPi(bcx, lldest, &[0u, abi::FAT_PTR_EXTRA]); + let llvtabledest = GEPi(bcx, lldest, &[0, abi::FAT_PTR_EXTRA]); let llvtabledest = PointerCast(bcx, llvtabledest, val_ty(vtable).ptr_to()); Store(bcx, vtable, llvtabledest); diff --git a/src/librustc_trans/trans/tvec.rs b/src/librustc_trans/trans/tvec.rs index 358e38a671d..844795b667b 100644 --- a/src/librustc_trans/trans/tvec.rs +++ b/src/librustc_trans/trans/tvec.rs @@ -73,7 +73,7 @@ pub fn make_drop_glue_unboxed<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let unit_size = llsize_of_alloc(ccx, llty); if unit_size != 0 { let len = get_len(bcx, vptr); - let not_empty = ICmp(bcx, llvm::IntNE, len, C_uint(ccx, 0u)); + let not_empty = ICmp(bcx, llvm::IntNE, len, C_uint(ccx, 0us)); with_cond(bcx, not_empty, |bcx| { let llalign = C_uint(ccx, machine::llalign_of_min(ccx, llty)); let size = Mul(bcx, C_uint(ccx, unit_size), len, DebugLoc::None); @@ -213,8 +213,8 @@ pub fn trans_lit_str<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let llbytes = C_uint(bcx.ccx(), bytes); let llcstr = C_cstr(bcx.ccx(), str_lit, false); let llcstr = consts::ptrcast(llcstr, Type::i8p(bcx.ccx())); - Store(bcx, llcstr, GEPi(bcx, lldest, &[0u, abi::FAT_PTR_ADDR])); - Store(bcx, llbytes, GEPi(bcx, lldest, &[0u, abi::FAT_PTR_EXTRA])); + Store(bcx, llcstr, GEPi(bcx, lldest, &[0, abi::FAT_PTR_ADDR])); + Store(bcx, llbytes, GEPi(bcx, lldest, &[0, abi::FAT_PTR_EXTRA])); bcx } } @@ -375,8 +375,8 @@ pub fn get_fixed_base_and_len(bcx: Block, fn get_slice_base_and_len(bcx: Block, llval: ValueRef) -> (ValueRef, ValueRef) { - let base = Load(bcx, GEPi(bcx, llval, &[0u, abi::FAT_PTR_ADDR])); - let len = Load(bcx, GEPi(bcx, llval, &[0u, abi::FAT_PTR_EXTRA])); + let base = Load(bcx, GEPi(bcx, llval, &[0, abi::FAT_PTR_ADDR])); + let len = Load(bcx, GEPi(bcx, llval, &[0, abi::FAT_PTR_EXTRA])); (base, len) } @@ -400,7 +400,7 @@ pub fn get_base_and_len(bcx: Block, ty::ty_uniq(ty) | ty::ty_rptr(_, ty::mt{ty, ..}) => match ty.sty { ty::ty_vec(_, None) | ty::ty_str => get_slice_base_and_len(bcx, llval), ty::ty_vec(_, Some(n)) => { - let base = GEPi(bcx, Load(bcx, llval), &[0u, 0u]); + let base = GEPi(bcx, Load(bcx, llval), &[0, 0]); (base, C_uint(ccx, n)) } _ => ccx.sess().bug("unexpected type in get_base_and_len"), @@ -430,7 +430,7 @@ pub fn iter_vec_loop<'blk, 'tcx, F>(bcx: Block<'blk, 'tcx>, let loop_counter = { // i = 0 let i = alloca(loop_bcx, bcx.ccx().int_type(), "__i"); - Store(loop_bcx, C_uint(bcx.ccx(), 0u), i); + Store(loop_bcx, C_uint(bcx.ccx(), 0us), i); Br(loop_bcx, cond_bcx.llbb, DebugLoc::None); i @@ -458,7 +458,7 @@ pub fn iter_vec_loop<'blk, 'tcx, F>(bcx: Block<'blk, 'tcx>, { // i += 1 let i = Load(inc_bcx, loop_counter); - let plusone = Add(inc_bcx, i, C_uint(bcx.ccx(), 1u), DebugLoc::None); + let plusone = Add(inc_bcx, i, C_uint(bcx.ccx(), 1us), DebugLoc::None); Store(inc_bcx, plusone, loop_counter); Br(inc_bcx, cond_bcx.llbb, DebugLoc::None); -- GitLab